xnu-3789.41.3.tar.gz

[apple/xnu.git] / iokit / Kernel / IOServicePM.cpp

diff --git a/iokit/Kernel/IOServicePM.cpp b/iokit/Kernel/IOServicePM.cpp
index 9ba2e752ca32e3851e545f02898afc5e035375ad..e7fbb08029bb668b45c52a7067c22f1b4bce748d 100644 (file)
--- a/iokit/Kernel/IOServicePM.cpp
+++ b/iokit/Kernel/IOServicePM.cpp
@@ -1,5 +1,5 @@
 /*
 /*

- * Copyright (c) 1998-2006 Apple Computer, Inc. All rights reserved.
+ * Copyright (c) 1998-2016 Apple Inc. All rights reserved.

  *
  * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
  * 
  *
  * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
  * 


@@ -26,9 +26,6 @@
  * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
  */
 
  * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
  */
 

-//#undef IOASSERT
-//#define IOASSERT    1
-

 #include <IOKit/assert.h>
 #include <IOKit/IOKitDebug.h>
 #include <IOKit/IOLib.h>
 #include <IOKit/assert.h>
 #include <IOKit/IOKitDebug.h>
 #include <IOKit/IOLib.h>


@@ -50,6 +47,7 @@
 
 #include <sys/proc.h>
 #include <sys/proc_internal.h>
 
 #include <sys/proc.h>
 #include <sys/proc_internal.h>

+#include <sys/sysctl.h>

 #include <libkern/OSDebug.h>
 #include <kern/thread.h>
 
 #include <libkern/OSDebug.h>
 #include <kern/thread.h>
 


@@ -79,26 +77,37 @@ static uint64_t computeTimeDeltaNS( const AbsoluteTime * start )
 OSDefineMetaClassAndStructors(IOPMprot, OSObject)
 #endif
 
 OSDefineMetaClassAndStructors(IOPMprot, OSObject)
 #endif
 

-// Container class for recording system power events
-OSDefineMetaClassAndStructors( PMEventDetails, OSObject );
-

 //******************************************************************************
 // Globals
 //******************************************************************************
 
 static bool                  gIOPMInitialized       = false;
 //******************************************************************************
 // Globals
 //******************************************************************************
 
 static bool                  gIOPMInitialized       = false;

-static uint32_t              gIOPMBusyCount         = 0;
-static uint32_t              gIOPMWorkCount         = 0;
+static uint32_t              gIOPMBusyRequestCount  = 0;
+static uint32_t              gIOPMWorkInvokeCount   = 0;

 static uint32_t              gIOPMTickleGeneration  = 0;
 static IOWorkLoop *          gIOPMWorkLoop          = 0;
 static IOPMRequestQueue *    gIOPMRequestQueue      = 0;
 static IOPMRequestQueue *    gIOPMReplyQueue        = 0;
 static IOPMWorkQueue *       gIOPMWorkQueue         = 0;
 static uint32_t              gIOPMTickleGeneration  = 0;
 static IOWorkLoop *          gIOPMWorkLoop          = 0;
 static IOPMRequestQueue *    gIOPMRequestQueue      = 0;
 static IOPMRequestQueue *    gIOPMReplyQueue        = 0;
 static IOPMWorkQueue *       gIOPMWorkQueue         = 0;

-static IOPMCompletionQueue * gIOPMFreeQueue         = 0;
+static IOPMCompletionQueue * gIOPMCompletionQueue   = 0;

 static IOPMRequest *         gIOPMRequest           = 0;
 static IOService *           gIOPMRootNode          = 0;
 static IOPlatformExpert *    gPlatform              = 0;
 
 static IOPMRequest *         gIOPMRequest           = 0;
 static IOService *           gIOPMRootNode          = 0;
 static IOPlatformExpert *    gPlatform              = 0;
 

+static char                  gIOSpinDumpKextName[128];
+static char                  gIOSpinDumpDelayType[16];
+static uint32_t              gIOSpinDumpDelayDuration = 0;
+
+static SYSCTL_STRING(_debug, OID_AUTO, swd_kext_name,
+        CTLFLAG_RW | CTLFLAG_KERN | CTLFLAG_LOCKED,
+        &gIOSpinDumpKextName, sizeof(gIOSpinDumpKextName), "");
+static SYSCTL_STRING(_debug, OID_AUTO, swd_delay_type,
+        CTLFLAG_RW | CTLFLAG_KERN | CTLFLAG_LOCKED,
+        &gIOSpinDumpDelayType, sizeof(gIOSpinDumpDelayType), "");
+static SYSCTL_INT(_debug, OID_AUTO, swd_delay_duration,
+        CTLFLAG_RW | CTLFLAG_KERN | CTLFLAG_LOCKED,
+        &gIOSpinDumpDelayDuration, 0, "");
+

 const OSSymbol *             gIOPMPowerClientDevice     = 0;
 const OSSymbol *             gIOPMPowerClientDriver     = 0;
 const OSSymbol *             gIOPMPowerClientChildProxy = 0;
 const OSSymbol *             gIOPMPowerClientDevice     = 0;
 const OSSymbol *             gIOPMPowerClientDriver     = 0;
 const OSSymbol *             gIOPMPowerClientChildProxy = 0;


@@ -108,11 +117,12 @@ const OSSymbol *             gIOPMPowerClientRootDomain = 0;
 static const OSSymbol *      gIOPMPowerClientAdvisoryTickle = 0;
 static bool                  gIOPMAdvisoryTickleEnabled = true;
 static thread_t              gIOPMWatchDogThread        = NULL;
 static const OSSymbol *      gIOPMPowerClientAdvisoryTickle = 0;
 static bool                  gIOPMAdvisoryTickleEnabled = true;
 static thread_t              gIOPMWatchDogThread        = NULL;

+uint32_t                     gCanSleepTimeout           = 0;

 
 static uint32_t getPMRequestType( void )
 {
     uint32_t type = kIOPMRequestTypeInvalid;
 
 static uint32_t getPMRequestType( void )
 {
     uint32_t type = kIOPMRequestTypeInvalid;

-       if (gIOPMRequest)
+    if (gIOPMRequest)

         type = gIOPMRequest->getType();
     return type;
 }
         type = gIOPMRequest->getType();
     return type;
 }


@@ -128,14 +138,13 @@ static IOPMRequestTag getPMRequestTag( void )
     return tag;
 }
 
     return tag;
 }
 

+SYSCTL_UINT(_kern, OID_AUTO, pmtimeout, CTLFLAG_RW | CTLFLAG_LOCKED, &gCanSleepTimeout, 0, "Power Management Timeout");
+

 //******************************************************************************
 // Macros
 //******************************************************************************
 
 //******************************************************************************
 // Macros
 //******************************************************************************
 

-#define OBFUSCATE(x) ((void *)(VM_KERNEL_ADDRPERM(x)))
-

 #define PM_ERROR(x...)              do { kprintf(x);IOLog(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)
 
                                     } while (false)
 #define PM_LOG(x...)                do { kprintf(x); } while (false)
 


@@ -157,7 +166,6 @@ static IOPMRequestTag getPMRequestTag( void )
                                     if ((kIOLogPMRootDomain & gIOKitDebug) && \
                                         (getPMRootDomain() == this)) { \
                                         kprintf("PMRD: " x); \
                                     if ((kIOLogPMRootDomain & gIOKitDebug) && \
                                         (getPMRootDomain() == this)) { \
                                         kprintf("PMRD: " x); \

-                                        getPMRootDomain()->sleepWakeDebugLog(x); \

                                     }} while (false)
 #define PM_ASSERT_IN_GATE(x)          \
 do {                                  \
                                     }} while (false)
 #define PM_ASSERT_IN_GATE(x)          \
 do {                                  \


@@ -169,18 +177,42 @@ do {                                  \
 #define PM_LOCK_SLEEP(event, dl)    IOLockSleepDeadline(fPMLock, event, dl, THREAD_UNINT)
 #define PM_LOCK_WAKEUP(event)       IOLockWakeup(fPMLock, event, false)
 
 #define PM_LOCK_SLEEP(event, dl)    IOLockSleepDeadline(fPMLock, event, dl, THREAD_UNINT)
 #define PM_LOCK_WAKEUP(event)       IOLockWakeup(fPMLock, event, false)
 

+#define us_per_s                    1000000

 #define ns_per_us                   1000
 #define ns_per_us                   1000

-#define k30Seconds                  (30*1000000)
+#define k30Seconds                  (30*us_per_s)
+#define k5Seconds                   ( 5*us_per_s)
+#define kCanSleepMaxTimeReq         k30Seconds
+#define kMaxTimeRequested           k30Seconds

 #define kMinAckTimeoutTicks         (10*1000000)
 #define kIOPMTardyAckSPSKey         "IOPMTardyAckSetPowerState"
 #define kIOPMTardyAckPSCKey         "IOPMTardyAckPowerStateChange"
 #define kPwrMgtKey                  "IOPowerManagement"
 
 #define kMinAckTimeoutTicks         (10*1000000)
 #define kIOPMTardyAckSPSKey         "IOPMTardyAckSetPowerState"
 #define kIOPMTardyAckPSCKey         "IOPMTardyAckPowerStateChange"
 #define kPwrMgtKey                  "IOPowerManagement"
 

-#define OUR_PMLog(t, a, b) do {          \
-    if (gIOKitDebug & kIOLogPower)       \
-        pwrMgt->pmPrint(t, a, b);        \
-    if (gIOKitTrace & kIOTracePowerMgmt) \
-        pwrMgt->pmTrace(t, a, b);        \
+#define OUR_PMLog(t, a, b) do {                 \
+    if (pwrMgt) {                               \
+        if (gIOKitDebug & kIOLogPower)          \
+            pwrMgt->pmPrint(t, a, b);           \
+        if (gIOKitTrace & kIOTracePowerMgmt)    \
+            pwrMgt->pmTrace(t, DBG_FUNC_NONE, a, b);        \
+    }                                           \
+    } while(0)
+
+#define OUR_PMLogFuncStart(t, a, b) do {        \
+    if (pwrMgt) {                               \
+        if (gIOKitDebug & kIOLogPower)          \
+            pwrMgt->pmPrint(t, a, b);           \
+        if (gIOKitTrace & kIOTracePowerMgmt)    \
+            pwrMgt->pmTrace(t, DBG_FUNC_START, a, b);       \
+    }                                           \
+    } while(0)
+
+#define OUR_PMLogFuncEnd(t, a, b) do {          \
+    if (pwrMgt) {                               \
+        if (gIOKitDebug & kIOLogPower)          \
+            pwrMgt->pmPrint(-t, a, b);          \
+        if (gIOKitTrace & kIOTracePowerMgmt)    \
+            pwrMgt->pmTrace(t, DBG_FUNC_END, a, b);        \
+    }                                           \

     } while(0)
 
 #define NS_TO_MS(nsec)              ((int)((nsec) / 1000000ULL))
     } while(0)
 
 #define NS_TO_MS(nsec)              ((int)((nsec) / 1000000ULL))


@@ -199,7 +231,11 @@ do {                                  \
 #define IS_POWER_RISE               (StateOrder(fHeadNotePowerState) > StateOrder(fCurrentPowerState))
 
 // log setPowerStates longer than (ns):
 #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)
 #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):
 // 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 +272,12 @@ enum {
          } while (false)
 
 static OSNumber * copyClientIDForNotification(
          } while (false)
 
 static OSNumber * copyClientIDForNotification(

-    OSObject *object, 
+    OSObject *object,

     IOPMInterestContext *context);
 
 static void logClientIDForNotification(
     OSObject *object,
     IOPMInterestContext *context);
 
 static void logClientIDForNotification(
     OSObject *object,

-    IOPMInterestContext *context, 
+    IOPMInterestContext *context,

     const char *logString);
 
 //*********************************************************************************
     const char *logString);
 
 //*********************************************************************************


@@ -295,31 +331,30 @@ enum {
 void IOService::PMinit( void )
 {
     if ( !initialized )
 void IOService::PMinit( void )
 {
     if ( !initialized )

-       {
-               if ( !gIOPMInitialized )
-               {
+    {
+        if ( !gIOPMInitialized )
+        {

             gPlatform = getPlatform();
             gIOPMWorkLoop = IOWorkLoop::workLoop();
             if (gIOPMWorkLoop)
             {
                 gIOPMRequestQueue = IOPMRequestQueue::create(
                     this, OSMemberFunctionCast(IOPMRequestQueue::Action,
             gPlatform = getPlatform();
             gIOPMWorkLoop = IOWorkLoop::workLoop();
             if (gIOPMWorkLoop)
             {
                 gIOPMRequestQueue = IOPMRequestQueue::create(
                     this, OSMemberFunctionCast(IOPMRequestQueue::Action,

-                        this, &IOService::servicePMRequestQueue));
+                        this, &IOService::actionPMRequestQueue));

 
                 gIOPMReplyQueue = IOPMRequestQueue::create(
                     this, OSMemberFunctionCast(IOPMRequestQueue::Action,
 
                 gIOPMReplyQueue = IOPMRequestQueue::create(
                     this, OSMemberFunctionCast(IOPMRequestQueue::Action,

-                        this, &IOService::servicePMReplyQueue));
+                        this, &IOService::actionPMReplyQueue));

 
 

-                gIOPMWorkQueue = IOPMWorkQueue::create(
-                    this,
+                gIOPMWorkQueue = IOPMWorkQueue::create(this,

                     OSMemberFunctionCast(IOPMWorkQueue::Action, this,
                     OSMemberFunctionCast(IOPMWorkQueue::Action, this,

-                        &IOService::servicePMRequest),
+                        &IOService::actionPMWorkQueueInvoke),

                     OSMemberFunctionCast(IOPMWorkQueue::Action, this,
                     OSMemberFunctionCast(IOPMWorkQueue::Action, this,

-                        &IOService::retirePMRequest));
+                        &IOService::actionPMWorkQueueRetire));

 
 

-                gIOPMFreeQueue = IOPMCompletionQueue::create(
+                gIOPMCompletionQueue = IOPMCompletionQueue::create(

                     this, OSMemberFunctionCast(IOPMCompletionQueue::Action,
                     this, OSMemberFunctionCast(IOPMCompletionQueue::Action,

-                        this, &IOService::servicePMFreeQueue));
+                        this, &IOService::actionPMCompletionQueue));

 
                 if (gIOPMWorkLoop->addEventSource(gIOPMRequestQueue) !=
                     kIOReturnSuccess)
 
                 if (gIOPMWorkLoop->addEventSource(gIOPMRequestQueue) !=
                     kIOReturnSuccess)


@@ -342,11 +377,13 @@ void IOService::PMinit( void )
                     gIOPMWorkQueue = 0;
                 }
 
                     gIOPMWorkQueue = 0;
                 }
 

-                if (gIOPMWorkLoop->addEventSource(gIOPMFreeQueue) !=
+                // Must be added after the work queue, which pushes request
+                // to the completion queue without signaling the work loop.
+                if (gIOPMWorkLoop->addEventSource(gIOPMCompletionQueue) !=

                     kIOReturnSuccess)
                 {
                     kIOReturnSuccess)
                 {

-                    gIOPMFreeQueue->release();
-                    gIOPMFreeQueue = 0;
+                    gIOPMCompletionQueue->release();
+                    gIOPMCompletionQueue = 0;

                 }
 
                 gIOPMPowerClientDevice =
                 }
 
                 gIOPMPowerClientDevice =


@@ -366,9 +403,12 @@ void IOService::PMinit( void )
 
                 gIOPMPowerClientRootDomain =
                     OSSymbol::withCStringNoCopy( "RootDomainPower" );
 
                 gIOPMPowerClientRootDomain =
                     OSSymbol::withCStringNoCopy( "RootDomainPower" );

+
+                gIOSpinDumpKextName[0] = '\0';
+                gIOSpinDumpDelayType[0] = '\0';

             }
 
             }
 

-            if (gIOPMRequestQueue && gIOPMReplyQueue && gIOPMFreeQueue)
+            if (gIOPMRequestQueue && gIOPMReplyQueue && gIOPMCompletionQueue)

                 gIOPMInitialized = true;
         }
         if (!gIOPMInitialized)
                 gIOPMInitialized = true;
         }
         if (!gIOPMInitialized)


@@ -430,20 +470,25 @@ void IOService::PMinit( void )
         }
 
         fAckTimer = thread_call_allocate(
         }
 
         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(
         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(
         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);
         assert(fDriverCallEntry);

+        if (kIOKextSpinDump & gIOKitDebug)
+        {
+            fSpinDumpTimer = thread_call_allocate(
+                &IOService::spindump_timer_expired, (thread_call_param_t)this);
+        }

 
         // Check for powerChangeDone override.
         if (OSMemberFunctionCast(void (*)(void),
 
         // 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;
         }
         {
             fPCDFunctionOverride = true;
         }


@@ -457,7 +502,7 @@ void IOService::PMinit( void )
             prot->thePlatform = gPlatform;
             fPMVars = prot;
             pm_vars = prot;
             prot->thePlatform = gPlatform;
             fPMVars = prot;
             pm_vars = prot;

-               }
+        }

 #else
         pm_vars = (void *) (uintptr_t) true;
 #endif
 #else
         pm_vars = (void *) (uintptr_t) true;
 #endif


@@ -511,6 +556,11 @@ void IOService::PMfree( void )
             thread_call_free(fDriverCallEntry);
             fDriverCallEntry = NULL;
         }
             thread_call_free(fDriverCallEntry);
             fDriverCallEntry = NULL;
         }

+        if ( fSpinDumpTimer ) {
+            thread_call_cancel(fSpinDumpTimer);
+            thread_call_free(fSpinDumpTimer);
+            fSpinDumpTimer = NULL;
+        }

         if ( fPMLock ) {
             IOLockFree(fPMLock);
             fPMLock = NULL;
         if ( fPMLock ) {
             IOLockFree(fPMLock);
             fPMLock = NULL;


@@ -648,20 +698,20 @@ void IOService::PMstop( void )
 void IOService::handlePMstop( IOPMRequest * request )
 {
     OSIterator *        iter;
 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
 
     // remove driver from prevent system sleep lists
     getPMRootDomain()->updatePreventIdleSleepList(this, false);
     getPMRootDomain()->updatePreventSystemSleepList(this, false);
 
     // remove the property

-    removeProperty(kPwrMgtKey);                        
+    removeProperty(kPwrMgtKey);

 
     // detach parents
     iter = getParentIterator(gIOPowerPlane);
 
     // detach parents
     iter = getParentIterator(gIOPowerPlane);


@@ -684,7 +734,7 @@ void IOService::handlePMstop( IOPMRequest * request )
 
     // detach IOConnections
     detachAbove( gIOPowerPlane );
 
     // detach IOConnections
     detachAbove( gIOPowerPlane );

-    
+

     // no more power state changes
     fParentsKnowState = false;
 
     // no more power state changes
     fParentsKnowState = false;
 


@@ -720,8 +770,8 @@ void IOService::handlePMstop( IOPMRequest * request )
 
     if ( fInterestedDrivers )
     {
 
     if ( fInterestedDrivers )
     {

-        IOPMinformeeList *     list = fInterestedDrivers;
-        IOPMinformee *         item;
+        IOPMinformeeList *  list = fInterestedDrivers;
+        IOPMinformee *      item;

 
         PM_LOCK();
         while ((item = list->firstInList()))
 
         PM_LOCK();
         while ((item = list->firstInList()))


@@ -749,104 +799,104 @@ void IOService::handlePMstop( IOPMRequest * request )
 
 IOReturn IOService::addPowerChild( IOService * child )
 {
 
 IOReturn IOService::addPowerChild( IOService * child )
 {

-       IOPowerConnection *     connection  = 0;
-       IOPMRequest *           requests[3] = {0, 0, 0};
-    OSIterator *               iter;
-       bool                            ok = true;
+    IOPowerConnection * connection  = 0;
+    IOPMRequest *       requests[3] = {0, 0, 0};
+    OSIterator *        iter;
+    bool                ok = true;

 
 

-       if (!child)
-               return kIOReturnBadArgument;
+    if (!child)
+        return kIOReturnBadArgument;

 
     if (!initialized || !child->initialized)
 
     if (!initialized || !child->initialized)

-               return IOPMNotYetInitialized;
+        return IOPMNotYetInitialized;

 
     OUR_PMLog( kPMLogAddChild, (uintptr_t) child, 0 );
 
 
     OUR_PMLog( kPMLogAddChild, (uintptr_t) child, 0 );
 

-       do {
-               // Is this child already one of our children?
+    do {
+        // Is this child already one of our children?

 
 

-               iter = child->getParentIterator( gIOPowerPlane );
-               if ( iter )
-               {
-                       IORegistryEntry *       entry;
-                       OSObject *                      next;
-
-                       while ((next = iter->getNextObject()))
-                       {
-                               if ((entry = OSDynamicCast(IORegistryEntry, next)) &&
-                                       isChild(entry, gIOPowerPlane))
-                               {
-                                       ok = false;
-                                       break;
-                               }                       
-                       }
-                       iter->release();
-               }
-               if (!ok)
-               {
-                       PM_LOG("%s: %s (%p) is already a child\n",
-                               getName(), child->getName(), OBFUSCATE(child));
-                       break;
-               }
+        iter = child->getParentIterator( gIOPowerPlane );
+        if ( iter )
+        {
+            IORegistryEntry *   entry;
+            OSObject *          next;
+
+            while ((next = iter->getNextObject()))
+            {
+                if ((entry = OSDynamicCast(IORegistryEntry, next)) &&
+                    isChild(entry, gIOPowerPlane))
+                {
+                    ok = false;
+                    break;
+                }
+            }
+            iter->release();
+        }
+        if (!ok)
+        {
+            PM_LOG("%s: %s (%p) is already a child\n",
+                getName(), child->getName(), OBFUSCATE(child));
+            break;
+        }

 
 

-               // Add the child to the power plane immediately, but the
-               // joining connection is marked as not ready.
-               // We want the child to appear in the power plane before
-               // returning to the caller, but don't want the caller to
-               // block on the PM work loop.
+        // Add the child to the power plane immediately, but the
+        // joining connection is marked as not ready.
+        // We want the child to appear in the power plane before
+        // returning to the caller, but don't want the caller to
+        // block on the PM work loop.

 
 

-               connection = new IOPowerConnection;
-               if (!connection)
-                       break;
+        connection = new IOPowerConnection;
+        if (!connection)
+            break;

 
 

-               // Create a chain of PM requests to perform the bottom-half
-               // work from the PM work loop.
+        // Create a chain of PM requests to perform the bottom-half
+        // work from the PM work loop.

 
 

-               requests[0] = acquirePMRequest(
-                                       /* target */ this,
-                                       /* type */   kIOPMRequestTypeAddPowerChild1 );
+        requests[0] = acquirePMRequest(
+                    /* target */ this,
+                    /* type */   kIOPMRequestTypeAddPowerChild1 );

 
 

-               requests[1] = acquirePMRequest(
-                                       /* target */ child,
-                                       /* type */   kIOPMRequestTypeAddPowerChild2 );
+        requests[1] = acquirePMRequest(
+                    /* target */ child,
+                    /* type */   kIOPMRequestTypeAddPowerChild2 );

 
 

-               requests[2] = acquirePMRequest(
-                                       /* target */ this,
-                                       /* type */   kIOPMRequestTypeAddPowerChild3 );
+        requests[2] = acquirePMRequest(
+                    /* target */ this,
+                    /* type */   kIOPMRequestTypeAddPowerChild3 );

 
 

-               if (!requests[0] || !requests[1] || !requests[2])
-                       break;
+        if (!requests[0] || !requests[1] || !requests[2])
+            break;

 
 

-               requests[0]->attachNextRequest( requests[1] );
-               requests[1]->attachNextRequest( requests[2] );
+        requests[0]->attachNextRequest( requests[1] );
+        requests[1]->attachNextRequest( requests[2] );

 
 

-               connection->init();
-               connection->start(this);
-               connection->setAwaitingAck(false);
-               connection->setReadyFlag(false);
+        connection->init();
+        connection->start(this);
+        connection->setAwaitingAck(false);
+        connection->setReadyFlag(false);

 
 

-               attachToChild( connection, gIOPowerPlane );
-               connection->attachToChild( child, gIOPowerPlane );
+        attachToChild( connection, gIOPowerPlane );
+        connection->attachToChild( child, gIOPowerPlane );

 
 

-               // connection needs to be released
-               requests[0]->fArg0 = connection;
-               requests[1]->fArg0 = connection;
-               requests[2]->fArg0 = connection;
+        // connection needs to be released
+        requests[0]->fArg0 = connection;
+        requests[1]->fArg0 = connection;
+        requests[2]->fArg0 = connection;

 
 

-               submitPMRequest( requests, 3 );
-               return kIOReturnSuccess;
-       }
-       while (false);
+        submitPMRequests( requests, 3 );
+        return kIOReturnSuccess;
+    }
+    while (false);

 
 

-       if (connection)  connection->release();
-       if (requests[0]) releasePMRequest(requests[0]);
-       if (requests[1]) releasePMRequest(requests[1]);
-       if (requests[2]) releasePMRequest(requests[2]);
+    if (connection)  connection->release();
+    if (requests[0]) releasePMRequest(requests[0]);
+    if (requests[1]) releasePMRequest(requests[1]);
+    if (requests[2]) releasePMRequest(requests[2]);

 
 

-       // Silent failure, to prevent platform drivers from adding the child
-       // to the root domain.
+    // Silent failure, to prevent platform drivers from adding the child
+    // to the root domain.

 
 

-       return kIOReturnSuccess;
+    return kIOReturnSuccess;

 }
 
 //*********************************************************************************
 }
 
 //*********************************************************************************


@@ -857,23 +907,23 @@ IOReturn IOService::addPowerChild( IOService * child )
 
 void IOService::addPowerChild1( IOPMRequest * request )
 {
 
 void IOService::addPowerChild1( IOPMRequest * request )
 {

-       IOPMPowerStateIndex tempDesire = kPowerStateZero;
+    IOPMPowerStateIndex tempDesire = kPowerStateZero;

 
 

-       // Make us temporary usable before adding the child.
+    // Make us temporary usable before adding the child.

 
 

-       PM_ASSERT_IN_GATE();
+    PM_ASSERT_IN_GATE();

     OUR_PMLog( kPMLogMakeUsable, kPMLogMakeUsable, 0 );
 
     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))))
         (IS_PM_ROOT || (StateOrder(fMaxPowerState) >= StateOrder(tempDesire))))

-       {
-               adjustPowerState(tempDesire);
-       }
+    {
+        adjustPowerState(tempDesire);
+    }

 }
 
 //*********************************************************************************
 }
 
 //*********************************************************************************


