X-Git-Url: https://git.saurik.com/apple/xnu.git/blobdiff_plain/22ba694c5857e62b5a553b1505dcf2e509177f28..04b8595b18b1b41ac7a206e4b3d51a635f8413d7:/iokit/Kernel/IOServicePM.cpp

diff --git a/iokit/Kernel/IOServicePM.cpp b/iokit/Kernel/IOServicePM.cpp
index 9ba2e752c..7c363a269 100644
--- a/iokit/Kernel/IOServicePM.cpp
+++ b/iokit/Kernel/IOServicePM.cpp
@@ -26,9 +26,6 @@
  * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
  */
 
-//#undef IOASSERT
-//#define IOASSERT    1
-
 #include <IOKit/assert.h>
 #include <IOKit/IOKitDebug.h>
 #include <IOKit/IOLib.h>
@@ -79,9 +76,6 @@ static uint64_t computeTimeDeltaNS( const AbsoluteTime * start )
 OSDefineMetaClassAndStructors(IOPMprot, OSObject)
 #endif
 
-// Container class for recording system power events
-OSDefineMetaClassAndStructors( PMEventDetails, OSObject );
-
 //******************************************************************************
 // Globals
 //******************************************************************************
@@ -112,7 +106,7 @@ static thread_t              gIOPMWatchDogThread        = NULL;
 static uint32_t getPMRequestType( void )
 {
     uint32_t type = kIOPMRequestTypeInvalid;
-	if (gIOPMRequest)
+    if (gIOPMRequest)
         type = gIOPMRequest->getType();
     return type;
 }
@@ -132,10 +126,7 @@ static IOPMRequestTag getPMRequestTag( void )
 // 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)
 
@@ -157,7 +148,6 @@ static IOPMRequestTag getPMRequestTag( void )
                                     if ((kIOLogPMRootDomain & gIOKitDebug) && \
                                         (getPMRootDomain() == this)) { \
                                         kprintf("PMRD: " x); \
-                                        getPMRootDomain()->sleepWakeDebugLog(x); \
                                     }} while (false)
 #define PM_ASSERT_IN_GATE(x)          \
 do {                                  \
@@ -199,7 +189,11 @@ do {                                  \
 #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):
@@ -236,12 +230,12 @@ enum {
          } while (false)
 
 static OSNumber * copyClientIDForNotification(
-    OSObject *object, 
+    OSObject *object,
     IOPMInterestContext *context);
 
 static void logClientIDForNotification(
     OSObject *object,
-    IOPMInterestContext *context, 
+    IOPMInterestContext *context,
     const char *logString);
 
 //*********************************************************************************
@@ -295,9 +289,9 @@ enum {
 void IOService::PMinit( void )
 {
     if ( !initialized )
-	{
-		if ( !gIOPMInitialized )
-		{
+    {
+        if ( !gIOPMInitialized )
+        {
             gPlatform = getPlatform();
             gIOPMWorkLoop = IOWorkLoop::workLoop();
             if (gIOPMWorkLoop)
@@ -430,20 +424,20 @@ void IOService::PMinit( void )
         }
 
         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);
 
         // 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;
         }
@@ -457,7 +451,7 @@ void IOService::PMinit( void )
             prot->thePlatform = gPlatform;
             fPMVars = prot;
             pm_vars = prot;
-		}
+        }
 #else
         pm_vars = (void *) (uintptr_t) true;
 #endif
@@ -648,20 +642,20 @@ void IOService::PMstop( void )
 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);
@@ -684,7 +678,7 @@ void IOService::handlePMstop( IOPMRequest * request )
 
     // detach IOConnections
     detachAbove( gIOPowerPlane );
-    
+
     // no more power state changes
     fParentsKnowState = false;
 
@@ -720,8 +714,8 @@ void IOService::handlePMstop( IOPMRequest * request )
 
     if ( fInterestedDrivers )
     {
-        IOPMinformeeList *	list = fInterestedDrivers;
-        IOPMinformee *		item;
+        IOPMinformeeList *  list = fInterestedDrivers;
+        IOPMinformee *      item;
 
         PM_LOCK();
         while ((item = list->firstInList()))
@@ -749,104 +743,104 @@ void IOService::handlePMstop( IOPMRequest * request )
 
 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?
-
-		iter = child->getParentIterator( gIOPowerPlane );
-		if ( iter )
-		{
-			IORegistryEntry *	entry;
-			OSObject *			next;
-
-			while ((next = iter->getNextObject()))
-			{
-				if ((entry = OSDynamicCast(IORegistryEntry, next)) &&
-					isChild(entry, gIOPowerPlane))
-				{
-					ok = false;
-					break;
-				}			
-			}
-			iter->release();
-		}
-		if (!ok)
-		{
-			PM_LOG("%s: %s (%p) is already a child\n",
-				getName(), child->getName(), OBFUSCATE(child));
-			break;
-		}
-
-		// Add the child to the power plane immediately, but the
-		// joining connection is marked as not ready.
-		// We want the child to appear in the power plane before
-		// returning to the caller, but don't want the caller to
-		// block on the PM work loop.
-
-		connection = new IOPowerConnection;
-		if (!connection)
-			break;
-
-		// Create a chain of PM requests to perform the bottom-half
-		// work from the PM work loop.
-
-		requests[0] = acquirePMRequest(
-					/* target */ this,
-					/* type */   kIOPMRequestTypeAddPowerChild1 );
-
-		requests[1] = acquirePMRequest(
-					/* target */ child,
-					/* type */   kIOPMRequestTypeAddPowerChild2 );
-
-		requests[2] = acquirePMRequest(
-					/* target */ this,
-					/* type */   kIOPMRequestTypeAddPowerChild3 );
-
-		if (!requests[0] || !requests[1] || !requests[2])
-			break;
-
-		requests[0]->attachNextRequest( requests[1] );
-		requests[1]->attachNextRequest( requests[2] );
-
-		connection->init();
-		connection->start(this);
-		connection->setAwaitingAck(false);
-		connection->setReadyFlag(false);
-
-		attachToChild( connection, gIOPowerPlane );
-		connection->attachToChild( child, gIOPowerPlane );
-
-		// connection needs to be released
-		requests[0]->fArg0 = connection;
-		requests[1]->fArg0 = connection;
-		requests[2]->fArg0 = connection;
-
-		submitPMRequest( 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]);
-
-	// Silent failure, to prevent platform drivers from adding the child
-	// to the root domain.
-
-	return kIOReturnSuccess;
+    do {
+        // Is this child already one of our children?
+
+        iter = child->getParentIterator( gIOPowerPlane );
+        if ( iter )
+        {
+            IORegistryEntry *   entry;
+            OSObject *          next;
+
+            while ((next = iter->getNextObject()))
+            {
+                if ((entry = OSDynamicCast(IORegistryEntry, next)) &&
+                    isChild(entry, gIOPowerPlane))
+                {
+                    ok = false;
+                    break;
+                }
+            }
+            iter->release();
+        }
+        if (!ok)
+        {
+            PM_LOG("%s: %s (%p) is already a child\n",
+                getName(), child->getName(), OBFUSCATE(child));
+            break;
+        }
+
+        // Add the child to the power plane immediately, but the
+        // joining connection is marked as not ready.
+        // We want the child to appear in the power plane before
+        // returning to the caller, but don't want the caller to
+        // block on the PM work loop.
+
+        connection = new IOPowerConnection;
+        if (!connection)
+            break;
+
+        // Create a chain of PM requests to perform the bottom-half
+        // work from the PM work loop.
+
+        requests[0] = acquirePMRequest(
+                    /* target */ this,
+                    /* type */   kIOPMRequestTypeAddPowerChild1 );
+
+        requests[1] = acquirePMRequest(
+                    /* target */ child,
+                    /* type */   kIOPMRequestTypeAddPowerChild2 );
+
+        requests[2] = acquirePMRequest(
+                    /* target */ this,
+                    /* type */   kIOPMRequestTypeAddPowerChild3 );
+
+        if (!requests[0] || !requests[1] || !requests[2])
+            break;
+
+        requests[0]->attachNextRequest( requests[1] );
+        requests[1]->attachNextRequest( requests[2] );
+
+        connection->init();
+        connection->start(this);
+        connection->setAwaitingAck(false);
+        connection->setReadyFlag(false);
+
+        attachToChild( connection, gIOPowerPlane );
+        connection->attachToChild( child, gIOPowerPlane );
+
+        // connection needs to be released
+        requests[0]->fArg0 = connection;
+        requests[1]->fArg0 = connection;
+        requests[2]->fArg0 = connection;
+
+        submitPMRequest( 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]);
+
+    // Silent failure, to prevent platform drivers from adding the child
+    // to the root domain.
+
+    return kIOReturnSuccess;
 }
 
 //*********************************************************************************
@@ -857,23 +851,23 @@ IOReturn IOService::addPowerChild( IOService * child )
 
 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);
+    }
 }
 
 //*********************************************************************************
@@ -885,40 +879,40 @@ void IOService::addPowerChild1( IOPMRequest * request )
 
 void IOService::addPowerChild2( IOPMRequest * request )
 {
-	IOPowerConnection * connection = (IOPowerConnection *) request->fArg0;
-	IOService *         parent;
-	IOPMPowerFlags		powerFlags;
-	bool				knowsState;
-	unsigned long		powerState;
-	unsigned long		tempDesire;
+    IOPowerConnection * connection = (IOPowerConnection *) request->fArg0;
+    IOService *         parent;
+    IOPMPowerFlags      powerFlags;
+    bool                knowsState;
+    unsigned long       powerState;
+    unsigned long       tempDesire;
 
-	PM_ASSERT_IN_GATE();
-	parent = (IOService *) connection->getParentEntry(gIOPowerPlane);
+    PM_ASSERT_IN_GATE();
+    parent = (IOService *) connection->getParentEntry(gIOPowerPlane);
 
-	if (!parent || !inPlane(gIOPowerPlane))
-	{
-		PM_LOG("%s: addPowerChild2 not in power plane\n", getName());
-		return;
-	}
+    if (!parent || !inPlane(gIOPowerPlane))
+    {
+        PM_LOG("%s: addPowerChild2 not in power plane\n", getName());
+        return;
+    }
 
-	// Parent will be waiting for us to complete this stage.
-	// It is safe to directly access parent's vars.
+    // Parent will be waiting for us to complete this stage.
+    // It is safe to directly access parent's vars.
 
-	knowsState = (parent->fPowerStates) && (parent->fParentsKnowState);
-	powerState = parent->fCurrentPowerState;
+    knowsState = (parent->fPowerStates) && (parent->fParentsKnowState);
+    powerState = parent->fCurrentPowerState;
 
-	if (knowsState)
-		powerFlags = parent->fPowerStates[powerState].outputPowerFlags;
-	else
-		powerFlags = 0;
+    if (knowsState)
+        powerFlags = parent->fPowerStates[powerState].outputPowerFlags;
+    else
+        powerFlags = 0;
 
-	// Set our power parent.
+    // Set our power parent.
 
     OUR_PMLog(kPMLogSetParent, knowsState, powerFlags);
 
-	setParentInfo( powerFlags, connection, knowsState );
+    setParentInfo( powerFlags, connection, knowsState );
 
-	connection->setReadyFlag(true);
+    connection->setReadyFlag(true);
 
     if ( fControllingDriver && fParentsKnowState )
     {
@@ -941,30 +935,30 @@ void IOService::addPowerChild2( IOPMRequest * request )
 
 void IOService::addPowerChild3( IOPMRequest * request )
 {
-	IOPowerConnection * connection = (IOPowerConnection *) request->fArg0;
-	IOService *         child;
+    IOPowerConnection * connection = (IOPowerConnection *) request->fArg0;
+    IOService *         child;
     IOPMrootDomain *    rootDomain = getPMRootDomain();
 
-	PM_ASSERT_IN_GATE();
-	child = (IOService *) connection->getChildEntry(gIOPowerPlane);
+    PM_ASSERT_IN_GATE();
+    child = (IOService *) connection->getChildEntry(gIOPowerPlane);
 
-	if (child && inPlane(gIOPowerPlane))
-	{
-		if ((this != rootDomain) && child->getProperty("IOPMStrictTreeOrder"))
-		{
-			PM_LOG1("%s: strict PM order enforced\n", getName());
-			fStrictTreeOrder = true;
-		}
+    if (child && inPlane(gIOPowerPlane))
+    {
+        if ((this != rootDomain) && child->getProperty("IOPMStrictTreeOrder"))
+        {
+            PM_LOG1("%s: strict PM order enforced\n", getName());
+            fStrictTreeOrder = true;
+        }
 
         if (rootDomain)
             rootDomain->joinAggressiveness( child );
-	}
-	else
-	{
-		PM_LOG("%s: addPowerChild3 not in power plane\n", getName());
-	}
+    }
+    else
+    {
+        PM_LOG("%s: addPowerChild3 not in power plane\n", getName());
+    }
 
-	connection->release();
+    connection->release();
 }
 
 #ifndef __LP64__
@@ -978,9 +972,9 @@ void IOService::addPowerChild3( IOPMRequest * request )
 //*********************************************************************************
 
 IOReturn IOService::setPowerParent(
-	IOPowerConnection * theParent, bool stateKnown, IOPMPowerFlags powerFlags )
+    IOPowerConnection * theParent, bool stateKnown, IOPMPowerFlags powerFlags )
 {
-	return kIOReturnUnsupported;
+    return kIOReturnUnsupported;
 }
 #endif /* !__LP64__ */
 
@@ -992,15 +986,15 @@ IOReturn IOService::setPowerParent(
 
 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);
@@ -1011,41 +1005,41 @@ IOReturn IOService::removePowerChild( IOPowerConnection * theNub )
 
     // Are we awaiting an ack from this child?
     if ( theNub->getAwaitingAck() )
-	{
-		// yes, pretend we got one
-		theNub->setAwaitingAck(false);
-		if (fHeadNotePendingAcks != 0 )
-		{
-			// that's one fewer ack to worry about
-			fHeadNotePendingAcks--;
-
-			// is that the last?
-			if ( fHeadNotePendingAcks == 0 )
-			{
-				stop_ack_timer();
-
-				// Request unblocked, work queue
-				// should re-scan all busy requests.
-				gIOPMWorkQueue->incrementProducerCount();
-			}
-		}
-	}
-
-	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;
-		}
-	}
+    {
+        // 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();
+            }
+        }
+    }
+
+    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;
 }
@@ -1057,43 +1051,43 @@ IOReturn IOService::removePowerChild( IOPowerConnection * theNub )
 //*********************************************************************************
 
 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
@@ -1132,27 +1126,27 @@ IOReturn IOService::registerPowerDriver(
         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;
 }
 
 //*********************************************************************************
@@ -1161,39 +1155,39 @@ IOReturn IOService::registerPowerDriver(
 
 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);
@@ -1203,34 +1197,34 @@ void IOService::handleRegisterPowerDriver( IOPMRequest * request )
                 // The minimum power state that the device is usable
                 fDeviceUsablePowerState = stateIndex;
             }
-		}
-        
-		// Register powerDriver as interested, unless already done.
-		// We don't want to register the default implementation since
-		// it does nothing. One ramification of not always registering
-		// is the one fewer retain count held.
-
-		root = getPlatform()->getProvider();
-		assert(root);
-		if (!root ||
-			((OSMemberFunctionCast(void (*)(void),
-				root, &IOService::powerStateDidChangeTo)) !=
-			((OSMemberFunctionCast(void (*)(void),
-				this, &IOService::powerStateDidChangeTo)))) ||
-			((OSMemberFunctionCast(void (*)(void),
-				root, &IOService::powerStateWillChangeTo)) !=
-			((OSMemberFunctionCast(void (*)(void),
-				this, &IOService::powerStateWillChangeTo)))))
-		{		
-			if (fInterestedDrivers->findItem(powerDriver) == NULL)
-			{
-				PM_LOCK();
-				fInterestedDrivers->appendNewInformee(powerDriver);
-				PM_UNLOCK();
-			}
-		}
-
-		// Examine all existing power clients and perform limit check.
+        }
+
+        // Register powerDriver as interested, unless already done.
+        // We don't want to register the default implementation since
+        // it does nothing. One ramification of not always registering
+        // is the one fewer retain count held.
+
+        root = getPlatform()->getProvider();
+        assert(root);
+        if (!root ||
+            ((OSMemberFunctionCast(void (*)(void),
+                root, &IOService::powerStateDidChangeTo)) !=
+            ((OSMemberFunctionCast(void (*)(void),
+                this, &IOService::powerStateDidChangeTo)))) ||
+            ((OSMemberFunctionCast(void (*)(void),
+                root, &IOService::powerStateWillChangeTo)) !=
+            ((OSMemberFunctionCast(void (*)(void),
+                this, &IOService::powerStateWillChangeTo)))))
+        {
+            if (fInterestedDrivers->findItem(powerDriver) == NULL)
+            {
+                PM_LOCK();
+                fInterestedDrivers->appendNewInformee(powerDriver);
+                PM_UNLOCK();
+            }
+        }
+
+        // Examine all existing power clients and perform limit check.
 
         if (fPowerClients &&
             (iter = OSCollectionIterator::withCollection(fPowerClients)))
@@ -1247,22 +1241,22 @@ void IOService::handleRegisterPowerDriver( IOPMRequest * request )
             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();
 }
 
 //*********************************************************************************
@@ -1276,8 +1270,8 @@ void IOService::handleRegisterPowerDriver( IOPMRequest * request )
 
 IOPMPowerFlags IOService::registerInterestedDriver( IOService * driver )
 {
-    IOPMRequest *	request;
-    bool			signal;
+    IOPMRequest *   request;
+    bool            signal;
 
     if (!driver || !initialized || !fInterestedDrivers)
         return 0;
@@ -1305,7 +1299,7 @@ IOPMPowerFlags IOService::registerInterestedDriver( IOService * driver )
     // for those clients that care.
 
     OUR_PMLog(kPMLogInterestedDriver, kIOPMDeviceUsable, 2);
-    return kIOPMDeviceUsable;	
+    return kIOPMDeviceUsable;
 }
 
 //*********************************************************************************
@@ -1314,8 +1308,8 @@ IOPMPowerFlags IOService::registerInterestedDriver( IOService * driver )
 
 IOReturn IOService::deRegisterInterestedDriver( IOService * driver )
 {
-    IOPMinformeeList *	list;
-    IOPMinformee *		item;
+    IOPMinformeeList *  list;
+    IOPMinformee *      item;
     IOPMRequest *       request;
     bool                signal;
 
@@ -1362,9 +1356,9 @@ IOReturn IOService::deRegisterInterestedDriver( IOService * driver )
 
 void IOService::handleInterestChanged( IOPMRequest * request )
 {
-    IOService *			driver;
-    IOPMinformee *		informee;
-    IOPMinformeeList *	list = fInterestedDrivers;
+    IOService *         driver;
+    IOPMinformee *      informee;
+    IOPMinformeeList *  list = fInterestedDrivers;
 
     PM_LOCK();
 
@@ -1422,21 +1416,21 @@ void IOService::handleInterestChanged( IOPMRequest * request )
 
 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;
 }
 
@@ -1446,24 +1440,24 @@ IOReturn IOService::acknowledgePowerChange( IOService * whichObject )
 
 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);
         }
@@ -1486,26 +1480,11 @@ bool IOService::handleAcknowledgePowerChange( IOPMRequest * request )
                 if (informee->timer > 0)
                 {
                     uint64_t nsec = computeTimeDeltaNS(&informee->startTime);
-                    if (nsec > LOG_SETPOWER_TIMES)
-                        PM_LOG("%s::powerState%sChangeTo(%p, %s, %lu -> %lu) async took %d ms\n",
-                            informee->whatObject->getName(),
-                            (fDriverCallReason == kDriverCallInformPreChange) ? "Will" : "Did",
-                            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
@@ -1540,21 +1519,21 @@ bool IOService::handleAcknowledgePowerChange( IOPMRequest * request )
                     }
                 }
             }
-	    }
-
-		if ( fHeadNotePendingAcks == 0 ) {
-			// yes, stop the timer
-			stop_ack_timer();
-			// and now we can continue
-			all_acked = true;
-		}
+        }
+
+        if ( fHeadNotePendingAcks == 0 ) {
+            // yes, stop the timer
+            stop_ack_timer();
+            // and now we can continue
+            all_acked = true;
+        }
     } else {
-        OUR_PMLog(kPMLogAcknowledgeErr3, 0, 0);	// not expecting anybody to ack
+        OUR_PMLog(kPMLogAcknowledgeErr3, 0, 0); // not expecting anybody to ack
     }
 
 no_err:
-	if (whichObject)
-		whichObject->release();
+    if (whichObject)
+        whichObject->release();
 
     return all_acked;
 }
@@ -1569,17 +1548,17 @@ no_err:
 
 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;
 }
 
 //*********************************************************************************
@@ -1588,10 +1567,10 @@ IOReturn IOService::acknowledgeSetPowerState( void )
 
 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
@@ -1601,13 +1580,13 @@ void IOService::adjustPowerState( uint32_t clamp )
         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);
+    }
 }
 
 //*********************************************************************************
@@ -1618,13 +1597,13 @@ IOReturn IOService::synchronizePowerTree(
     IOOptionBits    options,
     IOService *     notifyRoot )
 {
-	IOPMRequest *   request_c = 0;
+    IOPMRequest *   request_c = 0;
     IOPMRequest *   request_s;
 
     if (this != getPMRootDomain())
         return kIOReturnBadArgument;
-	if (!initialized)
-		return kIOPMNotYetInitialized;
+    if (!initialized)
+        return kIOPMNotYetInitialized;
 
     OUR_PMLog(kPMLogCSynchronizePowerTree, options, (notifyRoot != 0));
 
@@ -1634,7 +1613,7 @@ IOReturn IOService::synchronizePowerTree(
 
         // Cancels don't need to be synchronized.
         nr = acquirePMRequest(notifyRoot, kIOPMRequestTypeChildNotifyDelayCancel);
-        if (nr) submitPMRequest(nr);        
+        if (nr) submitPMRequest(nr);
         nr = acquirePMRequest(getPMRootDomain(), kIOPMRequestTypeChildNotifyDelayCancel);
         if (nr) submitPMRequest(nr);
     }
@@ -1650,15 +1629,15 @@ IOReturn IOService::synchronizePowerTree(
         request_c->attachNextRequest( request_s );
         submitPMRequest(request_c);
     }
-    
+
     request_s->fArg0 = (void *)(uintptr_t) options;
     submitPMRequest(request_s);
 
     return kIOReturnSuccess;
 
 error_no_memory:
-	if (request_c) releasePMRequest(request_c);
-	if (request_s) releasePMRequest(request_s);
+    if (request_c) releasePMRequest(request_c);
+    if (request_s) releasePMRequest(request_s);
     return kIOReturnNoMemory;
 }
 
@@ -1668,20 +1647,20 @@ error_no_memory:
 
 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__
@@ -1696,11 +1675,11 @@ void IOService::handleSynchronizePowerTree( IOPMRequest * request )
 //*********************************************************************************
 
 IOReturn IOService::powerDomainWillChangeTo(
-	IOPMPowerFlags		newPowerFlags,
-	IOPowerConnection *	whichParent )
+    IOPMPowerFlags      newPowerFlags,
+    IOPowerConnection * whichParent )
 {
-	assert(false);
-	return kIOReturnUnsupported;
+    assert(false);
+    return kIOReturnUnsupported;
 }
 #endif /* !__LP64__ */
 
@@ -1710,32 +1689,32 @@ IOReturn IOService::powerDomainWillChangeTo(
 
 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 )
@@ -1758,49 +1737,49 @@ void IOService::handlePowerDomainWillChangeTo( IOPMRequest * request )
 
     if ( fControllingDriver && !fInitialPowerChange )
     {
-		maxPowerState = fControllingDriver->maxCapabilityForDomainState(
-							combinedPowerFlags);
+        maxPowerState = fControllingDriver->maxCapabilityForDomainState(
+                            combinedPowerFlags);
 
         // 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().
@@ -1819,11 +1798,11 @@ exit_no_ack:
 //*********************************************************************************
 
 IOReturn IOService::powerDomainDidChangeTo(
-	IOPMPowerFlags		newPowerFlags,
-	IOPowerConnection *	whichParent )
+    IOPMPowerFlags      newPowerFlags,
+    IOPowerConnection * whichParent )
 {
-	assert(false);
-	return kIOReturnUnsupported;
+    assert(false);
+    return kIOReturnUnsupported;
 }
 #endif /* !__LP64__ */
 
@@ -1833,34 +1812,34 @@ IOReturn IOService::powerDomainDidChangeTo(
 
 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 (fInitialPowerChange)
         {
@@ -1913,40 +1892,41 @@ void IOService::handlePowerDomainDidChangeTo( IOPMRequest * request )
         myChangeFlags = kIOPMParentInitiated | kIOPMDomainDidChange |
                         (parentChangeFlags & kIOPMRootBroadcastFlags);
 
-		result = startPowerChange(
-				 /* flags        */	myChangeFlags,
-                 /* power state  */	maxPowerState,
-				 /* domain flags */	fParentsCurrentPowerFlags,
-				 /* connection   */	whichParent,
-				 /* parent flags */	0);
-	}
-
-	// Parent is expecting an ACK from us. If we did not embark on a state
-	// transition, i.e. startPowerChange() returned IOPMAckImplied. We are
-	// still required to issue an ACK to our parent.
-
-	if (IOPMAckImplied == result)
-	{
-		IOService * parent;
-		parent = (IOService *) whichParent->copyParentEntry(gIOPowerPlane);
-		assert(parent);
-		if ( parent )
-		{
-			parent->acknowledgePowerChange( whichParent );
-			parent->release();
-		}
-	}
-
-	// If the parent registers its power driver late, then this is the
-	// first opportunity to tell our parent about our desire. Or if the
+        result = startPowerChange(
+                 /* flags        */ myChangeFlags,
+                 /* power state  */ maxPowerState,
+                 /* domain flags */ fParentsCurrentPowerFlags,
+                 /* connection   */ whichParent,
+                 /* parent flags */ 0);
+    }
+
+    // Parent is expecting an ACK from us. If we did not embark on a state
+    // transition, i.e. startPowerChange() returned IOPMAckImplied. We are
+    // still required to issue an ACK to our parent.
+
+    if (IOPMAckImplied == result)
+    {
+        IOService * parent;
+        parent = (IOService *) whichParent->copyParentEntry(gIOPowerPlane);
+        assert(parent);
+        if ( parent )
+        {
+            parent->acknowledgePowerChange( whichParent );
+            parent->release();
+        }
+    }
+
+    // If the parent registers its power driver late, then this is the
+    // first opportunity to tell our parent about our desire. Or if the
     // child's desire changed during a parent change notify.
 