@@ -885,40 +935,40 @@ void IOService::addPowerChild1( IOPMRequest * request )
 
 void IOService::addPowerChild2( IOPMRequest * request )
 {
 
 void IOService::addPowerChild2( IOPMRequest * request )
 {

-       IOPowerConnection * connection = (IOPowerConnection *) request->fArg0;
-       IOService *         parent;
-       IOPMPowerFlags          powerFlags;
-       bool                            knowsState;
-       unsigned long           powerState;
-       unsigned long           tempDesire;
+    IOPowerConnection * connection = (IOPowerConnection *) request->fArg0;
+    IOService *         parent;
+    IOPMPowerFlags      powerFlags;
+    bool                knowsState;
+    unsigned long       powerState;
+    unsigned long       tempDesire;

 
 

-       PM_ASSERT_IN_GATE();
-       parent = (IOService *) connection->getParentEntry(gIOPowerPlane);
+    PM_ASSERT_IN_GATE();
+    parent = (IOService *) connection->getParentEntry(gIOPowerPlane);

 
 

-       if (!parent || !inPlane(gIOPowerPlane))
-       {
-               PM_LOG("%s: addPowerChild2 not in power plane\n", getName());
-               return;
-       }
+    if (!parent || !inPlane(gIOPowerPlane))
+    {
+        PM_LOG("%s: addPowerChild2 not in power plane\n", getName());
+        return;
+    }

 
 

-       // Parent will be waiting for us to complete this stage.
-       // It is safe to directly access parent's vars.
+    // Parent will be waiting for us to complete this stage.
+    // It is safe to directly access parent's vars.

 
 

-       knowsState = (parent->fPowerStates) && (parent->fParentsKnowState);
-       powerState = parent->fCurrentPowerState;
+    knowsState = (parent->fPowerStates) && (parent->fParentsKnowState);
+    powerState = parent->fCurrentPowerState;

 
 

-       if (knowsState)
-               powerFlags = parent->fPowerStates[powerState].outputPowerFlags;
-       else
-               powerFlags = 0;
+    if (knowsState)
+        powerFlags = parent->fPowerStates[powerState].outputPowerFlags;
+    else
+        powerFlags = 0;

 
 

-       // Set our power parent.
+    // Set our power parent.

 
     OUR_PMLog(kPMLogSetParent, knowsState, powerFlags);
 
 
     OUR_PMLog(kPMLogSetParent, knowsState, powerFlags);
 

-       setParentInfo( powerFlags, connection, knowsState );
+    setParentInfo( powerFlags, connection, knowsState );

 
 

-       connection->setReadyFlag(true);
+    connection->setReadyFlag(true);

 
     if ( fControllingDriver && fParentsKnowState )
     {
 
     if ( fControllingDriver && fParentsKnowState )
     {


@@ -941,30 +991,30 @@ void IOService::addPowerChild2( IOPMRequest * request )
 
 void IOService::addPowerChild3( IOPMRequest * request )
 {
 
 void IOService::addPowerChild3( IOPMRequest * request )
 {

-       IOPowerConnection * connection = (IOPowerConnection *) request->fArg0;
-       IOService *         child;
+    IOPowerConnection * connection = (IOPowerConnection *) request->fArg0;
+    IOService *         child;

     IOPMrootDomain *    rootDomain = getPMRootDomain();
 
     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 );
 
         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__
 }
 
 #ifndef __LP64__


@@ -978,9 +1028,9 @@ void IOService::addPowerChild3( IOPMRequest * request )
 //*********************************************************************************
 
 IOReturn IOService::setPowerParent(
 //*********************************************************************************
 
 IOReturn IOService::setPowerParent(

-       IOPowerConnection * theParent, bool stateKnown, IOPMPowerFlags powerFlags )
+    IOPowerConnection * theParent, bool stateKnown, IOPMPowerFlags powerFlags )

 {
 {

-       return kIOReturnUnsupported;
+    return kIOReturnUnsupported;

 }
 #endif /* !__LP64__ */
 
 }
 #endif /* !__LP64__ */
 


@@ -992,15 +1042,15 @@ IOReturn IOService::setPowerParent(
 
 IOReturn IOService::removePowerChild( IOPowerConnection * theNub )
 {
 
 IOReturn IOService::removePowerChild( IOPowerConnection * theNub )
 {

-    IORegistryEntry *  theChild;
+    IORegistryEntry *   theChild;

 
 

-       PM_ASSERT_IN_GATE();
+    PM_ASSERT_IN_GATE();

     OUR_PMLog( kPMLogRemoveChild, 0, 0 );
 
     theNub->retain();
 
     // detach nub from child
     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);
     if ( theChild )
     {
         theNub->detachFromChild(theChild, gIOPowerPlane);


@@ -1011,41 +1061,45 @@ IOReturn IOService::removePowerChild( IOPowerConnection * theNub )
 
     // Are we awaiting an ack from this child?
     if ( theNub->getAwaitingAck() )
 
     // Are we awaiting an ack from this child?
     if ( theNub->getAwaitingAck() )

-       {
-               // yes, pretend we got one
-               theNub->setAwaitingAck(false);
-               if (fHeadNotePendingAcks != 0 )
-               {
-                       // that's one fewer ack to worry about
-                       fHeadNotePendingAcks--;
-
-                       // is that the last?
-                       if ( fHeadNotePendingAcks == 0 )
-                       {
-                               stop_ack_timer();
-
-                               // Request unblocked, work queue
-                               // should re-scan all busy requests.
-                               gIOPMWorkQueue->incrementProducerCount();
-                       }
-               }
-       }
+    {
+        // yes, pretend we got one
+        theNub->setAwaitingAck(false);
+        if (fHeadNotePendingAcks != 0 )
+        {
+            // that's one fewer ack to worry about
+            fHeadNotePendingAcks--;

 
 

-       theNub->release();
+            // is that the last?
+            if ( fHeadNotePendingAcks == 0 )
+            {
+                stop_ack_timer();

 
 

-       // A child has gone away, re-scan children desires and clamp bits.
-    // The fPendingAdjustPowerRequest helps to reduce redundant parent work. 
+                // This parent may have a request in the work queue that is
+                // blocked on fHeadNotePendingAcks=0. And removePowerChild()
+                // is called while executing the child's PMstop request so they
+                // can occur simultaneously. IOPMWorkQueue::checkForWork() must
+                // restart and check all request queues again.

 
 

-       if (!fAdjustPowerScheduled)
-       {
-               IOPMRequest * request;
-               request = acquirePMRequest( this, kIOPMRequestTypeAdjustPowerState );
-               if (request)
-               {
-                       submitPMRequest( request );
-                       fAdjustPowerScheduled = true;
-               }
-       }
+                gIOPMWorkQueue->incrementProducerCount();
+            }
+        }
+    }
+
+    theNub->release();
+
+    // A child has gone away, re-scan children desires and clamp bits.
+    // The fPendingAdjustPowerRequest helps to reduce redundant parent work.
+
+    if (!fAdjustPowerScheduled)
+    {
+        IOPMRequest * request;
+        request = acquirePMRequest( this, kIOPMRequestTypeAdjustPowerState );
+        if (request)
+        {
+            submitPMRequest( request );
+            fAdjustPowerScheduled = true;
+        }
+    }

 
     return IOPMNoErr;
 }
 
     return IOPMNoErr;
 }


@@ -1057,43 +1111,43 @@ IOReturn IOService::removePowerChild( IOPowerConnection * theNub )
 //*********************************************************************************
 
 IOReturn IOService::registerPowerDriver(
 //*********************************************************************************
 
 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)
     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;
         {
             error = kIOReturnNoMemory;

-                       break;
+            break;

         }
 
         // Initialize to bogus values
         }
 
         // Initialize to bogus values


@@ -1132,27 +1186,27 @@ IOReturn IOService::registerPowerDriver(
         if (kIOReturnSuccess != error)
             break;
 
         if (kIOReturnSuccess != error)
             break;
 

-               request = acquirePMRequest( this, kIOPMRequestTypeRegisterPowerDriver );
-               if (!request)
+        request = acquirePMRequest( this, kIOPMRequestTypeRegisterPowerDriver );
+        if (!request)

         {
             error = kIOReturnNoMemory;
         {
             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;
         return kIOReturnSuccess;

-       }
-       while (false);
+    }
+    while (false);

 
 

-       if (powerStatesCopy)
-               IODelete(powerStatesCopy, IOPMPSEntry, numberOfStates);
+    if (powerStatesCopy)
+        IODelete(powerStatesCopy, IOPMPSEntry, numberOfStates);

 
 

-       return error;
+    return error;

 }
 
 //*********************************************************************************
 }
 
 //*********************************************************************************


@@ -1161,39 +1215,39 @@ IOReturn IOService::registerPowerDriver(
 
 void IOService::handleRegisterPowerDriver( IOPMRequest * request )
 {
 
 void IOService::handleRegisterPowerDriver( IOPMRequest * request )
 {

-       IOService *     powerDriver    = (IOService *)   request->fArg0;
-       IOPMPSEntry *   powerStates    = (IOPMPSEntry *) request->fArg1;
-       unsigned long   numberOfStates = (unsigned long) request->fArg2;
+    IOService *     powerDriver    = (IOService *)   request->fArg0;
+    IOPMPSEntry *   powerStates    = (IOPMPSEntry *) request->fArg1;
+    unsigned long   numberOfStates = (unsigned long) request->fArg2;

     unsigned long   i, stateIndex;
     unsigned long   lowestPowerState;
     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 )
     {
 
     if ( !fNumberOfPowerStates )
     {

-               OUR_PMLog(kPMLogControllingDriver,
-                       (unsigned long) numberOfStates,
-                       (unsigned long) kIOPMPowerStateVersion1);
+        OUR_PMLog(kPMLogControllingDriver,
+            (unsigned long) numberOfStates,
+            (unsigned long) kIOPMPowerStateVersion1);

 
         fPowerStates            = powerStates;
 
         fPowerStates            = powerStates;

-               fNumberOfPowerStates    = numberOfStates;
-               fControllingDriver      = powerDriver;
+        fNumberOfPowerStates    = numberOfStates;
+        fControllingDriver      = powerDriver;

         fCurrentCapabilityFlags = fPowerStates[0].capabilityFlags;
 
         lowestPowerState   = fPowerStates[0].stateOrderToIndex;
         fHighestPowerState = fPowerStates[numberOfStates - 1].stateOrderToIndex;
 
         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;
         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);
 
             stateIndex = fPowerStates[i].stateOrderToIndex;
             assert(stateIndex < numberOfStates);


@@ -1203,34 +1257,34 @@ void IOService::handleRegisterPowerDriver( IOPMRequest * request )
                 // The minimum power state that the device is usable
                 fDeviceUsablePowerState = stateIndex;
             }
                 // The minimum power state that the device is usable
                 fDeviceUsablePowerState = stateIndex;
             }

-               }
-        
-               // Register powerDriver as interested, unless already done.
-               // We don't want to register the default implementation since
-               // it does nothing. One ramification of not always registering
-               // is the one fewer retain count held.
-
-               root = getPlatform()->getProvider();
-               assert(root);
-               if (!root ||
-                       ((OSMemberFunctionCast(void (*)(void),
-                               root, &IOService::powerStateDidChangeTo)) !=
-                       ((OSMemberFunctionCast(void (*)(void),
-                               this, &IOService::powerStateDidChangeTo)))) ||
-                       ((OSMemberFunctionCast(void (*)(void),
-                               root, &IOService::powerStateWillChangeTo)) !=
-                       ((OSMemberFunctionCast(void (*)(void),
-                               this, &IOService::powerStateWillChangeTo)))))
-               {               
-                       if (fInterestedDrivers->findItem(powerDriver) == NULL)
-                       {
-                               PM_LOCK();
-                               fInterestedDrivers->appendNewInformee(powerDriver);
-                               PM_UNLOCK();
-                       }
-               }
+        }
+
+        // Register powerDriver as interested, unless already done.
+        // We don't want to register the default implementation since
+        // it does nothing. One ramification of not always registering
+        // is the one fewer retain count held.
+
+        root = getPlatform()->getProvider();
+        assert(root);
+        if (!root ||
+            ((OSMemberFunctionCast(void (*)(void),
+                root, &IOService::powerStateDidChangeTo)) !=
+            ((OSMemberFunctionCast(void (*)(void),
+                this, &IOService::powerStateDidChangeTo)))) ||
+            ((OSMemberFunctionCast(void (*)(void),
+                root, &IOService::powerStateWillChangeTo)) !=
+            ((OSMemberFunctionCast(void (*)(void),
+                this, &IOService::powerStateWillChangeTo)))))
+        {
+            if (fInterestedDrivers->findItem(powerDriver) == NULL)
+            {
+                PM_LOCK();
+                fInterestedDrivers->appendNewInformee(powerDriver);
+                PM_UNLOCK();
+            }
+        }

 
 

-               // Examine all existing power clients and perform limit check.
+        // Examine all existing power clients and perform limit check.

 
         if (fPowerClients &&
             (iter = OSCollectionIterator::withCollection(fPowerClients)))
 
         if (fPowerClients &&
             (iter = OSCollectionIterator::withCollection(fPowerClients)))


@@ -1247,22 +1301,22 @@ void IOService::handleRegisterPowerDriver( IOPMRequest * request )
             iter->release();
         }
 
             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);
         IODelete(powerStates, IOPMPSEntry, numberOfStates);

-       }
+    }

 
 

-       powerDriver->release();
+    powerDriver->release();

 }
 
 //*********************************************************************************
 }
 
 //*********************************************************************************


@@ -1276,8 +1330,8 @@ void IOService::handleRegisterPowerDriver( IOPMRequest * request )
 
 IOPMPowerFlags IOService::registerInterestedDriver( IOService * driver )
 {
 
 IOPMPowerFlags IOService::registerInterestedDriver( IOService * driver )
 {

-    IOPMRequest *      request;
-    bool                       signal;
+    IOPMRequest *   request;
+    bool            signal;

 
     if (!driver || !initialized || !fInterestedDrivers)
         return 0;
 
     if (!driver || !initialized || !fInterestedDrivers)
         return 0;


@@ -1305,7 +1359,7 @@ IOPMPowerFlags IOService::registerInterestedDriver( IOService * driver )
     // for those clients that care.
 
     OUR_PMLog(kPMLogInterestedDriver, kIOPMDeviceUsable, 2);
     // for those clients that care.
 
     OUR_PMLog(kPMLogInterestedDriver, kIOPMDeviceUsable, 2);

-    return kIOPMDeviceUsable;  
+    return kIOPMDeviceUsable;

 }
 
 //*********************************************************************************
 }
 
 //*********************************************************************************


@@ -1314,8 +1368,7 @@ IOPMPowerFlags IOService::registerInterestedDriver( IOService * driver )
 
 IOReturn IOService::deRegisterInterestedDriver( IOService * driver )
 {
 
 IOReturn IOService::deRegisterInterestedDriver( IOService * driver )
 {

-    IOPMinformeeList * list;
-    IOPMinformee *             item;
+    IOPMinformee *      item;

     IOPMRequest *       request;
     bool                signal;
 
     IOPMRequest *       request;
     bool                signal;
 


@@ -1325,18 +1378,25 @@ IOReturn IOService::deRegisterInterestedDriver( IOService * driver )
         return IOPMNotPowerManaged;
 
     PM_LOCK();
         return IOPMNotPowerManaged;
 
     PM_LOCK();

+    if (fInsertInterestSet)
+    {
+        fInsertInterestSet->removeObject(driver);
+    }
+
+    item = fInterestedDrivers->findItem(driver);
+    if (!item)
+    {
+        PM_UNLOCK();
+        return kIOReturnNotFound;
+    }
+

     signal = (!fRemoveInterestSet && !fInsertInterestSet);
     if (fRemoveInterestSet == NULL)
         fRemoveInterestSet = OSSet::withCapacity(4);
     if (fRemoveInterestSet)
     {
         fRemoveInterestSet->setObject(driver);
     signal = (!fRemoveInterestSet && !fInsertInterestSet);
     if (fRemoveInterestSet == NULL)
         fRemoveInterestSet = OSSet::withCapacity(4);
     if (fRemoveInterestSet)
     {
         fRemoveInterestSet->setObject(driver);

-        if (fInsertInterestSet)
-            fInsertInterestSet->removeObject(driver);
-
-        list = fInterestedDrivers;
-        item = list->findItem(driver);
-        if (item && item->active)
+        if (item->active)

         {
             item->active = false;
             waitForPMDriverCall( driver );
         {
             item->active = false;
             waitForPMDriverCall( driver );


@@ -1362,9 +1422,9 @@ IOReturn IOService::deRegisterInterestedDriver( IOService * driver )
 
 void IOService::handleInterestChanged( IOPMRequest * request )
 {
 
 void IOService::handleInterestChanged( IOPMRequest * request )
 {

-    IOService *                        driver;
-    IOPMinformee *             informee;
-    IOPMinformeeList * list = fInterestedDrivers;
+    IOService *         driver;
+    IOPMinformee *      informee;
+    IOPMinformeeList *  list = fInterestedDrivers;

 
     PM_LOCK();
 
 
     PM_LOCK();
 


@@ -1422,21 +1482,21 @@ void IOService::handleInterestChanged( IOPMRequest * request )
 
 IOReturn IOService::acknowledgePowerChange( IOService * whichObject )
 {
 
 IOReturn IOService::acknowledgePowerChange( IOService * whichObject )
 {

-       IOPMRequest * request;
+    IOPMRequest * request;

 
     if (!initialized)
 
     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;
 }
 
     return IOPMNoErr;
 }
 


@@ -1446,24 +1506,24 @@ IOReturn IOService::acknowledgePowerChange( IOService * whichObject )
 
 bool IOService::handleAcknowledgePowerChange( IOPMRequest * request )
 {
 
 bool IOService::handleAcknowledgePowerChange( IOPMRequest * request )
 {

-    IOPMinformee *             informee;
-    unsigned long              childPower = kIOPMUnknown;
-    IOService *                        theChild;
-       IOService *                     whichObject;
-       bool                            all_acked  = false;
+    IOPMinformee *      informee;
+    unsigned long       childPower = kIOPMUnknown;
+    IOService *         theChild;
+    IOService *         whichObject;
+    bool                all_acked  = false;

 
 

-       PM_ASSERT_IN_GATE();
-       whichObject = (IOService *) request->fArg0;
-       assert(whichObject);
+    PM_ASSERT_IN_GATE();
+    whichObject = (IOService *) request->fArg0;
+    assert(whichObject);

 
     // one of our interested drivers?
 
     // one of our interested drivers?

-       informee = fInterestedDrivers->findItem( whichObject );
+    informee = fInterestedDrivers->findItem( whichObject );

     if ( informee == NULL )
     {
         if ( !isChild(whichObject, gIOPowerPlane) )
         {
     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);
         }
         } else {
             OUR_PMLog(kPMLogChildAcknowledge, fHeadNotePendingAcks, 0);
         }


@@ -1482,32 +1542,18 @@ bool IOService::handleAcknowledgePowerChange( IOPMRequest * request )
             // make sure we're expecting this ack
             if ( informee->timer != 0 )
             {
             // make sure we're expecting this ack
             if ( informee->timer != 0 )
             {

-#if LOG_SETPOWER_TIMES
+

                 if (informee->timer > 0)
                 {
                     uint64_t nsec = computeTimeDeltaNS(&informee->startTime);
                 if (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), informee->whatObject->getRegistryEntryID(),
+                            NULL, fHeadNotePowerState);
+                    }

                 }
                 }

-#endif
+

                 // mark it acked
                 informee->timer = 0;
                 // that's one fewer to worry about
                 // mark it acked
                 informee->timer = 0;
                 // that's one fewer to worry about


@@ -1540,21 +1586,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 {
     } else {

-        OUR_PMLog(kPMLogAcknowledgeErr3, 0, 0);        // not expecting anybody to ack
+        OUR_PMLog(kPMLogAcknowledgeErr3, 0, 0); // not expecting anybody to ack

     }
 
 no_err:
     }
 
 no_err:

-       if (whichObject)
-               whichObject->release();
+    if (whichObject)
+        whichObject->release();

 
     return all_acked;
 }
 
     return all_acked;
 }


@@ -1569,17 +1615,17 @@ no_err:
 
 IOReturn IOService::acknowledgeSetPowerState( void )
 {
 
 IOReturn IOService::acknowledgeSetPowerState( void )
 {

-       IOPMRequest * request;
+    IOPMRequest * request;

 
     if (!initialized)
 
     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 +1634,10 @@ IOReturn IOService::acknowledgeSetPowerState( void )
 
 void IOService::adjustPowerState( uint32_t clamp )
 {
 
 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
         IOPMPowerChangeFlags changeFlags = kIOPMSelfInitiated;
 
         // Indicate that children desires must be ignored, and do not ask


@@ -1601,13 +1647,13 @@ void IOService::adjustPowerState( uint32_t clamp )
         if (getPMRequestType() == kIOPMRequestTypeRequestPowerStateOverride)
             changeFlags |= (kIOPMIgnoreChildren | kIOPMSkipAskPowerDown);
 
         if (getPMRequestType() == kIOPMRequestTypeRequestPowerStateOverride)
             changeFlags |= (kIOPMIgnoreChildren | kIOPMSkipAskPowerDown);
 

-               startPowerChange(
-                        /* flags        */     changeFlags,
-                        /* power state  */     fDesiredPowerState,
-                        /* domain flags */     0,
-                        /* connection   */     0,
-                        /* parent flags */     0);
-       }
+        startPowerChange(
+             /* flags        */ changeFlags,
+             /* power state  */ fDesiredPowerState,
+             /* domain flags */ 0,
+             /* connection   */ 0,
+             /* parent flags */ 0);
+    }

 }
 
 //*********************************************************************************
 }
 
 //*********************************************************************************


@@ -1618,13 +1664,13 @@ IOReturn IOService::synchronizePowerTree(
     IOOptionBits    options,
     IOService *     notifyRoot )
 {
     IOOptionBits    options,
     IOService *     notifyRoot )
 {

-       IOPMRequest *   request_c = 0;
+    IOPMRequest *   request_c = 0;

     IOPMRequest *   request_s;
 
     if (this != getPMRootDomain())
         return kIOReturnBadArgument;
     IOPMRequest *   request_s;
 
     if (this != getPMRootDomain())
         return kIOReturnBadArgument;

-       if (!initialized)
-               return kIOPMNotYetInitialized;
+    if (!initialized)
+        return kIOPMNotYetInitialized;

 
     OUR_PMLog(kPMLogCSynchronizePowerTree, options, (notifyRoot != 0));
 
 
     OUR_PMLog(kPMLogCSynchronizePowerTree, options, (notifyRoot != 0));
 


@@ -1634,7 +1680,7 @@ IOReturn IOService::synchronizePowerTree(
 
         // Cancels don't need to be synchronized.
         nr = acquirePMRequest(notifyRoot, kIOPMRequestTypeChildNotifyDelayCancel);
 
         // 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);
     }
         nr = acquirePMRequest(getPMRootDomain(), kIOPMRequestTypeChildNotifyDelayCancel);
         if (nr) submitPMRequest(nr);
     }


@@ -1650,15 +1696,15 @@ IOReturn IOService::synchronizePowerTree(
         request_c->attachNextRequest( request_s );
         submitPMRequest(request_c);
     }
         request_c->attachNextRequest( request_s );
         submitPMRequest(request_c);
     }

-    
+

     request_s->fArg0 = (void *)(uintptr_t) options;
     submitPMRequest(request_s);
 
     return kIOReturnSuccess;
 
 error_no_memory:
     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;
 }
 
     return kIOReturnNoMemory;
 }
 


@@ -1668,20 +1714,20 @@ error_no_memory:
 
 void IOService::handleSynchronizePowerTree( IOPMRequest * request )
 {
 
 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))
         (fCurrentPowerState == fHighestPowerState))