-	if ((!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().
@@ -1959,22 +1939,22 @@ exit_no_ack:
 // 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;
@@ -2017,12 +1997,11 @@ void IOService::trackSystemSleepPreventers(
 
     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;
 
@@ -2033,12 +2012,10 @@ void IOService::trackSystemSleepPreventers(
             }
         }
 #endif
-    
     }
 
     if ((oldCapability ^ newCapability) & kIOPMPreventSystemSleep)
     {
-        
         getPMRootDomain()->updatePreventSystemSleepList(this,
             ((oldCapability & kIOPMPreventSystemSleep) == 0));
     }
@@ -2053,45 +2030,45 @@ void IOService::trackSystemSleepPreventers(
 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:
@@ -2114,25 +2091,25 @@ IOReturn IOService::requestPowerDomainState(
                 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;
 
@@ -2169,24 +2146,24 @@ IOReturn IOService::requestPowerDomainState(
     }
 #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;
@@ -2230,8 +2207,8 @@ IOReturn IOService::makeUsable( void )
 
 IOPMPowerFlags IOService::currentCapability( void )
 {
-	if (!initialized)
-		return IOPMNotPowerManaged;
+    if (!initialized)
+        return IOPMNotPowerManaged;
 
     return fCurrentCapabilityFlags;
 }
@@ -2276,16 +2253,16 @@ IOReturn IOService::changePowerStateToPriv( unsigned long ordinal )
 IOReturn IOService::changePowerStateWithOverrideTo( IOPMPowerStateIndex ordinal,
                                                     IOPMRequestTag tag )
 {
-	IOPMRequest * request;
+    IOPMRequest * request;
 
-	if (!initialized)
-		return kIOPMNotYetInitialized;
+    if (!initialized)
+        return kIOPMNotYetInitialized;
 
     OUR_PMLog(kPMLogChangeStateToPriv, ordinal, 0);
 
-	request = acquirePMRequest( this, kIOPMRequestTypeRequestPowerStateOverride );
-	if (!request)
-		return kIOReturnNoMemory;
+    request = acquirePMRequest( this, kIOPMRequestTypeRequestPowerStateOverride );
+    if (!request)
+        return kIOReturnNoMemory;
 
     gIOPMPowerClientDevice->retain();
     request->fRequestTag = tag;
@@ -2297,18 +2274,18 @@ IOReturn IOService::changePowerStateWithOverrideTo( IOPMPowerStateIndex ordinal,
         request->installCompletionAction( action, target, param );
 #endif
 
-	// Prevent needless downwards power transitions by clamping power
-	// until the scheduled request is executed.
+    // Prevent needless downwards power transitions by clamping power
+    // until the scheduled request is executed.
 
-	if (gIOPMWorkLoop->inGate() && (ordinal < fNumberOfPowerStates))
-	{
-		fTempClampPowerState = 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;
 }
 
@@ -2332,16 +2309,16 @@ IOReturn IOService::requestPowerState(
     const OSSymbol *      client,
     uint32_t              state )
 {
-	IOPMRequest * request;
+    IOPMRequest * request;
 
     if (!client)
         return kIOReturnBadArgument;
-	if (!initialized)
-		return kIOPMNotYetInitialized;
+    if (!initialized)
+        return kIOPMNotYetInitialized;
 
-	request = acquirePMRequest( this, kIOPMRequestTypeRequestPowerState );
-	if (!request)
-		return kIOReturnNoMemory;
+    request = acquirePMRequest( this, kIOPMRequestTypeRequestPowerState );
+    if (!request)
+        return kIOReturnNoMemory;
 
     client->retain();
     request->fArg0 = (void *)(uintptr_t) state;
@@ -2352,17 +2329,17 @@ IOReturn IOService::requestPowerState(
         request->installCompletionAction( action, target, param );
 #endif
 
-	// Prevent needless downwards power transitions by clamping power
-	// until the scheduled request is executed.
+    // Prevent needless downwards power transitions by clamping power
+    // until the scheduled request is executed.
 
-	if (gIOPMWorkLoop->inGate() && (state < fNumberOfPowerStates))
-	{
-		fTempClampPowerState = StateMax(fTempClampPowerState, state);
-		fTempClampCount++;
-		request->fArg2 = (void *) (uintptr_t) true;
-	}
+    if (gIOPMWorkLoop->inGate() && (state < fNumberOfPowerStates))
+    {
+        fTempClampPowerState = StateMax(fTempClampPowerState, state);
+        fTempClampCount++;
+        request->fArg2 = (void *) (uintptr_t) true;
+    }
 
-	submitPMRequest( request );
+    submitPMRequest( request );
     return IOPMNoErr;
 }
 
@@ -2375,16 +2352,16 @@ void IOService::handleRequestPowerState( IOPMRequest * request )
     const OSSymbol * client = (const OSSymbol *)    request->fArg1;
     uint32_t         state  = (uint32_t)(uintptr_t) request->fArg0;
 
-	PM_ASSERT_IN_GATE();
-	if (request->fArg2)
-	{
-		assert(fTempClampCount != 0);
-		if (fTempClampCount)  fTempClampCount--;
-		if (!fTempClampCount) fTempClampPowerState = 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().
@@ -2394,14 +2371,14 @@ void IOService::handleRequestPowerState( IOPMRequest * request )
         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();
 }
 
@@ -2461,22 +2438,22 @@ uint32_t IOService::getPowerStateForClient( const OSSymbol * client )
 
 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;
 }
 
@@ -2486,22 +2463,22 @@ IOReturn IOService::powerOverrideOnPriv( void )
 
 IOReturn IOService::powerOverrideOffPriv( void )
 {
-	IOPMRequest * request;
+    IOPMRequest * request;
 
     if (!initialized)
-		return IOPMNotYetInitialized;
+        return IOPMNotYetInitialized;
 
-	if (gIOPMWorkLoop->inGate())
-	{
-		fDeviceOverrideEnabled = false;
-		return IOPMNoErr;
-	}
+    if (gIOPMWorkLoop->inGate())
+    {
+        fDeviceOverrideEnabled = false;
+        return IOPMNoErr;
+    }
 
-	request = acquirePMRequest( this, kIOPMRequestTypePowerOverrideOffPriv );
-	if (!request)
-		return kIOReturnNoMemory;
+    request = acquirePMRequest( this, kIOPMRequestTypePowerOverrideOffPriv );
+    if (!request)
+        return kIOReturnNoMemory;
 
-	submitPMRequest( request );
+    submitPMRequest( request );
     return IOPMNoErr;
 }
 
@@ -2511,19 +2488,19 @@ IOReturn IOService::powerOverrideOffPriv( void )
 
 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();
 }
 
 //*********************************************************************************
@@ -2532,20 +2509,20 @@ void IOService::handlePowerOverrideChanged( IOPMRequest * request )
 
 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.
 
@@ -2582,14 +2559,14 @@ void IOService::computeDesiredState( unsigned long localClamp, bool computeOnly
         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;
 
@@ -2599,9 +2576,9 @@ void IOService::computeDesiredState( unsigned long localClamp, bool computeOnly
                 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);
 
@@ -2629,7 +2606,7 @@ void IOService::computeDesiredState( unsigned long localClamp, bool computeOnly
 
     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)
     {
@@ -2677,7 +2654,7 @@ unsigned long IOService::currentPowerConsumption( void )
 
 IOWorkLoop * IOService::getPMworkloop( void )
 {
-	return gIOPMWorkLoop;
+    return gIOPMWorkLoop;
 }
 
 #if NOT_YET
@@ -2687,13 +2664,13 @@ IOWorkLoop * IOService::getPMworkloop( void )
 //*********************************************************************************
 
 static void
-applyToPowerChildren( 
+applyToPowerChildren(
     IOService *               service,
     IOServiceApplierFunction  applier,
     void *                    context,
     IOOptionBits              options )
 {
-	PM_ASSERT_IN_GATE();
+    PM_ASSERT_IN_GATE();
 
     IORegistryEntry *       entry;
     IORegistryIterator *    iter;
@@ -2721,13 +2698,13 @@ applyToPowerChildren(
 }
 
 static void
-applyToPowerParent( 
+applyToPowerParent(
     IOService *               service,
     IOServiceApplierFunction  applier,
     void *                    context,
     IOOptionBits              options )
 {
-	PM_ASSERT_IN_GATE();
+    PM_ASSERT_IN_GATE();
 
     IORegistryEntry *       entry;
     IORegistryIterator *    iter;
@@ -2777,18 +2754,18 @@ void IOService::setAdvisoryTickleEnable( bool enable )
 
 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++;
@@ -2796,29 +2773,29 @@ bool IOService::activityTickle( unsigned long type, unsigned long stateNumber )
 
         PM_ACTION_0(actionActivityTickle);
 
-		// Record the last tickle power state.
-		// This helps to filter out redundant tickles as
-		// this function may be called from the data path.
+        // Record the last tickle power state.
+        // This helps to filter out redundant tickles as
+        // this function may be called from the data path.
 
         if ((fActivityTicklePowerState == 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))
@@ -2827,27 +2804,27 @@ bool IOService::activityTickle( unsigned long type, unsigned long stateNumber )
 
         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;
 }
@@ -2858,12 +2835,12 @@ bool IOService::activityTickle( unsigned long type, unsigned long stateNumber )
 
 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
@@ -2879,6 +2856,7 @@ void IOService::handleActivityTickle( IOPMRequest * request )
     if (tickleFlags & kTickleTypeActivity)
     {
         IOPMPowerStateIndex deviceDesireOrder = StateOrder(fDeviceDesire);
+        uint32_t idleTimerGeneration = ticklePowerState; // kTickleTypePowerDrop
 
         if (tickleFlags & kTickleTypePowerRise)
         {
@@ -2890,7 +2868,8 @@ void IOService::handleActivityTickle( IOPMRequest * request )
                 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.
@@ -2898,7 +2877,7 @@ void IOService::handleActivityTickle( IOPMRequest * request )
             // 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)
             {
@@ -2935,10 +2914,10 @@ void IOService::handleActivityTickle( IOPMRequest * request )
         }
     }
 
-	if (adjustPower)
-	{
-		adjustPowerState();
-	}
+    if (adjustPower)
+    {
+        adjustPowerState();
+    }
 }
 
 //******************************************************************************
@@ -2951,7 +2930,7 @@ void IOService::handleActivityTickle( IOPMRequest * request )
 IOReturn IOService::setIdleTimerPeriod( unsigned long period )
 {
     if (!initialized)
-		return IOPMNotYetInitialized;
+        return IOPMNotYetInitialized;
 
     OUR_PMLog(kPMLogSetIdleTimerPeriod, period, fIdleTimerPeriod);
 
@@ -2969,7 +2948,7 @@ IOReturn IOService::setIdleTimerPeriod( unsigned long period )
 IOReturn IOService::setIgnoreIdleTimer( bool ignore )
 {
     if (!initialized)
-		return IOPMNotYetInitialized;
+        return IOPMNotYetInitialized;
 
     OUR_PMLog(kIOPMRequestTypeIgnoreIdleTimer, ignore, 0);
 
@@ -2993,7 +2972,7 @@ IOReturn IOService::setIgnoreIdleTimer( bool ignore )
 
 SInt32 IOService::nextIdleTimeout(
     AbsoluteTime currentTime,
-    AbsoluteTime lastActivity, 
+    AbsoluteTime lastActivity,
     unsigned int powerState)
 {
     AbsoluteTime        delta;
@@ -3004,7 +2983,7 @@ SInt32 IOService::nextIdleTimeout(
     // Calculate time difference using funky macro from clock.h.
     delta = currentTime;
     SUB_ABSOLUTETIME(&delta, &lastActivity);
-    
+
     // Figure it in seconds.
     absolutetime_to_nanoseconds(delta, &delta_ns);
     delta_secs = (SInt32)(delta_ns / NSEC_PER_SEC);
@@ -3014,7 +2993,7 @@ SInt32 IOService::nextIdleTimeout(
         delay_secs = (int) fIdleTimerPeriod - delta_secs;
     else
         delay_secs = (int) fIdleTimerPeriod;
-    
+
     return (SInt32)delay_secs;
 }
 
@@ -3028,10 +3007,10 @@ void IOService::start_PM_idle_timer( void )
     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);
 
@@ -3053,6 +3032,9 @@ void IOService::start_PM_idle_timer( void )
 
     IOLockUnlock(fActivityLock);
 
+    fNextIdleTimerPeriod = idle_in;
+    fIdleTimerStartTime = uptime;
+
     retain();
     clock_interval_to_absolutetime_interval(idle_in, kSecondScale, &deadline);
     ADD_ABSOLUTETIME(&deadline, &uptime);
@@ -3070,7 +3052,6 @@ void IOService::restartIdleTimer( void )
     {
         fIdleTimerStopped = false;
         fActivityTickleCount = 0;
-        clock_get_uptime(&fIdleTimerStartTime);
         start_PM_idle_timer();
     }
     else if (fHasAdvisoryDesire)
@@ -3092,15 +3073,15 @@ static void
 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();
 }
 
 //*********************************************************************************
@@ -3113,48 +3094,50 @@ idle_timer_expired(
 
 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;
 
-	// Check for device activity (tickles) over last timer period.
+    IOLockLock(fActivityLock);
 
-	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()
+    // Check for device activity (tickles) over last timer period.
+
+    if (fDeviceWasActive)
+    {
+        // Device was active - do not drop power, restart timer.
+        fDeviceWasActive = false;
+    }
+    else if (!fIdleTimerIgnored)
+    {
+        // No device activity - drop power state by one level.
+        // Decrement the cached tickle power state when possible.
+        // This value may be kInvalidTicklePowerState before activityTickle()
         // is called, but the power drop request must be issued regardless.
 
-		if ((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)
@@ -3167,25 +3150,25 @@ void IOService::idleTimerExpired( void )
         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__
@@ -3230,7 +3213,7 @@ IOReturn IOService::getAggressiveness( unsigned long type, unsigned long * curre
 
     if (!rootDomain)
         return kIOReturnNotReady;
-    
+
     return rootDomain->getAggressiveness( type, currentLevel );
 }
 
@@ -3257,10 +3240,10 @@ UInt32 IOService::getPowerState( void )
 
 IOReturn IOService::systemWake( void )
 {
-    OSIterator *		iter;
-    OSObject *			next;
-    IOPowerConnection *	connection;
-    IOService *			theChild;
+    OSIterator *        iter;
+    OSObject *          next;
+    IOPowerConnection * connection;
+    IOService *         theChild;
 
     iter = getChildIterator(gIOPowerPlane);
     if ( iter )
@@ -3269,17 +3252,17 @@ IOReturn IOService::systemWake( void )
         {
             if ( (connection = OSDynamicCast(IOPowerConnection, next)) )
             {
-				if (connection->getReadyFlag() == false)
-				{
-					PM_LOG3("[%s] %s: connection not ready\n",
-						getName(), __FUNCTION__);
-					continue;
-				}
+                if (connection->getReadyFlag() == false)
+                {
+                    PM_LOG3("[%s] %s: connection not ready\n",
+                        getName(), __FUNCTION__);
+                    continue;
+                }
 
                 theChild = (IOService *)connection->copyChildEntry(gIOPowerPlane);
                 if ( theChild )
                 {
-                	theChild->systemWake();
+                    theChild->systemWake();
                     theChild->release();
                 }
             }
@@ -3304,9 +3287,9 @@ IOReturn IOService::systemWake( void )
 
 IOReturn IOService::temperatureCriticalForZone( IOService * whichZone )
 {
-    IOService *	theParent;
-    IOService *	theNub;
-    
+    IOService * theParent;
+    IOService * theNub;
+
     OUR_PMLog(kPMLogCriticalTemp, 0, 0);
 
     if ( inPlane(gIOPowerPlane) && !IS_PM_ROOT )
@@ -3343,8 +3326,8 @@ IOReturn IOService::startPowerChange(
     IOPowerConnection *     parentConnection,
     IOPMPowerFlags          parentFlags )
 {
-	PM_ASSERT_IN_GATE();
-	assert( fMachineState == kIOPM_Finished );
+    PM_ASSERT_IN_GATE();
+    assert( fMachineState == kIOPM_Finished );
     assert( powerState < fNumberOfPowerStates );
 
     if (powerState >= fNumberOfPowerStates)
@@ -3361,7 +3344,7 @@ IOReturn IOService::startPowerChange(
             // 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;
@@ -3378,29 +3361,29 @@ IOReturn IOService::startPowerChange(
     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();
+    }
 }
 
 //*********************************************************************************
@@ -3409,10 +3392,10 @@ IOReturn IOService::startPowerChange(
 
 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 );
@@ -3422,7 +3405,7 @@ bool IOService::notifyInterestedDrivers( void )
 
     count = list->numberOfItems();
     if (!count)
-        goto done;	// no interested drivers
+        goto done;  // no interested drivers
 
     // Allocate an array of interested drivers and their return values
     // for the callout thread. Everything else is still "owned" by the
@@ -3442,7 +3425,7 @@ bool IOService::notifyInterestedDrivers( void )
 
         param = IONew(DriverCallParam, count);
         if (!param)
-            goto done;	// no memory
+            goto done;  // no memory
 
         fDriverCallParamPtr   = (void *) param;
         fDriverCallParamSlots = count;
@@ -3479,39 +3462,39 @@ done:
 
 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.
@@ -3525,23 +3508,23 @@ void IOService::notifyInterestedDriversDone( void )
                     result = kMinAckTimeoutTicks;
 
                 informee->timer = (result / (ACK_TIMER_PERIOD / ns_per_us)) + 1;
-			}
-			// else, child has already acked or driver has removed interest,
+            }
+            // else, child has already acked or driver has removed interest,
             // and head_note_pendingAcks decremented.
-			// informee may have been removed from the interested drivers list,
+            // informee may have been removed from the interested drivers list,
             // thus the informee must be retained across the callout.
 
-			informee->release();
-		}
+            informee->release();
+        }
 
-		fDriverCallParamCount = 0;
+        fDriverCallParamCount = 0;
 
-		if ( fHeadNotePendingAcks )
-		{
-			OUR_PMLog(kPMLogStartAckTimer, 0, 0);
-			start_ack_timer();
-		}
-	}
+        if ( fHeadNotePendingAcks )
+        {
+            OUR_PMLog(kPMLogStartAckTimer, 0, 0);
+            start_ack_timer();
+        }
+    }
 
     MS_POP();  // pop the machine state passed to notifyAll()
 
@@ -3566,7 +3549,7 @@ void IOService::notifyInterestedDriversDone( void )
 
 void IOService::notifyRootDomain( void )
 {
-	assert( fDriverCallBusy == false );
+    assert( fDriverCallBusy == false );
 
     // Only for root domain in the will-change phase
     if (!IS_ROOT_DOMAIN || (fMachineState != kIOPM_OurChangeSetPowerState))
@@ -3587,8 +3570,8 @@ void IOService::notifyRootDomain( void )
 
 void IOService::notifyRootDomainDone( void )
 {
-	assert( fDriverCallBusy == false );
-	assert( fMachineState == kIOPM_DriverThreadCallDone );
+    assert( fDriverCallBusy == false );
+    assert( fMachineState == kIOPM_DriverThreadCallDone );
 
     MS_POP();   // pop notifyAll() machine state
     notifyChildren();
@@ -3600,13 +3583,13 @@ void IOService::notifyRootDomainDone( void )
 
 void IOService::notifyChildren( void )
 {
-    OSIterator *		iter;
-    OSObject *			next;
-    IOPowerConnection *	connection;
-	OSArray *			children = 0;
+    OSIterator *        iter;
+    OSObject *          next;
+    IOPowerConnection * connection;
+    OSArray *           children = 0;
     IOPMrootDomain *    rootDomain;
     bool                delayNotify = false;
-    
+
     if ((fHeadNotePowerState != fCurrentPowerState) &&
         (IS_POWER_DROP == fIsPreChange) &&
         ((rootDomain = getPMRootDomain()) == this))
@@ -3616,8 +3599,8 @@ void IOService::notifyChildren( void )
             kIOPMTracePointWakePowerPlaneDrivers  );
     }
 
-	if (fStrictTreeOrder)
-		children = OSArray::withCapacity(8);
+    if (fStrictTreeOrder)
+        children = OSArray::withCapacity(8);
 
     // Sum child power consumption in notifyChild()
     fHeadNotePowerArrayEntry->staticPower = 0;
@@ -3629,12 +3612,12 @@ void IOService::notifyChildren( void )
         {
             if ((connection = OSDynamicCast(IOPowerConnection, next)))
             {
-				if (connection->getReadyFlag() == false)
-				{
-					PM_LOG3("[%s] %s: connection not ready\n",
-						getName(), __FUNCTION__);
-					continue;
-				}
+                if (connection->getReadyFlag() == false)
+                {
+                    PM_LOG3("[%s] %s: connection not ready\n",
+                        getName(), __FUNCTION__);
+                    continue;
+                }
 
                 // Mechanism to postpone the did-change notification to
                 // certain power children to order those children last.
@@ -3657,11 +3640,11 @@ void IOService::notifyChildren( void )
                     }
                 }
 
-				if (!delayNotify && children)
-					children->setObject( connection );
-				else
-					notifyChild( connection );
-			}
+                if (!delayNotify && children)
+                    children->setObject( connection );
+                else
+                    notifyChild( connection );
+            }
         }
         iter->release();
     }
@@ -3671,10 +3654,10 @@ void IOService::notifyChildren( void )
         children->release();
         children = 0;
     }
-	if (children)
-	{
+    if (children)
+    {
         assert(fNotifyChildArray == 0);
-        fNotifyChildArray = children;        
+        fNotifyChildArray = children;
         MS_PUSH(fMachineState);
 
         if (delayNotify)
@@ -3698,7 +3681,7 @@ void IOService::notifyChildren( void )
 
             fMachineState = kIOPM_NotifyChildrenOrdered;
         }
-	}
+    }
 }
 
 //*********************************************************************************
@@ -3707,33 +3690,33 @@ void IOService::notifyChildren( void )
 
 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()
-	}
+    }
 }
 
 //*********************************************************************************
@@ -3742,11 +3725,11 @@ void IOService::notifyChildrenOrdered( void )
 
 void IOService::notifyChildrenDelayed( void )
 {
-    IOPowerConnection *	connection;
+    IOPowerConnection * connection;
 
-	PM_ASSERT_IN_GATE();
-	assert(fNotifyChildArray);
-	assert(fMachineState == kIOPM_NotifyChildrenDelayed);
+    PM_ASSERT_IN_GATE();
+    assert(fNotifyChildArray);
+    assert(fMachineState == kIOPM_NotifyChildrenDelayed);
 
     // Wait after all non-delayed children and interested drivers have ack'ed,
     // then notify all delayed children. If notify delay is canceled, child
@@ -3755,17 +3738,17 @@ void IOService::notifyChildrenDelayed( void )
 
     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()
 }
 
@@ -3775,18 +3758,18 @@ void IOService::notifyChildrenDelayed( void )
 
 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;
 }
 
 //*********************************************************************************
@@ -3796,9 +3779,9 @@ IOReturn IOService::notifyAll( uint32_t nextMS )
 //*********************************************************************************
 
 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;
 
@@ -3813,30 +3796,30 @@ IOReturn IOService::actionDriverCalloutDone(
 
 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 );
 }
 
 //*********************************************************************************
@@ -3848,7 +3831,7 @@ void IOService::pmDriverCallout( IOService * from )
 void IOService::driverSetPowerState( void )
 {
     IOPMPowerStateIndex powerState;
-    DriverCallParam *	param;
+    DriverCallParam *   param;
     IOPMDriverCallEntry callEntry;
     AbsoluteTime        end;
     IOReturn            result;
@@ -3871,10 +3854,17 @@ void IOService::driverSetPowerState( void )
 
         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
@@ -3884,21 +3874,11 @@ void IOService::driverSetPowerState( void )
 
             SUB_ABSOLUTETIME(&end, &fDriverCallStartTime);
             absolutetime_to_nanoseconds(end, &nsec);
-            if (nsec > LOG_SETPOWER_TIMES)
-                PM_LOG("%s::setPowerState(%p, %lu -> %lu) took %d ms\n",
-                    fName, this, fCurrentPowerState, powerState, NS_TO_MS(nsec));
-
-            PMEventDetails *details = PMEventDetails::eventDetails(
-                                        kIOPMEventTypeSetPowerStateImmediate, // type
-                                        fName,								  // who
-                                        (uintptr_t)this,					  // owner unique
-                                        NULL,								  // interest name
-                                        (uint8_t)oldPowerState,				  // old
-                                        (uint8_t)powerState,				  // new
-                                        0,									  // result
-                                        NS_TO_US(nsec));					  // usec completion time
-
-            getPMRootDomain()->recordAndReleasePMEvent( details );
+            if (nsec > LOG_SETPOWER_TIMES) {
+                getPMRootDomain()->pmStatsRecordApplicationResponse(
+                    gIOPMStatsDriverPSChangeSlow,
+                    fName, kDriverCallSetPowerState, NS_TO_MS(nsec), 0, NULL, powerState);
+            }
         }
 #endif
     }