-       {
+    {

         IOOptionBits options = (uintptr_t) request->fArg0;
 
         IOOptionBits options = (uintptr_t) request->fArg0;
 

-               startPowerChange(
-                        /* flags        */     kIOPMSelfInitiated | kIOPMSynchronize |
+        startPowerChange(
+             /* flags        */ kIOPMSelfInitiated | kIOPMSynchronize |

                                 (options & kIOPMSyncNoChildNotify),
                                 (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__
 }
 
 #ifndef __LP64__


@@ -1696,11 +1742,11 @@ void IOService::handleSynchronizePowerTree( IOPMRequest * request )
 //*********************************************************************************
 
 IOReturn IOService::powerDomainWillChangeTo(
 //*********************************************************************************
 
 IOReturn IOService::powerDomainWillChangeTo(

-       IOPMPowerFlags          newPowerFlags,
-       IOPowerConnection *     whichParent )
+    IOPMPowerFlags      newPowerFlags,
+    IOPowerConnection * whichParent )

 {
 {

-       assert(false);
-       return kIOReturnUnsupported;
+    assert(false);
+    return kIOReturnUnsupported;

 }
 #endif /* !__LP64__ */
 
 }
 #endif /* !__LP64__ */
 


@@ -1710,32 +1756,32 @@ IOReturn IOService::powerDomainWillChangeTo(
 
 void IOService::handlePowerDomainWillChangeTo( IOPMRequest * request )
 {
 
 void IOService::handlePowerDomainWillChangeTo( IOPMRequest * request )
 {

-       IOPMPowerFlags           parentPowerFlags = (IOPMPowerFlags) request->fArg0;
-       IOPowerConnection *      whichParent = (IOPowerConnection *) request->fArg1;
+    IOPMPowerFlags       parentPowerFlags = (IOPMPowerFlags) request->fArg0;
+    IOPowerConnection *  whichParent = (IOPowerConnection *) request->fArg1;

     IOPMPowerChangeFlags parentChangeFlags = (IOPMPowerChangeFlags)(uintptr_t) request->fArg2;
     IOPMPowerChangeFlags myChangeFlags;
     IOPMPowerChangeFlags parentChangeFlags = (IOPMPowerChangeFlags)(uintptr_t) request->fArg2;
     IOPMPowerChangeFlags myChangeFlags;

-    OSIterator *                iter;
-    OSObject *                  next;
-    IOPowerConnection *         connection;
+    OSIterator *         iter;
+    OSObject *           next;
+    IOPowerConnection *  connection;

     IOPMPowerStateIndex  maxPowerState;
     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);
 
     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;
         goto exit_no_ack;

-       }
+    }

 
 

-       savedParentsKnowState = fParentsKnowState;
+    savedParentsKnowState = fParentsKnowState;

 
     // Combine parents' output power flags.
 
 
     // Combine parents' output power flags.
 

-       combinedPowerFlags = 0;
+    combinedPowerFlags = 0;

 
     iter = getParentIterator(gIOPowerPlane);
     if ( iter )
 
     iter = getParentIterator(gIOPowerPlane);
     if ( iter )


@@ -1758,49 +1804,56 @@ void IOService::handlePowerDomainWillChangeTo( IOPMRequest * request )
 
     if ( fControllingDriver && !fInitialPowerChange )
     {
 
     if ( fControllingDriver && !fInitialPowerChange )
     {

-               maxPowerState = fControllingDriver->maxCapabilityForDomainState(
-                                                       combinedPowerFlags);
+        maxPowerState = fControllingDriver->maxCapabilityForDomainState(
+                            combinedPowerFlags);
+
+        if (parentChangeFlags & kIOPMDomainPowerDrop)
+        {
+            // fMaxPowerState set a limit on self-initiated power changes.
+            // Update it before a parent power drop.
+            fMaxPowerState = maxPowerState;
+        }

 
         // Use kIOPMSynchronize below instead of kIOPMRootBroadcastFlags
         // to avoid propagating the root change flags if any service must
         // change power state due to root's will-change notification.
         // Root does not change power state for kIOPMSynchronize.
 
         // 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);
 
         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().
 
 exit_no_ack:
     // Drop the retain from notifyChild().


@@ -1819,11 +1872,11 @@ exit_no_ack:
 //*********************************************************************************
 
 IOReturn IOService::powerDomainDidChangeTo(
 //*********************************************************************************
 
 IOReturn IOService::powerDomainDidChangeTo(

-       IOPMPowerFlags          newPowerFlags,
-       IOPowerConnection *     whichParent )
+    IOPMPowerFlags      newPowerFlags,
+    IOPowerConnection * whichParent )

 {
 {

-       assert(false);
-       return kIOReturnUnsupported;
+    assert(false);
+    return kIOReturnUnsupported;

 }
 #endif /* !__LP64__ */
 
 }
 #endif /* !__LP64__ */
 


@@ -1833,34 +1886,41 @@ IOReturn IOService::powerDomainDidChangeTo(
 
 void IOService::handlePowerDomainDidChangeTo( IOPMRequest * request )
 {
 
 void IOService::handlePowerDomainDidChangeTo( IOPMRequest * request )
 {

-       IOPMPowerFlags           parentPowerFlags = (IOPMPowerFlags) request->fArg0;
-       IOPowerConnection *      whichParent = (IOPowerConnection *) request->fArg1;
+    IOPMPowerFlags       parentPowerFlags = (IOPMPowerFlags) request->fArg0;
+    IOPowerConnection *  whichParent = (IOPowerConnection *) request->fArg1;

     IOPMPowerChangeFlags parentChangeFlags = (IOPMPowerChangeFlags)(uintptr_t) request->fArg2;
     IOPMPowerChangeFlags myChangeFlags;
     IOPMPowerStateIndex  maxPowerState;
     IOPMPowerStateIndex  initialDesire = kPowerStateZero;
     bool                 computeDesire = false;
     bool                 desireChanged = false;
     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);
 
     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;
         goto exit_no_ack;

-       }
+    }

 
 

-       savedParentsKnowState = fParentsKnowState;
+    savedParentsKnowState = fParentsKnowState;

 
     setParentInfo(parentPowerFlags, whichParent, true);
 
     if ( fControllingDriver )
 
     setParentInfo(parentPowerFlags, whichParent, true);
 
     if ( fControllingDriver )

-       {
-               maxPowerState = fControllingDriver->maxCapabilityForDomainState(
-                                                       fParentsCurrentPowerFlags);
+    {
+        maxPowerState = fControllingDriver->maxCapabilityForDomainState(
+                            fParentsCurrentPowerFlags);
+
+        if ((parentChangeFlags & kIOPMDomainPowerDrop) == 0)
+        {
+            // fMaxPowerState set a limit on self-initiated power changes.
+            // Update it after a parent power rise.
+            fMaxPowerState = maxPowerState;
+        }

 
         if (fInitialPowerChange)
         {
 
         if (fInitialPowerChange)
         {


@@ -1913,40 +1973,41 @@ void IOService::handlePowerDomainDidChangeTo( IOPMRequest * request )
         myChangeFlags = kIOPMParentInitiated | kIOPMDomainDidChange |
                         (parentChangeFlags & kIOPMRootBroadcastFlags);
 
         myChangeFlags = kIOPMParentInitiated | kIOPMDomainDidChange |
                         (parentChangeFlags & kIOPMRootBroadcastFlags);
 

-               result = startPowerChange(
-                                /* flags        */     myChangeFlags,
-                 /* power state  */    maxPowerState,
-                                /* domain flags */     fParentsCurrentPowerFlags,
-                                /* connection   */     whichParent,
-                                /* parent flags */     0);
-       }
-
-       // Parent is expecting an ACK from us. If we did not embark on a state
-       // transition, i.e. startPowerChange() returned IOPMAckImplied. We are
-       // still required to issue an ACK to our parent.
-
-       if (IOPMAckImplied == result)
-       {
-               IOService * parent;
-               parent = (IOService *) whichParent->copyParentEntry(gIOPowerPlane);
-               assert(parent);
-               if ( parent )
-               {
-                       parent->acknowledgePowerChange( whichParent );
-                       parent->release();
-               }
-       }
+        result = startPowerChange(
+                 /* flags        */ myChangeFlags,
+                 /* power state  */ maxPowerState,
+                 /* domain flags */ fParentsCurrentPowerFlags,
+                 /* connection   */ whichParent,
+                 /* parent flags */ 0);
+    }
+
+    // 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 the parent registers its power driver late, then this is the
-       // first opportunity to tell our parent about our desire. Or if the
+    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.
 
     // 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().
 
 exit_no_ack:
     // Drop the retain from notifyChild().


@@ -1959,22 +2020,22 @@ exit_no_ack:
 // Set our connection data for one specific parent, and then combine all the parent
 // data together.
 //*********************************************************************************
 // Set our connection data for one specific parent, and then combine all the parent
 // data together.
 //*********************************************************************************

- 
+

 void IOService::setParentInfo(
 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);
 
     // set our connection data
     whichParent->setParentCurrentPowerFlags(newPowerFlags);
     whichParent->setParentKnowsState(knowsState);

-    
+

     // recompute our parent info
     fParentsCurrentPowerFlags = 0;
     fParentsKnowState = true;
     // recompute our parent info
     fParentsCurrentPowerFlags = 0;
     fParentsKnowState = true;


@@ -2017,12 +2078,11 @@ void IOService::trackSystemSleepPreventers(
 
     if ((oldCapability ^ newCapability) & kIOPMPreventIdleSleep)
     {
 
     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 SUPPORT_IDLE_CANCEL

-        if (idleCancelAllowed && (oldCapability & kIOPMPreventIdleSleep) == 0)
+        if (idleCancelAllowed && enablePrevention)

         {
             IOPMRequest *   cancelRequest;
 
         {
             IOPMRequest *   cancelRequest;
 


@@ -2033,12 +2093,10 @@ void IOService::trackSystemSleepPreventers(
             }
         }
 #endif
             }
         }
 #endif

-    

     }
 
     if ((oldCapability ^ newCapability) & kIOPMPreventSystemSleep)
     {
     }
 
     if ((oldCapability ^ newCapability) & kIOPMPreventSystemSleep)
     {

-        

         getPMRootDomain()->updatePreventSystemSleepList(this,
             ((oldCapability & kIOPMPreventSystemSleep) == 0));
     }
         getPMRootDomain()->updatePreventSystemSleepList(this,
             ((oldCapability & kIOPMPreventSystemSleep) == 0));
     }


@@ -2053,45 +2111,45 @@ void IOService::trackSystemSleepPreventers(
 IOReturn IOService::requestPowerDomainState(
     IOPMPowerFlags      childRequestPowerFlags,
     IOPowerConnection * childConnection,
 IOReturn IOService::requestPowerDomainState(
     IOPMPowerFlags      childRequestPowerFlags,
     IOPowerConnection * childConnection,

-    unsigned long              specification )
+    unsigned long       specification )

 {
     IOPMPowerStateIndex order, powerState;
 {
     IOPMPowerStateIndex order, powerState;

-       IOPMPowerFlags          outputPowerFlags;
+    IOPMPowerFlags      outputPowerFlags;

     IOService *         child;
     IOService *         child;

-       IOPMRequest *       subRequest;
+    IOPMRequest *       subRequest;

     bool                adjustPower = false;
 
     if (!initialized)
     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);
 
 
     OUR_PMLog(kPMLogRequestDomain, childRequestPowerFlags, specification);
 

-       if (!isChild(childConnection, gIOPowerPlane))
-               return kIOReturnNotAttached;
+    if (!isChild(childConnection, gIOPowerPlane))
+        return kIOReturnNotAttached;

 
     if (!fControllingDriver || !fNumberOfPowerStates)
         return kIOReturnNotReady;
 
 
     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
 
     // 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;
 
     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:
             // Use the lower power state when dropping power.
             // Must be careful since a power drop can be cancelled
             // from the following states:


@@ -2114,25 +2172,25 @@ IOReturn IOService::requestPowerDomainState(
                 PM_LOG1("%s: power drop cancelled in state %u by %s\n",
                     getName(), fMachineState, child->getName());
             }
                 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;
 
     }
     child->fHeadNoteDomainTargetFlags |= outputPowerFlags;
 


@@ -2169,24 +2227,24 @@ IOReturn IOService::requestPowerDomainState(
     }
 #endif
 
     }
 #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()))
     {
 
     if (adjustPower && !fDeviceOverrideEnabled &&
         (!fAdjustPowerScheduled || gIOPMRequest->getRootRequest()))
     {

-               subRequest = acquirePMRequest(
+        subRequest = acquirePMRequest(

             this, kIOPMRequestTypeAdjustPowerState, gIOPMRequest );
             this, kIOPMRequestTypeAdjustPowerState, gIOPMRequest );

-               if (subRequest)
-               {
-                       submitPMRequest( subRequest );
-                       fAdjustPowerScheduled = true;
-               }
+        if (subRequest)
+        {
+            submitPMRequest( subRequest );
+            fAdjustPowerScheduled = true;
+        }

     }
 
     return kIOReturnSuccess;
     }
 
     return kIOReturnSuccess;


@@ -2230,8 +2288,8 @@ IOReturn IOService::makeUsable( void )
 
 IOPMPowerFlags IOService::currentCapability( void )
 {
 
 IOPMPowerFlags IOService::currentCapability( void )
 {

-       if (!initialized)
-               return IOPMNotPowerManaged;
+    if (!initialized)
+        return IOPMNotPowerManaged;

 
     return fCurrentCapabilityFlags;
 }
 
     return fCurrentCapabilityFlags;
 }


@@ -2276,16 +2334,16 @@ IOReturn IOService::changePowerStateToPriv( unsigned long ordinal )
 IOReturn IOService::changePowerStateWithOverrideTo( IOPMPowerStateIndex ordinal,
                                                     IOPMRequestTag tag )
 {
 IOReturn IOService::changePowerStateWithOverrideTo( IOPMPowerStateIndex ordinal,
                                                     IOPMRequestTag tag )
 {

-       IOPMRequest * request;
+    IOPMRequest * request;

 
 

-       if (!initialized)
-               return kIOPMNotYetInitialized;
+    if (!initialized)
+        return kIOPMNotYetInitialized;

 
     OUR_PMLog(kPMLogChangeStateToPriv, ordinal, 0);
 
 
     OUR_PMLog(kPMLogChangeStateToPriv, ordinal, 0);
 

-       request = acquirePMRequest( this, kIOPMRequestTypeRequestPowerStateOverride );
-       if (!request)
-               return kIOReturnNoMemory;
+    request = acquirePMRequest( this, kIOPMRequestTypeRequestPowerStateOverride );
+    if (!request)
+        return kIOReturnNoMemory;

 
     gIOPMPowerClientDevice->retain();
     request->fRequestTag = tag;
 
     gIOPMPowerClientDevice->retain();
     request->fRequestTag = tag;


@@ -2297,18 +2355,18 @@ IOReturn IOService::changePowerStateWithOverrideTo( IOPMPowerStateIndex ordinal,
         request->installCompletionAction( action, target, param );
 #endif
 
         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;
 }
 
     return IOPMNoErr;
 }
 


@@ -2325,44 +2383,82 @@ IOReturn IOService::changePowerStateForRootDomain( IOPMPowerStateIndex ordinal )
 }
 
 //*********************************************************************************
 }
 
 //*********************************************************************************

-// [private] requestPowerState
+// [public for PMRD] quiescePowerTree
+//
+// For root domain to issue a request to quiesce the power tree.
+// Supplied callback invoked upon completion.

 //*********************************************************************************
 
 //*********************************************************************************
 

-IOReturn IOService::requestPowerState(
-    const OSSymbol *      client,
-    uint32_t              state )
+IOReturn IOService::quiescePowerTree(
+    void * target, IOPMCompletionAction action, void * param )

 {
 {

-       IOPMRequest * request;
+    IOPMRequest * request;

 
 

-    if (!client)
+    if (!initialized)
+        return kIOPMNotYetInitialized;
+    if (!target || !action)

         return kIOReturnBadArgument;
         return kIOReturnBadArgument;

-       if (!initialized)
-               return kIOPMNotYetInitialized;

 
 

-       request = acquirePMRequest( this, kIOPMRequestTypeRequestPowerState );
-       if (!request)
-               return kIOReturnNoMemory;
+    OUR_PMLog(kPMLogQuiescePowerTree, 0, 0);

 
 

-    client->retain();
-    request->fArg0 = (void *)(uintptr_t) state;
-    request->fArg1 = (void *)            client;
-    request->fArg2 = 0;
-#if NOT_READY
-    if (action)
-        request->installCompletionAction( action, target, param );
+    // Target the root node instead of root domain. This is to avoid blocking
+    // the quiesce request behind an existing root domain request in the work
+    // queue. Root parent and root domain requests in the work queue must not
+    // block the completion of the quiesce request.
+
+    request = acquirePMRequest(gIOPMRootNode, kIOPMRequestTypeQuiescePowerTree);
+    if (!request)
+        return kIOReturnNoMemory;
+
+    request->installCompletionAction(target, action, param);
+
+    // Submit through the normal request flow. This will make sure any request
+    // already in the request queue will get pushed over to the work queue for
+    // execution. Any request submitted after this request may not be serviced.
+
+    submitPMRequest( request );
+    return kIOReturnSuccess;
+}
+
+//*********************************************************************************
+// [private] requestPowerState
+//*********************************************************************************
+
+IOReturn IOService::requestPowerState(
+    const OSSymbol *      client,
+    uint32_t              state )
+{
+    IOPMRequest * request;
+
+    if (!client)
+        return kIOReturnBadArgument;
+    if (!initialized)
+        return kIOPMNotYetInitialized;
+
+    request = acquirePMRequest( this, kIOPMRequestTypeRequestPowerState );
+    if (!request)
+        return kIOReturnNoMemory;
+
+    client->retain();
+    request->fArg0 = (void *)(uintptr_t) state;
+    request->fArg1 = (void *)            client;
+    request->fArg2 = 0;
+#if NOT_READY
+    if (action)
+        request->installCompletionAction( action, target, param );

 #endif
 
 #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;
 }
 
     return IOPMNoErr;
 }
 


@@ -2375,16 +2471,16 @@ void IOService::handleRequestPowerState( IOPMRequest * request )
     const OSSymbol * client = (const OSSymbol *)    request->fArg1;
     uint32_t         state  = (uint32_t)(uintptr_t) request->fArg0;
 
     const OSSymbol * client = (const OSSymbol *)    request->fArg1;
     uint32_t         state  = (uint32_t)(uintptr_t) request->fArg0;
 

-       PM_ASSERT_IN_GATE();
-       if (request->fArg2)
-       {
-               assert(fTempClampCount != 0);
-               if (fTempClampCount)  fTempClampCount--;
-               if (!fTempClampCount) fTempClampPowerState = kPowerStateZero;
-       }
+    PM_ASSERT_IN_GATE();
+    if (request->fArg2)
+    {
+        assert(fTempClampCount != 0);
+        if (fTempClampCount)  fTempClampCount--;
+        if (!fTempClampCount) fTempClampPowerState = kPowerStateZero;
+    }

 
 

-       if (fNumberOfPowerStates && (state >= fNumberOfPowerStates))
-               state = fHighestPowerState;
+    if (fNumberOfPowerStates && (state >= fNumberOfPowerStates))
+        state = fHighestPowerState;

 
     // The power suppression due to changePowerStateWithOverrideTo() expires
     // upon the next "device" power request - changePowerStateToPriv().
 
     // The power suppression due to changePowerStateWithOverrideTo() expires
     // upon the next "device" power request - changePowerStateToPriv().


@@ -2394,14 +2490,14 @@ void IOService::handleRequestPowerState( IOPMRequest * request )
         fOverrideMaxPowerState = kIOPMPowerStateMax;
 
     if ((state == kPowerStateZero) &&
         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();
 }
 
     client->release();
 }
 


@@ -2461,22 +2557,22 @@ uint32_t IOService::getPowerStateForClient( const OSSymbol * client )
 
 IOReturn IOService::powerOverrideOnPriv( void )
 {
 
 IOReturn IOService::powerOverrideOnPriv( void )
 {

-       IOPMRequest * request;
+    IOPMRequest * request;

 
     if (!initialized)
 
     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;
 }
 
     return IOPMNoErr;
 }
 


@@ -2486,22 +2582,22 @@ IOReturn IOService::powerOverrideOnPriv( void )
 
 IOReturn IOService::powerOverrideOffPriv( void )
 {
 
 IOReturn IOService::powerOverrideOffPriv( void )
 {

-       IOPMRequest * request;
+    IOPMRequest * request;

 
     if (!initialized)
 
     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;
 }
 
     return IOPMNoErr;
 }
 


@@ -2511,19 +2607,19 @@ IOReturn IOService::powerOverrideOffPriv( void )
 
 void IOService::handlePowerOverrideChanged( IOPMRequest * request )
 {
 
 void IOService::handlePowerOverrideChanged( IOPMRequest * request )
 {

-       PM_ASSERT_IN_GATE();
-       if (request->getType() == kIOPMRequestTypePowerOverrideOnPriv)
-       {
-               OUR_PMLog(kPMLogOverrideOn, 0, 0);
-               fDeviceOverrideEnabled = true;
+    PM_ASSERT_IN_GATE();
+    if (request->getType() == kIOPMRequestTypePowerOverrideOnPriv)
+    {
+        OUR_PMLog(kPMLogOverrideOn, 0, 0);
+        fDeviceOverrideEnabled = true;
+    }
+    else
+    {
+        OUR_PMLog(kPMLogOverrideOff, 0, 0);
+        fDeviceOverrideEnabled = false;

     }
     }

-       else
-       {
-               OUR_PMLog(kPMLogOverrideOff, 0, 0);
-               fDeviceOverrideEnabled = false;
-       }

 
 

-       adjustPowerState();
+    adjustPowerState();

 }
 
 //*********************************************************************************
 }
 
 //*********************************************************************************


@@ -2532,20 +2628,20 @@ void IOService::handlePowerOverrideChanged( IOPMRequest * request )
 
 void IOService::computeDesiredState( unsigned long localClamp, bool computeOnly )
 {
 
 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;
 
     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;
         fDesiredPowerState = kPowerStateZero;

-               return;
-       }
+        return;
+    }

 
     // Examine the children's desired power state.
 
 
     // Examine the children's desired power state.
 


@@ -2582,14 +2678,14 @@ void IOService::computeDesiredState( unsigned long localClamp, bool computeOnly
         const OSSymbol * client;
         while ((client = (const OSSymbol *) iter->getNextObject()))
         {
         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;
 
             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;
 
             if (hasChildren && (client == gIOPMPowerClientChildProxy))
                 continue;
 


@@ -2599,9 +2695,9 @@ void IOService::computeDesiredState( unsigned long localClamp, bool computeOnly
                 continue;
 
             desiredState = getPowerStateForClient(client);
                 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);
 
 
             newPowerState = StateMax(newPowerState, desiredState);
 


@@ -2629,7 +2725,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,
 
     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)
     {
 
     if (!computeOnly)
     {


@@ -2675,10 +2771,12 @@ unsigned long IOService::currentPowerConsumption( void )
 // [deprecated] getPMworkloop
 //*********************************************************************************
 
 // [deprecated] getPMworkloop
 //*********************************************************************************
 

+#ifndef __LP64__

 IOWorkLoop * IOService::getPMworkloop( void )
 {
 IOWorkLoop * IOService::getPMworkloop( void )
 {

-       return gIOPMWorkLoop;
+    return gIOPMWorkLoop;

 }
 }

+#endif

 
 #if NOT_YET
 
 
 #if NOT_YET
 


@@ -2687,13 +2785,13 @@ IOWorkLoop * IOService::getPMworkloop( void )
 //*********************************************************************************
 
 static void
 //*********************************************************************************
 
 static void

-applyToPowerChildren( 
+applyToPowerChildren(

     IOService *               service,
     IOServiceApplierFunction  applier,
     void *                    context,
     IOOptionBits              options )
 {
     IOService *               service,
     IOServiceApplierFunction  applier,
     void *                    context,
     IOOptionBits              options )
 {

-       PM_ASSERT_IN_GATE();
+    PM_ASSERT_IN_GATE();

 
     IORegistryEntry *       entry;
     IORegistryIterator *    iter;
 
     IORegistryEntry *       entry;
     IORegistryIterator *    iter;


@@ -2721,13 +2819,13 @@ applyToPowerChildren(
 }
 
 static void
 }
 
 static void

-applyToPowerParent( 
+applyToPowerParent(

     IOService *               service,
     IOServiceApplierFunction  applier,
     void *                    context,
     IOOptionBits              options )
 {
     IOService *               service,
     IOServiceApplierFunction  applier,
     void *                    context,
     IOOptionBits              options )
 {

-       PM_ASSERT_IN_GATE();
+    PM_ASSERT_IN_GATE();

 
     IORegistryEntry *       entry;
     IORegistryIterator *    iter;
 
     IORegistryEntry *       entry;
     IORegistryIterator *    iter;


@@ -2777,18 +2875,18 @@ void IOService::setAdvisoryTickleEnable( bool enable )
 
 bool IOService::activityTickle( unsigned long type, unsigned long stateNumber )
 {
 
 bool IOService::activityTickle( unsigned long type, unsigned long stateNumber )
 {

-       IOPMRequest *   request;
-       bool                    noPowerChange = true;
+    IOPMRequest *   request;
+    bool            noPowerChange = true;

     uint32_t        tickleFlags;
 
     if (!initialized)
         return true;    // no power change
 
     if ((type == kIOPMSuperclassPolicy1) && StateOrder(stateNumber))
     uint32_t        tickleFlags;
 
     if (!initialized)
         return true;    // no power change
 
     if ((type == kIOPMSuperclassPolicy1) && StateOrder(stateNumber))

-       {
+    {

         IOLockLock(fActivityLock);
 
         IOLockLock(fActivityLock);
 

-               // Record device activity for the idle timer handler.
+        // Record device activity for the idle timer handler.

 
         fDeviceWasActive = true;
         fActivityTickleCount++;
 
         fDeviceWasActive = true;
         fActivityTickleCount++;


@@ -2796,29 +2894,29 @@ bool IOService::activityTickle( unsigned long type, unsigned long stateNumber )
 
         PM_ACTION_0(actionActivityTickle);
 
 
         PM_ACTION_0(actionActivityTickle);
 

-               // Record the last tickle power state.
-               // This helps to filter out redundant tickles as
-               // this function may be called from the data path.
+        // Record the last tickle power state.
+        // This helps to filter out redundant tickles as
+        // this function may be called from the data path.

 
         if ((fActivityTicklePowerState == kInvalidTicklePowerState)
         || StateOrder(fActivityTicklePowerState) < StateOrder(stateNumber))
 
         if ((fActivityTicklePowerState == kInvalidTicklePowerState)
         || StateOrder(fActivityTicklePowerState) < StateOrder(stateNumber))

-               {
-                       fActivityTicklePowerState = stateNumber;
-                       noPowerChange = false;
+        {
+            fActivityTicklePowerState = stateNumber;
+            noPowerChange = false;

 
             tickleFlags = kTickleTypeActivity | kTickleTypePowerRise;
 
             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;
                 request->fArg2 = (void *)(uintptr_t) gIOPMTickleGeneration;

-                               submitPMRequest(request);
-                       }
-               }
+                submitPMRequest(request);
+            }
+        }

 
 

-               IOLockUnlock(fActivityLock);
-       }
+        IOLockUnlock(fActivityLock);
+    }

 
     else if ((type == kIOPMActivityTickleTypeAdvisory) &&
              ((stateNumber = fDeviceUsablePowerState) != kPowerStateZero))
 
     else if ((type == kIOPMActivityTickleTypeAdvisory) &&
              ((stateNumber = fDeviceUsablePowerState) != kPowerStateZero))


@@ -2827,27 +2925,27 @@ bool IOService::activityTickle( unsigned long type, unsigned long stateNumber )
 
         fAdvisoryTickled = true;
 
 
         fAdvisoryTickled = true;
 

-               if (fAdvisoryTicklePowerState != stateNumber)
-               {
-                       fAdvisoryTicklePowerState = stateNumber;
-                       noPowerChange = false;
+        if (fAdvisoryTicklePowerState != stateNumber)
+        {
+            fAdvisoryTicklePowerState = stateNumber;
+            noPowerChange = false;

 
             tickleFlags = kTickleTypeAdvisory | kTickleTypePowerRise;
 
             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;
                 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;
 }
 
     return noPowerChange;
 }


@@ -2858,12 +2956,12 @@ bool IOService::activityTickle( unsigned long type, unsigned long stateNumber )
 
 void IOService::handleActivityTickle( IOPMRequest * request )
 {
 
 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;
     uint32_t tickleFlags        = (uint32_t)(uintptr_t) request->fArg1;
     uint32_t tickleGeneration   = (uint32_t)(uintptr_t) request->fArg2;
     bool     adjustPower        = false;

-    
-       PM_ASSERT_IN_GATE();
+
+    PM_ASSERT_IN_GATE();

     if (fResetPowerStateOnWake && (tickleGeneration != gIOPMTickleGeneration))
     {
         // Drivers that don't want power restored on wake will drop any
     if (fResetPowerStateOnWake && (tickleGeneration != gIOPMTickleGeneration))
     {
         // Drivers that don't want power restored on wake will drop any


@@ -2879,6 +2977,7 @@ void IOService::handleActivityTickle( IOPMRequest * request )
     if (tickleFlags & kTickleTypeActivity)
     {
         IOPMPowerStateIndex deviceDesireOrder = StateOrder(fDeviceDesire);
     if (tickleFlags & kTickleTypeActivity)
     {
         IOPMPowerStateIndex deviceDesireOrder = StateOrder(fDeviceDesire);

+        uint32_t idleTimerGeneration = ticklePowerState; // kTickleTypePowerDrop

 
         if (tickleFlags & kTickleTypePowerRise)
         {
 
         if (tickleFlags & kTickleTypePowerRise)
         {


@@ -2890,7 +2989,8 @@ void IOService::handleActivityTickle( IOPMRequest * request )
                 adjustPower = true;
             }
         }
                 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.
         {
             // Power drop due to idle timer expiration.
             // Do not allow idle timer to reduce power below tickle power.


@@ -2898,7 +2998,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.
             // 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)
             {
             deviceDesireOrder--;
             if (deviceDesireOrder < fNumberOfPowerStates)
             {


@@ -2935,10 +3035,10 @@ void IOService::handleActivityTickle( IOPMRequest * request )
         }
     }
 
         }
     }
 

-       if (adjustPower)
-       {
-               adjustPowerState();
-       }
+    if (adjustPower)
+    {
+        adjustPowerState();
+    }

 }
 
 //******************************************************************************
 }
 
 //******************************************************************************


@@ -2951,7 +3051,7 @@ void IOService::handleActivityTickle( IOPMRequest * request )
 IOReturn IOService::setIdleTimerPeriod( unsigned long period )
 {
     if (!initialized)
 IOReturn IOService::setIdleTimerPeriod( unsigned long period )
 {
     if (!initialized)

-               return IOPMNotYetInitialized;
+        return IOPMNotYetInitialized;

 
     OUR_PMLog(kPMLogSetIdleTimerPeriod, period, fIdleTimerPeriod);
 
 
     OUR_PMLog(kPMLogSetIdleTimerPeriod, period, fIdleTimerPeriod);
 


@@ -2969,7 +3069,7 @@ IOReturn IOService::setIdleTimerPeriod( unsigned long period )
 IOReturn IOService::setIgnoreIdleTimer( bool ignore )
 {
     if (!initialized)
 IOReturn IOService::setIgnoreIdleTimer( bool ignore )
 {
     if (!initialized)

-               return IOPMNotYetInitialized;
+        return IOPMNotYetInitialized;

 
     OUR_PMLog(kIOPMRequestTypeIgnoreIdleTimer, ignore, 0);
 
 
     OUR_PMLog(kIOPMRequestTypeIgnoreIdleTimer, ignore, 0);
 


@@ -2993,7 +3093,7 @@ IOReturn IOService::setIgnoreIdleTimer( bool ignore )
 
 SInt32 IOService::nextIdleTimeout(
     AbsoluteTime currentTime,
 
 SInt32 IOService::nextIdleTimeout(
     AbsoluteTime currentTime,

-    AbsoluteTime lastActivity, 
+    AbsoluteTime lastActivity,

     unsigned int powerState)
 {
     AbsoluteTime        delta;
     unsigned int powerState)
 {
     AbsoluteTime        delta;


@@ -3004,7 +3104,7 @@ SInt32 IOService::nextIdleTimeout(
     // Calculate time difference using funky macro from clock.h.
     delta = currentTime;
     SUB_ABSOLUTETIME(&delta, &lastActivity);
     // Calculate time difference using funky macro from clock.h.
     delta = currentTime;
     SUB_ABSOLUTETIME(&delta, &lastActivity);

-    
+

     // Figure it in seconds.
     absolutetime_to_nanoseconds(delta, &delta_ns);
     delta_secs = (SInt32)(delta_ns / NSEC_PER_SEC);
     // Figure it in seconds.
     absolutetime_to_nanoseconds(delta, &delta_ns);
     delta_secs = (SInt32)(delta_ns / NSEC_PER_SEC);


@@ -3014,7 +3114,7 @@ SInt32 IOService::nextIdleTimeout(
         delay_secs = (int) fIdleTimerPeriod - delta_secs;
     else
         delay_secs = (int) fIdleTimerPeriod;
         delay_secs = (int) fIdleTimerPeriod - delta_secs;
     else
         delay_secs = (int) fIdleTimerPeriod;

-    
+

     return (SInt32)delay_secs;
 }
 
     return (SInt32)delay_secs;
 }
 


@@ -3028,10 +3128,10 @@ void IOService::start_PM_idle_timer( void )
     static const int    minTimeout = 1;
     AbsoluteTime        uptime, deadline;
     SInt32              idle_in = 0;
     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);
 
 
     IOLockLock(fActivityLock);
 


@@ -3053,6 +3153,9 @@ void IOService::start_PM_idle_timer( void )
 
     IOLockUnlock(fActivityLock);
 
 
     IOLockUnlock(fActivityLock);
 

+    fNextIdleTimerPeriod = idle_in;
+    fIdleTimerStartTime = uptime;
+

     retain();
     clock_interval_to_absolutetime_interval(idle_in, kSecondScale, &deadline);
     ADD_ABSOLUTETIME(&deadline, &uptime);
     retain();
     clock_interval_to_absolutetime_interval(idle_in, kSecondScale, &deadline);
     ADD_ABSOLUTETIME(&deadline, &uptime);


@@ -3070,7 +3173,6 @@ void IOService::restartIdleTimer( void )
     {
         fIdleTimerStopped = false;
         fActivityTickleCount = 0;
     {
         fIdleTimerStopped = false;
         fActivityTickleCount = 0;

-        clock_get_uptime(&fIdleTimerStartTime);

         start_PM_idle_timer();
     }
     else if (fHasAdvisoryDesire)
         start_PM_idle_timer();
     }
     else if (fHasAdvisoryDesire)


@@ -3092,15 +3194,15 @@ static void
 idle_timer_expired(
     thread_call_param_t arg0, thread_call_param_t arg1 )
 {
 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);
 
             OSMemberFunctionCast(IOWorkLoop::Action, me,
                 &IOService::idleTimerExpired),
             me);
 

-       me->release();
+    me->release();

 }
 
 //*********************************************************************************
 }
 
 //*********************************************************************************


@@ -3113,48 +3215,50 @@ idle_timer_expired(
 
 void IOService::idleTimerExpired( void )
 {
 
 void IOService::idleTimerExpired( void )
 {

-       IOPMRequest *   request;
-       bool                    restartTimer = true;
+    IOPMRequest *   request;
+    bool            restartTimer = true;

     uint32_t        tickleFlags;
 
     if ( !initialized || !fIdleTimerPeriod || fIdleTimerStopped ||
          fLockedFlags.PMStop )
         return;
 
     uint32_t        tickleFlags;
 
     if ( !initialized || !fIdleTimerPeriod || fIdleTimerStopped ||
          fLockedFlags.PMStop )
         return;
 

-       IOLockLock(fActivityLock);
+    fIdleTimerStartTime = 0;
+
+    IOLockLock(fActivityLock);

 
 

-       // Check for device activity (tickles) over last timer period.
+    // Check for device activity (tickles) over last timer period.

 
 

-       if (fDeviceWasActive)
-       {
-               // Device was active - do not drop power, restart timer.
-               fDeviceWasActive = false;
-       }
-       else if (!fIdleTimerIgnored)
-       {
-               // No device activity - drop power state by one level.
-               // Decrement the cached tickle power state when possible.
-               // This value may be kInvalidTicklePowerState before activityTickle()
+    if (fDeviceWasActive)
+    {
+        // Device was active - do not drop power, restart timer.
+        fDeviceWasActive = false;
+    }
+    else if (!fIdleTimerIgnored)
+    {
+        // No device activity - drop power state by one level.
+        // Decrement the cached tickle power state when possible.
+        // This value may be kInvalidTicklePowerState before activityTickle()

         // is called, but the power drop request must be issued regardless.
 
         // is called, but the power drop request must be issued regardless.
 

-               if ((fActivityTicklePowerState != kInvalidTicklePowerState) &&
+        if ((fActivityTicklePowerState != kInvalidTicklePowerState) &&

             (fActivityTicklePowerState != kPowerStateZero))
             (fActivityTicklePowerState != kPowerStateZero))

-                       fActivityTicklePowerState--;
+            fActivityTicklePowerState--;

 
         tickleFlags = kTickleTypeActivity | kTickleTypePowerDrop;
 
         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;
             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)
     }
 
     if (fAdvisoryTickled)


@@ -3167,25 +3271,25 @@ void IOService::idleTimerExpired( void )
         fAdvisoryTicklePowerState = kInvalidTicklePowerState;
 
         tickleFlags = kTickleTypeAdvisory | kTickleTypePowerDrop;
         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;
             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__
 }
 
 #ifndef __LP64__


@@ -3230,7 +3334,7 @@ IOReturn IOService::getAggressiveness( unsigned long type, unsigned long * curre
 
     if (!rootDomain)
         return kIOReturnNotReady;
 
     if (!rootDomain)
         return kIOReturnNotReady;

-    
+

     return rootDomain->getAggressiveness( type, currentLevel );
 }
 
     return rootDomain->getAggressiveness( type, currentLevel );
 }
 


@@ -3257,10 +3361,10 @@ UInt32 IOService::getPowerState( void )
 
 IOReturn IOService::systemWake( void )
 {
 
 IOReturn IOService::systemWake( void )
 {

-    OSIterator *               iter;
-    OSObject *                 next;
-    IOPowerConnection *        connection;
-    IOService *                        theChild;
+    OSIterator *        iter;
+    OSObject *          next;
+    IOPowerConnection * connection;
+    IOService *         theChild;

 
     iter = getChildIterator(gIOPowerPlane);
     if ( iter )
 
     iter = getChildIterator(gIOPowerPlane);
     if ( iter )


@@ -3269,17 +3373,17 @@ IOReturn IOService::systemWake( void )
         {
             if ( (connection = OSDynamicCast(IOPowerConnection, next)) )
             {
         {
             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 = (IOService *)connection->copyChildEntry(gIOPowerPlane);
                 if ( theChild )
                 {

-                       theChild->systemWake();
+                    theChild->systemWake();

                     theChild->release();
                 }
             }
                     theChild->release();
                 }
             }


@@ -3304,9 +3408,9 @@ IOReturn IOService::systemWake( void )
 
 IOReturn IOService::temperatureCriticalForZone( IOService * whichZone )
 {
 
 IOReturn IOService::temperatureCriticalForZone( IOService * whichZone )
 {

-    IOService *        theParent;
-    IOService *        theNub;
-    
+    IOService * theParent;
+    IOService * theNub;
+

     OUR_PMLog(kPMLogCriticalTemp, 0, 0);
 
     if ( inPlane(gIOPowerPlane) && !IS_PM_ROOT )
     OUR_PMLog(kPMLogCriticalTemp, 0, 0);
 
     if ( inPlane(gIOPowerPlane) && !IS_PM_ROOT )


@@ -3343,8 +3447,8 @@ IOReturn IOService::startPowerChange(
     IOPowerConnection *     parentConnection,
     IOPMPowerFlags          parentFlags )
 {
     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)
     assert( powerState < fNumberOfPowerStates );
 
     if (powerState >= fNumberOfPowerStates)


@@ -3361,7 +3465,7 @@ IOReturn IOService::startPowerChange(
             // Reset device desire down to the clamped power state
             updatePowerClient(gIOPMPowerClientDevice, powerState);
             computeDesiredState(kPowerStateZero, true);
             // 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;
             // Invalidate tickle cache so the next tickle will issue a request
             IOLockLock(fActivityLock);
             fDeviceWasActive = false;


@@ -3378,29 +3482,29 @@ IOReturn IOService::startPowerChange(
     if (changeFlags & kIOPMNotDone)
         return IOPMAckImplied;
 
     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;
 
     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();
         if (changeFlags & kIOPMSynchronize)
             OurSyncStart();
         else
             OurChangeStart();

-               return 0;
-       }
-       else
-       {
-               assert(changeFlags & kIOPMParentInitiated);
+        return 0;
+    }
+    else
+    {
+        assert(changeFlags & kIOPMParentInitiated);

         fHeadNoteDomainFlags = domainFlags;
         fHeadNoteDomainFlags = domainFlags;

-               fHeadNoteParentFlags = parentFlags;
+        fHeadNoteParentFlags = parentFlags;

         fHeadNoteParentConnection = parentConnection;
         fHeadNoteParentConnection = parentConnection;

-               return ParentChangeStart();
-       }
+        return ParentChangeStart();
+    }

 }
 
 //*********************************************************************************
 }
 
 //*********************************************************************************


@@ -3409,10 +3513,11 @@ IOReturn IOService::startPowerChange(
 
 bool IOService::notifyInterestedDrivers( void )
 {
 
 bool IOService::notifyInterestedDrivers( void )
 {

-    IOPMinformee *             informee;
-    IOPMinformeeList * list = fInterestedDrivers;
-    DriverCallParam *  param;
-    IOItemCount                        count;
+    IOPMinformee *      informee;
+    IOPMinformeeList *  list = fInterestedDrivers;
+    DriverCallParam *   param;
+    IOItemCount         count;
+    IOItemCount         skipCnt = 0;

 
     PM_ASSERT_IN_GATE();
     assert( fDriverCallParamCount == 0 );
 
     PM_ASSERT_IN_GATE();
     assert( fDriverCallParamCount == 0 );


@@ -3422,7 +3527,7 @@ bool IOService::notifyInterestedDrivers( void )
 
     count = list->numberOfItems();
     if (!count)
 
     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
 
     // Allocate an array of interested drivers and their return values
     // for the callout thread. Everything else is still "owned" by the


@@ -3442,7 +3547,7 @@ bool IOService::notifyInterestedDrivers( void )
 
         param = IONew(DriverCallParam, count);
         if (!param)
 
         param = IONew(DriverCallParam, count);
         if (!param)

-            goto done; // no memory
+            goto done;  // no memory

 
         fDriverCallParamPtr   = (void *) param;
         fDriverCallParamSlots = count;
 
         fDriverCallParamPtr   = (void *) param;
         fDriverCallParamSlots = count;


@@ -3452,12 +3557,25 @@ bool IOService::notifyInterestedDrivers( void )
     assert(informee);
     for (IOItemCount i = 0; i < count; i++)
     {
     assert(informee);
     for (IOItemCount i = 0; i < count; i++)
     {

+        if (fInitialSetPowerState || (fHeadNoteChangeFlags & kIOPMInitialPowerChange)) {
+            // Skip notifying self, if 'kIOPMInitialDeviceState' is set and
+            // this is the initial power state change
+            if ((this == informee->whatObject) &&
+                (fHeadNotePowerArrayEntry->capabilityFlags & kIOPMInitialDeviceState)) {
+                skipCnt++;
+                continue;
+            }
+        }

         informee->timer = -1;
         param[i].Target = informee;
         informee->retain();
         informee = list->nextInList( informee );
     }
 
         informee->timer = -1;
         param[i].Target = informee;
         informee->retain();
         informee = list->nextInList( informee );
     }
 

+    count -= skipCnt;
+    if (!count) {
+        goto done;
+    }

     fDriverCallParamCount = count;
     fHeadNotePendingAcks  = count;
 
     fDriverCallParamCount = count;
     fHeadNotePendingAcks  = count;
 


@@ -3479,39 +3597,39 @@ done:
 
 void IOService::notifyInterestedDriversDone( void )
 {
 
 void IOService::notifyInterestedDriversDone( void )
 {

-    IOPMinformee *             informee;
-    IOItemCount                        count;
+    IOPMinformee *      informee;
+    IOItemCount         count;

     DriverCallParam *   param;
     IOReturn            result;
 
     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 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;
                     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.
                 assert(informee->timer == -1);
 
                 // Driver has not acked, and has returned a positive result.


@@ -3525,23 +3643,23 @@ void IOService::notifyInterestedDriversDone( void )
                     result = kMinAckTimeoutTicks;
 
                 informee->timer = (result / (ACK_TIMER_PERIOD / ns_per_us)) + 1;
                     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.
             // 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.
 
             // 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()
 
 
     MS_POP();  // pop the machine state passed to notifyAll()
 


@@ -3566,7 +3684,7 @@ void IOService::notifyInterestedDriversDone( void )
 
 void IOService::notifyRootDomain( void )
 {
 
 void IOService::notifyRootDomain( void )
 {

-       assert( fDriverCallBusy == false );
+    assert( fDriverCallBusy == false );

 
     // Only for root domain in the will-change phase
     if (!IS_ROOT_DOMAIN || (fMachineState != kIOPM_OurChangeSetPowerState))
 
     // Only for root domain in the will-change phase
     if (!IS_ROOT_DOMAIN || (fMachineState != kIOPM_OurChangeSetPowerState))


@@ -3587,8 +3705,8 @@ void IOService::notifyRootDomain( void )
 
 void IOService::notifyRootDomainDone( void )
 {
 
 void IOService::notifyRootDomainDone( void )
 {

-       assert( fDriverCallBusy == false );
-       assert( fMachineState == kIOPM_DriverThreadCallDone );
+    assert( fDriverCallBusy == false );
+    assert( fMachineState == kIOPM_DriverThreadCallDone );

 
     MS_POP();   // pop notifyAll() machine state
     notifyChildren();
 
     MS_POP();   // pop notifyAll() machine state
     notifyChildren();


@@ -3600,13 +3718,13 @@ void IOService::notifyRootDomainDone( void )
 
 void IOService::notifyChildren( void )
 {
 
 void IOService::notifyChildren( void )
 {

-    OSIterator *               iter;
-    OSObject *                 next;
-    IOPowerConnection *        connection;
-       OSArray *                       children = 0;
+    OSIterator *        iter;
+    OSObject *          next;
+    IOPowerConnection * connection;
+    OSArray *           children = 0;

     IOPMrootDomain *    rootDomain;
     bool                delayNotify = false;
     IOPMrootDomain *    rootDomain;
     bool                delayNotify = false;

-    
+

     if ((fHeadNotePowerState != fCurrentPowerState) &&
         (IS_POWER_DROP == fIsPreChange) &&
         ((rootDomain = getPMRootDomain()) == this))
     if ((fHeadNotePowerState != fCurrentPowerState) &&
         (IS_POWER_DROP == fIsPreChange) &&
         ((rootDomain = getPMRootDomain()) == this))


@@ -3616,8 +3734,8 @@ void IOService::notifyChildren( void )
             kIOPMTracePointWakePowerPlaneDrivers  );
     }
 
             kIOPMTracePointWakePowerPlaneDrivers  );
     }
 

-       if (fStrictTreeOrder)
-               children = OSArray::withCapacity(8);
+    if (fStrictTreeOrder)
+        children = OSArray::withCapacity(8);

 
     // Sum child power consumption in notifyChild()
     fHeadNotePowerArrayEntry->staticPower = 0;
 
     // Sum child power consumption in notifyChild()
     fHeadNotePowerArrayEntry->staticPower = 0;


@@ -3629,12 +3747,12 @@ void IOService::notifyChildren( void )
         {
             if ((connection = OSDynamicCast(IOPowerConnection, next)))
             {
         {
             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.
 
                 // Mechanism to postpone the did-change notification to
                 // certain power children to order those children last.


@@ -3657,11 +3775,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();
     }
         }
         iter->release();
     }


@@ -3671,10 +3789,10 @@ void IOService::notifyChildren( void )
         children->release();
         children = 0;
     }
         children->release();
         children = 0;
     }

-       if (children)
-       {
+    if (children)
+    {

         assert(fNotifyChildArray == 0);
         assert(fNotifyChildArray == 0);

-        fNotifyChildArray = children;        
+        fNotifyChildArray = children;

         MS_PUSH(fMachineState);
 
         if (delayNotify)
         MS_PUSH(fMachineState);
 
         if (delayNotify)


@@ -3698,7 +3816,7 @@ void IOService::notifyChildren( void )
 
             fMachineState = kIOPM_NotifyChildrenOrdered;
         }
 
             fMachineState = kIOPM_NotifyChildrenOrdered;
         }

-       }
+    }

 }
 
 //*********************************************************************************
 }
 
 //*********************************************************************************


@@ -3707,33 +3825,33 @@ void IOService::notifyChildren( void )
 
 void IOService::notifyChildrenOrdered( 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()
 
         MS_POP();   // pushed by notifyChildren()

-       }
+    }

 }
 
 //*********************************************************************************
 }
 
 //*********************************************************************************


@@ -3742,11 +3860,11 @@ void IOService::notifyChildrenOrdered( void )
 
 void IOService::notifyChildrenDelayed( void )
 {
 
 void IOService::notifyChildrenDelayed( void )
 {

-    IOPowerConnection *        connection;
+    IOPowerConnection * connection;

 
 

-       PM_ASSERT_IN_GATE();
-       assert(fNotifyChildArray);
-       assert(fMachineState == kIOPM_NotifyChildrenDelayed);
+    PM_ASSERT_IN_GATE();
+    assert(fNotifyChildArray);
+    assert(fMachineState == kIOPM_NotifyChildrenDelayed);

 
     // Wait after all non-delayed children and interested drivers have ack'ed,
     // then notify all delayed children. If notify delay is canceled, child
 
     // 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 +3873,17 @@ void IOService::notifyChildrenDelayed( void )
 
     for (int i = 0; ; i++)
     {
 
     for (int i = 0; ; i++)
     {

-               connection = (IOPowerConnection *) fNotifyChildArray->getObject(i);
+        connection = (IOPowerConnection *) fNotifyChildArray->getObject(i);

         if (!connection)
             break;
 
         if (!connection)
             break;
 

-               notifyChild( connection );
+        notifyChild( connection );

     }
 
     PM_LOG2("%s: notified delayed children\n", getName());
     fNotifyChildArray->release();
     fNotifyChildArray = 0;
     }
 
     PM_LOG2("%s: notified delayed children\n", getName());
     fNotifyChildArray->release();
     fNotifyChildArray = 0;

-    
+

     MS_POP();   // pushed by notifyChildren()
 }
 
     MS_POP();   // pushed by notifyChildren()
 }
 


@@ -3775,18 +3893,18 @@ void IOService::notifyChildrenDelayed( void )
 
 IOReturn IOService::notifyAll( uint32_t nextMS )
 {
 
 IOReturn IOService::notifyAll( uint32_t nextMS )
 {

-       // Save the machine state to be restored by notifyInterestedDriversDone()
+    // Save the machine state to be restored by notifyInterestedDriversDone()

 
 

-       PM_ASSERT_IN_GATE();
+    PM_ASSERT_IN_GATE();

     MS_PUSH(nextMS);
     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 +3914,9 @@ IOReturn IOService::notifyAll( uint32_t nextMS )
 //*********************************************************************************
 
 IOReturn IOService::actionDriverCalloutDone(
 //*********************************************************************************
 
 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;
 
 {
     IOServicePM * pwrMgt = (IOServicePM *) arg0;
 


@@ -3813,30 +3931,30 @@ IOReturn IOService::actionDriverCalloutDone(
 
 void IOService::pmDriverCallout( IOService * from )
 {
 
 void IOService::pmDriverCallout( IOService * from )
 {

-       assert(from);
-       switch (from->fDriverCallReason)
-       {
-               case kDriverCallSetPowerState:
-                       from->driverSetPowerState();
-                       break;
+    assert(from);
+    switch (from->fDriverCallReason)
+    {
+        case kDriverCallSetPowerState:
+            from->driverSetPowerState();
+            break;

 
 

-               case kDriverCallInformPreChange:
-               case kDriverCallInformPostChange:
-                       from->driverInformPowerChange();
-                       break;
+        case kDriverCallInformPreChange:
+        case kDriverCallInformPostChange:
+            from->driverInformPowerChange();
+            break;

 
         case kRootDomainInformPreChange:
             getPMRootDomain()->willNotifyPowerChildren(from->fHeadNotePowerState);
             break;
 
 
         case kRootDomainInformPreChange:
             getPMRootDomain()->willNotifyPowerChildren(from->fHeadNotePowerState);
             break;
 

-               default:
-                       panic("IOService::pmDriverCallout bad machine state %x",
+        default:
+            panic("IOService::pmDriverCallout bad machine state %x",

                 from->fDriverCallReason);
                 from->fDriverCallReason);

-       }
+    }

 
 

-       gIOPMWorkLoop->runAction(actionDriverCalloutDone,
-               /* target */ from,
-               /* arg0   */ (void *) from->pwrMgt );
+    gIOPMWorkLoop->runAction(actionDriverCalloutDone,
+        /* target */ from,
+        /* arg0   */ (void *) from->pwrMgt );

 }
 
 //*********************************************************************************
 }
 
 //*********************************************************************************


@@ -3848,7 +3966,7 @@ void IOService::pmDriverCallout( IOService * from )
 void IOService::driverSetPowerState( void )
 {
     IOPMPowerStateIndex powerState;
 void IOService::driverSetPowerState( void )
 {
     IOPMPowerStateIndex powerState;

-    DriverCallParam *  param;
+    DriverCallParam *   param;

     IOPMDriverCallEntry callEntry;
     AbsoluteTime        end;
     IOReturn            result;
     IOPMDriverCallEntry callEntry;
     AbsoluteTime        end;
     IOReturn            result;


@@ -3863,44 +3981,44 @@ void IOService::driverSetPowerState( void )
 
     if (assertPMDriverCall(&callEntry))
     {
 
     if (assertPMDriverCall(&callEntry))
     {

-        OUR_PMLog(          kPMLogProgramHardware, (uintptr_t) this, powerState);
+        OUR_PMLogFuncStart(kPMLogProgramHardware, (uintptr_t) this, powerState);
+        start_spindump_timer("SetState");

         clock_get_uptime(&fDriverCallStartTime);
         result = fControllingDriver->setPowerState( powerState, this );
         clock_get_uptime(&end);
         clock_get_uptime(&fDriverCallStartTime);
         result = fControllingDriver->setPowerState( powerState, this );
         clock_get_uptime(&end);

-        OUR_PMLog((UInt32) -kPMLogProgramHardware, (uintptr_t) this, (UInt32) result);
+        stop_spindump_timer();
+        OUR_PMLogFuncEnd(kPMLogProgramHardware, (uintptr_t) this, (UInt32) result);

 
         deassertPMDriverCall(&callEntry);
 
 
         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",
         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
+

         if ((result == IOPMAckImplied) || (result < 0))
         {
             uint64_t    nsec;
 
             SUB_ABSOLUTETIME(&end, &fDriverCallStartTime);
             absolutetime_to_nanoseconds(end, &nsec);
         if ((result == IOPMAckImplied) || (result < 0))
         {
             uint64_t    nsec;
 
             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), getRegistryEntryID(),
+                    NULL, powerState);
+            }

         }
         }

-#endif
+

     }
     else
         result = kIOPMAckImplied;
     }
     else
         result = kIOPMAckImplied;


@@ -3916,15 +4034,15 @@ void IOService::driverSetPowerState( void )
 
 void IOService::driverInformPowerChange( void )
 {
 
 void IOService::driverInformPowerChange( void )
 {

-    IOPMinformee *             informee;
-    IOService *                        driver;
-    DriverCallParam *  param;
+    IOPMinformee *      informee;
+    IOService *         driver;
+    DriverCallParam *   param;

     IOPMDriverCallEntry callEntry;
     IOPMDriverCallEntry callEntry;

-    IOPMPowerFlags             powerFlags;
+    IOPMPowerFlags      powerFlags;

     IOPMPowerStateIndex powerState;
     AbsoluteTime        end;
     IOReturn            result;
     IOPMPowerStateIndex powerState;
     AbsoluteTime        end;
     IOReturn            result;

-    IOItemCount                        count;
+    IOItemCount         count;

 
     assert( fDriverCallBusy );
     assert( fDriverCallParamPtr );
 
     assert( fDriverCallBusy );
     assert( fDriverCallParamPtr );


@@ -3945,53 +4063,42 @@ void IOService::driverInformPowerChange( void )
         {
             if (fDriverCallReason == kDriverCallInformPreChange)
             {
         {
             if (fDriverCallReason == kDriverCallInformPreChange)
             {

-                OUR_PMLog(kPMLogInformDriverPreChange, (uintptr_t) this, powerState);
+                OUR_PMLogFuncStart(kPMLogInformDriverPreChange, (uintptr_t) this, powerState);
+                start_spindump_timer("WillChange");

                 clock_get_uptime(&informee->startTime);
                 result = driver->powerStateWillChangeTo(powerFlags, powerState, this);
                 clock_get_uptime(&end);
                 clock_get_uptime(&informee->startTime);
                 result = driver->powerStateWillChangeTo(powerFlags, powerState, this);
                 clock_get_uptime(&end);

-                OUR_PMLog((UInt32)-kPMLogInformDriverPreChange, (uintptr_t) this, result);
+                stop_spindump_timer();
+                OUR_PMLogFuncEnd(kPMLogInformDriverPreChange, (uintptr_t) this, result);

             }
             else
             {
             }
             else
             {

-                OUR_PMLog(kPMLogInformDriverPostChange, (uintptr_t) this, powerState);
+                OUR_PMLogFuncStart(kPMLogInformDriverPostChange, (uintptr_t) this, powerState);
+                start_spindump_timer("DidChange");

                 clock_get_uptime(&informee->startTime);
                 result = driver->powerStateDidChangeTo(powerFlags, powerState, this);
                 clock_get_uptime(&end);
                 clock_get_uptime(&informee->startTime);
                 result = driver->powerStateDidChangeTo(powerFlags, powerState, this);
                 clock_get_uptime(&end);

-                OUR_PMLog((UInt32)-kPMLogInformDriverPostChange, (uintptr_t) this, result);
+                stop_spindump_timer();
+                OUR_PMLogFuncEnd(kPMLogInformDriverPostChange, (uintptr_t) this, result);

             }
             }

-    
+

             deassertPMDriverCall(&callEntry);
 
             deassertPMDriverCall(&callEntry);
 

-#if LOG_SETPOWER_TIMES
+

             if ((result == IOPMAckImplied) || (result < 0))
             {
                 uint64_t nsec;
 
                 SUB_ABSOLUTETIME(&end, &informee->startTime);
                 absolutetime_to_nanoseconds(end, &nsec);
             if ((result == IOPMAckImplied) || (result < 0))
             {
                 uint64_t nsec;
 
                 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), driver->getRegistryEntryID(),
+                        NULL, powerState);
+                }

             }
             }

-#endif
+

         }
         else
             result = kIOPMAckImplied;
         }
         else
             result = kIOPMAckImplied;


@@ -4013,11 +4120,11 @@ bool IOService::notifyChild( IOPowerConnection * theNub )
     IOReturn                ret = IOPMAckImplied;
     unsigned long           childPower;
     IOService *             theChild;
     IOReturn                ret = IOPMAckImplied;
     unsigned long           childPower;
     IOService *             theChild;

-       IOPMRequest *           childRequest;
+    IOPMRequest *           childRequest;

     IOPMPowerChangeFlags    requestArg2;
     IOPMPowerChangeFlags    requestArg2;

-       int                     requestType;
+    int                     requestType;

 
 

-       PM_ASSERT_IN_GATE();
+    PM_ASSERT_IN_GATE();

     theChild = (IOService *)(theNub->copyChildEntry(gIOPowerPlane));
     if (!theChild)
     {
     theChild = (IOService *)(theNub->copyChildEntry(gIOPowerPlane));
     if (!theChild)
     {


@@ -4026,7 +4133,7 @@ bool IOService::notifyChild( IOPowerConnection * theNub )
 
     // Unless the child handles the notification immediately and returns
     // kIOPMAckImplied, we'll be awaiting their acknowledgement later.
 
     // Unless the child handles the notification immediately and returns
     // kIOPMAckImplied, we'll be awaiting their acknowledgement later.

-       fHeadNotePendingAcks++;
+    fHeadNotePendingAcks++;

     theNub->setAwaitingAck(true);
 
     requestArg2 = fHeadNoteChangeFlags;
     theNub->setAwaitingAck(true);
 
     requestArg2 = fHeadNoteChangeFlags;


@@ -4037,21 +4144,21 @@ bool IOService::notifyChild( IOPowerConnection * theNub )
         kIOPMRequestTypePowerDomainWillChange :
         kIOPMRequestTypePowerDomainDidChange;
 
         kIOPMRequestTypePowerDomainWillChange :
         kIOPMRequestTypePowerDomainDidChange;
 

-       childRequest = acquirePMRequest( theChild, requestType );
-       if (childRequest)
-       {
+    childRequest = acquirePMRequest( theChild, requestType );
+    if (childRequest)
+    {

         theNub->retain();
         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 )
         {
         childPower = theChild->currentPowerConsumption();
         if ( childPower == kIOPMUnknown )
         {


@@ -4063,7 +4170,7 @@ bool IOService::notifyChild( IOPowerConnection * theNub )
     }
 
     theChild->release();
     }
 
     theChild->release();

-       return (IOPMAckImplied == ret);
+    return (IOPMAckImplied == ret);

 }
 
 //*********************************************************************************
 }
 
 //*********************************************************************************


@@ -4072,7 +4179,7 @@ bool IOService::notifyChild( IOPowerConnection * theNub )
 
 bool IOService::notifyControllingDriver( void )
 {
 
 bool IOService::notifyControllingDriver( void )
 {

-    DriverCallParam *  param;
+    DriverCallParam *   param;

 
     PM_ASSERT_IN_GATE();
     assert( fDriverCallParamCount == 0  );
 
     PM_ASSERT_IN_GATE();
     assert( fDriverCallParamCount == 0  );


@@ -4095,7 +4202,7 @@ bool IOService::notifyControllingDriver( void )
     {
         param = IONew(DriverCallParam, 1);
         if (!param)
     {
         param = IONew(DriverCallParam, 1);
         if (!param)

-            return false;      // no memory
+            return false;   // no memory

 
         fDriverCallParamPtr   = (void *) param;
         fDriverCallParamSlots = 1;
 
         fDriverCallParamPtr   = (void *) param;
         fDriverCallParamSlots = 1;


@@ -4119,28 +4226,28 @@ bool IOService::notifyControllingDriver( void )
 
 void IOService::notifyControllingDriverDone( void )
 {
 
 void IOService::notifyControllingDriverDone( void )
 {

-       DriverCallParam *       param;
-       IOReturn                        result;
+    DriverCallParam *   param;
+    IOReturn            result;
+
+    PM_ASSERT_IN_GATE();
+    param = (DriverCallParam *) fDriverCallParamPtr;

 
 

-       PM_ASSERT_IN_GATE();
-       param = (DriverCallParam *) fDriverCallParamPtr;
+    assert( fDriverCallBusy == false );
+    assert( fMachineState == kIOPM_DriverThreadCallDone );

 
 

-       assert( fDriverCallBusy == false );
-       assert( fMachineState == kIOPM_DriverThreadCallDone );
+    if (param && fDriverCallParamCount)
+    {
+        assert(fDriverCallParamCount == 1);

 
 

-       if (param && fDriverCallParamCount)
-       {
-               assert(fDriverCallParamCount == 1);
-               
-               // the return value from setPowerState()
-               result = param->Result;
+        // the return value from setPowerState()
+        result = param->Result;

 
 

-               if ((result == IOPMAckImplied) || (result < 0))
-               {
+        if ((result == IOPMAckImplied) || (result < 0))
+        {

             fDriverTimer = 0;
             fDriverTimer = 0;

-               }
-               else if (fDriverTimer)
-               {
+        }
+        else if (fDriverTimer)
+        {

             assert(fDriverTimer == -1);
 
             // Driver has not acked, and has returned a positive result.
             assert(fDriverTimer == -1);
 
             // Driver has not acked, and has returned a positive result.


@@ -4154,17 +4261,17 @@ void IOService::notifyControllingDriverDone( void )
                 result = kMinAckTimeoutTicks;
 
             fDriverTimer = (result / (ACK_TIMER_PERIOD / ns_per_us)) + 1;
                 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;
 
     MS_POP();   // pushed by OurChangeSetPowerState()
     fIsPreChange  = false;


@@ -4182,7 +4289,7 @@ void IOService::all_done( void )
     const IOPMPSEntry *     powerStatePtr;
     IOPMDriverCallEntry     callEntry;
     uint32_t                prevMachineState = fMachineState;
     const IOPMPSEntry *     powerStatePtr;
     IOPMDriverCallEntry     callEntry;
     uint32_t                prevMachineState = fMachineState;

-    bool                    callAction = false;
+    bool                    actionCalled = false;

     uint64_t                ts;
 
     fMachineState = kIOPM_Finished;
     uint64_t                ts;
 
     fMachineState = kIOPM_Finished;


@@ -4228,15 +4335,15 @@ void IOService::all_done( void )
     }
 
     // our power change
     }
 
     // our power change

-    if ( fHeadNoteChangeFlags & kIOPMSelfInitiated )
+    if (fHeadNoteChangeFlags & kIOPMSelfInitiated)

     {
     {

-        // could our driver switch to the new state?
-        if ( !( fHeadNoteChangeFlags & kIOPMNotDone) )
+        // power state changed
+        if ((fHeadNoteChangeFlags & kIOPMNotDone) == 0)

         {
             trackSystemSleepPreventers(
                 fCurrentPowerState, fHeadNotePowerState, fHeadNoteChangeFlags);
 
         {
             trackSystemSleepPreventers(
                 fCurrentPowerState, fHeadNotePowerState, fHeadNoteChangeFlags);
 

-                       // we changed, tell our parent
+            // we changed, tell our parent

             requestDomainPower(fHeadNotePowerState);
 
             // yes, did power raise?
             requestDomainPower(fHeadNotePowerState);
 
             // yes, did power raise?


@@ -4260,7 +4367,7 @@ void IOService::all_done( void )
             OUR_PMLog(kPMLogChangeDone, fCurrentPowerState, prevPowerState);
             PM_ACTION_2(actionPowerChangeDone,
                 fHeadNotePowerState, fHeadNoteChangeFlags);
             OUR_PMLog(kPMLogChangeDone, fCurrentPowerState, prevPowerState);
             PM_ACTION_2(actionPowerChangeDone,
                 fHeadNotePowerState, fHeadNoteChangeFlags);

-            callAction = true;
+            actionCalled = true;

 
             powerStatePtr = &fPowerStates[fCurrentPowerState];
             fCurrentCapabilityFlags = powerStatePtr->capabilityFlags;
 
             powerStatePtr = &fPowerStates[fCurrentPowerState];
             fCurrentCapabilityFlags = powerStatePtr->capabilityFlags;


@@ -4288,16 +4395,14 @@ void IOService::all_done( void )
         }
     }
 
         }
     }
 

-    // parent's power change
-    if ( fHeadNoteChangeFlags & kIOPMParentInitiated)
+    // parent-initiated power change
+    if (fHeadNoteChangeFlags & kIOPMParentInitiated)

     {
         if (fHeadNoteChangeFlags & kIOPMRootChangeDown)
             ParentChangeRootChangeDown();
     {
         if (fHeadNoteChangeFlags & kIOPMRootChangeDown)
             ParentChangeRootChangeDown();

-    
-        if (((fHeadNoteChangeFlags & kIOPMDomainWillChange) &&
-             (StateOrder(fCurrentPowerState) >= StateOrder(fHeadNotePowerState)))   ||
-                         ((fHeadNoteChangeFlags & kIOPMDomainDidChange)  &&
-             (StateOrder(fCurrentPowerState) < StateOrder(fHeadNotePowerState))))
+
+        // power state changed
+        if ((fHeadNoteChangeFlags & kIOPMNotDone) == 0)

         {
             trackSystemSleepPreventers(
                 fCurrentPowerState, fHeadNotePowerState, fHeadNoteChangeFlags);
         {
             trackSystemSleepPreventers(
                 fCurrentPowerState, fHeadNotePowerState, fHeadNoteChangeFlags);


@@ -4320,12 +4425,11 @@ void IOService::all_done( void )
 #if PM_VARS_SUPPORT
             fPMVars->myCurrentState = fCurrentPowerState;
 #endif
 #if PM_VARS_SUPPORT
             fPMVars->myCurrentState = fCurrentPowerState;
 #endif

-            fMaxPowerState = fControllingDriver->maxCapabilityForDomainState(fHeadNoteDomainFlags);

 
             OUR_PMLog(kPMLogChangeDone, fCurrentPowerState, prevPowerState);
             PM_ACTION_2(actionPowerChangeDone,
                 fHeadNotePowerState, fHeadNoteChangeFlags);
 
             OUR_PMLog(kPMLogChangeDone, fCurrentPowerState, prevPowerState);
             PM_ACTION_2(actionPowerChangeDone,
                 fHeadNotePowerState, fHeadNoteChangeFlags);

-            callAction = true;
+            actionCalled = true;

 
             powerStatePtr = &fPowerStates[fCurrentPowerState];
             fCurrentCapabilityFlags = powerStatePtr->capabilityFlags;
 
             powerStatePtr = &fPowerStates[fCurrentPowerState];
             fCurrentCapabilityFlags = powerStatePtr->capabilityFlags;


@@ -4350,7 +4454,7 @@ void IOService::all_done( void )
         fIdleTimerMinPowerState = kPowerStateZero;
     }
 
         fIdleTimerMinPowerState = kPowerStateZero;
     }
 

-    if (!callAction)
+    if (!actionCalled)

     {
         PM_ACTION_2(actionPowerChangeDone,
             fHeadNotePowerState, fHeadNoteChangeFlags);
     {
         PM_ACTION_2(actionPowerChangeDone,
             fHeadNotePowerState, fHeadNoteChangeFlags);


@@ -4368,12 +4472,12 @@ void IOService::all_done( void )
 
 void IOService::OurChangeStart( void )
 {
 
 void IOService::OurChangeStart( void )
 {

-       PM_ASSERT_IN_GATE();
+    PM_ASSERT_IN_GATE();

     OUR_PMLog( kPMLogStartDeviceChange, fHeadNotePowerState, fCurrentPowerState );
 
     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)))
     {
 
     if (!IS_PM_ROOT && (StateOrder(fMaxPowerState) < StateOrder(fHeadNotePowerState)))
     {


@@ -4383,12 +4487,12 @@ void IOService::OurChangeStart( void )
         return;
     }
 
         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))
 
     if (!fInitialPowerChange && (fHeadNotePowerState == fCurrentPowerState))

-       {
-               OurChangeFinish();
-               return;
+    {
+        OurChangeFinish();
+        return;

     }
     fInitialPowerChange = false;
 
     }
     fInitialPowerChange = false;
 


@@ -4397,8 +4501,8 @@ void IOService::OurChangeStart( void )
 
     PM_ACTION_2(actionPowerChangeStart, fHeadNotePowerState, &fHeadNoteChangeFlags);
 
 
     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)
     {
 
     if (IS_POWER_DROP)
     {


@@ -4409,8 +4513,8 @@ void IOService::OurChangeStart( void )
         fOutOfBandParameter = kNotifyApps;
         askChangeDown(fHeadNotePowerState);
     }
         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.
         // 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 +4599,7 @@ IOReturn IOService::requestDomainPower(
     IOPMPowerStateIndex             maxPowerState;
     IOPMRequestDomainPowerContext   context;
 
     IOPMPowerStateIndex             maxPowerState;
     IOPMRequestDomainPowerContext   context;
 

-       PM_ASSERT_IN_GATE();
+    PM_ASSERT_IN_GATE();

     assert(ourPowerState < fNumberOfPowerStates);
     if (ourPowerState >= fNumberOfPowerStates)
         return kIOReturnBadArgument;
     assert(ourPowerState < fNumberOfPowerStates);
     if (ourPowerState >= fNumberOfPowerStates)
         return kIOReturnBadArgument;


@@ -4505,7 +4609,7 @@ IOReturn IOService::requestDomainPower(
     // Fetch our input power flags for the requested power state.
     // Parent request is stated in terms of required power flags.
 
     // 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.
 
 
     // Disregard the "previous request" for power reservation.
 


@@ -4548,7 +4652,7 @@ done:
 
 void IOService::OurSyncStart( void )
 {
 
 void IOService::OurSyncStart( void )
 {

-       PM_ASSERT_IN_GATE();
+    PM_ASSERT_IN_GATE();

 
     if (fInitialPowerChange)
         return;
 
     if (fInitialPowerChange)
         return;


@@ -4557,8 +4661,8 @@ void IOService::OurSyncStart( void )
 
     if (fHeadNoteChangeFlags & kIOPMNotDone)
     {
 
     if (fHeadNoteChangeFlags & kIOPMNotDone)
     {

-               OurChangeFinish();
-               return;
+        OurChangeFinish();
+        return;

     }
 
     if (fHeadNoteChangeFlags & kIOPMSyncTellPowerDown)
     }
 
     if (fHeadNoteChangeFlags & kIOPMSyncTellPowerDown)


@@ -4581,7 +4685,7 @@ void IOService::OurSyncStart( void )
 // [private] OurChangeTellClientsPowerDown
 //
 // All applications and kernel clients have acknowledged our permission to drop
 // [private] OurChangeTellClientsPowerDown
 //
 // All applications and kernel clients have acknowledged our permission to drop

-// power. Here we notify them that we will lower the power and wait for acks. 
+// power. Here we notify them that we will lower the power and wait for acks.

 //*********************************************************************************
 
 void IOService::OurChangeTellClientsPowerDown( void )
 //*********************************************************************************
 
 void IOService::OurChangeTellClientsPowerDown( void )


@@ -4653,13 +4757,6 @@ void IOService::OurChangeNotifyInterestedDriversWillChange( void )
         if (IS_POWER_DROP)
         {
             rootDomain->tracePoint( kIOPMTracePointSleepWillChangeInterests );
         if (IS_POWER_DROP)
         {
             rootDomain->tracePoint( kIOPMTracePointSleepWillChangeInterests );

-
-            PMEventDetails *details = PMEventDetails::eventDetails(
-                                        kIOPMEventTypeAppNotificationsFinished,
-                                        NULL,
-                                        100,
-                                        kIOReturnSuccess);
-            rootDomain->recordAndReleasePMEvent( details );

         }
         else
             rootDomain->tracePoint( kIOPMTracePointWakeWillChangeInterests );
         }
         else
             rootDomain->tracePoint( kIOPMTracePointWakeWillChangeInterests );


@@ -4758,7 +4855,7 @@ void IOService::OurChangeFinish( void )
 
 IOReturn IOService::ParentChangeStart( 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
     OUR_PMLog( kPMLogStartParentChange, fHeadNotePowerState, fCurrentPowerState );
 
     // Root power domain has transitioned to its max power state


@@ -4777,10 +4874,10 @@ IOReturn IOService::ParentChangeStart( void )
     {
         PM_ACTION_2(actionPowerChangeStart, fHeadNotePowerState, &fHeadNoteChangeFlags);
 
     {
         PM_ACTION_2(actionPowerChangeStart, fHeadNotePowerState, &fHeadNoteChangeFlags);
 

-       // Tell apps and kernel clients
-       fInitialPowerChange = false;
+        // Tell apps and kernel clients
+        fInitialPowerChange = false;

         fMachineState = kIOPM_ParentChangeTellPriorityClientsPowerDown;
         fMachineState = kIOPM_ParentChangeTellPriorityClientsPowerDown;

-               tellChangeDown1(fHeadNotePowerState);
+        tellChangeDown1(fHeadNotePowerState);

         return IOPMWillAckLater;
     }
 
         return IOPMWillAckLater;
     }
 


@@ -4793,26 +4890,26 @@ IOReturn IOService::ParentChangeStart( void )
             {
                 // We power up, but not all the way
                 fHeadNotePowerState = fDesiredPowerState;
             {
                 // 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;
                 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 )
             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
         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;
         }
             ParentChangeTellCapabilityWillChange();
             return IOPMWillAckLater;
         }


@@ -4822,11 +4919,15 @@ IOReturn IOService::ParentChangeStart( void )
             // to our children.
             fMachineState     = kIOPM_SyncNotifyDidChange;
             fDriverCallReason = kDriverCallInformPreChange;
             // to our children.
             fMachineState     = kIOPM_SyncNotifyDidChange;
             fDriverCallReason = kDriverCallInformPreChange;

+            fHeadNoteChangeFlags |= kIOPMNotDone;

             notifyChildren();
             return IOPMWillAckLater;
         }
     }
 
             notifyChildren();
             return IOPMWillAckLater;
         }
     }
 

+    // No power state change necessary
+    fHeadNoteChangeFlags |= kIOPMNotDone;
+

     all_done();
     return IOPMAckImplied;
 }
     all_done();
     return IOPMAckImplied;
 }


@@ -4860,6 +4961,7 @@ void IOService::ParentChangeRootChangeDown( void )
         {
             updatePowerClient(gIOPMPowerClientDevice, kPowerStateZero);
             computeDesiredState(kPowerStateZero, true);
         {
             updatePowerClient(gIOPMPowerClientDevice, kPowerStateZero);
             computeDesiredState(kPowerStateZero, true);

+            requestDomainPower( fDesiredPowerState );

             PM_LOG1("%s: tickle desire removed\n", fName);
         }
 
             PM_LOG1("%s: tickle desire removed\n", fName);
         }
 


@@ -4938,7 +5040,7 @@ void IOService::ParentChangeRootChangeDown( void )
 void IOService::ParentChangeTellPriorityClientsPowerDown( void )
 {
     fMachineState = kIOPM_ParentChangeNotifyInterestedDriversWillChange;
 void IOService::ParentChangeTellPriorityClientsPowerDown( void )
 {
     fMachineState = kIOPM_ParentChangeNotifyInterestedDriversWillChange;

-       tellChangeDown2(fHeadNotePowerState);
+    tellChangeDown2(fHeadNotePowerState);

 }
 
 //*********************************************************************************
 }
 
 //*********************************************************************************


@@ -4965,7 +5067,7 @@ void IOService::ParentChangeTellCapabilityWillChange( void )
 
 void IOService::ParentChangeNotifyInterestedDriversWillChange( void )
 {
 
 void IOService::ParentChangeNotifyInterestedDriversWillChange( void )
 {

-       notifyAll( kIOPM_ParentChangeSetPowerState );
+    notifyAll( kIOPM_ParentChangeSetPowerState );

 }
 
 //*********************************************************************************
 }
 
 //*********************************************************************************


@@ -4994,7 +5096,7 @@ void IOService::ParentChangeSetPowerState( void )
 
 void IOService::ParentChangeWaitForPowerSettle( void )
 {
 
 void IOService::ParentChangeWaitForPowerSettle( void )
 {

-       fMachineState = kIOPM_ParentChangeNotifyInterestedDriversDidChange;
+    fMachineState = kIOPM_ParentChangeNotifyInterestedDriversDidChange;

     startSettleTimer();
 }
 
     startSettleTimer();
 }
 


@@ -5007,7 +5109,7 @@ void IOService::ParentChangeWaitForPowerSettle( void )
 
 void IOService::ParentChangeNotifyInterestedDriversDidChange( void )
 {
 
 void IOService::ParentChangeNotifyInterestedDriversDidChange( void )
 {

-       notifyAll( kIOPM_ParentChangeTellCapabilityDidChange ); 
+    notifyAll( kIOPM_ParentChangeTellCapabilityDidChange );

 }
 
 //*********************************************************************************
 }
 
 //*********************************************************************************


@@ -5027,13 +5129,13 @@ void IOService::ParentChangeTellCapabilityDidChange( void )
 //*********************************************************************************
 // [private] ParentAcknowledgePowerChange
 //
 //*********************************************************************************
 // [private] ParentAcknowledgePowerChange
 //

-// Acknowledge our power parent that our power change is done. 
+// Acknowledge our power parent that our power change is done.

 //*********************************************************************************
 
 void IOService::ParentChangeAcknowledgePowerChange( void )
 {
 //*********************************************************************************
 
 void IOService::ParentChangeAcknowledgePowerChange( void )
 {

-    IORegistryEntry *  nub;
-    IOService *                        parent;
+    IORegistryEntry *   nub;
+    IOService *         parent;

 
     nub = fHeadNoteParentConnection;
     nub->retain();
 
     nub = fHeadNoteParentConnection;
     nub->retain();


@@ -5059,8 +5161,8 @@ void IOService::ParentChangeAcknowledgePowerChange( void )
 
 void IOService::settleTimerExpired( void )
 {
 
 void IOService::settleTimerExpired( void )
 {

-       fSettleTimeUS = 0;
-       gIOPMWorkQueue->signalWorkAvailable();
+    fSettleTimeUS = 0;
+    gIOPMWorkQueue->signalWorkAvailable();

 }
 
 //*********************************************************************************
 }
 
 //*********************************************************************************


@@ -5072,15 +5174,15 @@ void IOService::settleTimerExpired( void )
 static void
 settle_timer_expired( thread_call_param_t arg0, thread_call_param_t arg1 )
 {
 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);
             OSMemberFunctionCast(IOWorkLoop::Action, me, &IOService::settleTimerExpired),
             me);

-       }
-       me->release();
+    }
+    me->release();

 }
 
 //*********************************************************************************
 }
 
 //*********************************************************************************


@@ -5101,9 +5203,9 @@ void IOService::startSettleTimer( void )
     IOPMPowerStateIndex stateIndex;
     IOPMPowerStateIndex currentOrder, newOrder, i;
     uint32_t            settleTime = 0;
     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);
 
     currentOrder = StateOrder(fCurrentPowerState);
     newOrder     = StateOrder(fHeadNotePowerState);


@@ -5160,16 +5262,16 @@ void IOService::startSettleTimer( void )
 #ifndef __LP64__
 void IOService::ack_timer_ticked ( void )
 {
 #ifndef __LP64__
 void IOService::ack_timer_ticked ( void )
 {

-       assert(false);
+    assert(false);

 }
 #endif /* !__LP64__ */
 
 bool IOService::ackTimerTick( void )
 {
 }
 #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:
     switch (fMachineState) {
         case kIOPM_OurChangeWaitForPowerSettle:
         case kIOPM_ParentChangeWaitForPowerSettle:


@@ -5187,30 +5289,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));
 
                     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
                     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();
                 } else {
                     // still waiting, set timer again
                     start_ack_timer();


@@ -5242,24 +5330,6 @@ bool IOService::ackTimerTick( void )
                                 OBFUSCATE(nextObject->whatObject), fName, fCurrentPowerState, fHeadNotePowerState,
                                 NS_TO_MS(nsec));
 
                                 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--;
                         }
                             // Pretend driver has acked.
                             fHeadNotePendingAcks--;
                         }


@@ -5271,7 +5341,7 @@ bool IOService::ackTimerTick( void )
                 if ( fHeadNotePendingAcks == 0 )
                 {
                     // yes, we can continue
                 if ( fHeadNotePendingAcks == 0 )
                 {
                     // yes, we can continue

-                                       done = true;
+                    done = true;

                 } else {
                     // no, set timer again
                     start_ack_timer();
                 } else {
                     // no, set timer again
                     start_ack_timer();


@@ -5290,19 +5360,19 @@ bool IOService::ackTimerTick( void )
         case kIOPM_SyncTellPriorityClientsPowerDown:
         case kIOPM_SyncNotifyWillChange:
         case kIOPM_TellCapabilityChangeDone:
         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);
             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",
             break;
 
         default:
             PM_LOG1("%s: unexpected ack timer tick (state = %d)\n",

-                               getName(), fMachineState);
+                getName(), fMachineState);

             break;
     }
             break;
     }

-       return done;
+    return done;

 }
 
 //*********************************************************************************
 }
 
 //*********************************************************************************


@@ -5312,14 +5382,20 @@ void IOService::start_watchdog_timer( void )
 {
     AbsoluteTime    deadline;
     boolean_t       pending;
 {
     AbsoluteTime    deadline;
     boolean_t       pending;

+    static int      timeout = -1;

 
 

-    if (!fWatchdogTimer || (kIOSleepWakeWdogOff & gIOKitDebug) || 
-                (getPMRootDomain()->sleepWakeDebugIsWdogEnabled() == false))
+    if (!fWatchdogTimer || (kIOSleepWakeWdogOff & gIOKitDebug))

        return;
 
     if (thread_call_isactive(fWatchdogTimer)) return;
        return;
 
     if (thread_call_isactive(fWatchdogTimer)) return;

+    if (timeout == -1) {
+       PE_parse_boot_argn("swd_timeout", &timeout, sizeof(timeout));
+    }
+    if (timeout < 60) {
+       timeout = WATCHDOG_TIMER_PERIOD;
+    }

 
 

-    clock_interval_to_deadline(WATCHDOG_TIMER_PERIOD, kSecondScale, &deadline);
+    clock_interval_to_deadline(timeout, kSecondScale, &deadline);

 
     retain();
     pending = thread_call_enter_delayed(fWatchdogTimer, deadline);
 
     retain();
     pending = thread_call_enter_delayed(fWatchdogTimer, deadline);


@@ -5336,8 +5412,7 @@ bool IOService::stop_watchdog_timer( void )
 {
     boolean_t   pending;
 
 {
     boolean_t   pending;
 

-    if (!fWatchdogTimer || (kIOSleepWakeWdogOff & gIOKitDebug) ||
-                (getPMRootDomain()->sleepWakeDebugIsWdogEnabled() == false))
+    if (!fWatchdogTimer || (kIOSleepWakeWdogOff & gIOKitDebug))

        return false;
 
     pending = thread_call_cancel(fWatchdogTimer);
        return false;
 
     pending = thread_call_cancel(fWatchdogTimer);


@@ -5366,25 +5441,33 @@ void IOService::reset_watchdog_timer( void )
 void
 IOService::watchdog_timer_expired( thread_call_param_t arg0, thread_call_param_t arg1 )
 {
 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;
 
 
     gIOPMWatchDogThread = current_thread();
     getPMRootDomain()->sleepWakeDebugTrig(true);
     gIOPMWatchDogThread = 0;

-    me->release();
+    thread_call_free(me->fWatchdogTimer);
+    me->fWatchdogTimer = 0;

 
 

-       return ;
+    return ;

 }
 
 
 }
 
 

+IOWorkLoop * IOService::getIOPMWorkloop( void )
+{
+    return gIOPMWorkLoop;
+}
+
+
+

 //*********************************************************************************
 // [private] start_ack_timer
 //*********************************************************************************
 
 void IOService::start_ack_timer( void )
 {
 //*********************************************************************************
 // [private] start_ack_timer
 //*********************************************************************************
 
 void IOService::start_ack_timer( void )
 {

-       start_ack_timer( ACK_TIMER_PERIOD, kNanosecondScale );
+    start_ack_timer( ACK_TIMER_PERIOD, kNanosecondScale );

 }
 
 void IOService::start_ack_timer ( UInt32 interval, UInt32 scale )
 }
 
 void IOService::start_ack_timer ( UInt32 interval, UInt32 scale )


@@ -5455,13 +5538,110 @@ IOService::actionAckTimerExpired(
 void
 IOService::ack_timer_expired( thread_call_param_t arg0, thread_call_param_t arg1 )
 {
 void
 IOService::ack_timer_expired( thread_call_param_t arg0, thread_call_param_t arg1 )
 {

-       IOService * me = (IOService *) arg0;
+    IOService * me = (IOService *) arg0;
+
+    if (gIOPMWorkLoop)
+    {
+        gIOPMWorkLoop->runAction(&actionAckTimerExpired, me);
+    }
+    me->release();
+}
+
+//*********************************************************************************
+// [private] start_spindump_timer
+//*********************************************************************************
+
+void IOService::start_spindump_timer( const char * delay_type )
+{
+    AbsoluteTime    deadline;
+    boolean_t       pending;
+
+    if (!fSpinDumpTimer || !(kIOKextSpinDump & gIOKitDebug))
+        return;
+
+    if (gIOSpinDumpKextName[0] == '\0' &&
+        !(PE_parse_boot_argn("swd_kext_name", &gIOSpinDumpKextName,
+        sizeof(gIOSpinDumpKextName))))
+    {
+        return;
+    }

 
 

-       if (gIOPMWorkLoop)
-       {
-               gIOPMWorkLoop->runAction(&actionAckTimerExpired, me);
-       }
-       me->release();
+    if (strncmp(gIOSpinDumpKextName, fName, sizeof(gIOSpinDumpKextName)) != 0)
+        return;
+
+    if (gIOSpinDumpDelayType[0] == '\0' &&
+        !(PE_parse_boot_argn("swd_delay_type", &gIOSpinDumpDelayType,
+        sizeof(gIOSpinDumpDelayType))))
+    {
+        strncpy(gIOSpinDumpDelayType, "SetState", sizeof(gIOSpinDumpDelayType));
+    }
+
+    if (strncmp(delay_type, gIOSpinDumpDelayType, sizeof(gIOSpinDumpDelayType)) != 0)
+        return;
+
+    if (gIOSpinDumpDelayDuration == 0 &&
+        !(PE_parse_boot_argn("swd_delay_duration", &gIOSpinDumpDelayDuration,
+        sizeof(gIOSpinDumpDelayDuration))))
+    {
+        gIOSpinDumpDelayDuration = 300;
+    }
+
+    clock_interval_to_deadline(gIOSpinDumpDelayDuration, kMillisecondScale, &deadline);
+
+    retain();
+    pending = thread_call_enter_delayed(fSpinDumpTimer, deadline);
+    if (pending) release();
+}
+
+//*********************************************************************************
+// [private] stop_spindump_timer
+//*********************************************************************************
+
+void IOService::stop_spindump_timer( void )
+{
+    boolean_t   pending;
+
+    if (!fSpinDumpTimer || !(kIOKextSpinDump & gIOKitDebug))
+        return;
+
+    pending = thread_call_cancel(fSpinDumpTimer);
+    if (pending) release();
+}
+
+
+//*********************************************************************************
+// [static] actionSpinDumpTimerExpired
+//
+// Inside PM work loop's gate.
+//*********************************************************************************
+
+IOReturn
+IOService::actionSpinDumpTimerExpired(
+    OSObject * target,
+    void * arg0, void * arg1,
+    void * arg2, void * arg3 )
+{
+    getPMRootDomain()->takeStackshot(false, false, true);
+
+    return kIOReturnSuccess;
+}
+
+//*********************************************************************************
+// spindump_timer_expired
+//
+// Thread call function. Holds a retain while the callout is in flight.
+//*********************************************************************************
+
+void
+IOService::spindump_timer_expired( thread_call_param_t arg0, thread_call_param_t arg1 )
+{
+    IOService * me = (IOService *) arg0;
+
+    if (gIOPMWorkLoop)
+    {
+        gIOPMWorkLoop->runAction(&actionSpinDumpTimerExpired, me);
+    }
+    me->release();

 }
 
 // MARK: -
 }
 
 // MARK: -


@@ -5473,7 +5653,7 @@ IOService::ack_timer_expired( thread_call_param_t arg0, thread_call_param_t arg1
 
 void IOService::tellSystemCapabilityChange( uint32_t nextMS )
 {
 
 void IOService::tellSystemCapabilityChange( uint32_t nextMS )
 {

-       MS_PUSH( nextMS );
+    MS_PUSH( nextMS );

     fMachineState       = kIOPM_TellCapabilityChangeDone;
     fOutOfBandMessage   = kIOMessageSystemCapabilityChange;
 
     fMachineState       = kIOPM_TellCapabilityChangeDone;
     fOutOfBandMessage   = kIOMessageSystemCapabilityChange;
 


@@ -5564,7 +5744,7 @@ static void logAppTimeouts( OSObject * object, void * arg )
     IOPMInterestContext *   context = (IOPMInterestContext *) arg;
     OSObject *              flag;
     unsigned int            clientIndex;
     IOPMInterestContext *   context = (IOPMInterestContext *) arg;
     OSObject *              flag;
     unsigned int            clientIndex;

-    int                     pid = -1;
+    int                     pid = 0;

     char                    name[128];
 
     if (OSDynamicCast(_IOServiceInterestNotifier, object))
     char                    name[128];
 
     if (OSDynamicCast(_IOServiceInterestNotifier, object))


@@ -5579,21 +5759,21 @@ static void logAppTimeouts( OSObject * object, void * arg )
             (flag = context->responseArray->getObject(clientIndex)) &&
             (flag != kOSBooleanTrue))
         {
             (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();
             }
             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,
             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);

 
         }
     }
 
         }
     }


@@ -5665,8 +5845,9 @@ bool IOService::tellClientsWithResponse( int messageType )
 {
     IOPMInterestContext     context;
     bool                    isRootDomain = IS_ROOT_DOMAIN;
 {
     IOPMInterestContext     context;
     bool                    isRootDomain = IS_ROOT_DOMAIN;

+    uint32_t                maxTimeOut = kMaxTimeRequested;

 
 

-       PM_ASSERT_IN_GATE();
+    PM_ASSERT_IN_GATE();

     assert( fResponseArray == NULL );
     assert( fNotifyClientArray == NULL );
 
     assert( fResponseArray == NULL );
     assert( fNotifyClientArray == NULL );
 


@@ -5683,7 +5864,7 @@ bool IOService::tellClientsWithResponse( int messageType )
 
     fResponseArray->setCapacityIncrement(8);
     if (++fSerialNumber == 0)
 
     fResponseArray->setCapacityIncrement(8);
     if (++fSerialNumber == 0)

-        fSerialNumber++;        
+        fSerialNumber++;

 
     context.responseArray    = fResponseArray;
     context.notifyClients    = 0;
 
     context.responseArray    = fResponseArray;
     context.notifyClients    = 0;


@@ -5706,7 +5887,7 @@ bool IOService::tellClientsWithResponse( int messageType )
     switch ( fOutOfBandParameter ) {
         case kNotifyApps:
             applyToInterested( gIOAppPowerStateInterest,
     switch ( fOutOfBandParameter ) {
         case kNotifyApps:
             applyToInterested( gIOAppPowerStateInterest,

-                               pmTellAppWithResponse, (void *) &context );
+                pmTellAppWithResponse, (void *) &context );

 
             if (isRootDomain &&
                 (fMachineState != kIOPM_OurChangeTellClientsPowerDown) &&
 
             if (isRootDomain &&
                 (fMachineState != kIOPM_OurChangeTellClientsPowerDown) &&


@@ -5718,14 +5899,21 @@ bool IOService::tellClientsWithResponse( int messageType )
                 context.notifyType  = kNotifyCapabilityChangeApps;
                 context.messageType = kIOMessageSystemCapabilityChange;
                 applyToInterested( gIOAppPowerStateInterest,
                 context.notifyType  = kNotifyCapabilityChangeApps;
                 context.messageType = kIOMessageSystemCapabilityChange;
                 applyToInterested( gIOAppPowerStateInterest,

-                    pmTellCapabilityAppWithResponse, (void *) &context ); 
+                    pmTellCapabilityAppWithResponse, (void *) &context );

                 context.notifyType  = fOutOfBandParameter;
                 context.messageType = messageType;
             }
                 context.notifyType  = fOutOfBandParameter;
                 context.messageType = messageType;
             }

-            context.maxTimeRequested = k30Seconds;
-
+           if(context.messageType == kIOMessageCanSystemSleep)
+           {
+               maxTimeOut = kCanSleepMaxTimeReq;
+               if(gCanSleepTimeout)
+               {
+                   maxTimeOut = (gCanSleepTimeout*us_per_s);
+               }
+           }
+           context.maxTimeRequested = maxTimeOut;

             applyToInterested( gIOGeneralInterest,
             applyToInterested( gIOGeneralInterest,

-                               pmTellClientWithResponse, (void *) &context );
+                pmTellClientWithResponse, (void *) &context );

 
             fNotifyClientArray = context.notifyClients;
             break;
 
             fNotifyClientArray = context.notifyClients;
             break;


@@ -5733,7 +5921,7 @@ bool IOService::tellClientsWithResponse( int messageType )
         case kNotifyPriority:
             context.enableTracing = isRootDomain;
             applyToInterested( gIOPriorityPowerStateInterest,
         case kNotifyPriority:
             context.enableTracing = isRootDomain;
             applyToInterested( gIOPriorityPowerStateInterest,

-                               pmTellClientWithResponse, (void *) &context );
+                pmTellClientWithResponse, (void *) &context );

 
             if (isRootDomain)
             {
 
             if (isRootDomain)
             {


@@ -5747,14 +5935,23 @@ bool IOService::tellClientsWithResponse( int messageType )
 
         case kNotifyCapabilityChangeApps:
             applyToInterested( gIOAppPowerStateInterest,
 
         case kNotifyCapabilityChangeApps:
             applyToInterested( gIOAppPowerStateInterest,

-                               pmTellCapabilityAppWithResponse, (void *) &context );
+                pmTellCapabilityAppWithResponse, (void *) &context );

             fNotifyClientArray = context.notifyClients;
             fNotifyClientArray = context.notifyClients;

-            context.maxTimeRequested = k30Seconds;
+           if(context.messageType == kIOMessageCanSystemSleep)
+           {
+               maxTimeOut = kCanSleepMaxTimeReq;
+               if(gCanSleepTimeout)
+               {
+                   maxTimeOut = (gCanSleepTimeout*us_per_s);
+               }
+           }
+           context.maxTimeRequested = maxTimeOut;

             break;
 
         case kNotifyCapabilityChangePriority:
             break;
 
         case kNotifyCapabilityChangePriority:

+            context.enableTracing = isRootDomain;

             applyToInterested( gIOPriorityPowerStateInterest,
             applyToInterested( gIOPriorityPowerStateInterest,

-                               pmTellCapabilityClientWithResponse, (void *) &context );
+                pmTellCapabilityClientWithResponse, (void *) &context );

             break;
     }
 
             break;
     }
 


@@ -5762,9 +5959,10 @@ bool IOService::tellClientsWithResponse( int messageType )
     if ( !checkForDone() )
     {
         OUR_PMLog(kPMLogStartAckTimer, context.maxTimeRequested, 0);
     if ( !checkForDone() )
     {
         OUR_PMLog(kPMLogStartAckTimer, context.maxTimeRequested, 0);

-        if (context.enableTracing)
-            getPMRootDomain()->traceDetail( context.maxTimeRequested / 1000 );
-               start_ack_timer( context.maxTimeRequested / 1000, kMillisecondScale );
+        if (context.enableTracing) {
+            getPMRootDomain()->traceDetail(context.messageType, 0, context.maxTimeRequested / 1000);
+        }
+        start_ack_timer( context.maxTimeRequested / 1000, kMillisecondScale );

         return false;
     }
 
         return false;
     }
 


@@ -5799,6 +5997,7 @@ void IOService::pmTellAppWithResponse( OSObject * object, void * arg )
     OSNumber                *clientID = NULL;
     proc_t                  proc = NULL;
     boolean_t               proc_suspended = FALSE;
     OSNumber                *clientID = NULL;
     proc_t                  proc = NULL;
     boolean_t               proc_suspended = FALSE;

+    OSObject *              waitForReply = kOSBooleanTrue;

 #if LOG_APP_RESPONSE_TIMES
     AbsoluteTime            now;
 #endif
 #if LOG_APP_RESPONSE_TIMES
     AbsoluteTime            now;
 #endif


@@ -5827,9 +6026,9 @@ void IOService::pmTellAppWithResponse( OSObject * object, void * arg )
             }
         }
     }
             }
         }
     }

-    
+

     if (context->messageFilter &&
     if (context->messageFilter &&

-        !context->messageFilter(context->us, object, context, 0, 0))
+        !context->messageFilter(context->us, object, context, 0, &waitForReply))

     {
         if (kIOLogDebugPower & gIOKitDebug)
         {
     {
         if (kIOLogDebugPower & gIOKitDebug)
         {


@@ -5853,18 +6052,29 @@ void IOService::pmTellAppWithResponse( OSObject * object, void * arg )
         logClientIDForNotification(object, context, "MESG App");
     }
 
         logClientIDForNotification(object, context, "MESG App");
     }
 

-#if LOG_APP_RESPONSE_TIMES
-    OSNumber * num;
-    clock_get_uptime(&now);
-    num = OSNumber::withNumber(AbsoluteTime_to_scalar(&now), sizeof(uint64_t) * 8);
-    if (num)
+    if (waitForReply == kOSBooleanTrue) 

     {
     {

-        context->responseArray->setObject(msgIndex, num);
-        num->release();
+
+        OSNumber * num;
+        clock_get_uptime(&now);
+        num = OSNumber::withNumber(AbsoluteTime_to_scalar(&now), sizeof(uint64_t) * 8);
+        if (num)
+        {
+            context->responseArray->setObject(msgIndex, num);
+            num->release();
+        }
+        else {
+            context->responseArray->setObject(msgIndex, kOSBooleanFalse);
+        }
+    }
+    else 
+    {
+        context->responseArray->setObject(msgIndex, kOSBooleanTrue);
+        if (kIOLogDebugPower & gIOKitDebug)
+        {
+            logClientIDForNotification(object, context, "App response ignored");
+        }

     }
     }

-    else
-#endif
-    context->responseArray->setObject(msgIndex, kOSBooleanFalse);

 
     if (context->notifyClients)
         context->notifyClients->setObject(msgIndex, object);
 
     if (context->notifyClients)
         context->notifyClients->setObject(msgIndex, object);


@@ -5899,7 +6109,7 @@ void IOService::pmTellClientWithResponse( OSObject * object, void * arg )
                 context->us->getName(),
                 getIOMessageString(context->messageType),
                 OBFUSCATE(object), OBFUSCATE(n->handler));
                 context->us->getName(),
                 getIOMessageString(context->messageType),
                 OBFUSCATE(object), OBFUSCATE(n->handler));

-               }        
+        }

         return;
     }
 
         return;
     }
 


@@ -5910,13 +6120,13 @@ void IOService::pmTellClientWithResponse( OSObject * object, void * arg )
 
     IOServicePM * pwrMgt = context->us->pwrMgt;
     if (gIOKitDebug & kIOLogPower) {
 
     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) {
         else if (notifier) {

-                       OUR_PMLog(kPMLogClientNotify, (uintptr_t) notifier->handler, 0);
+            OUR_PMLog(kPMLogClientNotify, (uintptr_t) notifier->handler, 0);

         }
     }
     if ((kIOLogDebugPower & gIOKitDebug) && notifier)
         }
     }
     if ((kIOLogDebugPower & gIOKitDebug) && notifier)


@@ -5934,10 +6144,7 @@ void IOService::pmTellClientWithResponse( OSObject * object, void * arg )
 
     if (context->enableTracing && (notifier != 0))
     {
 
     if (context->enableTracing && (notifier != 0))
     {

-        uint32_t detail = ((msgIndex & 0xff) << 24) |
-                          ((msgType & 0xfff) << 12) |
-                          (((uintptr_t) notifier->handler) & 0xfff);
-        getPMRootDomain()->traceDetail( detail );
+        getPMRootDomain()->traceDetail(msgType, msgIndex, (uintptr_t) notifier->handler);

     }
 
     retCode = context->us->messageClient(msgType, object, (void *) &notify, sizeof(notify));
     }
 
     retCode = context->us->messageClient(msgType, object, (void *) &notify, sizeof(notify));


@@ -5945,7 +6152,7 @@ void IOService::pmTellClientWithResponse( OSObject * object, void * arg )
     if (kIOReturnSuccess == retCode)
     {
         if (0 == notify.returnValue) {
     if (kIOReturnSuccess == retCode)
     {
         if (0 == notify.returnValue) {

-                       OUR_PMLog(kPMLogClientAcknowledge, msgRef, (uintptr_t) object);
+            OUR_PMLog(kPMLogClientAcknowledge, msgRef, (uintptr_t) object);

         } else {
             replied = kOSBooleanFalse;
             if ( notify.returnValue > context->maxTimeRequested )
         } else {
             replied = kOSBooleanFalse;
             if ( notify.returnValue > context->maxTimeRequested )


@@ -5966,7 +6173,7 @@ void IOService::pmTellClientWithResponse( OSObject * object, void * arg )
     } else {
         // not a client of ours
         // so we won't be waiting for response
     } 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);
     }
 
     context->responseArray->setObject(msgIndex, replied);


@@ -6016,7 +6223,7 @@ void IOService::pmTellCapabilityAppWithResponse( OSObject * object, void * arg )
         if (clientID) {
             clientIDString = IOCopyLogNameForPID(clientID->unsigned32BitValue());
         }
         if (clientID) {
             clientIDString = IOCopyLogNameForPID(clientID->unsigned32BitValue());
         }

-    
+

         PM_LOG("%s MESG App(%u) %s, wait %u, %s\n",
             context->us->getName(),
             msgIndex, getIOMessageString(msgType),
         PM_LOG("%s MESG App(%u) %s, wait %u, %s\n",
             context->us->getName(),
             msgIndex, getIOMessageString(msgType),


@@ -6038,7 +6245,7 @@ void IOService::pmTellCapabilityAppWithResponse( OSObject * object, void * arg )
     }
     else
     {
     }
     else
     {

-#if LOG_APP_RESPONSE_TIMES
+

         OSNumber * num;
         clock_get_uptime(&now);
         num = OSNumber::withNumber(AbsoluteTime_to_scalar(&now), sizeof(uint64_t) * 8);
         OSNumber * num;
         clock_get_uptime(&now);
         num = OSNumber::withNumber(AbsoluteTime_to_scalar(&now), sizeof(uint64_t) * 8);


@@ -6047,9 +6254,9 @@ void IOService::pmTellCapabilityAppWithResponse( OSObject * object, void * arg )
             context->responseArray->setObject(msgIndex, num);
             num->release();
         }
             context->responseArray->setObject(msgIndex, num);
             num->release();
         }

-        else
-#endif
-        context->responseArray->setObject(msgIndex, kOSBooleanFalse);
+        else {
+            context->responseArray->setObject(msgIndex, kOSBooleanFalse);
+        }

 
         if (context->notifyClients)
             context->notifyClients->setObject(msgIndex, object);
 
         if (context->notifyClients)
             context->notifyClients->setObject(msgIndex, object);


@@ -6084,7 +6291,7 @@ void IOService::pmTellCapabilityClientWithResponse(
                 context->us->getName(),
                 getIOMessageString(context->messageType),
                 OBFUSCATE(object), OBFUSCATE(n->handler));
                 context->us->getName(),
                 getIOMessageString(context->messageType),
                 OBFUSCATE(object), OBFUSCATE(n->handler));

-               }        
+        }

         return;
     }
 
         return;
     }
 


@@ -6095,14 +6302,14 @@ void IOService::pmTellCapabilityClientWithResponse(
 
     IOServicePM * pwrMgt = context->us->pwrMgt;
     if (gIOKitDebug & kIOLogPower) {
 
     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) {
         else if (notifier) {

-                       OUR_PMLog(kPMLogClientNotify, (uintptr_t) notifier->handler, 0);
-               }
+            OUR_PMLog(kPMLogClientNotify, (uintptr_t) notifier->handler, 0);
+        }

     }
     if ((kIOLogDebugPower & gIOKitDebug) && notifier)
     {
     }
     if ((kIOLogDebugPower & gIOKitDebug) && notifier)
     {


@@ -6117,10 +6324,7 @@ void IOService::pmTellCapabilityClientWithResponse(
 
     if (context->enableTracing && (notifier != 0))
     {
 
     if (context->enableTracing && (notifier != 0))
     {

-        uint32_t detail = ((msgIndex & 0xff) << 24) |
-                          ((msgType & 0xfff) << 12) |
-                          (((uintptr_t) notifier->handler) & 0xfff);
-        getPMRootDomain()->traceDetail( detail );
+        getPMRootDomain()->traceDetail(msgType, msgIndex, (uintptr_t) notifier->handler);

     }
 
     retCode = context->us->messageClient(
     }
 
     retCode = context->us->messageClient(


@@ -6131,7 +6335,7 @@ void IOService::pmTellCapabilityClientWithResponse(
         if ( 0 == msgArg.maxWaitForReply )
         {
             // client doesn't want time to respond
         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
         {
         }
         else
         {


@@ -6156,7 +6360,7 @@ void IOService::pmTellCapabilityClientWithResponse(
     {
         // not a client of ours
         // so we won't be waiting for response
     {
         // 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);
     }
 
     context->responseArray->setObject(msgIndex, replied);


@@ -6236,7 +6440,7 @@ void IOService::tellClients( int messageType )
 
 static void tellKernelClientApplier( OSObject * object, void * arg )
 {
 
 static void tellKernelClientApplier( OSObject * object, void * arg )
 {

-    IOPowerStateChangeNotification     notify;
+    IOPowerStateChangeNotification  notify;

     IOPMInterestContext *           context = (IOPMInterestContext *) arg;
 
     if (context->messageFilter &&
     IOPMInterestContext *           context = (IOPMInterestContext *) arg;
 
     if (context->messageFilter &&


@@ -6250,14 +6454,14 @@ static void tellKernelClientApplier( OSObject * object, void * arg )
                 context->us->getName(),
                 IOService::getIOMessageString(context->messageType),
                 OBFUSCATE(object), OBFUSCATE(n->handler));
                 context->us->getName(),
                 IOService::getIOMessageString(context->messageType),
                 OBFUSCATE(object), OBFUSCATE(n->handler));

-               }
+        }

         return;
     }
 
     notify.powerRef     = (void *) 0;
         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));
 
 
     context->us->messageClient(context->messageType, object, &notify, sizeof(notify));
 


@@ -6273,7 +6477,7 @@ static void tellKernelClientApplier( OSObject * object, void * arg )
 }
 
 static OSNumber * copyClientIDForNotification(
 }
 
 static OSNumber * copyClientIDForNotification(

-    OSObject *object, 
+    OSObject *object,

     IOPMInterestContext *context)
 {
     OSNumber *clientID = NULL;
     IOPMInterestContext *context)
 {
     OSNumber *clientID = NULL;


@@ -6283,27 +6487,27 @@ static OSNumber * copyClientIDForNotification(
 
 static void logClientIDForNotification(
     OSObject *object,
 
 static void logClientIDForNotification(
     OSObject *object,

-    IOPMInterestContext *context, 
+    IOPMInterestContext *context,

     const char *logString)
 {
     OSString *logClientID = NULL;
     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());
     {
         if (clientID)
             logClientID = IOCopyLogNameForPID(clientID->unsigned32BitValue());

-    
+

         PM_LOG("%s %s %s, %s\n",
             context->us->getName(), logString,
             IOService::getIOMessageString(context->messageType),
             logClientID ? logClientID->getCStringNoCopy() : "");
 
         PM_LOG("%s %s %s, %s\n",
             context->us->getName(), logString,
             IOService::getIOMessageString(context->messageType),
             logClientID ? logClientID->getCStringNoCopy() : "");
 

-        if (logClientID) 
+        if (logClientID)

             logClientID->release();
     }
             logClientID->release();
     }

-    
-    if (clientID) 
+
+    if (clientID)

         clientID->release();
 
     return;
         clientID->release();
 
     return;


@@ -6315,7 +6519,7 @@ static void tellAppClientApplier( OSObject * object, void * arg )
     OSNumber            * clientID = NULL;
     proc_t                proc = NULL;
     boolean_t             proc_suspended = FALSE;
     OSNumber            * clientID = NULL;
     proc_t                proc = NULL;
     boolean_t             proc_suspended = FALSE;

-    
+

     if (context->us == IOService::getPMRootDomain())
     {
         if ((clientID = copyClientIDForNotification(object, context)))
     if (context->us == IOService::getPMRootDomain())
     {
         if ((clientID = copyClientIDForNotification(object, context)))


@@ -6362,13 +6566,13 @@ static void tellAppClientApplier( OSObject * object, void * arg )
 
 bool IOService::checkForDone( void )
 {
 
 bool IOService::checkForDone( void )
 {

-    int                        i = 0;
-    OSObject * theFlag;
+    int         i = 0;
+    OSObject *  theFlag;

 
     if (fResponseArray == NULL) {
         return true;
     }
 
     if (fResponseArray == NULL) {
         return true;
     }

-    
+

     for (i = 0; ; i++) {
         theFlag = fResponseArray->getObject(i);
 
     for (i = 0; ; i++) {
         theFlag = fResponseArray->getObject(i);
 


@@ -6389,9 +6593,10 @@ bool IOService::checkForDone( void )
 
 bool IOService::responseValid( uint32_t refcon, int pid )
 {
 
 bool IOService::responseValid( uint32_t refcon, int pid )
 {

-    UInt16                     serialComponent;
-    UInt16                     ordinalComponent;
-    OSObject *         theFlag;
+    UInt16          serialComponent;
+    UInt16          ordinalComponent;
+    OSObject *      theFlag;
+    OSObject        *object = 0;

 
     serialComponent  = (refcon >> 16) & 0xFFFF;
     ordinalComponent = (refcon & 0xFFFF);
 
     serialComponent  = (refcon >> 16) & 0xFFFF;
     ordinalComponent = (refcon & 0xFFFF);


@@ -6400,25 +6605,28 @@ bool IOService::responseValid( uint32_t refcon, int pid )
     {
         return false;
     }
     {
         return false;
     }

-    
+

     if ( fResponseArray == NULL )
     {
         return false;
     }
     if ( fResponseArray == NULL )
     {
         return false;
     }

-    
+

     theFlag = fResponseArray->getObject(ordinalComponent);
     theFlag = fResponseArray->getObject(ordinalComponent);

-    
+

     if ( theFlag == 0 )
     {
         return false;
     }
 
     if ( theFlag == 0 )
     {
         return false;
     }
 

+    if (fNotifyClientArray) 
+        object = fNotifyClientArray->getObject(ordinalComponent);
+

     OSNumber * num;
     if ((num = OSDynamicCast(OSNumber, theFlag)))
     {
     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];
 
         uint64_t        nsec;
         char            name[128];
 


@@ -6428,18 +6636,6 @@ bool IOService::responseValid( uint32_t refcon, int pid )
         AbsoluteTime_to_scalar(&start) = num->unsigned64BitValue();
         SUB_ABSOLUTETIME(&now, &start);
         absolutetime_to_nanoseconds(now, &nsec);
         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)
         {
 
         if (kIOLogDebugPower & gIOKitDebug)
         {


@@ -6451,27 +6647,39 @@ bool IOService::responseValid( uint32_t refcon, int pid )
         // > 100 ms
         if (nsec > LOG_APP_RESPONSE_TIMES)
         {
         // > 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);
                 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;
     }
         theFlag = kOSBooleanFalse;
     }

+    else if (object) {
+        getPMRootDomain()->pmStatsRecordApplicationResponse(
+            gIOPMStatsApplicationResponsePrompt, 
+            0, 0, 0, pid, object);
+
+    }

 
 

-    if ( kOSBooleanFalse == theFlag ) 
+    if ( kOSBooleanFalse == theFlag )

     {
         fResponseArray->replaceObject(ordinalComponent, kOSBooleanTrue);
     }
     {
         fResponseArray->replaceObject(ordinalComponent, kOSBooleanTrue);
     }

-    
+

     return true;
 }
 
     return true;
 }
 


@@ -6485,7 +6693,7 @@ bool IOService::responseValid( uint32_t refcon, int pid )
 
 IOReturn IOService::allowPowerChange( unsigned long refcon )
 {
 
 IOReturn IOService::allowPowerChange( unsigned long refcon )
 {

-       IOPMRequest * request;
+    IOPMRequest * request;

 
     if ( !initialized )
     {
 
     if ( !initialized )
     {


@@ -6493,23 +6701,23 @@ IOReturn IOService::allowPowerChange( unsigned long refcon )
         return kIOReturnSuccess;
     }
 
         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 )
 {
 }
 
 #ifndef __LP64__
 IOReturn IOService::serializedAllowPowerChange2( unsigned long refcon )
 {

-       // [deprecated] public
-       return kIOReturnUnsupported;
+    // [deprecated] public
+    return kIOReturnUnsupported;

 }
 #endif /* !__LP64__ */
 
 }
 #endif /* !__LP64__ */
 


@@ -6523,7 +6731,7 @@ IOReturn IOService::serializedAllowPowerChange2( unsigned long refcon )
 
 IOReturn IOService::cancelPowerChange( unsigned long refcon )
 {
 
 IOReturn IOService::cancelPowerChange( unsigned long refcon )
 {

-       IOPMRequest *   request;
+    IOPMRequest *   request;

     char            name[128];
     pid_t           pid = proc_selfpid();
 
     char            name[128];
     pid_t           pid = proc_selfpid();
 


@@ -6537,8 +6745,8 @@ IOReturn IOService::cancelPowerChange( unsigned long refcon )
     proc_name(pid, name, sizeof(name));
     PM_ERROR("PM notification cancel (pid %d, %s)\n", pid, name);
 
     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;
     }
     {
         return kIOReturnNoMemory;
     }


@@ -6554,8 +6762,8 @@ IOReturn IOService::cancelPowerChange( unsigned long refcon )
 #ifndef __LP64__
 IOReturn IOService::serializedCancelPowerChange2( unsigned long refcon )
 {
 #ifndef __LP64__
 IOReturn IOService::serializedCancelPowerChange2( unsigned long refcon )
 {

-       // [deprecated] public
-       return kIOReturnUnsupported;
+    // [deprecated] public
+    return kIOReturnUnsupported;

 }
 
 //*********************************************************************************
 }
 
 //*********************************************************************************


@@ -6592,17 +6800,17 @@ IOReturn IOService::configurePowerStatesReport( IOReportConfigureAction action,
     unsigned long i;
     uint64_t                ts;
 
     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();
 
         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:
     {
         case kIOReportEnable:

-            if (fReportBuf)  
+            if (fReportBuf)

             {
                fReportClientCnt++;
                break;
             {
                fReportClientCnt++;
                break;


@@ -6628,7 +6836,7 @@ IOReturn IOService::configurePowerStatesReport( IOReportConfigureAction action,
                 if (fPowerStates[i].capabilityFlags & kIOPMLowPower)
                    bits |= kPMReportLowPower;
 
                 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();
                             ((StateOrder(fMaxPowerState) & 0xf) << 4) | (StateOrder(i) & 0xf));
             }
             ts = mach_absolute_time();


@@ -6673,16 +6881,16 @@ IOReturn IOService::updatePowerStatesReport( IOReportConfigureAction action, voi
     IOBufferMemoryDescriptor *dest = OSDynamicCast(IOBufferMemoryDescriptor, (OSObject *)destination);
 
 
     IOBufferMemoryDescriptor *dest = OSDynamicCast(IOBufferMemoryDescriptor, (OSObject *)destination);
 
 

-    if (!pwrMgt) 
+    if (!pwrMgt)

         return kIOReturnUnsupported;
         return kIOReturnUnsupported;

-    if (!fNumberOfPowerStates) 
+    if (!fNumberOfPowerStates)

         return kIOReturnSuccess;
 
     if ( !result || !dest ) return kIOReturnBadArgument;
     PM_LOCK();
 
     switch (action) {
         return kIOReturnSuccess;
 
     if ( !result || !dest ) return kIOReturnBadArgument;
     PM_LOCK();
 
     switch (action) {

-        case kIOReportCopyChannelData: 
+        case kIOReportCopyChannelData:

             if ( !fReportBuf )  {
                 rc = kIOReturnNotOpen;
                 break;
             if ( !fReportBuf )  {
                 rc = kIOReturnNotOpen;
                 break;


@@ -6696,7 +6904,8 @@ IOReturn IOService::updatePowerStatesReport( IOReportConfigureAction action, voi
             }
 
             STATEREPORT_UPDATERES(fReportBuf, kIOReportCopyChannelData, result);
             }
 
             STATEREPORT_UPDATERES(fReportBuf, kIOReportCopyChannelData, result);

-            dest->appendBytes(data2cpy, size2cpy); 
+            dest->appendBytes(data2cpy, size2cpy);
+            break;

 
         default:
             break;
 
         default:
             break;


@@ -6712,20 +6921,20 @@ IOReturn IOService::updatePowerStatesReport( IOReportConfigureAction action, voi
 //*********************************************************************************
 //  configureSimplePowerReport
 //
 //*********************************************************************************
 //  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;
 
 //*********************************************************************************
 IOReturn IOService::configureSimplePowerReport(IOReportConfigureAction action, void *result )
 {
 
     IOReturn rc = kIOReturnSuccess;
 

-    if ( !pwrMgt ) 
+    if ( !pwrMgt )

         return kIOReturnUnsupported;
 
         return kIOReturnUnsupported;
 

-    if ( !fNumberOfPowerStates ) 
+    if ( !fNumberOfPowerStates )

         return rc;
 
         return rc;
 

-    switch (action) 
+    switch (action)

     {
         case kIOReportEnable:
         case kIOReportDisable:
     {
         case kIOReportEnable:
         case kIOReportDisable:


@@ -6743,28 +6952,28 @@ IOReturn IOService::configureSimplePowerReport(IOReportConfigureAction action, v
 //*********************************************************************************
 //  updateSimplePowerReport
 //
 //*********************************************************************************
 //  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;
 //*********************************************************************************
 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;
 
 
     IOBufferMemoryDescriptor *dest = OSDynamicCast(IOBufferMemoryDescriptor, (OSObject *)destination);
     IOReturn rc = kIOReturnSuccess;
     unsigned bits = 0;
 
 

-    if ( !pwrMgt ) 
+    if ( !pwrMgt )

         return kIOReturnUnsupported;
     if ( !result || !dest ) return kIOReturnBadArgument;
 
         return kIOReturnUnsupported;
     if ( !result || !dest ) return kIOReturnBadArgument;
 

-    if ( !fNumberOfPowerStates ) 
+    if ( !fNumberOfPowerStates )

         return rc;
     PM_LOCK();
 
     switch (action) {
         return rc;
     PM_LOCK();
 
     switch (action) {

-        case kIOReportCopyChannelData: 
+        case kIOReportCopyChannelData:

 
             SIMPLEREPORT_INIT(buf, sizeof(buf),  getRegistryEntryID(), kPMCurrStateChID, kIOReportCategoryPower);
 
 
             SIMPLEREPORT_INIT(buf, sizeof(buf),  getRegistryEntryID(), kPMCurrStateChID, kIOReportCategoryPower);
 


@@ -6776,7 +6985,7 @@ IOReturn IOService::updateSimplePowerReport( IOReportConfigureAction action, voi
                bits |= kPMReportLowPower;
 
 
                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);
                                                                (StateOrder(fCurrentPowerState) & 0xf));
 
             SIMPLEREPORT_UPDATEPREP(buf, data2cpy, size2cpy);


@@ -6786,7 +6995,8 @@ IOReturn IOService::updateSimplePowerReport( IOReportConfigureAction action, voi
             }
 
             SIMPLEREPORT_UPDATERES(kIOReportCopyChannelData, result);
             }
 
             SIMPLEREPORT_UPDATERES(kIOReportCopyChannelData, result);

-            dest->appendBytes(data2cpy, size2cpy); 
+            dest->appendBytes(data2cpy, size2cpy);
+            break;

 
         default:
             break;
 
         default:
             break;


@@ -6811,7 +7021,7 @@ IOReturn IOService::updateSimplePowerReport( IOReportConfigureAction action, voi
 //*********************************************************************************
 
 IOReturn IOService::setPowerState(
 //*********************************************************************************
 
 IOReturn IOService::setPowerState(

-       unsigned long powerStateOrdinal, IOService * whatDevice )
+    unsigned long powerStateOrdinal, IOService * whatDevice )

 {
     return IOPMNoErr;
 }
 {
     return IOPMNoErr;
 }


@@ -6944,9 +7154,9 @@ IOReturn IOService::newTemperature( long currentTemp, IOService * whichZone )
 
 void IOService::systemWillShutdown( IOOptionBits specifier )
 {
 
 void IOService::systemWillShutdown( IOOptionBits specifier )
 {

-       IOPMrootDomain * rootDomain = IOService::getPMRootDomain();
-       if (rootDomain)
-               rootDomain->acknowledgeSystemWillShutdown( this );
+    IOPMrootDomain * rootDomain = IOService::getPMRootDomain();
+    if (rootDomain)
+        rootDomain->acknowledgeSystemWillShutdown( this );

 }
 
 // MARK: -
 }
 
 // MARK: -


@@ -6960,26 +7170,26 @@ IOPMRequest *
 IOService::acquirePMRequest( IOService * target, IOOptionBits requestType,
                              IOPMRequest * active )
 {
 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);
         }
     }
         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);
         PM_ERROR("%s: No memory for PM request type 0x%x\n",
             target->getName(), (uint32_t) requestType);

-       }
-       return request;
+    }
+    return request;

 }
 
 //*********************************************************************************
 }
 
 //*********************************************************************************


@@ -6988,96 +7198,102 @@ IOService::acquirePMRequest( IOService * target, IOOptionBits requestType,
 
 void IOService::releasePMRequest( IOPMRequest * request )
 {
 
 void IOService::releasePMRequest( IOPMRequest * request )
 {

-       if (request)
-       {
-               request->reset();
-               request->release();
-       }
+    if (request)
+    {
+        request->reset();
+        request->release();
+    }

 }
 
 //*********************************************************************************
 }
 
 //*********************************************************************************

-// [private] submitPMRequest
+// [private static] submitPMRequest

 //*********************************************************************************
 
 void IOService::submitPMRequest( IOPMRequest * request )
 {
 //*********************************************************************************
 
 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));
 
         OBFUSCATE(request->fArg1), OBFUSCATE(request->fArg2));
 

-       if (request->isReplyType())
-               gIOPMReplyQueue->queuePMRequest( request );
-       else
-               gIOPMRequestQueue->queuePMRequest( request );
+    if (request->isReplyType())
+        gIOPMReplyQueue->queuePMRequest( request );
+    else
+        gIOPMRequestQueue->queuePMRequest( request );

 }
 
 }
 

-void IOService::submitPMRequest( IOPMRequest ** requests, IOItemCount count )
+void IOService::submitPMRequests( IOPMRequest ** requests, IOItemCount count )

 {
 {

-       assert( requests );
-       assert( count > 0 );
-       assert( gIOPMRequestQueue );
+    assert( requests );
+    assert( count > 0 );
+    assert( gIOPMRequestQueue );

 
 

-       for (IOItemCount i = 0; i < count; i++)
-       {
-               IOPMRequest * req = requests[i];
-               PM_LOG1("[+ %02lx] %p [%p %s] %p %p %p\n",
-                       (long)req->getType(), OBFUSCATE(req),
-                       OBFUSCATE(req->getTarget()), req->getTarget()->getName(),
-                       OBFUSCATE(req->fArg0), 
+    for (IOItemCount i = 0; i < count; i++)
+    {
+        IOPMRequest * req = requests[i];
+        PM_LOG1("[+ %02lx] %p [%p %s] %p %p %p\n",
+            (long)req->getType(), OBFUSCATE(req),
+            OBFUSCATE(req->getTarget()), req->getTarget()->getName(),
+            OBFUSCATE(req->fArg0),

             OBFUSCATE(req->fArg1), OBFUSCATE(req->fArg2));
             OBFUSCATE(req->fArg1), OBFUSCATE(req->fArg2));

-       }
+    }

 
 

-       gIOPMRequestQueue->queuePMRequestChain( requests, count );
+    gIOPMRequestQueue->queuePMRequestChain( requests, count );

 }
 
 //*********************************************************************************
 }
 
 //*********************************************************************************

-// [private] servicePMRequestQueue
+// [private] actionPMRequestQueue

 //
 //

-// Called from IOPMRequestQueue::checkForWork().
+// IOPMRequestQueue::checkForWork() passing a new request to the request target.

 //*********************************************************************************
 
 //*********************************************************************************
 

-bool IOService::servicePMRequestQueue(
-       IOPMRequest *           request,
-       IOPMRequestQueue *      queue )
+bool IOService::actionPMRequestQueue(
+    IOPMRequest *       request,
+    IOPMRequestQueue *  queue )

 {
     bool more;
 
     if (initialized)
     {
 {
     bool more;
 
     if (initialized)
     {

-        // Work queue will immediately execute the queue'd request if possible.
-        // If execution blocks, the work queue will wait for a producer signal.
-        // Only need to signal more when completing attached requests.
+        // Work queue will immediately execute the request if the per-service
+        // request queue is empty. Note pwrMgt is the target's IOServicePM.

 
         more = gIOPMWorkQueue->queuePMRequest(request, pwrMgt);
 
         more = gIOPMWorkQueue->queuePMRequest(request, pwrMgt);

-        return more;

     }
     }

+    else
+    {
+        // Calling PM without PMinit() is not allowed, fail the request.
+        // Need to signal more when completing attached requests.
+
+        PM_LOG("%s: PM not initialized\n", getName());
+        PM_LOG1("[- %02x] %p [%p %s] !initialized\n",
+            request->getType(), OBFUSCATE(request),
+            OBFUSCATE(this), getName());

 
 

-    // Calling PM without PMinit() is not allowed, fail the request.
+        more = gIOPMCompletionQueue->queuePMRequest(request);
+        if (more) gIOPMWorkQueue->incrementProducerCount();
+    }

 
 

-    PM_LOG("%s: PM not initialized\n", getName());
-       fAdjustPowerScheduled = false;
-       more = gIOPMFreeQueue->queuePMRequest(request);
-    if (more) gIOPMWorkQueue->incrementProducerCount();
-       return more;
+    return more;

 }
 
 //*********************************************************************************
 }
 
 //*********************************************************************************

-// [private] servicePMFreeQueue
+// [private] actionPMCompletionQueue

 //
 //

-// Called from IOPMCompletionQueue::checkForWork().
+// IOPMCompletionQueue::checkForWork() passing a completed request to the
+// request target.

 //*********************************************************************************
 
 //*********************************************************************************
 

-bool IOService::servicePMFreeQueue(
-       IOPMRequest *             request,
-       IOPMCompletionQueue * queue )
+bool IOService::actionPMCompletionQueue(
+    IOPMRequest *         request,
+    IOPMCompletionQueue * queue )

 {
 {

-       bool            more = request->getNextRequest();
+    bool            more = (request->getNextRequest() != 0);

     IOPMRequest *   root = request->getRootRequest();
 
     if (root && (root != request))
     IOPMRequest *   root = request->getRootRequest();
 
     if (root && (root != request))


@@ -7085,38 +7301,46 @@ bool IOService::servicePMFreeQueue(
     if (more)
         gIOPMWorkQueue->incrementProducerCount();
 
     if (more)
         gIOPMWorkQueue->incrementProducerCount();
 

-       releasePMRequest( request );
-       return more;
+    releasePMRequest( request );
+    return more;

 }
 
 //*********************************************************************************
 }
 
 //*********************************************************************************

-// [private] retirePMRequest
+// [private] actionPMWorkQueueRetire

 //
 //

-// Called by IOPMWorkQueue to retire a completed request.
+// IOPMWorkQueue::checkForWork() passing a retired request to the request target.

 //*********************************************************************************
 
 //*********************************************************************************
 

-bool IOService::retirePMRequest( IOPMRequest * request, IOPMWorkQueue * queue )
+bool IOService::actionPMWorkQueueRetire( IOPMRequest * request, IOPMWorkQueue * queue )

 {
 {

-       assert(request && queue);
+    assert(request && queue);

 
 

-       PM_LOG1("[- %02x] %p [%p %s] state %d, busy %d\n",
-               request->getType(), OBFUSCATE(request), 
+    PM_LOG1("[- %02x] %p [%p %s] state %d, busy %d\n",
+        request->getType(), OBFUSCATE(request),

         OBFUSCATE(this), getName(),
         OBFUSCATE(this), getName(),

-               fMachineState, gIOPMBusyCount);
+        fMachineState, gIOPMBusyRequestCount);

 
 

-       // Catch requests created by idleTimerExpired().
+    // Catch requests created by idleTimerExpired()
+    if (request->getType() == kIOPMRequestTypeActivityTickle)
+    {
+        uint32_t tickleFlags = (uint32_t)(uintptr_t) request->fArg1;

 
 

-       if ((request->getType() == kIOPMRequestTypeActivityTickle) &&
-           (((uintptr_t) request->fArg1) & kTickleTypePowerDrop)  &&
-        fIdleTimerPeriod)
-       {
-        restartIdleTimer();
+        if ((tickleFlags & kTickleTypePowerDrop) && fIdleTimerPeriod)
+        {
+            restartIdleTimer();
+        }
+        else if (tickleFlags == (kTickleTypeActivity | kTickleTypePowerRise))
+        {
+            // Invalidate any idle power drop that got queued while
+            // processing this request.
+            fIdleTimerGeneration++;
+        }

     }
     }

+    
+    // When the completed request is linked, tell work queue there is
+    // more work pending.

 
 

-    // If the request is linked, then Work queue has already incremented its
-    // producer count.
-
-       return (gIOPMFreeQueue->queuePMRequest( request ));
+    return (gIOPMCompletionQueue->queuePMRequest( request ));

 }
 
 //*********************************************************************************
 }
 
 //*********************************************************************************


@@ -7127,99 +7351,100 @@ bool IOService::retirePMRequest( IOPMRequest * request, IOPMWorkQueue * queue )
 
 bool IOService::isPMBlocked( IOPMRequest * request, int count )
 {
 
 bool IOService::isPMBlocked( IOPMRequest * request, int count )
 {

-       int     reason = 0;
+    int reason = 0;

 
 

-       do {
-               if (kIOPM_Finished == fMachineState)
-                       break;
+    do {
+        if (kIOPM_Finished == fMachineState)
+            break;

 
 

-               if (kIOPM_DriverThreadCallDone == fMachineState)
-               {
+        if (kIOPM_DriverThreadCallDone == fMachineState)
+        {

             // 5 = kDriverCallInformPreChange
             // 6 = kDriverCallInformPostChange
             // 7 = kDriverCallSetPowerState
             // 8 = kRootDomainInformPreChange
             // 5 = kDriverCallInformPreChange
             // 6 = kDriverCallInformPostChange
             // 7 = kDriverCallSetPowerState
             // 8 = kRootDomainInformPreChange

-                       if (fDriverCallBusy)
+            if (fDriverCallBusy)

                 reason = 5 + fDriverCallReason;
                 reason = 5 + fDriverCallReason;

-                       break;
-               }
+            break;
+        }

 
 

-               // Waiting on driver's setPowerState() timeout.
-               if (fDriverTimer)
-               {
-                       reason = 1; break;
-               }
+        // Waiting on driver's setPowerState() timeout.
+        if (fDriverTimer)
+        {
+            reason = 1; break;
+        }

 
 

-               // Child or interested driver acks pending.
-               if (fHeadNotePendingAcks)
-               {
-                       reason = 2; break;
-               }
+        // Child or interested driver acks pending.
+        if (fHeadNotePendingAcks)
+        {
+            reason = 2; break;
+        }

 
 

-               // Waiting on apps or priority power interest clients.
-               if (fResponseArray)
-               {
-                       reason = 3; break;
-               }
+        // Waiting on apps or priority power interest clients.
+        if (fResponseArray)
+        {
+            reason = 3; break;
+        }

 
 

-               // Waiting on settle timer expiration.
-               if (fSettleTimeUS)
-               {
-                       reason = 4; break;
-               }
-       } while (false);
+        // Waiting on settle timer expiration.
+        if (fSettleTimeUS)
+        {
+            reason = 4; break;
+        }
+    } while (false);

 
 

-       fWaitReason = reason;
+    fWaitReason = reason;

 
 

-       if (reason)
-       {
-               if (count)
-               {
-                       PM_LOG1("[B %02x] %p [%p %s] state %d, reason %d\n",
-                               request->getType(), OBFUSCATE(request), 
+    if (reason)
+    {
+        if (count)
+        {
+            PM_LOG1("[B %02x] %p [%p %s] state %d, reason %d\n",
+                request->getType(), OBFUSCATE(request),

                 OBFUSCATE(this), getName(),
                 OBFUSCATE(this), getName(),

-                               fMachineState, reason);
-               }
+                fMachineState, reason);
+        }

 
 

-               return true;
-       }
+        return true;
+    }

 
 

-       return false;
+    return false;

 }
 
 //*********************************************************************************
 }
 
 //*********************************************************************************

-// [private] servicePMRequest
+// [private] actionPMWorkQueueInvoke

 //
 //

-// Service a request from our work queue.
+// IOPMWorkQueue::checkForWork() passing a request to the
+// request target for execution.

 //*********************************************************************************
 
 //*********************************************************************************
 

-bool IOService::servicePMRequest( IOPMRequest * request, IOPMWorkQueue * queue )
+bool IOService::actionPMWorkQueueInvoke( IOPMRequest * request, IOPMWorkQueue * queue )

 {
 {

-       bool    done = false;
-       int             loop = 0;
+    bool    done = false;
+    int     loop = 0;

 
 

-       assert(request && queue);
+    assert(request && queue);

 
 

-       while (isPMBlocked(request, loop++) == false)
-       {
-               PM_LOG1("[W %02x] %p [%p %s] state %d\n",
-                       request->getType(), OBFUSCATE(request), 
+    while (isPMBlocked(request, loop++) == false)
+    {
+        PM_LOG1("[W %02x] %p [%p %s] state %d\n",
+            request->getType(), OBFUSCATE(request),

             OBFUSCATE(this), getName(), fMachineState);
 
             OBFUSCATE(this), getName(), fMachineState);
 

-               gIOPMRequest = request;
-        gIOPMWorkCount++;
+        gIOPMRequest = request;
+        gIOPMWorkInvokeCount++;

 
 

-               // Every PM machine states must be handled in one of the cases below.
+        // Every PM machine states must be handled in one of the cases below.

 
 

-               switch ( fMachineState )
-               {
-                       case kIOPM_Finished:
+        switch ( fMachineState )
+        {
+            case kIOPM_Finished:

                 start_watchdog_timer();
 
                 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)
                 {
                 // Root domain might self cancel due to assertions.
                 if (IS_ROOT_DOMAIN)
                 {


@@ -7230,153 +7455,125 @@ bool IOService::servicePMRequest( IOPMRequest * request, IOPMWorkQueue * queue )
                 }
 
                 // askChangeDown() done, was it vetoed?
                 }
 
                 // askChangeDown() done, was it vetoed?

-                               if (!fDoNotPowerDown)
-                               {
+                if (!fDoNotPowerDown)
+                {
+                    // no, we can continue
+                    OurChangeTellClientsPowerDown();
+                }
+                else
+                {
+                    OUR_PMLog(kPMLogIdleCancel, (uintptr_t) this, fMachineState);
+                    PM_ERROR("%s: idle cancel, state %u\n", fName, fMachineState);

                     if (IS_ROOT_DOMAIN) {
                     if (IS_ROOT_DOMAIN) {

-                        PMEventDetails *details = PMEventDetails::eventDetails(
-                                                    kIOPMEventTypeAppNotificationsFinished,
-                                                    NULL,
-                                                    0,
-                                                    0);
-                                               
-                                               getPMRootDomain()->recordAndReleasePMEvent( details );
+                        // RootDomain already sent "WillSleep" to its clients
+                        tellChangeUp(fCurrentPowerState);

                     }
                     }

-
-                                       // 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 );
+                    else {
+                        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?
                 // PMRD: tellChangeDown/kNotifyApps done, was it cancelled?

-                               if (fDoNotPowerDown)
-                               {
-                                       OUR_PMLog(kPMLogIdleCancel, (uintptr_t) this, fMachineState);
-                                       PM_ERROR("%s: idle cancel, state %u\n", fName, fMachineState);
-                                       // yes, rescind the warning
-                                       tellNoChangeDown(fHeadNotePowerState);
-                                       // mark the change note un-actioned
-                                       fHeadNoteChangeFlags |= kIOPMNotDone;
-                                       // and we're done
-                                       OurChangeFinish();
-                               }
-                               else
-                                       OurChangeTellUserPMPolicyPowerDown();
-                               break;
-
-                       case kIOPM_OurChangeTellPriorityClientsPowerDown:
-                               // PMRD:     LastCallBeforeSleep notify done
-                // Non-PMRD: tellChangeDown/kNotifyApps done
-                               if (fDoNotPowerDown)
-                               {
+                if (fDoNotPowerDown)
+                {
+                    OUR_PMLog(kPMLogIdleCancel, (uintptr_t) this, fMachineState);
+                    PM_ERROR("%s: idle cancel, state %u\n", fName, fMachineState);

                     if (IS_ROOT_DOMAIN) {
                     if (IS_ROOT_DOMAIN) {

-                                               PMEventDetails *details = PMEventDetails::eventDetails(
-                                                    kIOPMEventTypeSleepDone,
-                                                    NULL,
-                                                    2, /* reason: 2 == Client cancelled wake */
-                                                    kIOReturnAborted); /* result */
-                                               
-                                               getPMRootDomain()->recordAndReleasePMEvent( details );
+                        // RootDomain already sent "WillSleep" to its clients
+                        tellChangeUp(fCurrentPowerState);

                     }
                     }

-                                       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 );
+                    else {
+                        tellNoChangeDown(fHeadNotePowerState);

                     }
                     }

-                                       // yes, we can continue
-                                       OurChangeTellPriorityClientsPowerDown();  
-                               }
-                               break;
+                    // mark the change note un-actioned
+                    fHeadNoteChangeFlags |= kIOPMNotDone;
+                    // and we're done
+                    OurChangeFinish();
+                }
+                else
+                    OurChangeTellUserPMPolicyPowerDown();
+                break;
+
+            case kIOPM_OurChangeTellPriorityClientsPowerDown:
+                // PMRD:     LastCallBeforeSleep notify done
+                // Non-PMRD: tellChangeDown/kNotifyApps done
+                if (fDoNotPowerDown)
+                {
+                    OUR_PMLog(kPMLogIdleCancel, (uintptr_t) this, fMachineState);
+                    PM_ERROR("%s: idle revert, state %u\n", fName, fMachineState);
+                    // no, tell clients we're back in the old state
+                    tellChangeUp(fCurrentPowerState);
+                    // mark the change note un-actioned
+                    fHeadNoteChangeFlags |= kIOPMNotDone;
+                    // and we're done
+                    OurChangeFinish();
+                }
+                else
+                {
+                    // yes, we can continue
+                    OurChangeTellPriorityClientsPowerDown();
+                }
+                break;

 
 

-                       case kIOPM_OurChangeNotifyInterestedDriversWillChange:
-                               OurChangeNotifyInterestedDriversWillChange();
-                               break;
+            case kIOPM_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_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_ParentChangeTellCapabilityDidChange:
                 ParentChangeTellCapabilityDidChange();
                 break;
 

-                       case kIOPM_ParentChangeAcknowledgePowerChange:
-                               ParentChangeAcknowledgePowerChange();
-                               break;
+            case kIOPM_ParentChangeAcknowledgePowerChange:
+                ParentChangeAcknowledgePowerChange();
+                break;

 
 

-                       case kIOPM_DriverThreadCallDone:
+            case kIOPM_DriverThreadCallDone:

                 switch (fDriverCallReason)
                 {
                     case kDriverCallInformPreChange:
                 switch (fDriverCallReason)
                 {
                     case kDriverCallInformPreChange:


@@ -7393,15 +7590,15 @@ bool IOService::servicePMRequest( IOPMRequest * request, IOPMWorkQueue * queue )
                         panic("%s: bad call reason %x",
                             getName(), fDriverCallReason);
                 }
                         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()
 
             case kIOPM_NotifyChildrenStart:
                 // pop notifyAll() state saved by notifyInterestedDriversDone()


@@ -7418,41 +7615,41 @@ bool IOService::servicePMRequest( IOPMRequest * request, IOPMWorkQueue * queue )
                         &fHeadNoteChangeFlags, &cancel);
                     fDoNotPowerDown = cancel;
                 }
                         &fHeadNoteChangeFlags, &cancel);
                     fDoNotPowerDown = cancel;
                 }

-                               if (!fDoNotPowerDown)
-                               {
+                if (!fDoNotPowerDown)
+                {

                     fMachineState = kIOPM_SyncTellPriorityClientsPowerDown;
                     fOutOfBandParameter = kNotifyApps;
                     tellChangeDown(fHeadNotePowerState);
                     fMachineState = kIOPM_SyncTellPriorityClientsPowerDown;
                     fOutOfBandParameter = kNotifyApps;
                     tellChangeDown(fHeadNotePowerState);

-                               }
-                               else
-                               {
+                }
+                else
+                {

                     // Cancelled by IOPMrootDomain::askChangeDownDone() or
                     // askChangeDown/kNotifyApps
                     // 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?
                 break;
 
             case kIOPM_SyncTellPriorityClientsPowerDown:
                 // PMRD: tellChangeDown/kNotifyApps done, was it cancelled?

-                               if (!fDoNotPowerDown)
-                               {
+                if (!fDoNotPowerDown)
+                {

                     fMachineState = kIOPM_SyncNotifyWillChange;
                     fOutOfBandParameter = kNotifyPriority;
                     tellChangeDown(fHeadNotePowerState);
                 }
                 else
                 {
                     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)
 
             case kIOPM_SyncNotifyWillChange:
                 if (kIOPMSyncNoChildNotify & fHeadNoteChangeFlags)


@@ -7515,22 +7712,22 @@ bool IOService::servicePMRequest( IOPMRequest * request, IOPMWorkQueue * queue )
                 tellClientsWithResponse( fOutOfBandMessage );
                 break;
 
                 tellClientsWithResponse( fOutOfBandMessage );
                 break;
 

-                       default:
-                               panic("servicePMWorkQueue: unknown machine state %x",
+            default:
+                panic("PMWorkQueueInvoke: unknown machine state %x",

                     fMachineState);
                     fMachineState);

-               }
+        }

 
 

-               gIOPMRequest = 0;
+        gIOPMRequest = 0;

 
 

-               if (fMachineState == kIOPM_Finished)
-               {
+        if (fMachineState == kIOPM_Finished)
+        {

             stop_watchdog_timer();
             stop_watchdog_timer();

-                       done = true;
-                       break;
-               }
-       }
+            done = true;
+            break;
+        }
+    }

 
 

-       return done;
+    return done;

 }
 
 //*********************************************************************************
 }
 
 //*********************************************************************************


@@ -7539,64 +7736,65 @@ bool IOService::servicePMRequest( IOPMRequest * request, IOPMWorkQueue * queue )
 
 void IOService::executePMRequest( IOPMRequest * request )
 {
 
 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:
         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:
 
         case kIOPMRequestTypeSynchronizePowerTree:

-                       handleSynchronizePowerTree( request );
-                       break;
+            handleSynchronizePowerTree( request );
+            break;

 
         case kIOPMRequestTypeSetIdleTimerPeriod:
             {
                 fIdleTimerPeriod = (uintptr_t) request->fArg0;
 
         case kIOPMRequestTypeSetIdleTimerPeriod:
             {
                 fIdleTimerPeriod = (uintptr_t) request->fArg0;

+                fNextIdleTimerPeriod = fIdleTimerPeriod;

                 if ((false == fLockedFlags.PMStop) && (fIdleTimerPeriod > 0))
                     restartIdleTimer();
             }
                 if ((false == fLockedFlags.PMStop) && (fIdleTimerPeriod > 0))
                     restartIdleTimer();
             }


@@ -7606,35 +7804,42 @@ void IOService::executePMRequest( IOPMRequest * request )
             fIdleTimerIgnored = request->fArg0 ? 1 : 0;
             break;
 
             fIdleTimerIgnored = request->fArg0 ? 1 : 0;
             break;
 

-               default:
-                       panic("executePMRequest: unknown request type %x", request->getType());
-       }
+        case kIOPMRequestTypeQuiescePowerTree:
+            gIOPMWorkQueue->finishQuiesceRequest(request);
+            break;
+
+        default:
+            panic("executePMRequest: unknown request type %x", request->getType());
+    }

 }
 
 //*********************************************************************************
 }
 
 //*********************************************************************************

-// [private] servicePMReplyQueue
+// [private] actionPMReplyQueue
+//
+// IOPMRequestQueue::checkForWork() passing a reply-type request to the
+// request target.

 //*********************************************************************************
 
 //*********************************************************************************
 

-bool IOService::servicePMReplyQueue( IOPMRequest * request, IOPMRequestQueue * queue )
+bool IOService::actionPMReplyQueue( IOPMRequest * request, IOPMRequestQueue * queue )

 {
 {

-       bool more = false;
+    bool more = false;

 
 

-       assert( request && queue );
-       assert( request->isReplyType() );
+    assert( request && queue );
+    assert( request->isReplyType() );

 
 

-       PM_LOG1("[A %02x] %p [%p %s] state %d\n",
-               request->getType(), OBFUSCATE(request), 
+    PM_LOG1("[A %02x] %p [%p %s] state %d\n",
+        request->getType(), OBFUSCATE(request),

         OBFUSCATE(this), getName(), fMachineState);
 
         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))
                               (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.
                 {
                     // Clients are not allowed to cancel when kIOPMSkipAskPowerDown
                     // flag is set. Only root domain will set this flag.


@@ -7652,115 +7857,106 @@ bool IOService::servicePMReplyQueue( IOPMRequest * request, IOPMRequestQueue * q
                         getPMRootDomain()->pmStatsRecordApplicationResponse(
                             gIOPMStatsApplicationResponseCancel,
                             name ? name->getCStringNoCopy() : "", 0,
                         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);
                     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();
             }
             // OSString containing app name in Arg2 must be released.
             if (request->getType() == kIOPMRequestTypeCancelPowerChange)
             {
                 OSObject * obj = (OSObject *) request->fArg2;
                 if (obj) obj->release();
             }

-                       break;
-
-               case kIOPMRequestTypeAckPowerChange:
-                       more = handleAcknowledgePowerChange( request );
-                       break;
-
-               case kIOPMRequestTypeAckSetPowerState:
-                       if (fDriverTimer == -1)
-                       {
-                               // driver acked while setPowerState() call is in-flight.
-                               // take this ack, return value from setPowerState() is irrelevant.
-                               OUR_PMLog(kPMLogDriverAcknowledgeSet,
-                                       (uintptr_t) this, fDriverTimer);
-                               fDriverTimer = 0;
-                       }
-                       else if (fDriverTimer > 0)
-                       {
-                               // expected ack, stop the timer
-                               stop_ack_timer();
-
-#if LOG_SETPOWER_TIMES
+            break;
+
+        case kIOPMRequestTypeAckPowerChange:
+            more = handleAcknowledgePowerChange( request );
+            break;
+
+        case kIOPMRequestTypeAckSetPowerState:
+            if (fDriverTimer == -1)
+            {
+                // driver acked while setPowerState() call is in-flight.
+                // take this ack, return value from setPowerState() is irrelevant.
+                OUR_PMLog(kPMLogDriverAcknowledgeSet,
+                    (uintptr_t) this, fDriverTimer);
+                fDriverTimer = 0;
+            }
+            else if (fDriverTimer > 0)
+            {
+                // expected ack, stop the timer
+                stop_ack_timer();
+
+

                 uint64_t nsec = computeTimeDeltaNS(&fDriverCallStartTime);
                 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 );
-#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)
+                if (nsec > LOG_SETPOWER_TIMES) {
+                    getPMRootDomain()->pmStatsRecordApplicationResponse(
+                        gIOPMStatsDriverPSChangeSlow,
+                        fName, kDriverCallSetPowerState, NS_TO_MS(nsec), getRegistryEntryID(),
+                        NULL, fHeadNotePowerState);
+                }
+
+                OUR_PMLog(kPMLogDriverAcknowledgeSet, (uintptr_t) this, fDriverTimer);
+                fDriverTimer = 0;
+                more = true;
+            }
+            else
+            {
+                // unexpected ack
+                OUR_PMLog(kPMLogAcknowledgeErr4, (uintptr_t) this, 0);
+            }
+            break;
+
+        case kIOPMRequestTypeInterestChanged:
+            handleInterestChanged( request );
+            more = true;
+            break;
+
+        case kIOPMRequestTypeIdleCancel:
+            if ((fMachineState == kIOPM_OurChangeTellClientsPowerDown)

              || (fMachineState == kIOPM_OurChangeTellUserPMPolicyPowerDown)
              || (fMachineState == kIOPM_OurChangeTellUserPMPolicyPowerDown)

-             || (fMachineState == kIOPM_OurChangeTellPriorityClientsPowerDown) 
+             || (fMachineState == kIOPM_OurChangeTellPriorityClientsPowerDown)

              || (fMachineState == kIOPM_SyncTellClientsPowerDown)
              || (fMachineState == kIOPM_SyncTellPriorityClientsPowerDown))
              || (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);
                 PM_LOG2("%s: cancel from machine state %d\n",
                     getName(), fMachineState);

-                               fDoNotPowerDown = true;
+                fDoNotPowerDown = true;

                 // Stop waiting for app replys.
                 // Stop waiting for app replys.

-                               if ((fMachineState == kIOPM_OurChangeTellPriorityClientsPowerDown) ||
-                                       (fMachineState == kIOPM_OurChangeTellUserPMPolicyPowerDown) ||
-                                       (fMachineState == kIOPM_SyncTellPriorityClientsPowerDown))
-                                       cleanClientResponses(false);
-                               more = true;
-                       }
-                       break;
+                if ((fMachineState == kIOPM_OurChangeTellPriorityClientsPowerDown) ||
+                    (fMachineState == kIOPM_OurChangeTellUserPMPolicyPowerDown) ||
+                    (fMachineState == kIOPM_SyncTellPriorityClientsPowerDown) ||
+                    (fMachineState == kIOPM_SyncTellClientsPowerDown) )
+                    cleanClientResponses(false);
+                more = true;
+            }
+            break;

 
         case kIOPMRequestTypeChildNotifyDelayCancel:
             if (fMachineState == kIOPM_NotifyChildrenDelayed)
             {
 
         case kIOPMRequestTypeChildNotifyDelayCancel:
             if (fMachineState == kIOPM_NotifyChildrenDelayed)
             {

-                PM_LOG2("%s: delay notify cancelled\n", getName());                
+                PM_LOG2("%s: delay notify cancelled\n", getName());

                 notifyChildrenDelayed();
             }
             break;
 
                 notifyChildrenDelayed();
             }
             break;
 

-               default:
-                       panic("servicePMReplyQueue: unknown reply type %x",
-                request->getType());
-       }
+        default:
+            panic("PMReplyQueue: unknown reply type %x", request->getType());
+    }

 
 

-       more |= gIOPMFreeQueue->queuePMRequest(request);
+    more |= gIOPMCompletionQueue->queuePMRequest(request);

     if (more)
         gIOPMWorkQueue->incrementProducerCount();
 
     if (more)
         gIOPMWorkQueue->incrementProducerCount();
 

-       return more;
+    return more;

 }
 
 //*********************************************************************************
 }
 
 //*********************************************************************************


@@ -7784,7 +7980,7 @@ bool IOService::assertPMDriverCall(
     {
         goto fail;
     }
     {
         goto fail;
     }

-    
+

     if (((options & kIOPMADC_NoInactiveCheck) == 0) && isInactive())
     {
         goto fail;
     if (((options & kIOPMADC_NoInactiveCheck) == 0) && isInactive())
     {
         goto fail;


@@ -7862,7 +8058,7 @@ void IOService::waitForPMDriverCall( IOService * target )
                 }
                 continue;
             }
                 }
                 continue;
             }

-            
+

             wait = true;
             break;
         }
             wait = true;
             break;
         }


@@ -7890,7 +8086,7 @@ const char * IOService::getIOMessageString( uint32_t msg )
 {
 #define MSG_ENTRY(x)    {(int) x, #x}
 
 {
 #define MSG_ENTRY(x)    {(int) x, #x}
 

-    static const IONamedValue msgNames[] = { 
+    static const IONamedValue msgNames[] = {

         MSG_ENTRY( kIOMessageCanDevicePowerOff      ),
         MSG_ENTRY( kIOMessageDeviceWillPowerOff     ),
         MSG_ENTRY( kIOMessageDeviceWillNotPowerOff  ),
         MSG_ENTRY( kIOMessageCanDevicePowerOff      ),
         MSG_ENTRY( kIOMessageDeviceWillPowerOff     ),
         MSG_ENTRY( kIOMessageDeviceWillNotPowerOff  ),


@@ -7925,54 +8121,57 @@ OSDefineMetaClassAndStructors( IOPMRequest, IOCommand );
 
 IOPMRequest * IOPMRequest::create( void )
 {
 
 IOPMRequest * IOPMRequest::create( void )
 {

-       IOPMRequest * me = OSTypeAlloc(IOPMRequest);
-       if (me && !me->init(0, kIOPMRequestTypeInvalid))
-       {
-               me->release();
-               me = 0;
-       }
-       return me;
+    IOPMRequest * me = OSTypeAlloc(IOPMRequest);
+    if (me && !me->init(0, kIOPMRequestTypeInvalid))
+    {
+        me->release();
+        me = 0;
+    }
+    return me;

 }
 
 bool IOPMRequest::init( IOService * target, IOOptionBits type )
 {
 }
 
 bool IOPMRequest::init( IOService * target, IOOptionBits type )
 {

-       if (!IOCommand::init())
-               return false;
+    if (!IOCommand::init())
+        return false;

 
 

-       fType             = type;
-       fTarget           = target;
-#if NOT_READY
-    fCompletionStatus = kIOReturnSuccess;
-#endif
+    fRequestType = type;
+    fTarget = target;
+
+    if (fTarget)
+        fTarget->retain();
+
+    // Root node and root domain requests does not prevent the power tree from
+    // becoming quiescent.

 
 

-       if (fTarget)
-               fTarget->retain();
+    fIsQuiesceBlocker = ((fTarget != gIOPMRootNode) &&
+                         (fTarget != IOService::getPMRootDomain()));

 
 

-       return true;
+    return true;

 }
 
 void IOPMRequest::reset( void )
 {
 }
 
 void IOPMRequest::reset( void )
 {

-       assert( fWorkWaitCount == 0 );
-       assert( fFreeWaitCount == 0 );
+    assert( fWorkWaitCount == 0 );
+    assert( fFreeWaitCount == 0 );

 
 

-       detachNextRequest();
+    detachNextRequest();

     detachRootRequest();
 
     detachRootRequest();
 

-       fType = kIOPMRequestTypeInvalid;
-
-#if NOT_READY
-       if (fCompletionAction)
-       {
-        fCompletionAction(fCompletionTarget, fCompletionParam, fCompletionStatus);
+    if (fCompletionAction && (fRequestType == kIOPMRequestTypeQuiescePowerTree))
+    {
+        // Call the completion on PM work loop context
+        fCompletionAction(fCompletionTarget, fCompletionParam);
+        fCompletionAction = 0;

     }
     }

-#endif

 
 

-       if (fTarget)
-       {
-               fTarget->release();
-               fTarget = 0;
-       }       
+    fRequestType = kIOPMRequestTypeInvalid;
+
+    if (fTarget)
+    {
+        fTarget->release();
+        fTarget = 0;
+    }

 }
 
 bool IOPMRequest::attachNextRequest( IOPMRequest * next )
 }
 
 bool IOPMRequest::attachNextRequest( IOPMRequest * next )


@@ -7987,8 +8186,8 @@ bool IOPMRequest::attachNextRequest( IOPMRequest * next )
         fRequestNext->fWorkWaitCount++;
 #if LOG_REQUEST_ATTACH
         PM_LOG("Attached next: %p [0x%x] -> %p [0x%x, %u] %s\n",
         fRequestNext->fWorkWaitCount++;
 #if LOG_REQUEST_ATTACH
         PM_LOG("Attached next: %p [0x%x] -> %p [0x%x, %u] %s\n",

-            OBFUSCATE(this), (uint32_t) fType, OBFUSCATE(fRequestNext),
-            (uint32_t) fRequestNext->fType,
+            OBFUSCATE(this), fRequestType, OBFUSCATE(fRequestNext),
+            fRequestNext->fRequestType,

             (uint32_t) fRequestNext->fWorkWaitCount,
             fTarget->getName());
 #endif
             (uint32_t) fRequestNext->fWorkWaitCount,
             fTarget->getName());
 #endif


@@ -8008,8 +8207,8 @@ bool IOPMRequest::detachNextRequest( void )
             fRequestNext->fWorkWaitCount--;
 #if LOG_REQUEST_ATTACH
         PM_LOG("Detached next: %p [0x%x] -> %p [0x%x, %u] %s\n",
             fRequestNext->fWorkWaitCount--;
 #if LOG_REQUEST_ATTACH
         PM_LOG("Detached next: %p [0x%x] -> %p [0x%x, %u] %s\n",

-            OBFUSCATE(this), (uint32_t) fType, OBFUSCATE(fRequestNext),
-            (uint32_t) fRequestNext->fType,
+            OBFUSCATE(this), fRequestType, OBFUSCATE(fRequestNext),
+            fRequestNext->fRequestType,

             (uint32_t) fRequestNext->fWorkWaitCount,
             fTarget->getName());
 #endif
             (uint32_t) fRequestNext->fWorkWaitCount,
             fTarget->getName());
 #endif


@@ -8076,82 +8275,90 @@ OSDefineMetaClassAndStructors( IOPMRequestQueue, IOEventSource );
 
 IOPMRequestQueue * IOPMRequestQueue::create( IOService * inOwner, Action inAction )
 {
 
 IOPMRequestQueue * IOPMRequestQueue::create( IOService * inOwner, Action inAction )
 {

-       IOPMRequestQueue * me = OSTypeAlloc(IOPMRequestQueue);
-       if (me && !me->init(inOwner, inAction))
-       {
-               me->release();
-               me = 0;
-       }
-       return me;
+    IOPMRequestQueue * me = OSTypeAlloc(IOPMRequestQueue);
+    if (me && !me->init(inOwner, inAction))
+    {
+        me->release();
+        me = 0;
+    }
+    return me;

 }
 
 bool IOPMRequestQueue::init( IOService * inOwner, Action inAction )
 {
 }
 
 bool IOPMRequestQueue::init( IOService * inOwner, Action inAction )
 {

-       if (!inAction || !IOEventSource::init(inOwner, (IOEventSourceAction)inAction))
+    if (!inAction || !IOEventSource::init(inOwner, (IOEventSourceAction)inAction))

         return false;
 
         return false;
 

-       queue_init(&fQueue);
-       fLock = IOLockAlloc();
-       return (fLock != 0);
+    queue_init(&fQueue);
+    fLock = IOLockAlloc();
+    return (fLock != 0);

 }
 
 void IOPMRequestQueue::free( void )
 {
 }
 
 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 )
 {
 }
 
 void IOPMRequestQueue::queuePMRequest( IOPMRequest * request )
 {

-       assert(request);
-       IOLockLock(fLock);
-       queue_enter(&fQueue, request, IOPMRequest *, fCommandChain);
-       IOLockUnlock(fLock);
-       if (workLoop) signalWorkAvailable();
+    assert(request);
+    IOLockLock(fLock);
+    queue_enter(&fQueue, request, typeof(request), fCommandChain);
+    IOLockUnlock(fLock);
+    if (workLoop) signalWorkAvailable();

 }
 
 void
 IOPMRequestQueue::queuePMRequestChain( IOPMRequest ** requests, IOItemCount count )
 {
 }
 
 void
 IOPMRequestQueue::queuePMRequestChain( IOPMRequest ** requests, IOItemCount count )
 {

-       IOPMRequest * next;
+    IOPMRequest * next;

 
 

-       assert(requests && count);
-       IOLockLock(fLock);
-       while (count--)
-       {
-               next = *requests;
-               requests++;
-               queue_enter(&fQueue, next, IOPMRequest *, fCommandChain);
-       }
-       IOLockUnlock(fLock);
-       if (workLoop) signalWorkAvailable();
+    assert(requests && count);
+    IOLockLock(fLock);
+    while (count--)
+    {
+        next = *requests;
+        requests++;
+        queue_enter(&fQueue, next, typeof(next), fCommandChain);
+    }
+    IOLockUnlock(fLock);
+    if (workLoop) signalWorkAvailable();

 }
 
 bool IOPMRequestQueue::checkForWork( void )
 {
 }
 
 bool IOPMRequestQueue::checkForWork( void )
 {

-    Action                     dqAction = (Action) action;
-       IOPMRequest *   request;
-       IOService *             target;
-       bool                    more = false;
+    Action          dqAction = (Action) action;
+    IOPMRequest *   request;
+    IOService *     target;
+    int             dequeueCount = 0;
+    bool            more = false;

 
 

-       IOLockLock( fLock );
+    IOLockLock( fLock );

 
 

-       while (!queue_empty(&fQueue))
-       {
-               queue_remove_first( &fQueue, request, IOPMRequest *, fCommandChain );           
-               IOLockUnlock( fLock );
-               target = request->getTarget();
-               assert(target);
-               more |= (*dqAction)( target, request, this );
-               IOLockLock( fLock );
-       }
+    while (!queue_empty(&fQueue))
+    {
+        if (dequeueCount++ >= kMaxDequeueCount)
+        {
+            // Allow other queues a chance to work
+            more = true;
+            break;
+        }
+    
+        queue_remove_first(&fQueue, request, typeof(request), fCommandChain);
+        IOLockUnlock(fLock);
+        target = request->getTarget();
+        assert(target);
+        more |= (*dqAction)( target, request, this );
+        IOLockLock( fLock );
+    }

 
 

-       IOLockUnlock( fLock );
-       return more;
+    IOLockUnlock( fLock );
+    return more;

 }
 
 // MARK: -
 }
 
 // MARK: -


@@ -8160,67 +8367,87 @@ bool IOPMRequestQueue::checkForWork( void )
 //*********************************************************************************
 // IOPMWorkQueue Class
 //
 //*********************************************************************************
 // IOPMWorkQueue Class
 //

-// Queue of IOServicePM objects with busy IOPMRequest(s).
+// Queue of IOServicePM objects, each with a queue of IOPMRequest sharing the
+// same target.

 //*********************************************************************************
 
 OSDefineMetaClassAndStructors( IOPMWorkQueue, IOEventSource );
 
 IOPMWorkQueue *
 //*********************************************************************************
 
 OSDefineMetaClassAndStructors( IOPMWorkQueue, IOEventSource );
 
 IOPMWorkQueue *

-IOPMWorkQueue::create( IOService * inOwner, Action work, Action retire )
+IOPMWorkQueue::create( IOService * inOwner, Action invoke, Action retire )

 {
 {

-       IOPMWorkQueue * me = OSTypeAlloc(IOPMWorkQueue);
-       if (me && !me->init(inOwner, work, retire))
-       {
-               me->release();
-               me = 0;
-       }
-       return me;
+    IOPMWorkQueue * me = OSTypeAlloc(IOPMWorkQueue);
+    if (me && !me->init(inOwner, invoke, retire))
+    {
+        me->release();
+        me = 0;
+    }
+    return me;

 }
 
 }
 

-bool IOPMWorkQueue::init( IOService * inOwner, Action work, Action retire )
+bool IOPMWorkQueue::init( IOService * inOwner, Action invoke, Action retire )

 {
 {

-       if (!work || !retire ||
-               !IOEventSource::init(inOwner, (IOEventSourceAction)0))
-               return false;
+    if (!invoke || !retire ||
+        !IOEventSource::init(inOwner, (IOEventSourceAction)0))
+        return false;

 
 

-       queue_init(&fWorkQueue);
+    queue_init(&fWorkQueue);

 
 

-       fWorkAction    = work;
-       fRetireAction  = retire;
+    fInvokeAction  = invoke;
+    fRetireAction  = retire;

     fConsumerCount = fProducerCount = 0;
 
     fConsumerCount = fProducerCount = 0;
 

-       return true;
+    return true;

 }
 
 bool IOPMWorkQueue::queuePMRequest( IOPMRequest * request, IOServicePM * pwrMgt )
 {
 }
 
 bool IOPMWorkQueue::queuePMRequest( IOPMRequest * request, IOServicePM * pwrMgt )
 {

-    bool more = false;
-    bool empty;
+    queue_head_t *  requestQueue;
+    bool            more  = false;
+    bool            empty;

 
 

-       assert( request );
+    assert( request );

     assert( pwrMgt );
     assert( pwrMgt );

-       assert( onThread() );
+    assert( onThread() );

     assert( queue_next(&request->fCommandChain) ==
             queue_prev(&request->fCommandChain) );
 
     assert( queue_next(&request->fCommandChain) ==
             queue_prev(&request->fCommandChain) );
 

-       gIOPMBusyCount++;
+    gIOPMBusyRequestCount++;
+
+    if (request->isQuiesceType())
+    {
+        if ((request->getTarget() == gIOPMRootNode) && !fQuiesceStartTime)
+        {
+            // Attach new quiesce request to all quiesce blockers in the queue
+            fQuiesceStartTime = mach_absolute_time();
+            attachQuiesceRequest(request);
+            fQuiesceRequest = request;
+        }
+    }
+    else if (fQuiesceRequest && request->isQuiesceBlocker())
+    {
+        // Attach the new quiesce blocker to the blocked quiesce request
+        request->attachNextRequest(fQuiesceRequest);
+    }

 
     // Add new request to the tail of the per-service request queue.
     // Then immediately check the request queue to minimize latency
     // if the queue was empty.
 
 
     // Add new request to the tail of the per-service request queue.
     // Then immediately check the request queue to minimize latency
     // if the queue was empty.
 

-    empty = queue_empty(&pwrMgt->RequestHead);
-       queue_enter(&pwrMgt->RequestHead, request, IOPMRequest *, fCommandChain);
+    requestQueue = &pwrMgt->RequestHead;
+    empty = queue_empty(requestQueue);
+    queue_enter(requestQueue, request, typeof(request), fCommandChain);

     if (empty)
     {
     if (empty)
     {

-        more = checkRequestQueue(&pwrMgt->RequestHead, &empty);
+        more = checkRequestQueue(requestQueue, &empty);

         if (!empty)
         {
         if (!empty)
         {

-            // New Request is blocked, add IOServicePM to work queue.
+            // Request just added is blocked, add its target IOServicePM
+            // to the work queue.

             assert( queue_next(&pwrMgt->WorkChain) ==
                     queue_prev(&pwrMgt->WorkChain) );
 
             assert( queue_next(&pwrMgt->WorkChain) ==
                     queue_prev(&pwrMgt->WorkChain) );
 

-            queue_enter(&fWorkQueue, pwrMgt, IOServicePM *, WorkChain);
+            queue_enter(&fWorkQueue, pwrMgt, typeof(pwrMgt), WorkChain);

             fQueueLength++;
             PM_LOG3("IOPMWorkQueue: [%u] added %s@%p to queue\n",
                 fQueueLength, pwrMgt->Name, OBFUSCATE(pwrMgt));
             fQueueLength++;
             PM_LOG3("IOPMWorkQueue: [%u] added %s@%p to queue\n",
                 fQueueLength, pwrMgt->Name, OBFUSCATE(pwrMgt));


@@ -8230,40 +8457,53 @@ bool IOPMWorkQueue::queuePMRequest( IOPMRequest * request, IOServicePM * pwrMgt
     return more;
 }
 
     return more;
 }
 

-bool IOPMWorkQueue::checkRequestQueue( queue_head_t * queue, bool * empty )
+bool IOPMWorkQueue::checkRequestQueue( queue_head_t * requestQueue, bool * empty )

 {
 {

-       IOPMRequest *   request;
-       IOService *             target;
+    IOPMRequest *   request;
+    IOService *     target;

     bool            more = false;
     bool            more = false;

-       bool                    done = false;
+    bool            done = false;

 
 

-    assert(!queue_empty(queue));
+    assert(!queue_empty(requestQueue));

     do {
     do {

-               request = (IOPMRequest *) queue_first(queue);
-               if (request->isWorkBlocked())
-            break;  // cannot start, blocked on attached request
+        request = (typeof(request)) queue_first(requestQueue);
+        if (request->isWorkBlocked())
+            break;  // request dispatch blocked on attached request

 
 

-               target = request->getTarget();
-        done = (*fWorkAction)( target, request, this );
-               if (!done)
-            break;  // work started, blocked on PM state machine
+        target = request->getTarget();
+        if (fInvokeAction)
+        {
+            done = (*fInvokeAction)( target, request, this );
+        }
+        else
+        {
+            PM_LOG("PM request 0x%x dropped\n", request->getType());
+            done = true;
+        }
+        if (!done)
+            break;  // PM state machine blocked
+
+        assert(gIOPMBusyRequestCount > 0);
+        if (gIOPMBusyRequestCount)
+            gIOPMBusyRequestCount--;

 
 

-        assert(gIOPMBusyCount > 0);
-               if (gIOPMBusyCount)
-            gIOPMBusyCount--;
+        if (request == fQuiesceRequest)
+        {
+            fQuiesceRequest = 0;
+        }

 
 

-        queue_remove_first(queue, request, IOPMRequest *, fCommandChain);
+        queue_remove_first(requestQueue, request, typeof(request), fCommandChain);

         more |= (*fRetireAction)( target, request, this );
         more |= (*fRetireAction)( target, request, this );

-        done = queue_empty(queue);
+        done = queue_empty(requestQueue);

     } while (!done);
 
     *empty = done;
 
     if (more)
     {
     } while (!done);
 
     *empty = done;
 
     if (more)
     {

-        // Retired request blocks another request, since the
-        // blocked request may reside in the work queue, we
-        // must bump the producer count to avoid work stall.
+        // Retired a request that may unblock a previously visited request
+        // that is still waiting on the work queue. Must trigger another
+        // queue check.

         fProducerCount++;
     }
 
         fProducerCount++;
     }
 


@@ -8272,17 +8512,17 @@ bool IOPMWorkQueue::checkRequestQueue( queue_head_t * queue, bool * empty )
 
 bool IOPMWorkQueue::checkForWork( void )
 {
 
 bool IOPMWorkQueue::checkForWork( void )
 {

-       IOServicePM *   entry;
-       IOServicePM *   next;
-    bool                       more = false;
+    IOServicePM *   entry;
+    IOServicePM *   next;
+    bool            more = false;

     bool            empty;
 
 #if WORK_QUEUE_STATS
     fStatCheckForWork++;
 #endif
 
     bool            empty;
 
 #if WORK_QUEUE_STATS
     fStatCheckForWork++;
 #endif
 

-    // Each producer signal triggers a full iteration over
-    // all IOServicePM entries in the work queue.
+    // Iterate over all IOServicePM entries in the work queue,
+    // and check each entry's request queue.

 
     while (fConsumerCount != fProducerCount)
     {
 
     while (fConsumerCount != fProducerCount)
     {


@@ -8291,38 +8531,38 @@ bool IOPMWorkQueue::checkForWork( void )
 
         fConsumerCount = fProducerCount;
 
 
         fConsumerCount = fProducerCount;
 

-#if WORK_QUEUE_STATS        
+#if WORK_QUEUE_STATS

         if (queue_empty(&fWorkQueue))
         {
             fStatQueueEmpty++;
             break;
         }
         fStatScanEntries++;
         if (queue_empty(&fWorkQueue))
         {
             fStatQueueEmpty++;
             break;
         }
         fStatScanEntries++;

-        uint32_t cachedWorkCount = gIOPMWorkCount;
+        uint32_t cachedWorkCount = gIOPMWorkInvokeCount;

 #endif
 
 #endif
 

-        entry = (IOServicePM *) queue_first(&fWorkQueue);
+        __IGNORE_WCASTALIGN(entry = (typeof(entry)) queue_first(&fWorkQueue));

         while (!queue_end(&fWorkQueue, (queue_entry_t) entry))
         {
             more |= checkRequestQueue(&entry->RequestHead, &empty);
 
             // Get next entry, points to head if current entry is last.
         while (!queue_end(&fWorkQueue, (queue_entry_t) entry))
         {
             more |= checkRequestQueue(&entry->RequestHead, &empty);
 
             // Get next entry, points to head if current entry is last.

-            next = (IOServicePM *) queue_next(&entry->WorkChain);
+            __IGNORE_WCASTALIGN(next = (typeof(next)) queue_next(&entry->WorkChain));

 
 

-            // if request queue is empty, remove IOServicePM from queue.
+            // if request queue is empty, remove IOServicePM from work queue.

             if (empty)
             {
                 assert(fQueueLength);
                 if (fQueueLength) fQueueLength--;
                 PM_LOG3("IOPMWorkQueue: [%u] removed %s@%p from queue\n",
                     fQueueLength, entry->Name, OBFUSCATE(entry));
             if (empty)
             {
                 assert(fQueueLength);
                 if (fQueueLength) fQueueLength--;
                 PM_LOG3("IOPMWorkQueue: [%u] removed %s@%p from queue\n",
                     fQueueLength, entry->Name, OBFUSCATE(entry));

-                queue_remove(&fWorkQueue, entry, IOServicePM *, WorkChain);
+                queue_remove(&fWorkQueue, entry, typeof(entry), WorkChain);

             }
             entry = next;
         }
 
 #if WORK_QUEUE_STATS
             }
             entry = next;
         }
 
 #if WORK_QUEUE_STATS

-        if (cachedWorkCount == gIOPMWorkCount)
+        if (cachedWorkCount == gIOPMWorkInvokeCount)

             fStatNoWorkDone++;
 #endif
     }
             fStatNoWorkDone++;
 #endif
     }


@@ -8333,7 +8573,7 @@ bool IOPMWorkQueue::checkForWork( void )
 void IOPMWorkQueue::signalWorkAvailable( void )
 {
     fProducerCount++;
 void IOPMWorkQueue::signalWorkAvailable( void )
 {
     fProducerCount++;

-       IOEventSource::signalWorkAvailable();
+    IOEventSource::signalWorkAvailable();

 }
 
 void IOPMWorkQueue::incrementProducerCount( void )
 }
 
 void IOPMWorkQueue::incrementProducerCount( void )


@@ -8341,6 +8581,42 @@ void IOPMWorkQueue::incrementProducerCount( void )
     fProducerCount++;
 }
 
     fProducerCount++;
 }
 

+void IOPMWorkQueue::attachQuiesceRequest( IOPMRequest * quiesceRequest )
+{
+    IOServicePM *   entry;
+    IOPMRequest *   request;
+
+    if (queue_empty(&fWorkQueue))
+    {
+        return;
+    }
+
+    queue_iterate(&fWorkQueue, entry, typeof(entry), WorkChain)
+    {
+        queue_iterate(&entry->RequestHead, request, typeof(request), fCommandChain)
+        {
+            // Attach the quiesce request to any request in the queue that
+            // is not linked to a next request. These requests will block
+            // the quiesce request.
+            
+            if (request->isQuiesceBlocker())
+            {
+                request->attachNextRequest(quiesceRequest);
+            }
+        }
+    }
+}
+
+void IOPMWorkQueue::finishQuiesceRequest( IOPMRequest * quiesceRequest )
+{
+    if (fQuiesceRequest && (quiesceRequest == fQuiesceRequest) &&
+        (fQuiesceStartTime != 0))
+    {
+        fInvokeAction = 0;
+        fQuiesceFinishTime = mach_absolute_time();
+    }
+}
+

 // MARK: -
 // MARK: IOPMCompletionQueue
 
 // MARK: -
 // MARK: IOPMCompletionQueue
 


@@ -8353,50 +8629,50 @@ OSDefineMetaClassAndStructors( IOPMCompletionQueue, IOEventSource );
 IOPMCompletionQueue *
 IOPMCompletionQueue::create( IOService * inOwner, Action inAction )
 {
 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 )
 {
 }
 
 bool IOPMCompletionQueue::init( IOService * inOwner, Action inAction )
 {

-       if (!inAction || !IOEventSource::init(inOwner, (IOEventSourceAction)inAction))
+    if (!inAction || !IOEventSource::init(inOwner, (IOEventSourceAction)inAction))

         return false;
 
         return false;
 

-       queue_init(&fQueue);
-       return true;
+    queue_init(&fQueue);
+    return true;

 }
 
 bool IOPMCompletionQueue::queuePMRequest( IOPMRequest * request )
 {
     bool more;
 
 }
 
 bool IOPMCompletionQueue::queuePMRequest( IOPMRequest * request )
 {
     bool more;
 

-       assert(request);
+    assert(request);

     // unblock dependent request
     more = request->detachNextRequest();
     // unblock dependent request
     more = request->detachNextRequest();

-       queue_enter(&fQueue, request, IOPMRequest *, fCommandChain);
+    queue_enter(&fQueue, request, typeof(request), fCommandChain);

     return more;
 }
 
 bool IOPMCompletionQueue::checkForWork( void )
 {
     return more;
 }
 
 bool IOPMCompletionQueue::checkForWork( void )
 {

-    Action                     dqAction = (Action) action;
-       IOPMRequest *   request;
-       IOPMRequest *   next;
-       IOService *             target;
-       bool                    more = false;
+    Action          dqAction = (Action) action;
+    IOPMRequest *   request;
+    IOPMRequest *   next;
+    IOService *     target;
+    bool            more = false;

 
 

-    request = (IOPMRequest *) queue_first(&fQueue);
+    request = (typeof(request)) queue_first(&fQueue);

     while (!queue_end(&fQueue, (queue_entry_t) request))
     {
     while (!queue_end(&fQueue, (queue_entry_t) request))
     {

-        next = (IOPMRequest *) queue_next(&request->fCommandChain);
-               if (!request->isFreeBlocked())
+        next = (typeof(next)) queue_next(&request->fCommandChain);
+        if (!request->isFreeBlocked())

         {
         {

-            queue_remove(&fQueue, request, IOPMRequest *, fCommandChain);
+            queue_remove(&fQueue, request, typeof(request), fCommandChain);

             target = request->getTarget();
             assert(target);
             more |= (*dqAction)( target, request, this );
             target = request->getTarget();
             assert(target);
             more |= (*dqAction)( target, request, this );


@@ -8431,13 +8707,13 @@ setPMProperty( OSDictionary * dict, const char * key, uint64_t value )
 
 IOReturn IOServicePM::gatedSerialize( OSSerialize * s  ) const
 {
 
 IOReturn IOServicePM::gatedSerialize( OSSerialize * s  ) const
 {

-       OSDictionary *  dict;
-       bool                    ok = false;
+    OSDictionary *  dict;
+    bool            ok = false;

     int             powerClamp = -1;
     int             powerClamp = -1;

-       int                             dictSize = 5;
+    int             dictSize = 6;

 
 

-       if (IdleTimerPeriod)
-               dictSize += 4;
+    if (IdleTimerPeriod)
+        dictSize += 4;

 
     if (PMActions.parameter & kPMActionsFlagLimitPower)
     {
 
     if (PMActions.parameter & kPMActionsFlagLimitPower)
     {


@@ -8459,9 +8735,10 @@ IOReturn IOServicePM::gatedSerialize( OSSerialize * s  ) const
     else
         dict = OSDictionary::withCapacity(dictSize);
 
     else
         dict = OSDictionary::withCapacity(dictSize);
 

-       if (dict)
-       {
+    if (dict)
+    {

         setPMProperty(dict, "CurrentPowerState", CurrentPowerState);
         setPMProperty(dict, "CurrentPowerState", CurrentPowerState);

+        setPMProperty(dict, "CapabilityFlags", CurrentCapabilityFlags);

         if (NumberOfPowerStates)
             setPMProperty(dict, "MaxPowerState", NumberOfPowerStates-1);
         if (DesiredPowerState != CurrentPowerState)
         if (NumberOfPowerStates)
             setPMProperty(dict, "MaxPowerState", NumberOfPowerStates-1);
         if (DesiredPowerState != CurrentPowerState)


@@ -8473,38 +8750,38 @@ IOReturn IOServicePM::gatedSerialize( OSSerialize * s  ) const
         if (powerClamp >= 0)
             setPMProperty(dict, "PowerClamp", powerClamp);
 
         if (powerClamp >= 0)
             setPMProperty(dict, "PowerClamp", powerClamp);
 

-               if (IdleTimerPeriod)
-               {
+        if (IdleTimerPeriod)
+        {

             AbsoluteTime    now;
             AbsoluteTime    delta;
             uint64_t        nsecs;
 
             clock_get_uptime(&now);
 
             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))
             {
             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));
             }
 
                 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);
                 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)
 
 #if WORK_QUEUE_STATS
         if (gIOPMRootNode == Owner)


@@ -8526,11 +8803,11 @@ IOReturn IOServicePM::gatedSerialize( OSSerialize * s  ) const
             dict->removeObject(gIOPMPowerClientAdvisoryTickle);
         }
 
             dict->removeObject(gIOPMPowerClientAdvisoryTickle);
         }
 

-               ok = dict->serialize(s);
-               dict->release();
-       }
+        ok = dict->serialize(s);
+        dict->release();
+    }

 
 

-       return (ok ? kIOReturnSuccess : kIOReturnNoMemory);
+    return (ok ? kIOReturnSuccess : kIOReturnNoMemory);

 }
 
 bool IOServicePM::serialize( OSSerialize * s ) const
 }
 
 bool IOServicePM::serialize( OSSerialize * s ) const


@@ -8544,11 +8821,11 @@ bool IOServicePM::serialize( OSSerialize * s ) const
        ret = gatedSerialize(s);
     }
     else if (gIOPMWorkLoop)
        ret = gatedSerialize(s);
     }
     else if (gIOPMWorkLoop)

-       {
-               ret = gIOPMWorkLoop->runAction(
+    {
+        ret = gIOPMWorkLoop->runAction(

             OSMemberFunctionCast(IOWorkLoop::Action, this, &IOServicePM::gatedSerialize),
             (OSObject *) this, (void *) s);
             OSMemberFunctionCast(IOWorkLoop::Action, this, &IOServicePM::gatedSerialize),
             (OSObject *) this, (void *) s);

-       }
+    }

 
     return (kIOReturnSuccess == ret);
 }
 
     return (kIOReturnSuccess == ret);
 }


@@ -8563,87 +8840,19 @@ void IOServicePM::pmPrint(
 
 void IOServicePM::pmTrace(
     uint32_t        event,
 
 void IOServicePM::pmTrace(
     uint32_t        event,

+    uint32_t        eventFunc,

     uintptr_t       param1,
     uintptr_t       param2 ) const
 {
     uintptr_t       param1,
     uintptr_t       param2 ) const
 {

-    const char *  who = Name;
-    uint64_t    regId = Owner->getRegistryEntryID();
-    uintptr_t    name = 0;
-
-    static const uint32_t sStartStopBitField[] =
-    { 0x00000000, 0x00000040 }; // Only Program Hardware so far
-
-    // Arcane formula from Hacker's Delight by Warren
-    // abs(x)  = ((int) x >> 31) ^ (x + ((int) x >> 31))
-    uint32_t sgnevent = ((int) event >> 31);
-    uint32_t absevent = sgnevent ^ (event + sgnevent);
-    uint32_t code     = IODBG_POWER(absevent);
-
-    uint32_t bit = 1 << (absevent & 0x1f);
-    if ((absevent < (sizeof(sStartStopBitField) * 8)) &&
-        (sStartStopBitField[absevent >> 5] & bit))
-    {
-        // Or in the START or END bits, Start = 1 & END = 2
-        //      If sgnevent ==  0 then START -  0 => START
-        // else if sgnevent == -1 then START - -1 => END
-        code |= DBG_FUNC_START - sgnevent;
-    }
-
-    // Copy the first characters of the name into an uintptr_t
-    for (uint32_t i = 0; (i < sizeof(uintptr_t) && who[i] != 0); i++)
-    {
-        ((char *) &name)[sizeof(uintptr_t) - i - 1] = who[i];
-    }
-
-    IOTimeStampConstant(code, name, (uintptr_t) regId, param1, param2);
-}
-
-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;
+    uintptr_t nameAsArg = 0;
+
+    assert(event < KDBG_CODE_MAX);
+    assert((eventFunc & ~KDBG_FUNC_MASK) == 0);
+
+    // Copy the first characters of the name into an uintptr_t.
+    // NULL termination is not required.
+    strncpy((char*)&nameAsArg, Name, sizeof(nameAsArg));
+
+    IOTimeStampConstant(IODBG_POWER(event) | eventFunc, nameAsArg, (uintptr_t)Owner->getRegistryEntryID(), (uintptr_t)(OBFUSCATE(param1)), (uintptr_t)(OBFUSCATE(param2)));

 }
 
 }