@@ -3916,15 +3896,15 @@ void IOService::driverSetPowerState( void )
 
 void IOService::driverInformPowerChange( void )
 {
-    IOPMinformee *		informee;
-    IOService *			driver;
-    DriverCallParam *	param;
+    IOPMinformee *      informee;
+    IOService *         driver;
+    DriverCallParam *   param;
     IOPMDriverCallEntry callEntry;
-    IOPMPowerFlags		powerFlags;
+    IOPMPowerFlags      powerFlags;
     IOPMPowerStateIndex powerState;
     AbsoluteTime        end;
     IOReturn            result;
-    IOItemCount			count;
+    IOItemCount         count;
 
     assert( fDriverCallBusy );
     assert( fDriverCallParamPtr );
@@ -3959,7 +3939,7 @@ void IOService::driverInformPowerChange( void )
                 clock_get_uptime(&end);
                 OUR_PMLog((UInt32)-kPMLogInformDriverPostChange, (uintptr_t) this, result);
             }
-    
+
             deassertPMDriverCall(&callEntry);
 
 #if LOG_SETPOWER_TIMES
@@ -3969,27 +3949,11 @@ void IOService::driverInformPowerChange( void )
 
                 SUB_ABSOLUTETIME(&end, &informee->startTime);
                 absolutetime_to_nanoseconds(end, &nsec);
-                if (nsec > LOG_SETPOWER_TIMES)
-                    PM_LOG("%s::powerState%sChangeTo(%p, %s, %lu -> %lu) took %d ms\n",
-                        driver->getName(),
-                        (fDriverCallReason == kDriverCallInformPreChange) ? "Will" : "Did",
-                        driver, fName, fCurrentPowerState, powerState, NS_TO_MS(nsec));
-
-                uint16_t logType = (fDriverCallReason == kDriverCallInformPreChange) 
-                                    ? kIOPMEventTypePSWillChangeTo
-                                    : kIOPMEventTypePSDidChangeTo;
-
-                PMEventDetails *details = PMEventDetails::eventDetails(
-                                            logType,						// type
-                                            fName,							// who
-                                            (uintptr_t)this,				// owner unique
-                                            driver->getName(),				// interest name
-                                            (uint8_t)fCurrentPowerState,	// old
-                                            (uint8_t)fHeadNotePowerState,	// new
-                                            0,								// result
-                                            NS_TO_US(nsec));				// usec completion time
-
-                getPMRootDomain()->recordAndReleasePMEvent( details );
+                if (nsec > LOG_SETPOWER_TIMES) {
+                    getPMRootDomain()->pmStatsRecordApplicationResponse(
+                        gIOPMStatsDriverPSChangeSlow, driver->getName(),
+                        fDriverCallReason, NS_TO_MS(nsec), 0, NULL, powerState);
+                }
             }
 #endif
         }
@@ -4013,11 +3977,11 @@ bool IOService::notifyChild( IOPowerConnection * theNub )
     IOReturn                ret = IOPMAckImplied;
     unsigned long           childPower;
     IOService *             theChild;
-	IOPMRequest *           childRequest;
+    IOPMRequest *           childRequest;
     IOPMPowerChangeFlags    requestArg2;
-	int                     requestType;
+    int                     requestType;
 
-	PM_ASSERT_IN_GATE();
+    PM_ASSERT_IN_GATE();
     theChild = (IOService *)(theNub->copyChildEntry(gIOPowerPlane));
     if (!theChild)
     {
@@ -4026,7 +3990,7 @@ bool IOService::notifyChild( IOPowerConnection * theNub )
 
     // Unless the child handles the notification immediately and returns
     // kIOPMAckImplied, we'll be awaiting their acknowledgement later.
-	fHeadNotePendingAcks++;
+    fHeadNotePendingAcks++;
     theNub->setAwaitingAck(true);
 
     requestArg2 = fHeadNoteChangeFlags;
@@ -4037,21 +4001,21 @@ bool IOService::notifyChild( IOPowerConnection * theNub )
         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 )
         {
@@ -4063,7 +4027,7 @@ bool IOService::notifyChild( IOPowerConnection * theNub )
     }
 
     theChild->release();
-	return (IOPMAckImplied == ret);
+    return (IOPMAckImplied == ret);
 }
 
 //*********************************************************************************
@@ -4072,7 +4036,7 @@ bool IOService::notifyChild( IOPowerConnection * theNub )
 
 bool IOService::notifyControllingDriver( void )
 {
-    DriverCallParam *	param;
+    DriverCallParam *   param;
 
     PM_ASSERT_IN_GATE();
     assert( fDriverCallParamCount == 0  );
@@ -4095,7 +4059,7 @@ bool IOService::notifyControllingDriver( void )
     {
         param = IONew(DriverCallParam, 1);
         if (!param)
-            return false;	// no memory
+            return false;   // no memory
 
         fDriverCallParamPtr   = (void *) param;
         fDriverCallParamSlots = 1;
@@ -4119,28 +4083,28 @@ bool IOService::notifyControllingDriver( void )
 
 void IOService::notifyControllingDriverDone( void )
 {
-	DriverCallParam *	param;
-	IOReturn			result;
+    DriverCallParam *   param;
+    IOReturn            result;
+
+    PM_ASSERT_IN_GATE();
+    param = (DriverCallParam *) fDriverCallParamPtr;
 
-	PM_ASSERT_IN_GATE();
-	param = (DriverCallParam *) fDriverCallParamPtr;
+    assert( fDriverCallBusy == false );
+    assert( fMachineState == kIOPM_DriverThreadCallDone );
 
-	assert( fDriverCallBusy == false );
-	assert( fMachineState == kIOPM_DriverThreadCallDone );
+    if (param && fDriverCallParamCount)
+    {
+        assert(fDriverCallParamCount == 1);
 
-	if (param && fDriverCallParamCount)
-	{
-		assert(fDriverCallParamCount == 1);
-		
-		// the return value from setPowerState()
-		result = param->Result;
+        // the return value from setPowerState()
+        result = param->Result;
 
-		if ((result == IOPMAckImplied) || (result < 0))
-		{
+        if ((result == IOPMAckImplied) || (result < 0))
+        {
             fDriverTimer = 0;
-		}
-		else if (fDriverTimer)
-		{
+        }
+        else if (fDriverTimer)
+        {
             assert(fDriverTimer == -1);
 
             // Driver has not acked, and has returned a positive result.
@@ -4154,17 +4118,17 @@ void IOService::notifyControllingDriverDone( void )
                 result = kMinAckTimeoutTicks;
 
             fDriverTimer = (result / (ACK_TIMER_PERIOD / ns_per_us)) + 1;
-		}
-		// else, child has already acked and driver_timer reset to 0.
+        }
+        // else, child has already acked and driver_timer reset to 0.
 
-		fDriverCallParamCount = 0;
+        fDriverCallParamCount = 0;
 
-		if ( fDriverTimer )
-		{
-			OUR_PMLog(kPMLogStartAckTimer, 0, 0);
-			start_ack_timer();
-		}
-	}
+        if ( fDriverTimer )
+        {
+            OUR_PMLog(kPMLogStartAckTimer, 0, 0);
+            start_ack_timer();
+        }
+    }
 
     MS_POP();   // pushed by OurChangeSetPowerState()
     fIsPreChange  = false;
@@ -4236,7 +4200,7 @@ void IOService::all_done( void )
             trackSystemSleepPreventers(
                 fCurrentPowerState, fHeadNotePowerState, fHeadNoteChangeFlags);
 
-			// we changed, tell our parent
+            // we changed, tell our parent
             requestDomainPower(fHeadNotePowerState);
 
             // yes, did power raise?
@@ -4293,10 +4257,10 @@ void IOService::all_done( void )
     {
         if (fHeadNoteChangeFlags & kIOPMRootChangeDown)
             ParentChangeRootChangeDown();
-    
+
         if (((fHeadNoteChangeFlags & kIOPMDomainWillChange) &&
              (StateOrder(fCurrentPowerState) >= StateOrder(fHeadNotePowerState)))   ||
-			  ((fHeadNoteChangeFlags & kIOPMDomainDidChange)  &&
+              ((fHeadNoteChangeFlags & kIOPMDomainDidChange)  &&
              (StateOrder(fCurrentPowerState) < StateOrder(fHeadNotePowerState))))
         {
             trackSystemSleepPreventers(
@@ -4368,12 +4332,12 @@ void IOService::all_done( void )
 
 void IOService::OurChangeStart( void )
 {
-	PM_ASSERT_IN_GATE();
+    PM_ASSERT_IN_GATE();
     OUR_PMLog( kPMLogStartDeviceChange, fHeadNotePowerState, fCurrentPowerState );
 
-	// fMaxPowerState is our maximum possible power state based on the current
-	// power state of our parents.  If we are trying to raise power beyond the
-	// maximum, send an async request for more power to all parents.
+    // fMaxPowerState is our maximum possible power state based on the current
+    // power state of our parents.  If we are trying to raise power beyond the
+    // maximum, send an async request for more power to all parents.
 
     if (!IS_PM_ROOT && (StateOrder(fMaxPowerState) < StateOrder(fHeadNotePowerState)))
     {
@@ -4383,12 +4347,12 @@ void IOService::OurChangeStart( void )
         return;
     }
 
-	// Redundant power changes skips to the end of the state machine.
+    // Redundant power changes skips to the end of the state machine.
 
     if (!fInitialPowerChange && (fHeadNotePowerState == fCurrentPowerState))
-	{
-		OurChangeFinish();
-		return;
+    {
+        OurChangeFinish();
+        return;
     }
     fInitialPowerChange = false;
 
@@ -4397,8 +4361,8 @@ void IOService::OurChangeStart( void )
 
     PM_ACTION_2(actionPowerChangeStart, fHeadNotePowerState, &fHeadNoteChangeFlags);
 
-	// Two separate paths, depending if power is being raised or lowered.
-	// Lowering power is subject to approval by clients of this service.
+    // Two separate paths, depending if power is being raised or lowered.
+    // Lowering power is subject to approval by clients of this service.
 
     if (IS_POWER_DROP)
     {
@@ -4409,8 +4373,8 @@ void IOService::OurChangeStart( void )
         fOutOfBandParameter = kNotifyApps;
         askChangeDown(fHeadNotePowerState);
     }
-	else
-	{
+    else
+    {
         // This service is raising power and parents are able to support the
         // new power state. However a parent may have already committed to
         // drop power, which might force this object to temporarily drop power.
@@ -4495,7 +4459,7 @@ IOReturn IOService::requestDomainPower(
     IOPMPowerStateIndex             maxPowerState;
     IOPMRequestDomainPowerContext   context;
 
-	PM_ASSERT_IN_GATE();
+    PM_ASSERT_IN_GATE();
     assert(ourPowerState < fNumberOfPowerStates);
     if (ourPowerState >= fNumberOfPowerStates)
         return kIOReturnBadArgument;
@@ -4505,7 +4469,7 @@ IOReturn IOService::requestDomainPower(
     // 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.
 
@@ -4548,7 +4512,7 @@ done:
 
 void IOService::OurSyncStart( void )
 {
-	PM_ASSERT_IN_GATE();
+    PM_ASSERT_IN_GATE();
 
     if (fInitialPowerChange)
         return;
@@ -4557,8 +4521,8 @@ void IOService::OurSyncStart( void )
 
     if (fHeadNoteChangeFlags & kIOPMNotDone)
     {
-		OurChangeFinish();
-		return;
+        OurChangeFinish();
+        return;
     }
 
     if (fHeadNoteChangeFlags & kIOPMSyncTellPowerDown)
@@ -4581,7 +4545,7 @@ void IOService::OurSyncStart( void )
 // [private] OurChangeTellClientsPowerDown
 //
 // All applications and kernel clients have acknowledged our permission to drop
-// power. Here we notify them that we will lower the power and wait for acks. 
+// power. Here we notify them that we will lower the power and wait for acks.
 //*********************************************************************************
 
 void IOService::OurChangeTellClientsPowerDown( void )
@@ -4653,13 +4617,6 @@ void IOService::OurChangeNotifyInterestedDriversWillChange( void )
         if (IS_POWER_DROP)
         {
             rootDomain->tracePoint( kIOPMTracePointSleepWillChangeInterests );
-
-            PMEventDetails *details = PMEventDetails::eventDetails(
-                                        kIOPMEventTypeAppNotificationsFinished,
-                                        NULL,
-                                        100,
-                                        kIOReturnSuccess);
-            rootDomain->recordAndReleasePMEvent( details );
         }
         else
             rootDomain->tracePoint( kIOPMTracePointWakeWillChangeInterests );
@@ -4758,7 +4715,7 @@ void IOService::OurChangeFinish( void )
 
 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
@@ -4777,10 +4734,10 @@ IOReturn IOService::ParentChangeStart( void )
     {
         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;
     }
 
@@ -4793,26 +4750,26 @@ IOReturn IOService::ParentChangeStart( void )
             {
                 // 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;
         }
@@ -4938,7 +4895,7 @@ void IOService::ParentChangeRootChangeDown( void )
 void IOService::ParentChangeTellPriorityClientsPowerDown( void )
 {
     fMachineState = kIOPM_ParentChangeNotifyInterestedDriversWillChange;
-	tellChangeDown2(fHeadNotePowerState);
+    tellChangeDown2(fHeadNotePowerState);
 }
 
 //*********************************************************************************
@@ -4965,7 +4922,7 @@ void IOService::ParentChangeTellCapabilityWillChange( void )
 
 void IOService::ParentChangeNotifyInterestedDriversWillChange( void )
 {
-	notifyAll( kIOPM_ParentChangeSetPowerState );
+    notifyAll( kIOPM_ParentChangeSetPowerState );
 }
 
 //*********************************************************************************
@@ -4994,7 +4951,7 @@ void IOService::ParentChangeSetPowerState( void )
 
 void IOService::ParentChangeWaitForPowerSettle( void )
 {
-	fMachineState = kIOPM_ParentChangeNotifyInterestedDriversDidChange;
+    fMachineState = kIOPM_ParentChangeNotifyInterestedDriversDidChange;
     startSettleTimer();
 }
 
@@ -5007,7 +4964,7 @@ void IOService::ParentChangeWaitForPowerSettle( void )
 
 void IOService::ParentChangeNotifyInterestedDriversDidChange( void )
 {
-	notifyAll( kIOPM_ParentChangeTellCapabilityDidChange );	
+    notifyAll( kIOPM_ParentChangeTellCapabilityDidChange );
 }
 
 //*********************************************************************************
@@ -5027,13 +4984,13 @@ void IOService::ParentChangeTellCapabilityDidChange( void )
 //*********************************************************************************
 // [private] ParentAcknowledgePowerChange
 //
-// Acknowledge our power parent that our power change is done. 
+// Acknowledge our power parent that our power change is done.
 //*********************************************************************************
 
 void IOService::ParentChangeAcknowledgePowerChange( void )
 {
-    IORegistryEntry *	nub;
-    IOService *			parent;
+    IORegistryEntry *   nub;
+    IOService *         parent;
 
     nub = fHeadNoteParentConnection;
     nub->retain();
@@ -5059,8 +5016,8 @@ void IOService::ParentChangeAcknowledgePowerChange( void )
 
 void IOService::settleTimerExpired( void )
 {
-	fSettleTimeUS = 0;
-	gIOPMWorkQueue->signalWorkAvailable();
+    fSettleTimeUS = 0;
+    gIOPMWorkQueue->signalWorkAvailable();
 }
 
 //*********************************************************************************
@@ -5072,15 +5029,15 @@ void IOService::settleTimerExpired( void )
 static void
 settle_timer_expired( thread_call_param_t arg0, thread_call_param_t arg1 )
 {
-	IOService * me = (IOService *) arg0;
+    IOService * me = (IOService *) arg0;
 
-	if (gIOPMWorkLoop && gIOPMWorkQueue)
-	{
-		gIOPMWorkLoop->runAction(
+    if (gIOPMWorkLoop && gIOPMWorkQueue)
+    {
+        gIOPMWorkLoop->runAction(
             OSMemberFunctionCast(IOWorkLoop::Action, me, &IOService::settleTimerExpired),
             me);
-	}
-	me->release();
+    }
+    me->release();
 }
 
 //*********************************************************************************
@@ -5101,9 +5058,9 @@ void IOService::startSettleTimer( void )
     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);
@@ -5160,16 +5117,16 @@ void IOService::startSettleTimer( void )
 #ifndef __LP64__
 void IOService::ack_timer_ticked ( void )
 {
-	assert(false);
+    assert(false);
 }
 #endif /* !__LP64__ */
 
 bool IOService::ackTimerTick( void )
 {
-    IOPMinformee *		nextObject;
-	bool				done = false;
+    IOPMinformee *      nextObject;
+    bool                done = false;
 
-	PM_ASSERT_IN_GATE();
+    PM_ASSERT_IN_GATE();
     switch (fMachineState) {
         case kIOPM_OurChangeWaitForPowerSettle:
         case kIOPM_ParentChangeWaitForPowerSettle:
@@ -5187,30 +5144,16 @@ bool IOService::ackTimerTick( void )
                     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();
@@ -5242,24 +5185,6 @@ bool IOService::ackTimerTick( void )
                                 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--;
                         }
@@ -5271,7 +5196,7 @@ bool IOService::ackTimerTick( void )
                 if ( fHeadNotePendingAcks == 0 )
                 {
                     // yes, we can continue
-					done = true;
+                    done = true;
                 } else {
                     // no, set timer again
                     start_ack_timer();
@@ -5290,19 +5215,19 @@ bool IOService::ackTimerTick( void )
         case kIOPM_SyncTellPriorityClientsPowerDown:
         case kIOPM_SyncNotifyWillChange:
         case kIOPM_TellCapabilityChangeDone:
-			// apps didn't respond in time
+            // apps didn't respond in time
             cleanClientResponses(true);
             OUR_PMLog(kPMLogClientTardy, 0, 1);
-			// tardy equates to approval
-			done = true;
+            // tardy equates to approval
+            done = true;
             break;
 
         default:
             PM_LOG1("%s: unexpected ack timer tick (state = %d)\n",
-				getName(), fMachineState);
+                getName(), fMachineState);
             break;
     }
-	return done;
+    return done;
 }
 
 //*********************************************************************************
@@ -5313,8 +5238,7 @@ void IOService::start_watchdog_timer( void )
     AbsoluteTime    deadline;
     boolean_t       pending;
 
-    if (!fWatchdogTimer || (kIOSleepWakeWdogOff & gIOKitDebug) || 
-                (getPMRootDomain()->sleepWakeDebugIsWdogEnabled() == false))
+    if (!fWatchdogTimer || (kIOSleepWakeWdogOff & gIOKitDebug))
        return;
 
     if (thread_call_isactive(fWatchdogTimer)) return;
@@ -5336,8 +5260,7 @@ bool IOService::stop_watchdog_timer( void )
 {
     boolean_t   pending;
 
-    if (!fWatchdogTimer || (kIOSleepWakeWdogOff & gIOKitDebug) ||
-                (getPMRootDomain()->sleepWakeDebugIsWdogEnabled() == false))
+    if (!fWatchdogTimer || (kIOSleepWakeWdogOff & gIOKitDebug))
        return false;
 
     pending = thread_call_cancel(fWatchdogTimer);
@@ -5366,15 +5289,16 @@ void IOService::reset_watchdog_timer( void )
 void
 IOService::watchdog_timer_expired( thread_call_param_t arg0, thread_call_param_t arg1 )
 {
-	IOService * me = (IOService *) arg0;
+    IOService * me = (IOService *) arg0;
 
 
     gIOPMWatchDogThread = current_thread();
     getPMRootDomain()->sleepWakeDebugTrig(true);
     gIOPMWatchDogThread = 0;
-    me->release();
+    thread_call_free(me->fWatchdogTimer);
+    me->fWatchdogTimer = 0;
 
-	return ;
+    return ;
 }
 
 
@@ -5384,7 +5308,7 @@ IOService::watchdog_timer_expired( thread_call_param_t arg0, thread_call_param_t
 
 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 )
@@ -5455,13 +5379,13 @@ IOService::actionAckTimerExpired(
 void
 IOService::ack_timer_expired( thread_call_param_t arg0, thread_call_param_t arg1 )
 {
-	IOService * me = (IOService *) arg0;
+    IOService * me = (IOService *) arg0;
 
-	if (gIOPMWorkLoop)
-	{
-		gIOPMWorkLoop->runAction(&actionAckTimerExpired, me);
-	}
-	me->release();
+    if (gIOPMWorkLoop)
+    {
+        gIOPMWorkLoop->runAction(&actionAckTimerExpired, me);
+    }
+    me->release();
 }
 
 // MARK: -
@@ -5473,7 +5397,7 @@ IOService::ack_timer_expired( thread_call_param_t arg0, thread_call_param_t arg1
 
 void IOService::tellSystemCapabilityChange( uint32_t nextMS )
 {
-	MS_PUSH( nextMS );
+    MS_PUSH( nextMS );
     fMachineState       = kIOPM_TellCapabilityChangeDone;
     fOutOfBandMessage   = kIOMessageSystemCapabilityChange;
 
@@ -5579,21 +5503,21 @@ static void logAppTimeouts( OSObject * object, void * arg )
             (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);
 
         }
     }
@@ -5666,7 +5590,7 @@ bool IOService::tellClientsWithResponse( int messageType )
     IOPMInterestContext     context;
     bool                    isRootDomain = IS_ROOT_DOMAIN;
 
-	PM_ASSERT_IN_GATE();
+    PM_ASSERT_IN_GATE();
     assert( fResponseArray == NULL );
     assert( fNotifyClientArray == NULL );
 
@@ -5683,7 +5607,7 @@ bool IOService::tellClientsWithResponse( int messageType )
 
     fResponseArray->setCapacityIncrement(8);
     if (++fSerialNumber == 0)
-        fSerialNumber++;        
+        fSerialNumber++;
 
     context.responseArray    = fResponseArray;
     context.notifyClients    = 0;
@@ -5706,7 +5630,7 @@ bool IOService::tellClientsWithResponse( int messageType )
     switch ( fOutOfBandParameter ) {
         case kNotifyApps:
             applyToInterested( gIOAppPowerStateInterest,
-				pmTellAppWithResponse, (void *) &context );
+                pmTellAppWithResponse, (void *) &context );
 
             if (isRootDomain &&
                 (fMachineState != kIOPM_OurChangeTellClientsPowerDown) &&
@@ -5718,14 +5642,14 @@ bool IOService::tellClientsWithResponse( int messageType )
                 context.notifyType  = kNotifyCapabilityChangeApps;
                 context.messageType = kIOMessageSystemCapabilityChange;
                 applyToInterested( gIOAppPowerStateInterest,
-                    pmTellCapabilityAppWithResponse, (void *) &context ); 
+                    pmTellCapabilityAppWithResponse, (void *) &context );
                 context.notifyType  = fOutOfBandParameter;
                 context.messageType = messageType;
             }
             context.maxTimeRequested = k30Seconds;
 
             applyToInterested( gIOGeneralInterest,
-				pmTellClientWithResponse, (void *) &context );
+                pmTellClientWithResponse, (void *) &context );
 
             fNotifyClientArray = context.notifyClients;
             break;
@@ -5733,7 +5657,7 @@ bool IOService::tellClientsWithResponse( int messageType )
         case kNotifyPriority:
             context.enableTracing = isRootDomain;
             applyToInterested( gIOPriorityPowerStateInterest,
-				pmTellClientWithResponse, (void *) &context );
+                pmTellClientWithResponse, (void *) &context );
 
             if (isRootDomain)
             {
@@ -5747,14 +5671,14 @@ bool IOService::tellClientsWithResponse( int messageType )
 
         case kNotifyCapabilityChangeApps:
             applyToInterested( gIOAppPowerStateInterest,
-				pmTellCapabilityAppWithResponse, (void *) &context );
+                pmTellCapabilityAppWithResponse, (void *) &context );
             fNotifyClientArray = context.notifyClients;
             context.maxTimeRequested = k30Seconds;
             break;
 
         case kNotifyCapabilityChangePriority:
             applyToInterested( gIOPriorityPowerStateInterest,
-				pmTellCapabilityClientWithResponse, (void *) &context );
+                pmTellCapabilityClientWithResponse, (void *) &context );
             break;
     }
 
@@ -5764,7 +5688,7 @@ bool IOService::tellClientsWithResponse( int messageType )
         OUR_PMLog(kPMLogStartAckTimer, context.maxTimeRequested, 0);
         if (context.enableTracing)
             getPMRootDomain()->traceDetail( context.maxTimeRequested / 1000 );
-		start_ack_timer( context.maxTimeRequested / 1000, kMillisecondScale );
+        start_ack_timer( context.maxTimeRequested / 1000, kMillisecondScale );
         return false;
     }
 
@@ -5799,6 +5723,7 @@ void IOService::pmTellAppWithResponse( OSObject * object, void * arg )
     OSNumber                *clientID = NULL;
     proc_t                  proc = NULL;
     boolean_t               proc_suspended = FALSE;
+    OSObject *              waitForReply = kOSBooleanTrue;
 #if LOG_APP_RESPONSE_TIMES
     AbsoluteTime            now;
 #endif
@@ -5827,9 +5752,9 @@ void IOService::pmTellAppWithResponse( OSObject * object, void * arg )
             }
         }
     }
-    
+
     if (context->messageFilter &&
-        !context->messageFilter(context->us, object, context, 0, 0))
+        !context->messageFilter(context->us, object, context, 0, &waitForReply))
     {
         if (kIOLogDebugPower & gIOKitDebug)
         {
@@ -5853,18 +5778,29 @@ void IOService::pmTellAppWithResponse( OSObject * object, void * arg )
         logClientIDForNotification(object, context, "MESG App");
     }
 
+    if (waitForReply == kOSBooleanTrue) 
+    {
 #if LOG_APP_RESPONSE_TIMES
-    OSNumber * num;
-    clock_get_uptime(&now);
-    num = OSNumber::withNumber(AbsoluteTime_to_scalar(&now), sizeof(uint64_t) * 8);
-    if (num)
+        OSNumber * num;
+        clock_get_uptime(&now);
+        num = OSNumber::withNumber(AbsoluteTime_to_scalar(&now), sizeof(uint64_t) * 8);
+        if (num)
+        {
+            context->responseArray->setObject(msgIndex, num);
+            num->release();
+        }
+        else
+#endif
+        context->responseArray->setObject(msgIndex, kOSBooleanFalse);
+    }
+    else 
     {
-        context->responseArray->setObject(msgIndex, num);
-        num->release();
+        context->responseArray->setObject(msgIndex, kOSBooleanTrue);
+        if (kIOLogDebugPower & gIOKitDebug)
+        {
+            logClientIDForNotification(object, context, "App response ignored");
+        }
     }
-    else
-#endif
-    context->responseArray->setObject(msgIndex, kOSBooleanFalse);
 
     if (context->notifyClients)
         context->notifyClients->setObject(msgIndex, object);
@@ -5899,7 +5835,7 @@ void IOService::pmTellClientWithResponse( OSObject * object, void * arg )
                 context->us->getName(),
                 getIOMessageString(context->messageType),
                 OBFUSCATE(object), OBFUSCATE(n->handler));
-		}        
+        }
         return;
     }
 
@@ -5910,13 +5846,13 @@ void IOService::pmTellClientWithResponse( OSObject * object, void * arg )
 
     IOServicePM * pwrMgt = context->us->pwrMgt;
     if (gIOKitDebug & kIOLogPower) {
-		OUR_PMLog(kPMLogClientNotify, msgRef, msgType);
-		if (OSDynamicCast(IOService, object)) {
-			const char *who = ((IOService *) object)->getName();
-			gPlatform->PMLog(who, kPMLogClientNotify, (uintptr_t) object, 0);
-		}
+        OUR_PMLog(kPMLogClientNotify, msgRef, msgType);
+        if (OSDynamicCast(IOService, object)) {
+            const char *who = ((IOService *) object)->getName();
+            gPlatform->PMLog(who, kPMLogClientNotify, (uintptr_t) object, 0);
+        }
         else if (notifier) {
-			OUR_PMLog(kPMLogClientNotify, (uintptr_t) notifier->handler, 0);
+            OUR_PMLog(kPMLogClientNotify, (uintptr_t) notifier->handler, 0);
         }
     }
     if ((kIOLogDebugPower & gIOKitDebug) && notifier)
@@ -5945,7 +5881,7 @@ void IOService::pmTellClientWithResponse( OSObject * object, void * arg )
     if (kIOReturnSuccess == retCode)
     {
         if (0 == notify.returnValue) {
-			OUR_PMLog(kPMLogClientAcknowledge, msgRef, (uintptr_t) object);
+            OUR_PMLog(kPMLogClientAcknowledge, msgRef, (uintptr_t) object);
         } else {
             replied = kOSBooleanFalse;
             if ( notify.returnValue > context->maxTimeRequested )
@@ -5966,7 +5902,7 @@ void IOService::pmTellClientWithResponse( OSObject * object, void * arg )
     } else {
         // not a client of ours
         // so we won't be waiting for response
-		OUR_PMLog(kPMLogClientAcknowledge, msgRef, 0);
+        OUR_PMLog(kPMLogClientAcknowledge, msgRef, 0);
     }
 
     context->responseArray->setObject(msgIndex, replied);
@@ -6016,7 +5952,7 @@ void IOService::pmTellCapabilityAppWithResponse( OSObject * object, void * arg )
         if (clientID) {
             clientIDString = IOCopyLogNameForPID(clientID->unsigned32BitValue());
         }
-    
+
         PM_LOG("%s MESG App(%u) %s, wait %u, %s\n",
             context->us->getName(),
             msgIndex, getIOMessageString(msgType),
@@ -6084,7 +6020,7 @@ void IOService::pmTellCapabilityClientWithResponse(
                 context->us->getName(),
                 getIOMessageString(context->messageType),
                 OBFUSCATE(object), OBFUSCATE(n->handler));
-		}        
+        }
         return;
     }
 
@@ -6095,14 +6031,14 @@ void IOService::pmTellCapabilityClientWithResponse(
 
     IOServicePM * pwrMgt = context->us->pwrMgt;
     if (gIOKitDebug & kIOLogPower) {
-		OUR_PMLog(kPMLogClientNotify, msgRef, msgType);
-		if (OSDynamicCast(IOService, object)) {
-			const char *who = ((IOService *) object)->getName();
-			gPlatform->PMLog(who, kPMLogClientNotify, (uintptr_t) object, 0);
-		}
+        OUR_PMLog(kPMLogClientNotify, msgRef, msgType);
+        if (OSDynamicCast(IOService, object)) {
+            const char *who = ((IOService *) object)->getName();
+            gPlatform->PMLog(who, kPMLogClientNotify, (uintptr_t) object, 0);
+        }
         else if (notifier) {
-			OUR_PMLog(kPMLogClientNotify, (uintptr_t) notifier->handler, 0);
-		}
+            OUR_PMLog(kPMLogClientNotify, (uintptr_t) notifier->handler, 0);
+        }
     }
     if ((kIOLogDebugPower & gIOKitDebug) && notifier)
     {
@@ -6131,7 +6067,7 @@ void IOService::pmTellCapabilityClientWithResponse(
         if ( 0 == msgArg.maxWaitForReply )
         {
             // client doesn't want time to respond
-			OUR_PMLog(kPMLogClientAcknowledge, msgRef, (uintptr_t) object);
+            OUR_PMLog(kPMLogClientAcknowledge, msgRef, (uintptr_t) object);
         }
         else
         {
@@ -6156,7 +6092,7 @@ void IOService::pmTellCapabilityClientWithResponse(
     {
         // not a client of ours
         // so we won't be waiting for response
-		OUR_PMLog(kPMLogClientAcknowledge, msgRef, 0);
+        OUR_PMLog(kPMLogClientAcknowledge, msgRef, 0);
     }
 
     context->responseArray->setObject(msgIndex, replied);
@@ -6236,7 +6172,7 @@ void IOService::tellClients( int messageType )
 
 static void tellKernelClientApplier( OSObject * object, void * arg )
 {
-    IOPowerStateChangeNotification	notify;
+    IOPowerStateChangeNotification  notify;
     IOPMInterestContext *           context = (IOPMInterestContext *) arg;
 
     if (context->messageFilter &&
@@ -6250,14 +6186,14 @@ static void tellKernelClientApplier( OSObject * object, void * arg )
                 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, &notify, sizeof(notify));
 
@@ -6273,7 +6209,7 @@ static void tellKernelClientApplier( OSObject * object, void * arg )
 }
 
 static OSNumber * copyClientIDForNotification(
-    OSObject *object, 
+    OSObject *object,
     IOPMInterestContext *context)
 {
     OSNumber *clientID = NULL;
@@ -6283,27 +6219,27 @@ static OSNumber * copyClientIDForNotification(
 
 static void logClientIDForNotification(
     OSObject *object,
-    IOPMInterestContext *context, 
+    IOPMInterestContext *context,
     const char *logString)
 {
     OSString *logClientID = NULL;
-    OSNumber *clientID = copyClientIDForNotification(object, context);    
+    OSNumber *clientID = copyClientIDForNotification(object, context);
 
-    if (logString) 
+    if (logString)
     {
         if (clientID)
             logClientID = IOCopyLogNameForPID(clientID->unsigned32BitValue());
-    
+
         PM_LOG("%s %s %s, %s\n",
             context->us->getName(), logString,
             IOService::getIOMessageString(context->messageType),
             logClientID ? logClientID->getCStringNoCopy() : "");
 
-        if (logClientID) 
+        if (logClientID)
             logClientID->release();
     }
-    
-    if (clientID) 
+
+    if (clientID)
         clientID->release();
 
     return;
@@ -6315,7 +6251,7 @@ static void tellAppClientApplier( OSObject * object, void * arg )
     OSNumber            * clientID = NULL;
     proc_t                proc = NULL;
     boolean_t             proc_suspended = FALSE;
-    
+
     if (context->us == IOService::getPMRootDomain())
     {
         if ((clientID = copyClientIDForNotification(object, context)))
@@ -6362,13 +6298,13 @@ static void tellAppClientApplier( OSObject * object, void * arg )
 
 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);
 
@@ -6389,9 +6325,10 @@ bool IOService::checkForDone( void )
 
 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);
@@ -6400,25 +6337,28 @@ bool IOService::responseValid( uint32_t refcon, int pid )
     {
         return false;
     }
-    
+
     if ( fResponseArray == NULL )
     {
         return false;
     }
-    
+
     theFlag = fResponseArray->getObject(ordinalComponent);
-    
+
     if ( theFlag == 0 )
     {
         return false;
     }
 
+    if (fNotifyClientArray) 
+        object = fNotifyClientArray->getObject(ordinalComponent);
+
     OSNumber * num;
     if ((num = OSDynamicCast(OSNumber, theFlag)))
     {
 #if LOG_APP_RESPONSE_TIMES
-        AbsoluteTime	now;
-        AbsoluteTime	start;
+        AbsoluteTime    now;
+        AbsoluteTime    start;
         uint64_t        nsec;
         char            name[128];
 
@@ -6428,18 +6368,6 @@ bool IOService::responseValid( uint32_t refcon, int pid )
         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)
         {
@@ -6451,27 +6379,39 @@ bool IOService::responseValid( uint32_t refcon, int pid )
         // > 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;
 }
 
@@ -6485,7 +6425,7 @@ bool IOService::responseValid( uint32_t refcon, int pid )
 
 IOReturn IOService::allowPowerChange( unsigned long refcon )
 {
-	IOPMRequest * request;
+    IOPMRequest * request;
 
     if ( !initialized )
     {
@@ -6493,23 +6433,23 @@ IOReturn IOService::allowPowerChange( unsigned long refcon )
         return kIOReturnSuccess;
     }
 
-	request = acquirePMRequest( this, kIOPMRequestTypeAllowPowerChange );
-	if (!request)
-		return kIOReturnNoMemory;
+    request = acquirePMRequest( this, kIOPMRequestTypeAllowPowerChange );
+    if (!request)
+        return kIOReturnNoMemory;
 
-	request->fArg0 = (void *)            refcon;
-	request->fArg1 = (void *)(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__ */
 
@@ -6523,7 +6463,7 @@ IOReturn IOService::serializedAllowPowerChange2( unsigned long refcon )
 
 IOReturn IOService::cancelPowerChange( unsigned long refcon )
 {
-	IOPMRequest *   request;
+    IOPMRequest *   request;
     char            name[128];
     pid_t           pid = proc_selfpid();
 
@@ -6537,8 +6477,8 @@ IOReturn IOService::cancelPowerChange( unsigned long refcon )
     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;
     }
@@ -6554,8 +6494,8 @@ IOReturn IOService::cancelPowerChange( unsigned long refcon )
 #ifndef __LP64__
 IOReturn IOService::serializedCancelPowerChange2( unsigned long refcon )
 {
-	// [deprecated] public
-	return kIOReturnUnsupported;
+    // [deprecated] public
+    return kIOReturnUnsupported;
 }
 
 //*********************************************************************************
@@ -6592,17 +6532,17 @@ IOReturn IOService::configurePowerStatesReport( IOReportConfigureAction action,
     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;
@@ -6628,7 +6568,7 @@ IOReturn IOService::configurePowerStatesReport( IOReportConfigureAction action,
                 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();
@@ -6673,16 +6613,16 @@ IOReturn IOService::updatePowerStatesReport( IOReportConfigureAction action, voi
     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;
@@ -6696,7 +6636,7 @@ IOReturn IOService::updatePowerStatesReport( IOReportConfigureAction action, voi
             }
 
             STATEREPORT_UPDATERES(fReportBuf, kIOReportCopyChannelData, result);
-            dest->appendBytes(data2cpy, size2cpy); 
+            dest->appendBytes(data2cpy, size2cpy);
 
         default:
             break;
@@ -6712,20 +6652,20 @@ IOReturn IOService::updatePowerStatesReport( IOReportConfigureAction action, voi
 //*********************************************************************************
 //  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:
@@ -6743,28 +6683,28 @@ IOReturn IOService::configureSimplePowerReport(IOReportConfigureAction action, v
 //*********************************************************************************
 //  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);
 
@@ -6776,7 +6716,7 @@ IOReturn IOService::updateSimplePowerReport( IOReportConfigureAction action, voi
                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);
@@ -6786,7 +6726,7 @@ IOReturn IOService::updateSimplePowerReport( IOReportConfigureAction action, voi
             }
 
             SIMPLEREPORT_UPDATERES(kIOReportCopyChannelData, result);
-            dest->appendBytes(data2cpy, size2cpy); 
+            dest->appendBytes(data2cpy, size2cpy);
 
         default:
             break;
@@ -6811,7 +6751,7 @@ IOReturn IOService::updateSimplePowerReport( IOReportConfigureAction action, voi
 //*********************************************************************************
 
 IOReturn IOService::setPowerState(
-	unsigned long powerStateOrdinal, IOService * whatDevice )
+    unsigned long powerStateOrdinal, IOService * whatDevice )
 {
     return IOPMNoErr;
 }
@@ -6944,9 +6884,9 @@ IOReturn IOService::newTemperature( long currentTemp, IOService * whichZone )
 
 void IOService::systemWillShutdown( IOOptionBits specifier )
 {
-	IOPMrootDomain * rootDomain = IOService::getPMRootDomain();
-	if (rootDomain)
-		rootDomain->acknowledgeSystemWillShutdown( this );
+    IOPMrootDomain * rootDomain = IOService::getPMRootDomain();
+    if (rootDomain)
+        rootDomain->acknowledgeSystemWillShutdown( this );
 }
 
 // MARK: -
@@ -6960,26 +6900,26 @@ IOPMRequest *
 IOService::acquirePMRequest( IOService * target, IOOptionBits requestType,
                              IOPMRequest * active )
 {
-	IOPMRequest * request;
+    IOPMRequest * request;
 
-	assert(target);
+    assert(target);
 
-	request = IOPMRequest::create();
-	if (request)
-	{
-		request->init( target, requestType );
+    request = IOPMRequest::create();
+    if (request)
+    {
+        request->init( target, requestType );
         if (active)
         {
             IOPMRequest * root = active->getRootRequest();
             if (root) request->attachRootRequest(root);
         }
     }
-	else
-	{
+    else
+    {
         PM_ERROR("%s: No memory for PM request type 0x%x\n",
             target->getName(), (uint32_t) requestType);
-	}
-	return request;
+    }
+    return request;
 }
 
 //*********************************************************************************
@@ -6988,11 +6928,11 @@ IOService::acquirePMRequest( IOService * target, IOOptionBits requestType,
 
 void IOService::releasePMRequest( IOPMRequest * request )
 {
-	if (request)
-	{
-		request->reset();
-		request->release();
-	}
+    if (request)
+    {
+        request->reset();
+        request->release();
+    }
 }
 
 //*********************************************************************************
@@ -7001,39 +6941,39 @@ void IOService::releasePMRequest( IOPMRequest * request )
 
 void IOService::submitPMRequest( IOPMRequest * request )
 {
-	assert( request );
-	assert( gIOPMReplyQueue );
-	assert( gIOPMRequestQueue );
+    assert( request );
+    assert( gIOPMReplyQueue );
+    assert( gIOPMRequestQueue );
 
-	PM_LOG1("[+ %02lx] %p [%p %s] %p %p %p\n",
-		(long)request->getType(), OBFUSCATE(request),
-		OBFUSCATE(request->getTarget()), request->getTarget()->getName(),
-		OBFUSCATE(request->fArg0), 
+    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 )
 {
-	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), 
+    assert( requests );
+    assert( count > 0 );
+    assert( gIOPMRequestQueue );
+
+    for (IOItemCount i = 0; i < count; i++)
+    {
+        IOPMRequest * req = requests[i];
+        PM_LOG1("[+ %02lx] %p [%p %s] %p %p %p\n",
+            (long)req->getType(), OBFUSCATE(req),
+            OBFUSCATE(req->getTarget()), req->getTarget()->getName(),
+            OBFUSCATE(req->fArg0),
             OBFUSCATE(req->fArg1), OBFUSCATE(req->fArg2));
-	}
+    }
 
-	gIOPMRequestQueue->queuePMRequestChain( requests, count );
+    gIOPMRequestQueue->queuePMRequestChain( requests, count );
 }
 
 //*********************************************************************************
@@ -7043,8 +6983,8 @@ void IOService::submitPMRequest( IOPMRequest ** requests, IOItemCount count )
 //*********************************************************************************
 
 bool IOService::servicePMRequestQueue(
-	IOPMRequest *		request,
-	IOPMRequestQueue *	queue )
+    IOPMRequest *       request,
+    IOPMRequestQueue *  queue )
 {
     bool more;
 
@@ -7061,10 +7001,10 @@ bool IOService::servicePMRequestQueue(
     // Calling PM without PMinit() is not allowed, fail the request.
 
     PM_LOG("%s: PM not initialized\n", getName());
-	fAdjustPowerScheduled = false;
-	more = gIOPMFreeQueue->queuePMRequest(request);
+    fAdjustPowerScheduled = false;
+    more = gIOPMFreeQueue->queuePMRequest(request);
     if (more) gIOPMWorkQueue->incrementProducerCount();
-	return more;
+    return more;
 }
 
 //*********************************************************************************
@@ -7074,10 +7014,10 @@ bool IOService::servicePMRequestQueue(
 //*********************************************************************************
 
 bool IOService::servicePMFreeQueue(
-	IOPMRequest *		  request,
-	IOPMCompletionQueue * queue )
+    IOPMRequest *         request,
+    IOPMCompletionQueue * queue )
 {
-	bool            more = request->getNextRequest();
+    bool            more = request->getNextRequest();
     IOPMRequest *   root = request->getRootRequest();
 
     if (root && (root != request))
@@ -7085,8 +7025,8 @@ bool IOService::servicePMFreeQueue(
     if (more)
         gIOPMWorkQueue->incrementProducerCount();
 
-	releasePMRequest( request );
-	return more;
+    releasePMRequest( request );
+    return more;
 }
 
 //*********************************************************************************
@@ -7097,26 +7037,35 @@ bool IOService::servicePMFreeQueue(
 
 bool IOService::retirePMRequest( 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, gIOPMBusyCount);
 
-	// Catch requests created by idleTimerExpired().
+    // Catch requests created by idleTimerExpired().
 
-	if ((request->getType() == kIOPMRequestTypeActivityTickle) &&
-	    (((uintptr_t) request->fArg1) & kTickleTypePowerDrop)  &&
-        fIdleTimerPeriod)
-	{
-        restartIdleTimer();
+    if (request->getType() == kIOPMRequestTypeActivityTickle)
+    {
+        uint32_t tickleFlags = (uint32_t)(uintptr_t) request->fArg1;
+
+        if ((tickleFlags & kTickleTypePowerDrop) && fIdleTimerPeriod)
+        {
+            restartIdleTimer();
+        }
+        else if (tickleFlags == (kTickleTypeActivity | kTickleTypePowerRise))
+        {
+            // Invalidate any idle power drop that got queued while
+            // processing this request.
+            fIdleTimerGeneration++;
+        }
     }
 
     // If the request is linked, then Work queue has already incremented its
     // producer count.
 
-	return (gIOPMFreeQueue->queuePMRequest( request ));
+    return (gIOPMFreeQueue->queuePMRequest( request ));
 }
 
 //*********************************************************************************
@@ -7127,64 +7076,64 @@ bool IOService::retirePMRequest( IOPMRequest * request, IOPMWorkQueue * queue )
 
 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;
-		}
-
-		// Waiting on driver's setPowerState() timeout.
-		if (fDriverTimer)
-		{
-			reason = 1; break;
-		}
-
-		// Child or interested driver acks pending.
-		if (fHeadNotePendingAcks)
-		{
-			reason = 2; break;
-		}
-
-		// Waiting on apps or priority power interest clients.
-		if (fResponseArray)
-		{
-			reason = 3; break;
-		}
-
-		// Waiting on settle timer expiration.
-		if (fSettleTimeUS)
-		{
-			reason = 4; break;
-		}
-	} while (false);
-
-	fWaitReason = reason;
-
-	if (reason)
-	{
-		if (count)
-		{
-			PM_LOG1("[B %02x] %p [%p %s] state %d, reason %d\n",
-				request->getType(), OBFUSCATE(request), 
+            break;
+        }
+
+        // Waiting on driver's setPowerState() timeout.
+        if (fDriverTimer)
+        {
+            reason = 1; break;
+        }
+
+        // Child or interested driver acks pending.
+        if (fHeadNotePendingAcks)
+        {
+            reason = 2; break;
+        }
+
+        // Waiting on apps or priority power interest clients.
+        if (fResponseArray)
+        {
+            reason = 3; break;
+        }
+
+        // Waiting on settle timer expiration.
+        if (fSettleTimeUS)
+        {
+            reason = 4; break;
+        }
+    } while (false);
+
+    fWaitReason = reason;
+
+    if (reason)
+    {
+        if (count)
+        {
+            PM_LOG1("[B %02x] %p [%p %s] state %d, reason %d\n",
+                request->getType(), OBFUSCATE(request),
                 OBFUSCATE(this), getName(),
-				fMachineState, reason);
-		}
+                fMachineState, reason);
+        }
 
-		return true;
-	}
+        return true;
+    }
 
-	return false;
+    return false;
 }
 
 //*********************************************************************************
@@ -7195,31 +7144,31 @@ bool IOService::isPMBlocked( IOPMRequest * request, int count )
 
 bool IOService::servicePMRequest( 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;
+        gIOPMRequest = request;
         gIOPMWorkCount++;
 
-		// 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)
                 {
@@ -7230,153 +7179,115 @@ bool IOService::servicePMRequest( IOPMRequest * request, IOPMWorkQueue * queue )
                 }
 
                 // askChangeDown() done, was it vetoed?
-				if (!fDoNotPowerDown)
-				{
-                    if (IS_ROOT_DOMAIN) {
-                        PMEventDetails *details = PMEventDetails::eventDetails(
-                                                    kIOPMEventTypeAppNotificationsFinished,
-                                                    NULL,
-                                                    0,
-                                                    0);
-						
-						getPMRootDomain()->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:
@@ -7393,15 +7304,15 @@ bool IOService::servicePMRequest( IOPMRequest * request, IOPMWorkQueue * queue )
                         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()
@@ -7418,41 +7329,41 @@ bool IOService::servicePMRequest( IOPMRequest * request, IOPMWorkQueue * queue )
                         &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)
@@ -7515,22 +7426,22 @@ bool IOService::servicePMRequest( IOPMRequest * request, IOPMWorkQueue * queue )
                 tellClientsWithResponse( fOutOfBandMessage );
                 break;
 
-			default:
-				panic("servicePMWorkQueue: unknown machine state %x",
+            default:
+                panic("servicePMWorkQueue: 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;
 }
 
 //*********************************************************************************
@@ -7539,64 +7450,65 @@ bool IOService::servicePMRequest( IOPMRequest * request, IOPMWorkQueue * queue )
 
 void IOService::executePMRequest( IOPMRequest * request )
 {
-	assert( kIOPM_Finished == fMachineState );
+    assert( kIOPM_Finished == fMachineState );
 
-	switch (request->getType())
-	{
-		case kIOPMRequestTypePMStop:
-			handlePMstop( request );
-			break;
+    switch (request->getType())
+    {
+        case kIOPMRequestTypePMStop:
+            handlePMstop( request );
+            break;
 
-		case kIOPMRequestTypeAddPowerChild1:
-			addPowerChild1( request );
-			break;
+        case kIOPMRequestTypeAddPowerChild1:
+            addPowerChild1( request );
+            break;
 
-		case kIOPMRequestTypeAddPowerChild2:
-			addPowerChild2( request );
-			break;
+        case kIOPMRequestTypeAddPowerChild2:
+            addPowerChild2( request );
+            break;
 
-		case kIOPMRequestTypeAddPowerChild3:
-			addPowerChild3( request );
-			break;
+        case kIOPMRequestTypeAddPowerChild3:
+            addPowerChild3( request );
+            break;
 
-		case kIOPMRequestTypeRegisterPowerDriver:
-			handleRegisterPowerDriver( request );
-			break;
+        case kIOPMRequestTypeRegisterPowerDriver:
+            handleRegisterPowerDriver( request );
+            break;
 
-		case kIOPMRequestTypeAdjustPowerState:
-			fAdjustPowerScheduled = false;
-			adjustPowerState();
-			break;
+        case kIOPMRequestTypeAdjustPowerState:
+            fAdjustPowerScheduled = false;
+            adjustPowerState();
+            break;
 
-		case kIOPMRequestTypePowerDomainWillChange:
-			handlePowerDomainWillChangeTo( request );
-			break;
+        case kIOPMRequestTypePowerDomainWillChange:
+            handlePowerDomainWillChangeTo( request );
+            break;
 
-		case kIOPMRequestTypePowerDomainDidChange:
-			handlePowerDomainDidChangeTo( request );
-			break;
+        case kIOPMRequestTypePowerDomainDidChange:
+            handlePowerDomainDidChangeTo( request );
+            break;
 
-		case kIOPMRequestTypeRequestPowerState:
+        case kIOPMRequestTypeRequestPowerState:
         case kIOPMRequestTypeRequestPowerStateOverride:
-			handleRequestPowerState( request );
-			break;
+            handleRequestPowerState( request );
+            break;
 
-		case kIOPMRequestTypePowerOverrideOnPriv:
-		case kIOPMRequestTypePowerOverrideOffPriv:
-			handlePowerOverrideChanged( request );
-			break;
+        case kIOPMRequestTypePowerOverrideOnPriv:
+        case kIOPMRequestTypePowerOverrideOffPriv:
+            handlePowerOverrideChanged( request );
+            break;
 
-		case kIOPMRequestTypeActivityTickle:
-			handleActivityTickle( request );
-			break;
+        case kIOPMRequestTypeActivityTickle:
+            handleActivityTickle( request );
+            break;
 
         case kIOPMRequestTypeSynchronizePowerTree:
-			handleSynchronizePowerTree( request );
-			break;
+            handleSynchronizePowerTree( request );
+            break;
 
         case kIOPMRequestTypeSetIdleTimerPeriod:
             {
                 fIdleTimerPeriod = (uintptr_t) request->fArg0;
+                fNextIdleTimerPeriod = fIdleTimerPeriod;
                 if ((false == fLockedFlags.PMStop) && (fIdleTimerPeriod > 0))
                     restartIdleTimer();
             }
@@ -7606,9 +7518,9 @@ void IOService::executePMRequest( IOPMRequest * request )
             fIdleTimerIgnored = request->fArg0 ? 1 : 0;
             break;
 
-		default:
-			panic("executePMRequest: unknown request type %x", request->getType());
-	}
+        default:
+            panic("executePMRequest: unknown request type %x", request->getType());
+    }
 }
 
 //*********************************************************************************
@@ -7617,24 +7529,24 @@ void IOService::executePMRequest( IOPMRequest * request )
 
 bool IOService::servicePMReplyQueue( 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.
@@ -7652,115 +7564,105 @@ bool IOService::servicePMReplyQueue( IOPMRequest * request, IOPMRequestQueue * q
                         getPMRootDomain()->pmStatsRecordApplicationResponse(
                             gIOPMStatsApplicationResponseCancel,
                             name ? name->getCStringNoCopy() : "", 0,
-                            0, (int)(uintptr_t) request->fArg1);
+                            0, (int)(uintptr_t) request->fArg1, 0);
                     }
                 }
 
-				if (checkForDone())
-				{
-					stop_ack_timer();
+                if (checkForDone())
+                {
+                    stop_ack_timer();
                     cleanClientResponses(false);
-					more = true;
-				}
-			}
+                    more = true;
+                }
+            }
             // OSString containing app name in Arg2 must be released.
             if (request->getType() == kIOPMRequestTypeCancelPowerChange)
             {
                 OSObject * obj = (OSObject *) request->fArg2;
                 if (obj) obj->release();
             }
-			break;
-
-		case kIOPMRequestTypeAckPowerChange:
-			more = handleAcknowledgePowerChange( request );
-			break;
-
-		case kIOPMRequestTypeAckSetPowerState:
-			if (fDriverTimer == -1)
-			{
-				// driver acked while setPowerState() call is in-flight.
-				// take this ack, return value from setPowerState() is irrelevant.
-				OUR_PMLog(kPMLogDriverAcknowledgeSet,
-					(uintptr_t) this, fDriverTimer);
-				fDriverTimer = 0;
-			}
-			else if (fDriverTimer > 0)
-			{
-				// expected ack, stop the timer
-				stop_ack_timer();
+            break;
+
+        case kIOPMRequestTypeAckPowerChange:
+            more = handleAcknowledgePowerChange( request );
+            break;
+
+        case kIOPMRequestTypeAckSetPowerState:
+            if (fDriverTimer == -1)
+            {
+                // driver acked while setPowerState() call is in-flight.
+                // take this ack, return value from setPowerState() is irrelevant.
+                OUR_PMLog(kPMLogDriverAcknowledgeSet,
+                    (uintptr_t) this, fDriverTimer);
+                fDriverTimer = 0;
+            }
+            else if (fDriverTimer > 0)
+            {
+                // expected ack, stop the timer
+                stop_ack_timer();
 
 #if LOG_SETPOWER_TIMES
                 uint64_t nsec = computeTimeDeltaNS(&fDriverCallStartTime);
-                if (nsec > LOG_SETPOWER_TIMES)
-                    PM_LOG("%s::setPowerState(%p, %lu -> %lu) async took %d ms\n",
-                        fName, 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))
+                    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",
+        default:
+            panic("servicePMReplyQueue: unknown reply type %x",
                 request->getType());
-	}
+    }
 
-	more |= gIOPMFreeQueue->queuePMRequest(request);
+    more |= gIOPMFreeQueue->queuePMRequest(request);
     if (more)
         gIOPMWorkQueue->incrementProducerCount();
 
-	return more;
+    return more;
 }
 
 //*********************************************************************************
@@ -7784,7 +7686,7 @@ bool IOService::assertPMDriverCall(
     {
         goto fail;
     }
-    
+
     if (((options & kIOPMADC_NoInactiveCheck) == 0) && isInactive())
     {
         goto fail;
@@ -7862,7 +7764,7 @@ void IOService::waitForPMDriverCall( IOService * target )
                 }
                 continue;
             }
-            
+
             wait = true;
             break;
         }
@@ -7890,7 +7792,7 @@ const char * IOService::getIOMessageString( uint32_t msg )
 {
 #define MSG_ENTRY(x)    {(int) x, #x}
 
-    static const IONamedValue msgNames[] = { 
+    static const IONamedValue msgNames[] = {
         MSG_ENTRY( kIOMessageCanDevicePowerOff      ),
         MSG_ENTRY( kIOMessageDeviceWillPowerOff     ),
         MSG_ENTRY( kIOMessageDeviceWillNotPowerOff  ),
@@ -7925,54 +7827,54 @@ OSDefineMetaClassAndStructors( IOPMRequest, IOCommand );
 
 IOPMRequest * IOPMRequest::create( void )
 {
-	IOPMRequest * me = OSTypeAlloc(IOPMRequest);
-	if (me && !me->init(0, kIOPMRequestTypeInvalid))
-	{
-		me->release();
-		me = 0;
-	}
-	return me;
+    IOPMRequest * me = OSTypeAlloc(IOPMRequest);
+    if (me && !me->init(0, kIOPMRequestTypeInvalid))
+    {
+        me->release();
+        me = 0;
+    }
+    return me;
 }
 
 bool IOPMRequest::init( IOService * target, IOOptionBits type )
 {
-	if (!IOCommand::init())
-		return false;
+    if (!IOCommand::init())
+        return false;
 
-	fType             = type;
-	fTarget           = target;
+    fType             = type;
+    fTarget           = target;
 #if NOT_READY
     fCompletionStatus = kIOReturnSuccess;
 #endif
 
-	if (fTarget)
-		fTarget->retain();
+    if (fTarget)
+        fTarget->retain();
 
-	return true;
+    return true;
 }
 
 void IOPMRequest::reset( void )
 {
-	assert( fWorkWaitCount == 0 );
-	assert( fFreeWaitCount == 0 );
+    assert( fWorkWaitCount == 0 );
+    assert( fFreeWaitCount == 0 );
 
-	detachNextRequest();
+    detachNextRequest();
     detachRootRequest();
 
-	fType = kIOPMRequestTypeInvalid;
+    fType = kIOPMRequestTypeInvalid;
 
 #if NOT_READY
-	if (fCompletionAction)
-	{
+    if (fCompletionAction)
+    {
         fCompletionAction(fCompletionTarget, fCompletionParam, fCompletionStatus);
     }
 #endif
 
-	if (fTarget)
-	{
-		fTarget->release();
-		fTarget = 0;
-	}	
+    if (fTarget)
+    {
+        fTarget->release();
+        fTarget = 0;
+    }
 }
 
 bool IOPMRequest::attachNextRequest( IOPMRequest * next )
@@ -8076,82 +7978,82 @@ OSDefineMetaClassAndStructors( IOPMRequestQueue, IOEventSource );
 
 IOPMRequestQueue * IOPMRequestQueue::create( IOService * inOwner, Action inAction )
 {
-	IOPMRequestQueue * me = OSTypeAlloc(IOPMRequestQueue);
-	if (me && !me->init(inOwner, inAction))
-	{
-		me->release();
-		me = 0;
-	}
-	return me;
+    IOPMRequestQueue * me = OSTypeAlloc(IOPMRequestQueue);
+    if (me && !me->init(inOwner, inAction))
+    {
+        me->release();
+        me = 0;
+    }
+    return me;
 }
 
 bool IOPMRequestQueue::init( IOService * inOwner, Action inAction )
 {
-	if (!inAction || !IOEventSource::init(inOwner, (IOEventSourceAction)inAction))
+    if (!inAction || !IOEventSource::init(inOwner, (IOEventSourceAction)inAction))
         return false;
 
-	queue_init(&fQueue);
-	fLock = IOLockAlloc();
-	return (fLock != 0);
+    queue_init(&fQueue);
+    fLock = IOLockAlloc();
+    return (fLock != 0);
 }
 
 void IOPMRequestQueue::free( void )
 {
-	if (fLock)
-	{
-		IOLockFree(fLock);
-		fLock = 0;
-	}
-	return IOEventSource::free();
+    if (fLock)
+    {
+        IOLockFree(fLock);
+        fLock = 0;
+    }
+    return IOEventSource::free();
 }
 
 void IOPMRequestQueue::queuePMRequest( IOPMRequest * request )
 {
-	assert(request);
-	IOLockLock(fLock);
-	queue_enter(&fQueue, request, IOPMRequest *, fCommandChain);
-	IOLockUnlock(fLock);
-	if (workLoop) signalWorkAvailable();
+    assert(request);
+    IOLockLock(fLock);
+    queue_enter(&fQueue, request, IOPMRequest *, 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, IOPMRequest *, 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;
+    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))
+    {
+        queue_remove_first( &fQueue, request, IOPMRequest *, fCommandChain );
+        IOLockUnlock( fLock );
+        target = request->getTarget();
+        assert(target);
+        more |= (*dqAction)( target, request, this );
+        IOLockLock( fLock );
+    }
 
-	IOLockUnlock( fLock );
-	return more;
+    IOLockUnlock( fLock );
+    return more;
 }
 
 // MARK: -
@@ -8168,28 +8070,28 @@ OSDefineMetaClassAndStructors( IOPMWorkQueue, IOEventSource );
 IOPMWorkQueue *
 IOPMWorkQueue::create( IOService * inOwner, Action work, 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, work, retire))
+    {
+        me->release();
+        me = 0;
+    }
+    return me;
 }
 
 bool IOPMWorkQueue::init( IOService * inOwner, Action work, Action retire )
 {
-	if (!work || !retire ||
-		!IOEventSource::init(inOwner, (IOEventSourceAction)0))
-		return false;
+    if (!work || !retire ||
+        !IOEventSource::init(inOwner, (IOEventSourceAction)0))
+        return false;
 
-	queue_init(&fWorkQueue);
+    queue_init(&fWorkQueue);
 
-	fWorkAction    = work;
-	fRetireAction  = retire;
+    fWorkAction    = work;
+    fRetireAction  = retire;
     fConsumerCount = fProducerCount = 0;
 
-	return true;
+    return true;
 }
 
 bool IOPMWorkQueue::queuePMRequest( IOPMRequest * request, IOServicePM * pwrMgt )
@@ -8197,20 +8099,20 @@ bool IOPMWorkQueue::queuePMRequest( IOPMRequest * request, IOServicePM * pwrMgt
     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++;
+    gIOPMBusyCount++;
 
     // 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);
+    queue_enter(&pwrMgt->RequestHead, request, IOPMRequest *, fCommandChain);
     if (empty)
     {
         more = checkRequestQueue(&pwrMgt->RequestHead, &empty);
@@ -8232,24 +8134,24 @@ bool IOPMWorkQueue::queuePMRequest( IOPMRequest * request, IOServicePM * pwrMgt
 
 bool IOPMWorkQueue::checkRequestQueue( queue_head_t * queue, bool * empty )
 {
-	IOPMRequest *	request;
-	IOService *		target;
+    IOPMRequest *   request;
+    IOService *     target;
     bool            more = false;
-	bool			done = false;
+    bool            done = false;
 
     assert(!queue_empty(queue));
     do {
-		request = (IOPMRequest *) queue_first(queue);
-		if (request->isWorkBlocked())
+        request = (IOPMRequest *) queue_first(queue);
+        if (request->isWorkBlocked())
             break;  // cannot start, blocked on attached request
 
-		target = request->getTarget();
+        target = request->getTarget();
         done = (*fWorkAction)( target, request, this );
-		if (!done)
+        if (!done)
             break;  // work started, blocked on PM state machine
 
         assert(gIOPMBusyCount > 0);
-		if (gIOPMBusyCount)
+        if (gIOPMBusyCount)
             gIOPMBusyCount--;
 
         queue_remove_first(queue, request, IOPMRequest *, fCommandChain);
@@ -8272,9 +8174,9 @@ bool IOPMWorkQueue::checkRequestQueue( queue_head_t * queue, bool * empty )
 
 bool IOPMWorkQueue::checkForWork( void )
 {
-	IOServicePM *   entry;
-	IOServicePM *   next;
-    bool			more = false;
+    IOServicePM *   entry;
+    IOServicePM *   next;
+    bool            more = false;
     bool            empty;
 
 #if WORK_QUEUE_STATS
@@ -8291,7 +8193,7 @@ bool IOPMWorkQueue::checkForWork( void )
 
         fConsumerCount = fProducerCount;
 
-#if WORK_QUEUE_STATS        
+#if WORK_QUEUE_STATS
         if (queue_empty(&fWorkQueue))
         {
             fStatQueueEmpty++;
@@ -8333,7 +8235,7 @@ bool IOPMWorkQueue::checkForWork( void )
 void IOPMWorkQueue::signalWorkAvailable( void )
 {
     fProducerCount++;
-	IOEventSource::signalWorkAvailable();
+    IOEventSource::signalWorkAvailable();
 }
 
 void IOPMWorkQueue::incrementProducerCount( void )
@@ -8353,48 +8255,48 @@ OSDefineMetaClassAndStructors( IOPMCompletionQueue, IOEventSource );
 IOPMCompletionQueue *
 IOPMCompletionQueue::create( IOService * inOwner, Action inAction )
 {
-	IOPMCompletionQueue * me = OSTypeAlloc(IOPMCompletionQueue);
-	if (me && !me->init(inOwner, inAction))
-	{
-		me->release();
-		me = 0;
-	}
-	return me;
+    IOPMCompletionQueue * me = OSTypeAlloc(IOPMCompletionQueue);
+    if (me && !me->init(inOwner, inAction))
+    {
+        me->release();
+        me = 0;
+    }
+    return me;
 }
 
 bool IOPMCompletionQueue::init( IOService * inOwner, Action inAction )
 {
-	if (!inAction || !IOEventSource::init(inOwner, (IOEventSourceAction)inAction))
+    if (!inAction || !IOEventSource::init(inOwner, (IOEventSourceAction)inAction))
         return false;
 
-	queue_init(&fQueue);
-	return true;
+    queue_init(&fQueue);
+    return true;
 }
 
 bool IOPMCompletionQueue::queuePMRequest( IOPMRequest * request )
 {
     bool more;
 
-	assert(request);
+    assert(request);
     // unblock dependent request
     more = request->detachNextRequest();
-	queue_enter(&fQueue, request, IOPMRequest *, fCommandChain);
+    queue_enter(&fQueue, request, IOPMRequest *, 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);
     while (!queue_end(&fQueue, (queue_entry_t) request))
     {
         next = (IOPMRequest *) queue_next(&request->fCommandChain);
-		if (!request->isFreeBlocked())
+        if (!request->isFreeBlocked())
         {
             queue_remove(&fQueue, request, IOPMRequest *, fCommandChain);
             target = request->getTarget();
@@ -8431,13 +8333,13 @@ setPMProperty( OSDictionary * dict, const char * key, uint64_t value )
 
 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)
     {
@@ -8459,9 +8361,10 @@ IOReturn IOServicePM::gatedSerialize( OSSerialize * s  ) const
     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)
@@ -8473,38 +8376,38 @@ IOReturn IOServicePM::gatedSerialize( OSSerialize * s  ) const
         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)
@@ -8526,11 +8429,11 @@ IOReturn IOServicePM::gatedSerialize( OSSerialize * s  ) const
             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
@@ -8544,11 +8447,11 @@ 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);
 }
@@ -8598,52 +8501,3 @@ void IOServicePM::pmTrace(
     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;
-}
-