Loading...
--- xnu/xnu-12377.101.15/iokit/Kernel/IOServicePM.cpp
+++ xnu/xnu-201/iokit/Kernel/IOServicePM.cpp
@@ -1,1393 +1,721 @@
/*
- * Copyright (c) 1998-2020 Apple Inc. All rights reserved.
+ * Copyright (c) 1998-2000 Apple Computer, Inc. All rights reserved.
*
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
+ * @APPLE_LICENSE_HEADER_START@
+ *
+ * The contents of this file constitute Original Code as defined in and
+ * are subject to the Apple Public Source License Version 1.1 (the
+ * "License"). You may not use this file except in compliance with the
+ * License. Please obtain a copy of the License at
+ * http://www.apple.com/publicsource and read it before using this file.
+ *
+ * This Original Code and all software distributed under the License are
+ * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
+ * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
+ * License for the specific language governing rights and limitations
+ * under the License.
+ *
+ * @APPLE_LICENSE_HEADER_END@
*/
-
+
+#include <IOKit/IOService.h>
+#include <IOKit/IOLib.h>
+#include <IOKit/IOCommandQueue.h>
+#include <IOKit/IOCommandGate.h>
+#include <IOKit/IOTimerEventSource.h>
+#include <IOKit/IOWorkLoop.h>
+#include <IOKit/IOPlatformExpert.h>
#include <IOKit/assert.h>
-#include <IOKit/IOKitDebug.h>
-#include <IOKit/IOLib.h>
#include <IOKit/IOMessage.h>
-#include <IOKit/IOPlatformExpert.h>
-#include <IOKit/IOService.h>
-#include <IOKit/IOUserServer.h>
-#include <IOKit/IOEventSource.h>
-#include <IOKit/IOWorkLoop.h>
-#include <IOKit/IOCommand.h>
-#include <IOKit/IOTimeStamp.h>
-#include <IOKit/IOReportMacros.h>
-#include <IOKit/IODeviceTreeSupport.h>
-#include <IOKit/IOKitKeysPrivate.h>
-
-#include <IOKit/pwr_mgt/IOPMlog.h>
#include <IOKit/pwr_mgt/IOPMinformee.h>
-#include <IOKit/pwr_mgt/IOPMinformeeList.h>
-#include <IOKit/pwr_mgt/IOPowerConnection.h>
-#include <IOKit/pwr_mgt/RootDomain.h>
-#include <IOKit/pwr_mgt/IOPMPrivate.h>
-
-#include <sys/proc.h>
-#include <sys/proc_internal.h>
-#include <sys/sysctl.h>
-#include <libkern/OSDebug.h>
-#include <kern/thread.h>
-#if DEVELOPMENT || DEBUG
-#include <os/system_event_log.h>
-#endif /* DEVELOPMENT || DEBUG */
-
-// Required for notification instrumentation
-#include "IOServicePrivate.h"
-#include "IOServicePMPrivate.h"
-#include "IOKitKernelInternal.h"
-
-#if USE_SETTLE_TIMER
-static void settle_timer_expired(thread_call_param_t, thread_call_param_t);
-#endif
-static void idle_timer_expired(thread_call_param_t, thread_call_param_t);
-static void tellKernelClientApplier(OSObject * object, void * arg);
-static void tellAppClientApplier(OSObject * object, void * arg);
-static const char * getNotificationPhaseString(uint32_t phase);
-
-static uint64_t
-computeTimeDeltaNS( const AbsoluteTime * start )
-{
- AbsoluteTime now;
- uint64_t nsec;
-
- clock_get_uptime(&now);
- SUB_ABSOLUTETIME(&now, start);
- absolutetime_to_nanoseconds(now, &nsec);
- return nsec;
-}
-
-#if PM_VARS_SUPPORT
-OSDefineMetaClassAndStructors(IOPMprot, OSObject)
-#endif
-
-//******************************************************************************
-// Globals
-//******************************************************************************
-
-static bool gIOPMInitialized = false;
-static uint32_t gIOPMBusyRequestCount = 0;
-static uint32_t gIOPMWorkInvokeCount = 0;
-static uint32_t gIOPMTickleGeneration = 0;
-static IOWorkLoop * gIOPMWorkLoop = NULL;
-static IOPMRequestQueue * gIOPMRequestQueue = NULL;
-static IOPMRequestQueue * gIOPMReplyQueue = NULL;
-static IOPMWorkQueue * gIOPMWorkQueue = NULL;
-static IOPMCompletionQueue * gIOPMCompletionQueue = NULL;
-static IOPMRequest * gIOPMRequest = NULL;
-static IOService * gIOPMRootNode = NULL;
-static IOPlatformExpert * gPlatform = NULL;
-static IOLock * gIOPMInitLock = NULL;
-
-// log setPowerStates and powerStateChange longer than (ns):
-static uint64_t gIOPMSetPowerStateLogNS =
-#if defined(__i386__) || defined(__x86_64__)
- (300ULL * 1000ULL * 1000ULL)
-#else
- (50ULL * 1000ULL * 1000ULL)
-#endif
-;
-
-const OSSymbol * gIOPMPowerClientDevice = NULL;
-const OSSymbol * gIOPMPowerClientDriver = NULL;
-const OSSymbol * gIOPMPowerClientChildProxy = NULL;
-const OSSymbol * gIOPMPowerClientChildren = NULL;
-const OSSymbol * gIOPMPowerClientRootDomain = NULL;
-
-static const OSSymbol * gIOPMPowerClientAdvisoryTickle = NULL;
-static bool gIOPMAdvisoryTickleEnabled = true;
-static thread_t gIOPMWatchDogThread = NULL;
-TUNABLE_WRITEABLE(uint32_t, gSleepAckTimeout, "pmtimeout", 0);
+#include "IOKit/pwr_mgt/IOPMinformeeList.h"
+#include "IOKit/pwr_mgt/IOPMchangeNoteList.h"
+#include "IOKit/pwr_mgt/IOPMlog.h"
+#include "IOKit/pwr_mgt/IOPowerConnection.h"
+#include <kern/clock.h>
+
+#define super IORegistryEntry
+
+static void ack_timer_expired(thread_call_param_t);
+static void settle_timer_expired(thread_call_param_t);
+void PMreceiveCmd ( OSObject *, void *, void *, void *, void * );
+static void PM_idle_timer_expired(OSObject *, IOTimerEventSource *);
+static void c_PM_Clamp_Timer_Expired (OSObject * client,IOTimerEventSource *);
+void tellAppWithResponse ( OSObject * object, void * context);
+void tellClientWithResponse ( OSObject * object, void * context);
+void tellClient ( OSObject * object, void * context);
+IOReturn serializedAllowPowerChange ( OSObject *, void *, void *, void *, void *);
+IOReturn serializedCancelPowerChange ( OSObject *, void *, void *, void *, void *);
+
+extern const IORegistryPlane * gIOPowerPlane;
+
+
+// and there's 1000 nanoseconds in a microsecond:
+#define ns_per_us 1000
+
+
+// The current change note is processed by a state machine.
+// Inputs are acks from interested parties, ack from the controlling driver,
+// ack timeouts, settle timeout, and powerStateDidChange from the parent.
+// These are the states:
+
+enum {
+ IOPMour_prechange_03 = 1,
+ IOPMour_prechange_04,
+ IOPMour_prechange_05,
+ IOPMour_prechange_1,
+ IOPMour_prechange_2,
+ IOPMour_prechange_3,
+ IOPMour_prechange_4,
+ IOPMparent_down_0,
+ IOPMparent_down_05,
+ IOPMparent_down_2,
+ IOPMparent_down_3,
+ IOPMparent_down_4,
+ IOPMparent_down_5,
+ IOPMparent_down_6,
+ IOPMparent_up_0,
+ IOPMparent_up_1,
+ IOPMparent_up_4,
+ IOPMparent_up_5,
+ IOPMparent_up_6,
+ IOPMfinished
+ };
+
+enum { // values of outofbandparameter
+ kNotifyApps,
+ kNotifyPriority
+};
+
+struct context { // used for applyToInterested
+ OSArray * responseFlags;
+ UInt16 serialNumber;
+ UInt16 counter;
+ UInt32 maxTimeRequested;
+ int msgType;
+ IOService * us;
+ IOLock * flags_lock;
+ unsigned long stateNumber;
+ IOPMPowerFlags stateFlags;
+};
+
+ // five minutes in microseconds
+#define FIVE_MINUTES 5*60*1000000
+#define k30seconds 30*1000000
/*
- * While waiting for a driver callout to complete, we log any instances
- * that have taken longer than the below period (in milliseconds) to return.
- */
-TUNABLE_WRITEABLE(uint32_t, gDriverCalloutTimer, "pmcallouttimer", 2000);
-
-static uint32_t
-getPMRequestType( void )
-{
- uint32_t type = kIOPMRequestTypeInvalid;
- if (gIOPMRequest) {
- type = gIOPMRequest->getType();
- }
- return type;
-}
-
-SYSCTL_UINT(_kern, OID_AUTO, pmtimeout, CTLFLAG_RW | CTLFLAG_LOCKED, &gSleepAckTimeout, 0, "Power Management Timeout");
-SYSCTL_UINT(_kern, OID_AUTO, pmcallouttimer, CTLFLAG_RW | CTLFLAG_LOCKED, &gDriverCalloutTimer, 0, "Power Management Driver Callout Log Timer");
-
-//******************************************************************************
-// Macros
-//******************************************************************************
-
-#define PM_ERROR(x...) do { kprintf(x);IOLog(x); \
- } while (false)
-#define PM_LOG(x...) do { kprintf(x); } while (false)
-
-#define PM_LOG1(x...) do { \
- if (kIOLogDebugPower & gIOKitDebug) \
- kprintf(x); } while (false)
-
-#define PM_LOG2(x...) do { \
- if (kIOLogDebugPower & gIOKitDebug) \
- kprintf(x); } while (false)
-
-#if 0
-#define PM_LOG3(x...) do { kprintf(x); } while (false)
-#else
-#define PM_LOG3(x...)
-#endif
-
-#define RD_LOG(x...) do { \
- if ((kIOLogPMRootDomain & gIOKitDebug) && \
- (getPMRootDomain() == this)) { \
- IOLog("PMRD: " x); \
- }} while (false)
-#define PM_ASSERT_IN_GATE(x) \
-do { \
- assert(gIOPMWorkLoop->inGate()); \
-} while(false)
-
-#define PM_LOCK() IOLockLock(fPMLock)
-#define PM_UNLOCK() IOLockUnlock(fPMLock)
-#define PM_LOCK_SLEEP(event, dl) IOLockSleepDeadline(fPMLock, event, dl, THREAD_UNINT)
-#define PM_LOCK_WAKEUP(event) IOLockWakeup(fPMLock, event, false)
-
-#define us_per_s 1000000
-#define ns_per_us 1000
-#define k30Seconds (30*us_per_s)
-#define k5Seconds ( 5*us_per_s)
-#define k7Seconds ( 7*us_per_s)
-#if !defined(XNU_TARGET_OS_OSX)
-#define kCanSleepMaxTimeReq k5Seconds
-#define kWillSleepMaxTimeReq k7Seconds
-#else /* defined(XNU_TARGET_OS_OSX) */
-#define kCanSleepMaxTimeReq k30Seconds
-#define kWillSleepMaxTimeReq k30Seconds
-#endif /* defined(XNU_TARGET_OS_OSX) */
-#define kMaxTimeRequested k30Seconds
-#define kMinAckTimeoutTicks (10*1000000)
-#define kIOPMTardyAckSPSKey "IOPMTardyAckSetPowerState"
-#define kIOPMTardyAckPSCKey "IOPMTardyAckPowerStateChange"
-#define kPwrMgtKey "IOPowerManagement"
-
-#define OUR_PMLog(t, a, b) do { \
- if (pwrMgt) { \
- if (gIOKitDebug & kIOLogPower) \
- pwrMgt->pmPrint(t, a, b); \
- if (gIOKitTrace & kIOTracePowerMgmt) \
- pwrMgt->pmTrace(t, DBG_FUNC_NONE, a, b); \
- } \
- } while(0)
-
-#define OUR_PMLogFuncStart(t, a, b) do { \
- if (pwrMgt) { \
- if (gIOKitDebug & kIOLogPower) \
- pwrMgt->pmPrint(t, a, b); \
- if (gIOKitTrace & kIOTracePowerMgmt) \
- pwrMgt->pmTrace(t, DBG_FUNC_START, a, b); \
- } \
- } while(0)
-
-#define OUR_PMLogFuncEnd(t, a, b) do { \
- if (pwrMgt) { \
- if (gIOKitDebug & kIOLogPower) \
- pwrMgt->pmPrint(-t, a, b); \
- if (gIOKitTrace & kIOTracePowerMgmt) \
- pwrMgt->pmTrace(t, DBG_FUNC_END, a, b); \
- } \
- } while(0)
-
-#define NS_TO_MS(nsec) ((int)((nsec) / 1000000ULL))
-#define NS_TO_US(nsec) ((int)((nsec) / 1000ULL))
-
-#define SUPPORT_IDLE_CANCEL 1
-
-#define kIOPMPowerStateMax 0xFFFFFFFF
-#define kInvalidTicklePowerState kIOPMPowerStateMax
-
-#define kNoTickleCancelWindow (60ULL * 1000ULL * 1000ULL * 1000ULL)
-
-#define IS_PM_ROOT (this == gIOPMRootNode)
-#define IS_ROOT_DOMAIN (getPMRootDomain() == this)
-#define IS_POWER_DROP (StateOrder(fHeadNotePowerState) < StateOrder(fCurrentPowerState))
-#define IS_POWER_RISE (StateOrder(fHeadNotePowerState) > StateOrder(fCurrentPowerState))
-
-// log app responses longer than (ns):
-#define LOG_APP_RESPONSE_TIMES (100ULL * 1000ULL * 1000ULL)
-// use message tracer to log messages longer than (ns):
-#define LOG_APP_RESPONSE_MSG_TRACER (3 * 1000ULL * 1000ULL * 1000ULL)
-
-// log kext responses longer than (ns):
-#define LOG_KEXT_RESPONSE_TIMES (100ULL * 1000ULL * 1000ULL)
-
-enum {
- kReserveDomainPower = 1
-};
-
-#define MS_PUSH(n) \
- do { assert(kIOPM_BadMachineState == fSavedMachineState); \
- assert(kIOPM_BadMachineState != n); \
- fSavedMachineState = n; } while (false)
-
-#define MS_POP() \
- do { assert(kIOPM_BadMachineState != fSavedMachineState); \
- fMachineState = fSavedMachineState; \
- fSavedMachineState = kIOPM_BadMachineState; } while (false)
-
-#define PM_ACTION_TICKLE(a) \
- do { if (fPMActions.a) { \
- (fPMActions.a)(fPMActions.target, this, &fPMActions); } \
- } while (false)
-
-#define PM_ACTION_CHANGE(a, x, y) \
- do { if (fPMActions.a) { \
- (fPMActions.a)(fPMActions.target, this, &fPMActions, gIOPMRequest, x, y); } \
- } while (false)
-
-#define PM_ACTION_CLIENT(a, x, y, z) \
- do { if (fPMActions.a) { \
- (fPMActions.a)(fPMActions.target, this, &fPMActions, x, y, z); } \
- } while (false)
-
-static OSNumber * copyClientIDForNotification(
- OSObject *object,
- IOPMInterestContext *context);
-
-static void logClientIDForNotification(
- OSObject *object,
- IOPMInterestContext *context,
- const char *logString);
-
-//*********************************************************************************
-// PM machine states
-//
-// Check kgmacros after modifying machine states.
-//*********************************************************************************
-
-enum {
- kIOPM_Finished = 0,
-
- kIOPM_OurChangeTellClientsPowerDown = 1,
- kIOPM_OurChangeTellUserPMPolicyPowerDown = 2,
- kIOPM_OurChangeTellPriorityClientsPowerDown = 3,
- kIOPM_OurChangeNotifyInterestedDriversWillChange = 4,
- kIOPM_OurChangeSetPowerState = 5,
- kIOPM_OurChangeWaitForPowerSettle = 6,
- kIOPM_OurChangeNotifyInterestedDriversDidChange = 7,
- kIOPM_OurChangeTellCapabilityDidChange = 8,
- kIOPM_OurChangeFinish = 9,
-
- kIOPM_ParentChangeTellPriorityClientsPowerDown = 10,
- kIOPM_ParentChangeNotifyInterestedDriversWillChange = 11,
- kIOPM_ParentChangeSetPowerState = 12,
- kIOPM_ParentChangeWaitForPowerSettle = 13,
- kIOPM_ParentChangeNotifyInterestedDriversDidChange = 14,
- kIOPM_ParentChangeTellCapabilityDidChange = 15,
- kIOPM_ParentChangeAcknowledgePowerChange = 16,
-
- kIOPM_NotifyChildrenStart = 17,
- kIOPM_NotifyChildrenOrdered = 18,
- kIOPM_NotifyChildrenDelayed = 19,
- kIOPM_SyncTellClientsPowerDown = 20,
- kIOPM_SyncTellPriorityClientsPowerDown = 21,
- kIOPM_SyncNotifyWillChange = 22,
- kIOPM_SyncNotifyDidChange = 23,
- kIOPM_SyncTellCapabilityDidChange = 24,
- kIOPM_SyncFinish = 25,
- kIOPM_TellCapabilityChangeDone = 26,
- kIOPM_DriverThreadCallDone = 27,
-
- kIOPM_BadMachineState = 0xFFFFFFFF
-};
-
-//*********************************************************************************
-// [private static] allocPMInitLock
-//
-// Allocate gIOPMInitLock prior to gIOPMWorkLoop initialization.
-//*********************************************************************************
-
-void
-IOService::allocPMInitLock( void )
-{
- gIOPMInitLock = IOLockAlloc();
- assert(gIOPMInitLock);
-}
-
-//*********************************************************************************
-// [public] PMinit
-//
-// Initialize power management.
-//*********************************************************************************
-
-void
-IOService::PMinit( void )
-{
- if (!initialized) {
- IOLockLock(gIOPMInitLock);
- if (!gIOPMInitialized) {
- gPlatform = getPlatform();
- gIOPMWorkLoop = IOWorkLoop::workLoop();
- if (gIOPMWorkLoop) {
- assert(OSDynamicCast(IOPMrootDomain, this));
- gIOPMRequestQueue = IOPMRequestQueue::create(
- this, OSMemberFunctionCast(IOPMRequestQueue::Action,
- this, &IOService::actionPMRequestQueue));
-
- gIOPMReplyQueue = IOPMRequestQueue::create(
- this, OSMemberFunctionCast(IOPMRequestQueue::Action,
- this, &IOService::actionPMReplyQueue));
-
- gIOPMWorkQueue = IOPMWorkQueue::create(this,
- OSMemberFunctionCast(IOPMWorkQueue::Action, this,
- &IOService::actionPMWorkQueueInvoke),
- OSMemberFunctionCast(IOPMWorkQueue::Action, this,
- &IOService::actionPMWorkQueueRetire));
-
- gIOPMCompletionQueue = IOPMCompletionQueue::create(
- this, OSMemberFunctionCast(IOPMCompletionQueue::Action,
- this, &IOService::actionPMCompletionQueue));
-
- if (gIOPMWorkLoop->addEventSource(gIOPMRequestQueue) !=
- kIOReturnSuccess) {
- gIOPMRequestQueue->release();
- gIOPMRequestQueue = NULL;
- }
-
- if (gIOPMWorkLoop->addEventSource(gIOPMReplyQueue) !=
- kIOReturnSuccess) {
- gIOPMReplyQueue->release();
- gIOPMReplyQueue = NULL;
- }
-
- if (gIOPMWorkLoop->addEventSource(gIOPMWorkQueue) !=
- kIOReturnSuccess) {
- gIOPMWorkQueue->release();
- gIOPMWorkQueue = NULL;
- }
-
- // Must be added after the work queue, which pushes request
- // to the completion queue without signaling the work loop.
- if (gIOPMWorkLoop->addEventSource(gIOPMCompletionQueue) !=
- kIOReturnSuccess) {
- gIOPMCompletionQueue->release();
- gIOPMCompletionQueue = NULL;
- }
-
- gIOPMPowerClientDevice =
- OSSymbol::withCStringNoCopy( "DevicePowerState" );
-
- gIOPMPowerClientDriver =
- OSSymbol::withCStringNoCopy( "DriverPowerState" );
-
- gIOPMPowerClientChildProxy =
- OSSymbol::withCStringNoCopy( "ChildProxyPowerState" );
-
- gIOPMPowerClientChildren =
- OSSymbol::withCStringNoCopy( "ChildrenPowerState" );
-
- gIOPMPowerClientAdvisoryTickle =
- OSSymbol::withCStringNoCopy( "AdvisoryTicklePowerState" );
-
- gIOPMPowerClientRootDomain =
- OSSymbol::withCStringNoCopy( "RootDomainPower" );
- }
-
- if (gIOPMRequestQueue && gIOPMReplyQueue && gIOPMCompletionQueue) {
- gIOPMInitialized = true;
- }
-
-#if (DEVELOPMENT || DEBUG)
- uint32_t setPowerStateLogMS = 0;
- if (PE_parse_boot_argn("setpowerstate_log", &setPowerStateLogMS, sizeof(setPowerStateLogMS))) {
- gIOPMSetPowerStateLogNS = setPowerStateLogMS * 1000000ULL;
- }
-#endif
- }
-
- IOLockUnlock(gIOPMInitLock);
-
- if (!gIOPMInitialized) {
- return;
- }
-
- pwrMgt = new IOServicePM;
- pwrMgt->init();
- setProperty(kPwrMgtKey, pwrMgt);
-
- queue_init(&pwrMgt->WorkChain);
- queue_init(&pwrMgt->RequestHead);
- queue_init(&pwrMgt->PMDriverCallQueue);
-
- fOwner = this;
- fPMLock = IOLockAlloc();
- fInterestedDrivers = new IOPMinformeeList;
- fInterestedDrivers->initialize();
- fDesiredPowerState = kPowerStateZero;
- fDeviceDesire = kPowerStateZero;
- fInitialPowerChange = true;
- fInitialSetPowerState = true;
- fPreviousRequestPowerFlags = 0;
- fDeviceOverrideEnabled = false;
- fMachineState = kIOPM_Finished;
- fSavedMachineState = kIOPM_BadMachineState;
- fIdleTimerMinPowerState = kPowerStateZero;
- fActivityLock = IOLockAlloc();
- fStrictTreeOrder = false;
- fActivityTicklePowerState = kInvalidTicklePowerState;
- fAdvisoryTicklePowerState = kInvalidTicklePowerState;
- fControllingDriver = NULL;
- fPowerStates = NULL;
- fNumberOfPowerStates = 0;
- fCurrentPowerState = kPowerStateZero;
- fParentsCurrentPowerFlags = 0;
- fMaxPowerState = kPowerStateZero;
- fName = getName();
- fParentsKnowState = false;
- fSerialNumber = 0;
- fResponseArray = NULL;
- fNotifyClientArray = NULL;
- fCurrentPowerConsumption = kIOPMUnknown;
- fOverrideMaxPowerState = kIOPMPowerStateMax;
-
- if (!gIOPMRootNode && (getParentEntry(gIOPowerPlane) == getRegistryRoot())) {
- gIOPMRootNode = this;
- fParentsKnowState = true;
- } else if (getProperty(kIOPMResetPowerStateOnWakeKey) == kOSBooleanTrue) {
- fResetPowerStateOnWake = true;
- }
-
- if (IS_ROOT_DOMAIN) {
- fWatchdogTimer = thread_call_allocate(
- &IOService::watchdog_timer_expired, (thread_call_param_t)this);
- fWatchdogLock = IOLockAlloc();
-
- fBlockedArray = OSArray::withCapacity(4);
- }
-
- fAckTimer = thread_call_allocate(
- &IOService::ack_timer_expired, (thread_call_param_t)this);
-#if USE_SETTLE_TIMER
- fSettleTimer = thread_call_allocate(
- &settle_timer_expired, (thread_call_param_t)this);
-#endif
- fIdleTimer = thread_call_allocate(
- &idle_timer_expired, (thread_call_param_t)this);
- fDriverCallTimer = thread_call_allocate(
- &IOService::pmDriverCalloutTimer, (thread_call_param_t)this);
- fDriverCallEntry = thread_call_allocate(
- (thread_call_func_t) &IOService::pmDriverCallout, this);
- assert(fDriverCallEntry);
-
- // Check for powerChangeDone override.
- if (OSMemberFunctionCast(void (*)(void),
- getResourceService(), &IOService::powerChangeDone) !=
- OSMemberFunctionCast(void (*)(void),
- this, &IOService::powerChangeDone)) {
- fPCDFunctionOverride = true;
- }
-
-#if PM_VARS_SUPPORT
- IOPMprot * prot = new IOPMprot;
- if (prot) {
- prot->init();
- prot->ourName = fName;
- prot->thePlatform = gPlatform;
- fPMVars = prot;
- pm_vars = prot;
- }
-#else
- pm_vars = (void *) (uintptr_t) true;
-#endif
-
- initialized = true;
- }
-}
-
-//*********************************************************************************
-// [private] PMfree
-//
-// Free the data created by PMinit. Only called from IOService::free().
-//*********************************************************************************
-
-void
-IOService::PMfree( void )
-{
- initialized = false;
- pm_vars = NULL;
-
- if (pwrMgt) {
- assert(fMachineState == kIOPM_Finished);
- assert(fInsertInterestSet == NULL);
- assert(fRemoveInterestSet == NULL);
- assert(fNotifyChildArray == NULL);
- assert(queue_empty(&pwrMgt->RequestHead));
- assert(queue_empty(&fPMDriverCallQueue));
-
- if (fWatchdogTimer) {
- thread_call_cancel(fWatchdogTimer);
- thread_call_free(fWatchdogTimer);
- fWatchdogTimer = NULL;
- }
-
- if (fWatchdogLock) {
- IOLockFree(fWatchdogLock);
- fWatchdogLock = NULL;
- }
-
- if (fBlockedArray) {
- fBlockedArray->release();
- fBlockedArray = NULL;
- }
-#if USE_SETTLE_TIMER
- if (fSettleTimer) {
- thread_call_cancel(fSettleTimer);
- thread_call_free(fSettleTimer);
- fSettleTimer = NULL;
- }
-#endif
- if (fAckTimer) {
- thread_call_cancel(fAckTimer);
- thread_call_free(fAckTimer);
- fAckTimer = NULL;
- }
- if (fIdleTimer) {
- thread_call_cancel(fIdleTimer);
- thread_call_free(fIdleTimer);
- fIdleTimer = NULL;
- }
- if (fDriverCallEntry) {
- thread_call_free(fDriverCallEntry);
- fDriverCallEntry = NULL;
- }
- if (fDriverCallTimer) {
- thread_call_free(fDriverCallTimer);
- fDriverCallTimer = NULL;
- }
- if (fPMLock) {
- IOLockFree(fPMLock);
- fPMLock = NULL;
- }
- if (fActivityLock) {
- IOLockFree(fActivityLock);
- fActivityLock = NULL;
- }
- if (fInterestedDrivers) {
- fInterestedDrivers->release();
- fInterestedDrivers = NULL;
- }
- if (fDriverCallParamSlots && fDriverCallParamPtr) {
- IODelete(fDriverCallParamPtr, DriverCallParam, fDriverCallParamSlots);
- fDriverCallParamPtr = NULL;
- fDriverCallParamSlots = 0;
- }
- if (fResponseArray) {
- fResponseArray->release();
- fResponseArray = NULL;
- }
- if (fNotifyClientArray) {
- fNotifyClientArray->release();
- fNotifyClientArray = NULL;
- }
- if (fReportBuf && fNumberOfPowerStates) {
- IOFreeData(fReportBuf, STATEREPORT_BUFSIZE(fNumberOfPowerStates));
- fReportBuf = NULL;
- }
- if (fPowerStates && fNumberOfPowerStates) {
- IODeleteData(fPowerStates, IOPMPSEntry, fNumberOfPowerStates);
- fNumberOfPowerStates = 0;
- fPowerStates = NULL;
- }
- if (fPowerClients) {
- fPowerClients->release();
- fPowerClients = NULL;
- }
-
-#if PM_VARS_SUPPORT
- if (fPMVars) {
- fPMVars->release();
- fPMVars = NULL;
- }
-#endif
-
- pwrMgt->release();
- pwrMgt = NULL;
- }
-}
-
-void
-IOService::PMDebug( uint32_t event, uintptr_t param1, uintptr_t param2 )
-{
- OUR_PMLog(event, param1, param2);
-}
-
-//*********************************************************************************
-// [public] joinPMtree
+ There are two different kinds of power state changes. One is initiated by a subclassed device object which has either
+ decided to change power state, or its controlling driver has suggested it, or some other driver wants to use the
+ idle device and has asked it to become usable. The second kind of power state change is initiated by the power
+ domain parent. The two are handled slightly differently.
+
+There is a queue of so-called change notifications, or change notes for short. Usually the queue is empty, and when
+ it isn't, usually there is one change note in it, but since it's possible to have more than one power state change pending
+ at one time, a queue is implemented. Example: the subclass device decides it's idle and initiates a change to a lower
+ power state. This causes interested parties to be notified, but they don't all acknowledge right away. This causes the
+ change note to sit in the queue until all the acks are received. During this time, the device decides it isn't idle anymore and
+ wants to raise power back up again. This change can't be started, however, because the previous one isn't complete yet,
+ so the second one waits in the queue. During this time, the parent decides to lower or raise the power state of the entire
+ power domain and notifies the device, and that notification goes into the queue, too, and can't be actioned until the
+ others are.
+
+ This is how a power change initiated by the subclass device is handled:
+ First, all interested parties are notified of the change via their powerStateWillChangeTo method. If they all don't
+ acknowledge via return code, then we have to wait. If they do, or when they finally all acknowledge via our
+ acknowledgePowerChange method, then we can continue. We call the controlling driver, instructing it to change to
+ the new state. Then we wait for power to settle. If there is no settling-time, or after it has passed, we notify
+ interested parties again, this time via their powerStateDidChangeTo methods. When they have all acked, we're done.
+ If we lowered power and don't need the power domain to be in its current power state, we suggest to the parent that
+ it lower the power domain state.
+
+ This is how a change to a lower power domain state initiated by the parent is handled:
+ First, we figure out what power state we will be in when the new domain state is reached. Then all interested parties are
+ notified that we are moving to that new state. When they have acknowledged, we call the controlling driver to assume
+ that state and we wait for power to settle. Then we acknowledge our preparedness to our parent. When all its interested
+ parties have acknowledged, it lowers power and then notifies its interested parties again. When we get this call, we notify
+ our interested parties that the power state has changed, and when they have all acknowledged, we're done.
+
+ This is how a change to a higher power domain state initiated by the parent is handled:
+ We figure out what power state we will be in when the new domain state is reached. If it is different from our current
+ state we acknowledge the parent. When all the parent's interested parties have acknowledged, it raises power in the
+domain and waits for power to settle. Then it notifies everyone that the new state has been reached. When we get this call,
+ we call the controlling driver, instructing it to assume the new state, and wait for power to settle. Then we notify our interested
+ parties. When they all acknowledge we are done.
+
+ In either of the two cases above, it is possible that we will not be changing state even though the domain is. Examples:
+ A change to a lower domain state may not affect us because we are already in a low enough state, and
+ We will not take advantage of a change to a higher domain state, because we have no need of the higher power.
+ In such a case, there is nothing to do but acknowledge the parent. So when the parent calls our powerDomainWillChange
+ method, and we decide that we will not be changing state, we merely acknowledge the parent, via return code, and wait.
+ When the parent subsequently calls powerStateDidChange, we acknowledge again via return code, and the change is complete.
+
+ Power state changes are processed in a state machine, and since there are four varieties of power state changes, there are
+ four major paths through the state machine:
+
+ The fourth is nearly trivial. In this path, the parent is changing the domain state, but we are not changing the device state.
+ The change starts when the parent calls powerDomainWillChange. All we do is acknowledge the parent.
+When the parent calls powerStateDidChange, we acknowledge the parent again, and we're done.
+
+ The first is fairly simple. It starts when a power domain child calls requestPowerDomainState and we decide to change power states
+ to accomodate the child, or if our power-controlling driver calls changePowerStateTo, or if some other driver which is using our
+ device calls makeUsable, or if a subclassed object calls changePowerStateToPriv. These are all power changes initiated by us, not
+ forced upon us by the parent. We start by notifying interested parties. If they all acknowledge via return code, we can go
+ on to state "our_prechange_1". Otherwise, we start the ack timer and wait for the stragglers to acknowlege by calling
+ acknowledgePowerChange. We move on to state "our_prechange_1" when all the stragglers have acknowledged,
+ or when the ack timer expires on all those which didn't acknowledge. In "our_prechange_1" we call the power-controlling
+ driver to change the power state of the hardware. If it returns saying it has done so, we go on to state "our_prechange_2".
+ Otherwise, we have to wait for it, so we set the ack timer and wait. When it calls acknowledgeSetPowerState, or when the
+ ack timer expires, we go on. In "our_prechange_2", we look in the power state array to see if there is any settle time required
+ when changing from our current state to the new state. If not, we go right away to "our_prechange_3". Otherwise, we
+ set the settle timer and wait. When it expires, we move on. In "our_prechange_3" state, we notify all our interested parties
+ via their powerStateDidChange methods that we have finished changing power state. If they all acknowledge via return
+ code, we move on to "our_prechange_4". Otherwise we set the ack timer and wait. When they have all acknowledged, or
+ when the ack timer has expired for those that didn't, we move on to "our_prechange_4", where we remove the used
+ change note from the head of the queue and start the next one if one exists.
+
+ Parent-initiated changes are more complex in the state machine. First, power going up and power going down are handled
+ differently, so they have different paths throught the state machine. Second, we can acknowledge the parent's notification
+ in two different ways, so each of the parent paths is really two.
+
+ When the parent calls our powerDomainWillChange method, notifying us that it will lower power in the domain, we decide
+ what state that will put our device in. Then we embark on the state machine path "IOPMparent_down_1"
+ and "IOPMparent_down_2", in which we notify interested parties of the upcoming change, instruct our driver to make
+ the change, check for settle time, and notify interested parties of the completed change. If we get to the end of this path without
+ stalling due to an interested party which didn't acknowledge via return code, due to the controlling driver not able to change
+ state right away, or due to a non-zero settling time, then we return IOPMAckImplied to the parent, and we're done with the change.
+ If we do stall in any of those states, we return IOPMWillAckLater to the parent and enter the parallel path "IOPMparent_down_4"
+ "IOPMparent_down_5", and "IOPMparent_down_3", where we continue with the same processing, except that at the end we
+ acknowledge the parent explicitly via acknowledgePowerChange, and we're done with the change.
+Then when the parent calls us at powerStateDidChange we acknowledging via return code, because we have already made
+ the power change. In any case, when we are done we remove the used change note from the head of the queue and start on the next one.
+
+ The case of the parent raising power in the domain is handled similarly in that there are parallel paths, one for no-stall
+ that ends in implicit acknowleging the parent, and one that has stalled at least once that ends in explicit acknowledging
+ the parent. This case is different, though in that our device changes state in the second half, after the parent calls
+ powerStateDidChange rather than before, as in the power-lowering case.
+
+ When the parent calls our powerDomainWillChange method, notifying us that it will raise power in the domain, we acknowledge
+ via return code, because there's really nothing we can do until the power is actually raised in the domain.
+ When the parent calls us at powerStateDidChange, we start by notifying our interested parties. If they all acknowledge via return code,
+ we go on to" IOPMparent_up_1" to instruct the driver to raise its power level. After that, we check for any
+ necessary settling time in "IOPMparent_up_2", and we notify all interested parties that power has changed
+ in "IOPMparent_up_3". If none of these operations stall, we acknowledge the parent via return code, release
+ the change note, and start the next, if there is one. If one of them does stall, we enter the parallel path "IOPMparent_up_0",
+ "IOPMparent_up_4", "IOPMparent_up_5", and "IOPMparent_up_6", which ends with
+ our explicit acknowledgement to the parent.
+
+*/
+
+
+const char priv_key[ ] = "Power Management private data";
+const char prot_key[ ] = "Power Management protected data";
+
+
+void IOService::PMinit ( void )
+{
+ if ( ! initialized ) {
+
+ pm_vars = new IOPMprot; // make space for our variables
+ priv = new IOPMpriv;
+ pm_vars->init();
+ priv->init();
+
+ setProperty(prot_key, (OSObject *) pm_vars); // add these to the properties
+ setProperty(priv_key, (OSObject *) priv);
+
+ priv->owner = this;
+ pm_vars->theNumberOfPowerStates = 0; // then initialize them
+ priv->we_are_root = false;
+ pm_vars->theControllingDriver = NULL;
+ priv->our_lock = IOLockAlloc();
+ priv->flags_lock = IOLockAlloc();
+ priv->queue_lock = IOLockAlloc();
+ pm_vars->childLock = IOLockAlloc();
+ pm_vars->parentLock = IOLockAlloc();
+ priv->interestedDrivers = new IOPMinformeeList;
+ priv->interestedDrivers->initialize();
+ priv->changeList = new IOPMchangeNoteList;
+ priv->changeList->initialize();
+ pm_vars->aggressiveness = 0;
+ for (unsigned int i = 0; i <= kMaxType; i++) {
+ pm_vars->current_aggressiveness_values[i] = 0;
+ pm_vars->current_aggressiveness_valid[i] = false;
+ }
+ pm_vars->myCurrentState = 0;
+ priv->imminentState = 0;
+ priv->ourDesiredPowerState = 0;
+ pm_vars->parentsCurrentPowerFlags = 0;
+ pm_vars->maxCapability = 0;
+ priv->driverDesire = 0;
+ priv->deviceDesire = 0;
+ priv->initial_change = true;
+ priv->need_to_become_usable = false;
+ priv->previousRequest = 0;
+ priv->device_overrides = false;
+ priv->machine_state = IOPMfinished;
+ pm_vars->commandQueue = NULL;
+ priv->timerEventSrc = NULL;
+ priv->clampTimerEventSrc = NULL;
+ pm_vars->PMworkloop = NULL;
+ priv->activityLock = NULL;
+ pm_vars->ourName = getName();
+ pm_vars->thePlatform = getPlatform();
+ pm_vars->parentsKnowState = false;
+ assert( pm_vars->thePlatform != 0 );
+ priv->clampOn = false;
+ pm_vars->serialNumber = 0;
+ pm_vars->responseFlags = NULL;
+ pm_vars->doNotPowerDown = true;
+ pm_vars->PMcommandGate = NULL;
+ priv->ackTimer = thread_call_allocate((thread_call_func_t)ack_timer_expired, (thread_call_param_t)this);
+ priv->settleTimer = thread_call_allocate((thread_call_func_t)settle_timer_expired, (thread_call_param_t)this);
+ initialized = true;
+ }
+}
+
+
+//*********************************************************************************
+// PMfree
+//
+// Free up the data created in PMinit, if it exists.
+//*********************************************************************************
+void IOService::PMfree ( void )
+{
+ if ( priv ) {
+ if ( priv->clampTimerEventSrc != NULL ) {
+ getPMworkloop()->removeEventSource(priv->clampTimerEventSrc);
+ priv->clampTimerEventSrc->release();
+ priv->clampTimerEventSrc = NULL;
+ }
+ if ( priv->timerEventSrc != NULL ) {
+ pm_vars->PMworkloop->removeEventSource(priv->timerEventSrc);
+ priv->timerEventSrc->release();
+ priv->timerEventSrc = NULL;
+ }
+ if ( priv->settleTimer ) {
+ thread_call_cancel(priv->settleTimer);
+ thread_call_free(priv->settleTimer);
+ priv->settleTimer = NULL;
+ }
+ if ( priv->ackTimer ) {
+ thread_call_cancel(priv->ackTimer);
+ thread_call_free(priv->ackTimer);
+ priv->ackTimer = NULL;
+ }
+ if ( priv->our_lock ) {
+ IOLockFree(priv->our_lock);
+ priv->our_lock = NULL;
+ }
+ if ( priv->flags_lock ) {
+ IOLockFree(priv->flags_lock);
+ priv->flags_lock = NULL;
+ }
+ if ( priv->activityLock ) {
+ IOLockFree(priv->activityLock);
+ priv->activityLock = NULL;
+ }
+ priv->interestedDrivers->release();
+ priv->changeList->release();
+ priv->release(); // remove instance variables
+ }
+
+ if ( pm_vars ) {
+ if ( pm_vars->commandQueue ) {
+ pm_vars->commandQueue->release();
+ pm_vars->commandQueue = NULL;
+ }
+ if ( pm_vars->PMcommandGate ) {
+ pm_vars->PMcommandGate->release();
+ pm_vars->PMcommandGate = NULL;
+ }
+ if ( pm_vars->PMworkloop ) {
+ // The work loop object returned from getPMworkLoop() is
+ // never retained, therefore it should not be released.
+ // pm_vars->PMworkloop->release();
+ pm_vars->PMworkloop = NULL;
+ }
+ if ( pm_vars->responseFlags ) {
+ pm_vars->responseFlags->release();
+ pm_vars->responseFlags = NULL;
+ }
+ pm_vars->release(); // remove instance variables
+ }
+}
+
+
+//*********************************************************************************
+// PMstop
+//
+// Disconnect the node from its parents and children in the Power Plane.
+//*********************************************************************************
+void IOService::PMstop ( void )
+{
+ OSIterator * iter;
+ OSObject * next;
+ IOPowerConnection * connection;
+ IOService * theChild;
+ IOService * theParent;
+
+ removeProperty(prot_key); // remove the properties
+ removeProperty(priv_key);
+
+ iter = getParentIterator(gIOPowerPlane); // detach parents
+
+ if ( iter ) {
+ while ( (next = iter->getNextObject()) ) {
+ if ( (connection = OSDynamicCast(IOPowerConnection,next)) ) {
+ theParent = (IOService *)connection->copyParentEntry(gIOPowerPlane);
+ if ( theParent ) {
+ theParent->removePowerChild(connection);
+ theParent->release();
+ }
+ }
+ }
+ iter->release();
+ }
+ detachAbove( gIOPowerPlane ); // detach IOConnections
+
+ pm_vars->parentsKnowState = false; // no more power state changes
+
+ iter = getChildIterator(gIOPowerPlane); // detach children
+
+ if ( iter ) {
+ while ( (next = iter->getNextObject()) ) {
+ if ( (connection = OSDynamicCast(IOPowerConnection,next)) ) {
+ theChild = ((IOService *)(connection->copyChildEntry(gIOPowerPlane)));
+ if ( theChild ) {
+ connection->detachFromChild(theChild,gIOPowerPlane); // detach nub from child
+ theChild->release();
+ }
+ detachFromChild(connection,gIOPowerPlane); // detach us from nub
+ }
+ }
+ iter->release();
+ }
+
+ // Remove all interested drivers from the list, including the power
+ // controlling driver.
+ //
+ // Usually, the controlling driver and the policy-maker functionality
+ // are implemented by the same object, and without the deregistration,
+ // the object will be holding an extra retain on itself, and cannot
+ // be freed.
+
+ if ( priv && priv->interestedDrivers )
+ {
+ IOPMinformee * informee;
+
+ while (( informee = priv->interestedDrivers->firstInList() ))
+ deRegisterInterestedDriver( informee->whatObject );
+ }
+}
+
+
+//*********************************************************************************
+// joinPMtree
//
// A policy-maker calls its nub here when initializing, to be attached into
// the power management hierarchy. The default function is to call the
// platform expert, which knows how to do it. This method is overridden
-// by a nub subclass which may either know how to do it, or may need to
-// take other action.
+// by a nub subclass which may either know how to do it, or may need
+// to take other action.
//
// This may be the only "power management" method used in a nub,
// meaning it may not be initialized for power management.
//*********************************************************************************
-
-void
-IOService::joinPMtree( IOService * driver )
-{
- IOPlatformExpert * platform;
-
- platform = getPlatform();
- assert(platform != NULL);
- platform->PMRegisterDevice(this, driver);
-}
-
-#ifndef __LP64__
-//*********************************************************************************
-// [deprecated] youAreRoot
+void IOService::joinPMtree ( IOService * driver )
+{
+ IOPlatformExpert * thePlatform;
+
+ thePlatform = getPlatform();
+ assert(thePlatform != 0 );
+ thePlatform->PMRegisterDevice(this,driver);
+}
+
+
+//*********************************************************************************
+// youAreRoot
//
// Power Managment is informing us that we are the root power domain.
-//*********************************************************************************
-
-IOReturn
-IOService::youAreRoot( void )
-{
- return IOPMNoErr;
-}
-#endif /* !__LP64__ */
-
-//*********************************************************************************
-// [public] PMstop
-//
-// Immediately stop driver callouts. Schedule an async stop request to detach
-// from power plane.
-//*********************************************************************************
-
-void
-IOService::PMstop( void )
-{
- IOPMRequest * request;
-
- if (!initialized) {
- return;
- }
-
- PM_LOCK();
-
- if (fLockedFlags.PMStop) {
- PM_LOG2("%s: PMstop() already stopped\n", fName);
- PM_UNLOCK();
- return;
- }
-
- // Inhibit future driver calls.
- fLockedFlags.PMStop = true;
-
- // Wait for all prior driver calls to finish.
- waitForPMDriverCall();
-
- PM_UNLOCK();
-
- // The rest of the work is performed async.
- request = acquirePMRequest( this, kIOPMRequestTypePMStop );
- if (request) {
- PM_LOG2("%s: %p PMstop\n", getName(), OBFUSCATE(this));
- submitPMRequest( request );
- }
-}
-
-//*********************************************************************************
-// [private] handlePMstop
-//
-// Disconnect the node from all parents and children in the power plane.
-//*********************************************************************************
-
-void
-IOService::handlePMstop( IOPMRequest * request )
-{
- OSIterator * iter;
- OSObject * next;
- IOPowerConnection * connection;
- IOService * theChild;
- IOService * theParent;
-
- PM_ASSERT_IN_GATE();
- PM_LOG2("%s: %p %s start\n", getName(), OBFUSCATE(this), __FUNCTION__);
-
- // remove driver from prevent system sleep lists
- getPMRootDomain()->updatePreventIdleSleepList(this, false);
- getPMRootDomain()->updatePreventSystemSleepList(this, false);
-
- // remove the property
- removeProperty(kPwrMgtKey);
-
- // detach parents
- iter = getParentIterator(gIOPowerPlane);
- if (iter) {
- while ((next = iter->getNextObject())) {
- if ((connection = OSDynamicCast(IOPowerConnection, next))) {
- theParent = (IOService *)connection->copyParentEntry(gIOPowerPlane);
- if (theParent) {
- theParent->removePowerChild(connection);
- theParent->release();
- }
- }
- }
- iter->release();
- }
-
- // detach IOConnections
- detachAbove( gIOPowerPlane );
-
- // no more power state changes
- fParentsKnowState = false;
-
- // detach children
- iter = getChildIterator(gIOPowerPlane);
- if (iter) {
- while ((next = iter->getNextObject())) {
- if ((connection = OSDynamicCast(IOPowerConnection, next))) {
- theChild = ((IOService *)(connection->copyChildEntry(gIOPowerPlane)));
- if (theChild) {
- // detach nub from child
- connection->detachFromChild(theChild, gIOPowerPlane);
- theChild->release();
- }
- // detach us from nub
- detachFromChild(connection, gIOPowerPlane);
- }
- }
- iter->release();
- }
-
- // Remove all interested drivers from the list, including the power
- // controlling driver.
- //
- // Usually, the controlling driver and the policy-maker functionality
- // are implemented by the same object, and without the deregistration,
- // the object will be holding an extra retain on itself, and cannot
- // be freed.
-
- if (fInterestedDrivers) {
- IOPMinformeeList * list = fInterestedDrivers;
- IOPMinformee * item;
-
- PM_LOCK();
- while ((item = list->firstInList())) {
- list->removeFromList(item->whatObject);
- }
- PM_UNLOCK();
- }
-
- // Clear idle period to prevent idleTimerExpired() from servicing
- // idle timer expirations.
-
- fIdleTimerPeriod = 0;
- if (fIdleTimer && thread_call_cancel(fIdleTimer)) {
- release();
- }
-
- PM_LOG2("%s: %p %s done\n", getName(), OBFUSCATE(this), __FUNCTION__);
-}
-
-//*********************************************************************************
-// [public] addPowerChild
-//
-// Power Management is informing us who our children are.
-//*********************************************************************************
-
-IOReturn
-IOService::addPowerChild( IOService * child )
-{
- IOPowerConnection * connection = NULL;
- IOPMRequest * requests[3] = {NULL, NULL, NULL};
- OSIterator * iter;
- bool ok = true;
-
- if (!child) {
- return kIOReturnBadArgument;
- }
-
- if (!initialized || !child->initialized) {
- return IOPMNotYetInitialized;
- }
-
- OUR_PMLog( kPMLogAddChild, (uintptr_t) child, 0 );
-
- do {
- // Is this child already one of our children?
-
- iter = child->getParentIterator( gIOPowerPlane );
- if (iter) {
- IORegistryEntry * entry;
- OSObject * next;
-
- while ((next = iter->getNextObject())) {
- if ((entry = OSDynamicCast(IORegistryEntry, next)) &&
- isChild(entry, gIOPowerPlane)) {
- ok = false;
- break;
- }
- }
- iter->release();
- }
- if (!ok) {
- PM_LOG2("%s: %s (%p) is already a child\n",
- getName(), child->getName(), OBFUSCATE(child));
- break;
- }
-
- // Add the child to the power plane immediately, but the
- // joining connection is marked as not ready.
- // We want the child to appear in the power plane before
- // returning to the caller, but don't want the caller to
- // block on the PM work loop.
-
- connection = new IOPowerConnection;
- if (!connection) {
- break;
- }
-
- // Create a chain of PM requests to perform the bottom-half
- // work from the PM work loop.
-
- requests[0] = acquirePMRequest(
- /* target */ this,
- /* type */ kIOPMRequestTypeAddPowerChild1 );
-
- requests[1] = acquirePMRequest(
- /* target */ child,
- /* type */ kIOPMRequestTypeAddPowerChild2 );
-
- requests[2] = acquirePMRequest(
- /* target */ this,
- /* type */ kIOPMRequestTypeAddPowerChild3 );
-
- if (!requests[0] || !requests[1] || !requests[2]) {
- break;
- }
-
- requests[0]->attachNextRequest( requests[1] );
- requests[1]->attachNextRequest( requests[2] );
-
- connection->init();
- connection->start(this);
- connection->setAwaitingAck(false);
- connection->setReadyFlag(false);
-
- attachToChild( connection, gIOPowerPlane );
- connection->attachToChild( child, gIOPowerPlane );
-
- // connection needs to be released
- requests[0]->fArg0 = connection;
- requests[1]->fArg0 = connection;
- requests[2]->fArg0 = connection;
-
- submitPMRequests( requests, 3 );
- return kIOReturnSuccess;
- }while (false);
-
- if (connection) {
- connection->release();
- }
- if (requests[0]) {
- releasePMRequest(requests[0]);
- }
- if (requests[1]) {
- releasePMRequest(requests[1]);
- }
- if (requests[2]) {
- releasePMRequest(requests[2]);
- }
-
- // Silent failure, to prevent platform drivers from adding the child
- // to the root domain.
-
- return kIOReturnSuccess;
-}
-
-//*********************************************************************************
-// [private] addPowerChild1
-//
-// Step 1/3 of adding a power child. Called on the power parent.
-//*********************************************************************************
-
-void
-IOService::addPowerChild1( IOPMRequest * request )
-{
- IOPMPowerStateIndex tempDesire = kPowerStateZero;
-
- // Make us temporary usable before adding the child.
-
- PM_ASSERT_IN_GATE();
- OUR_PMLog( kPMLogMakeUsable, kPMLogMakeUsable, 0 );
-
- if (fControllingDriver && inPlane(gIOPowerPlane) && fParentsKnowState) {
- tempDesire = fHighestPowerState;
- }
-
- if ((tempDesire != kPowerStateZero) &&
- (IS_PM_ROOT || (StateOrder(fMaxPowerState) >= StateOrder(tempDesire)))) {
- adjustPowerState(tempDesire);
- }
-}
-
-//*********************************************************************************
-// [private] addPowerChild2
-//
-// Step 2/3 of adding a power child. Called on the joining child.
-// Execution blocked behind addPowerChild1.
-//*********************************************************************************
-
-void
-IOService::addPowerChild2( IOPMRequest * request )
-{
- IOPowerConnection * connection = (IOPowerConnection *) request->fArg0;
- IOService * parent;
- IOPMPowerFlags powerFlags;
- bool knowsState;
- IOPMPowerStateIndex powerState;
- IOPMPowerStateIndex tempDesire;
-
- PM_ASSERT_IN_GATE();
- parent = (IOService *) connection->getParentEntry(gIOPowerPlane);
-
- 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.
-
- knowsState = (parent->fPowerStates) && (parent->fParentsKnowState);
- powerState = parent->fCurrentPowerState;
-
- if (knowsState) {
- powerFlags = parent->fPowerStates[powerState].outputPowerFlags;
- } else {
- powerFlags = 0;
- }
-
- // Set our power parent.
-
- OUR_PMLog(kPMLogSetParent, knowsState, powerFlags);
-
- setParentInfo( powerFlags, connection, knowsState );
-
- connection->setReadyFlag(true);
-
- if (fControllingDriver && fParentsKnowState) {
- fMaxPowerState = fControllingDriver->driverMaxCapabilityForDomainState(this, fParentsCurrentPowerFlags);
- // initially change into the state we are already in
- tempDesire = fControllingDriver->driverInitialPowerStateForDomainState(fParentsCurrentPowerFlags);
- fPreviousRequestPowerFlags = (IOPMPowerFlags)(-1);
- adjustPowerState(tempDesire);
- }
-}
-
-//*********************************************************************************
-// [private] addPowerChild3
-//
-// Step 3/3 of adding a power child. Called on the parent.
-// Execution blocked behind addPowerChild2.
-//*********************************************************************************
-
-void
-IOService::addPowerChild3( IOPMRequest * request )
-{
- IOPowerConnection * connection = (IOPowerConnection *) request->fArg0;
- IOService * child;
- IOPMrootDomain * rootDomain = getPMRootDomain();
-
- PM_ASSERT_IN_GATE();
- child = (IOService *) connection->getChildEntry(gIOPowerPlane);
-
- if (child && inPlane(gIOPowerPlane)) {
- if ((this != rootDomain) && child->getProperty("IOPMStrictTreeOrder")) {
- PM_LOG1("%s: strict PM order enforced\n", getName());
- fStrictTreeOrder = true;
- }
-
- if (rootDomain) {
- rootDomain->joinAggressiveness( child );
- }
- } else {
- PM_LOG("%s: addPowerChild3 not in power plane\n", getName());
- }
-
- connection->release();
-}
-
-bool
-IOService::currentOrPendingPowerState(uint32_t state)
-{
- return (fCurrentPowerState == state) || (fHeadNotePowerState == state);
-}
-
-void
-IOService::addPMDriverClass(uint64_t driverClass)
-{
- if (pwrMgt) {
- fPMDriverClass |= driverClass;
- }
-}
-
-#ifndef __LP64__
-//*********************************************************************************
-// [deprecated] setPowerParent
+// The only difference between us and any other power domain is that
+// we have no parent and therefore never call it.
+//*********************************************************************************
+IOReturn IOService::youAreRoot ( void )
+{
+ priv-> we_are_root = true;
+ pm_vars->parentsKnowState = true;
+ attachToParent( getRegistryRoot(),gIOPowerPlane );
+
+ return IOPMNoErr;
+}
+
+
+//*********************************************************************************
+// setPowerParent
//
// Power Management is informing us who our parent is.
// If we have a controlling driver, find out, given our newly-informed
// power domain state, what state it would be in, and then tell it
// to assume that state.
//*********************************************************************************
-
-IOReturn
-IOService::setPowerParent(
- IOPowerConnection * theParent, bool stateKnown, IOPMPowerFlags powerFlags )
-{
- return kIOReturnUnsupported;
-}
-#endif /* !__LP64__ */
-
-//*********************************************************************************
-// [public] removePowerChild
-//
-// Called on a parent whose child is being removed by PMstop().
-//*********************************************************************************
-
-IOReturn
-IOService::removePowerChild( IOPowerConnection * theNub )
-{
- IORegistryEntry * theChild;
-
- PM_ASSERT_IN_GATE();
- OUR_PMLog( kPMLogRemoveChild, 0, 0 );
-
- theNub->retain();
-
- // detach nub from child
- theChild = theNub->copyChildEntry(gIOPowerPlane);
- if (theChild) {
- theNub->detachFromChild(theChild, gIOPowerPlane);
- theChild->release();
- }
- // detach from the nub
- detachFromChild(theNub, gIOPowerPlane);
-
- // Are we awaiting an ack from this child?
- if (theNub->getAwaitingAck()) {
- // 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();
- getPMRootDomain()->reset_watchdog_timer(this, 0);
-
- // This parent may have a request in the work queue that is
- // blocked on fHeadNotePendingAcks=0. And removePowerChild()
- // is called while executing the child's PMstop request so they
- // can occur simultaneously. IOPMWorkQueue::checkForWork() must
- // restart and check all request queues again.
-
- gIOPMWorkQueue->incrementProducerCount();
- }
- }
- }
-
- theNub->release();
-
- // 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;
-}
-
-//*********************************************************************************
-// [public] registerPowerDriver
+IOReturn IOService::setPowerParent ( IOPowerConnection * theParent, bool stateKnown, IOPMPowerFlags currentState )
+{
+ OSIterator * iter;
+ OSObject * next;
+ IOPowerConnection * connection;
+ unsigned long tempDesire;
+
+ pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogSetParent,stateKnown,currentState);
+
+ IOLockLock(pm_vars->parentLock);
+
+ if ( stateKnown && ((pm_vars->PMworkloop == NULL) || (pm_vars->PMcommandGate == NULL)) ) {
+ getPMworkloop(); // we have a path to the root
+ if ( pm_vars->PMworkloop != NULL ) { // find out the workloop
+ if ( pm_vars->PMcommandGate == NULL ) { // and make our command gate
+ pm_vars->PMcommandGate = IOCommandGate::commandGate((OSObject *)this);
+ if ( pm_vars->PMcommandGate != NULL ) {
+ pm_vars->PMworkloop->addEventSource(pm_vars->PMcommandGate);
+ }
+ }
+ }
+ }
+
+ IOLockUnlock(pm_vars->parentLock);
+
+ theParent->setParentCurrentPowerFlags(currentState); // set our connection data
+ theParent->setParentKnowsState(stateKnown);
+
+ pm_vars->parentsKnowState = true; // combine parent knowledge
+ pm_vars->parentsCurrentPowerFlags = 0;
+
+ iter = getParentIterator(gIOPowerPlane);
+
+ if ( iter ) {
+ while ( (next = iter->getNextObject()) ) {
+ if ( (connection = OSDynamicCast(IOPowerConnection,next)) ) {
+ pm_vars->parentsKnowState &= connection->parentKnowsState();
+ pm_vars->parentsCurrentPowerFlags |= connection->parentCurrentPowerFlags();
+ }
+ }
+ iter->release();
+ }
+
+ if ( (pm_vars->theControllingDriver != NULL) &&
+ (pm_vars->parentsKnowState) ) {
+ pm_vars->maxCapability = pm_vars->theControllingDriver->maxCapabilityForDomainState(pm_vars->parentsCurrentPowerFlags);
+ tempDesire = priv->deviceDesire; // initially change into the state we are already in
+ priv->deviceDesire = pm_vars->theControllingDriver->initialPowerStateForDomainState(pm_vars->parentsCurrentPowerFlags);
+ computeDesiredState();
+ priv->previousRequest = 0xffffffff;
+ changeState();
+ priv->deviceDesire = tempDesire; // put this back like before
+ }
+
+ return IOPMNoErr;
+}
+
+
+//*********************************************************************************
+// addPowerChild
+//
+// Power Management is informing us who our children are.
+//*********************************************************************************
+IOReturn IOService::addPowerChild ( IOService * theChild )
+{
+ IOPowerConnection * connection;
+ unsigned int i;
+
+ if ( ! initialized ) {
+ return IOPMNotYetInitialized; // we're not a power-managed IOService
+ }
+
+ pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogAddChild,0,0);
+
+ connection = new IOPowerConnection; // make a nub
+
+ connection->init();
+ connection->start(this);
+ connection->setAwaitingAck(false);
+
+ attachToChild( connection,gIOPowerPlane ); // connect it up
+ connection->attachToChild( theChild,gIOPowerPlane );
+ connection->release();
+
+ if ( (pm_vars->theControllingDriver == NULL) || // tell it the current state of the power domain
+ ! (inPlane(gIOPowerPlane)) ||
+ ! (pm_vars->parentsKnowState) ) {
+ theChild->setPowerParent(connection,false,0);
+ if ( inPlane(gIOPowerPlane) ) {
+ for (i = 0; i <= kMaxType; i++) {
+ if ( pm_vars->current_aggressiveness_valid[i] ) {
+ theChild->setAggressiveness (i, pm_vars->current_aggressiveness_values[i]);
+ }
+ }
+ }
+ }
+ else {
+ theChild->setPowerParent(connection,true,pm_vars->thePowerStates[pm_vars->myCurrentState].outputPowerCharacter);
+ for (i = 0; i <= kMaxType; i++) {
+ if ( pm_vars->current_aggressiveness_valid[i] ) {
+ theChild->setAggressiveness (i, pm_vars->current_aggressiveness_values[i]);
+ }
+ }
+ add_child_to_active_change(connection); // catch it up if change is in progress
+ }
+
+ return IOPMNoErr;
+}
+
+
+//*********************************************************************************
+// removePowerChild
+//
+//*********************************************************************************
+IOReturn IOService::removePowerChild ( IOPowerConnection * theNub )
+{
+ IORegistryEntry * theChild;
+
+ pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogRemoveChild,0,0);
+
+ theNub->retain();
+
+ theChild = theNub->copyChildEntry(gIOPowerPlane); // detach nub from child
+ if ( theChild ) {
+ theNub->detachFromChild(theChild, gIOPowerPlane);
+ theChild->release();
+ }
+ detachFromChild(theNub,gIOPowerPlane); // detach from the nub
+
+ if ( theNub->getAwaitingAck() ) { // are we awaiting an ack from this child?
+ theNub->setAwaitingAck(false); // yes, pretend we got one
+ if ( acquire_lock() ) {
+ if (priv->head_note_pendingAcks != 0 ) {
+ priv->head_note_pendingAcks -= 1; // that's one fewer ack to worry about
+ if ( priv->head_note_pendingAcks == 0 ) { // is that the last?
+ stop_ack_timer(); // yes, stop the timer
+ IOUnlock(priv->our_lock);
+ all_acked(); // and now we can continue our power change
+ }
+ else {
+ IOUnlock(priv->our_lock);
+ }
+ }
+ else {
+ IOUnlock(priv->our_lock);
+ }
+ }
+ }
+
+ theNub->release();
+
+ if ( (pm_vars->theControllingDriver == NULL) || // if not fully initialized
+ ! (inPlane(gIOPowerPlane)) ||
+ ! (pm_vars->parentsKnowState) ) {
+ return IOPMNoErr; // we can do no more
+ }
+
+ computeDesiredState(); // this may be different now
+ changeState(); // change state if we can now tolerate lower power
+
+ return IOPMNoErr;
+}
+
+
+//*********************************************************************************
+// registerPowerDriver
//
// A driver has called us volunteering to control power to our device.
-//*********************************************************************************
-
-IOReturn
-IOService::registerPowerDriver(
- IOService * powerDriver,
- IOPMPowerState * powerStates,
- unsigned long numberOfStates )
-{
- IOPMRequest * request;
- IOPMPSEntry * powerStatesCopy = NULL;
- 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 = IONewData(IOPMPSEntry, numberOfStates);
- if (!powerStatesCopy) {
- error = kIOReturnNoMemory;
- break;
- }
-
- // Initialize to bogus values
- for (IOPMPowerStateIndex i = 0; i < numberOfStates; i++) {
- powerStatesCopy[i].stateOrderToIndex = kIOPMPowerStateMax;
- }
-
- for (uint32_t i = 0; i < numberOfStates; i++) {
- powerStatesCopy[i].capabilityFlags = powerStates[i].capabilityFlags;
- powerStatesCopy[i].outputPowerFlags = powerStates[i].outputPowerCharacter;
- powerStatesCopy[i].inputPowerFlags = powerStates[i].inputPowerRequirement;
- powerStatesCopy[i].staticPower = powerStates[i].staticPower;
-#if USE_SETTLE_TIMER
- powerStatesCopy[i].settleUpTime = powerStates[i].settleUpTime;
- powerStatesCopy[i].settleDownTime = powerStates[i].settleDownTime;
-#endif
- if (powerStates[i].version >= kIOPMPowerStateVersion2) {
- stateOrder = powerStates[i].stateOrder;
- } else {
- stateOrder = i;
- }
-
- if (stateOrder < numberOfStates) {
- powerStatesCopy[i].stateOrder = stateOrder;
- powerStatesCopy[stateOrder].stateOrderToIndex = i;
- }
- }
-
- for (IOPMPowerStateIndex i = 0; i < numberOfStates; i++) {
- if (powerStatesCopy[i].stateOrderToIndex == kIOPMPowerStateMax) {
- // power state order missing
- error = kIOReturnBadArgument;
- break;
- }
- }
- if (kIOReturnSuccess != error) {
- break;
- }
-
- request = acquirePMRequest( this, kIOPMRequestTypeRegisterPowerDriver );
- if (!request) {
- error = kIOReturnNoMemory;
- break;
- }
-
- powerDriver->retain();
- request->fArg0 = (void *) powerDriver;
- request->fArg1 = (void *) powerStatesCopy;
- request->fArg2 = (void *) numberOfStates;
-
- submitPMRequest( request );
- return kIOReturnSuccess;
- }while (false);
-
- if (powerStatesCopy) {
- IODeleteData(powerStatesCopy, IOPMPSEntry, numberOfStates);
- }
-
- return error;
-}
-
-//*********************************************************************************
-// [private] handleRegisterPowerDriver
-//*********************************************************************************
-
-void
-IOService::handleRegisterPowerDriver( IOPMRequest * request )
-{
- IOService * powerDriver = (IOService *) request->fArg0;
- IOPMPSEntry * powerStates = (IOPMPSEntry *) request->fArg1;
- IOPMPowerStateIndex numberOfStates = (IOPMPowerStateIndex) request->fArg2;
- IOPMPowerStateIndex i, stateIndex;
- IOPMPowerStateIndex lowestPowerState;
- IOService * root;
- OSIterator * iter;
-
- PM_ASSERT_IN_GATE();
- assert(powerStates);
- assert(powerDriver);
- assert(numberOfStates > 1);
-
- if (!fNumberOfPowerStates) {
- OUR_PMLog(kPMLogControllingDriver, numberOfStates, kIOPMPowerStateVersion1);
-
- fPowerStates = powerStates;
- fNumberOfPowerStates = numberOfStates;
- fControllingDriver = powerDriver;
- fCurrentCapabilityFlags = fPowerStates[0].capabilityFlags;
-
- lowestPowerState = fPowerStates[0].stateOrderToIndex;
- fHighestPowerState = fPowerStates[numberOfStates - 1].stateOrderToIndex;
-
- IOPMrootDomain * rootDomain = getPMRootDomain();
- if (rootDomain) {
- rootDomain->handleRegisterPowerDriver(this);
- }
- if (!fPMDriverClass && (!reserved || !reserved->uvars)) {
- uint32_t aotFlags;
- IOService * service;
- OSObject * object;
- OSData * data;
-
- // Disallow kIOPMAOTPower states unless device tree enabled
-
- aotFlags = 0;
- service = this;
- while (service && !service->inPlane(gIODTPlane)) {
- service = service->getProvider();
- }
- if (service) {
- object = service->copyProperty(kIOPMAOTPowerKey, gIODTPlane);
- data = OSDynamicCast(OSData, object);
- if (data && (data->getLength() >= sizeof(uint32_t))) {
- aotFlags = ((uint32_t *)data->getBytesNoCopy())[0];
- }
- OSSafeReleaseNULL(object);
- }
- if (!aotFlags) {
- for (i = 0; i < numberOfStates; i++) {
- if (kIOPMAOTPower & fPowerStates[i].inputPowerFlags) {
- fPowerStates[i].inputPowerFlags = 0xFFFFFFFF;
- fPowerStates[i].capabilityFlags = 0;
- fPowerStates[i].outputPowerFlags = 0;
- }
- }
- }
- }
-
- // OR'in all the output power flags
- fMergedOutputPowerFlags = 0;
- fDeviceUsablePowerState = lowestPowerState;
- for (i = 0; i < numberOfStates; i++) {
- fMergedOutputPowerFlags |= fPowerStates[i].outputPowerFlags;
-
- stateIndex = fPowerStates[i].stateOrderToIndex;
- assert(stateIndex < numberOfStates);
- if ((fDeviceUsablePowerState == lowestPowerState) &&
- (fPowerStates[stateIndex].capabilityFlags & IOPMDeviceUsable)) {
- // The minimum power state that the device is usable
- fDeviceUsablePowerState = stateIndex;
- }
- }
-
- // Register powerDriver as interested, unless already done.
- // We don't want to register the default implementation since
- // it does nothing. One ramification of not always registering
- // is the one fewer retain count held.
-
- root = getPlatform()->getProvider();
- assert(root);
- if (!root ||
- ((OSMemberFunctionCast(void (*)(void),
- root, &IOService::powerStateDidChangeTo)) !=
- ((OSMemberFunctionCast(void (*)(void),
- this, &IOService::powerStateDidChangeTo)))) ||
- ((OSMemberFunctionCast(void (*)(void),
- root, &IOService::powerStateWillChangeTo)) !=
- ((OSMemberFunctionCast(void (*)(void),
- this, &IOService::powerStateWillChangeTo))))) {
- if (fInterestedDrivers->findItem(powerDriver) == NULL) {
- PM_LOCK();
- fInterestedDrivers->appendNewInformee(powerDriver);
- PM_UNLOCK();
- }
- }
-
- // Examine all existing power clients and perform limit check.
-
- if (fPowerClients &&
- (iter = OSCollectionIterator::withCollection(fPowerClients))) {
- const OSSymbol * client;
- while ((client = (const OSSymbol *) iter->getNextObject())) {
- IOPMPowerStateIndex powerState = getPowerStateForClient(client);
- if (powerState >= numberOfStates) {
- updatePowerClient(client, fHighestPowerState);
- }
- }
- iter->release();
- }
-
- // Populate IOPMActions for a few special services
- getPMRootDomain()->tagPowerPlaneService(this, &fPMActions, fNumberOfPowerStates - 1);
-
- if (inPlane(gIOPowerPlane) && fParentsKnowState) {
- IOPMPowerStateIndex tempDesire;
- fMaxPowerState = fControllingDriver->driverMaxCapabilityForDomainState(this, fParentsCurrentPowerFlags);
- // initially change into the state we are already in
- tempDesire = fControllingDriver->driverInitialPowerStateForDomainState(fParentsCurrentPowerFlags);
- adjustPowerState(tempDesire);
- }
- } else {
- OUR_PMLog(kPMLogControllingDriverErr2, numberOfStates, 0);
- IODeleteData(powerStates, IOPMPSEntry, numberOfStates);
- }
-
- powerDriver->release();
-}
-
-//*********************************************************************************
-// [public] registerInterestedDriver
+// If the power state array it provides is richer than the one we already
+// know about (supplied by an earlier volunteer), then accept the offer.
+// Notify all interested parties of our power state, which we now know.
+//*********************************************************************************
+
+IOReturn IOService::registerPowerDriver ( IOService * controllingDriver, IOPMPowerState* powerStates, unsigned long numberOfStates )
+{
+ unsigned long i;
+ unsigned long tempDesire;
+
+ if ( (numberOfStates > pm_vars->theNumberOfPowerStates) && (numberOfStates > 1) ) {
+ if ( priv->changeList->currentChange() == -1 ) {
+ if ( controllingDriver != NULL ) {
+ if ( numberOfStates <= IOPMMaxPowerStates ) {
+ switch ( powerStates[0].version ) {
+ case 1:
+ pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogControllingDriver,
+ (unsigned long)numberOfStates, (unsigned long)powerStates[0].version);
+ for ( i = 0; i < numberOfStates; i++ ) {
+ pm_vars->thePowerStates[i] = powerStates[i];
+ }
+ break;
+ case 2:
+ pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogControllingDriver,
+ (unsigned long) numberOfStates,(unsigned long) powerStates[0].version);
+ for ( i = 0; i < numberOfStates; i++ ) {
+ pm_vars->thePowerStates[i].version = powerStates[i].version;
+ pm_vars->thePowerStates[i].capabilityFlags = powerStates[i].capabilityFlags;
+ pm_vars->thePowerStates[i].outputPowerCharacter = powerStates[i].outputPowerCharacter;
+ pm_vars->thePowerStates[i].inputPowerRequirement = powerStates[i].inputPowerRequirement;
+ pm_vars->thePowerStates[i].staticPower = powerStates[i].staticPower;
+ pm_vars->thePowerStates[i].unbudgetedPower = powerStates[i].unbudgetedPower;
+ pm_vars->thePowerStates[i].powerToAttain = powerStates[i].powerToAttain;
+ pm_vars->thePowerStates[i].timeToAttain = powerStates[i].timeToAttain;
+ pm_vars->thePowerStates[i].settleUpTime = powerStates[i].settleUpTime;
+ pm_vars->thePowerStates[i].timeToLower = powerStates[i].timeToLower;
+ pm_vars->thePowerStates[i].settleDownTime = powerStates[i].settleDownTime;
+ pm_vars->thePowerStates[i].powerDomainBudget = powerStates[i].powerDomainBudget;
+ }
+ break;
+ default:
+ pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogControllingDriverErr1,
+ (unsigned long)powerStates[0].version,0);
+ return IOPMNoErr;
+ }
+
+ pm_vars->myCharacterFlags = 0; // make a mask of all the character bits we know about
+ for ( i = 0; i < numberOfStates; i++ ) {
+ pm_vars->myCharacterFlags |= pm_vars->thePowerStates[i].outputPowerCharacter;
+ }
+
+ pm_vars->theNumberOfPowerStates = numberOfStates;
+ pm_vars->theControllingDriver = controllingDriver;
+ if ( priv->interestedDrivers->findItem(controllingDriver) == NULL ) { // register it as interested
+ registerInterestedDriver (controllingDriver ); // unless already done
+ }
+ if ( priv->need_to_become_usable ) {
+ priv->need_to_become_usable = false;
+ priv->deviceDesire = pm_vars->theNumberOfPowerStates - 1;
+ }
+
+ if ( inPlane(gIOPowerPlane) &&
+ (pm_vars->parentsKnowState) ) {
+ pm_vars->maxCapability = pm_vars->theControllingDriver->maxCapabilityForDomainState(pm_vars->parentsCurrentPowerFlags);
+ tempDesire = priv->deviceDesire; // initially change into the state we are already in
+ priv->deviceDesire = pm_vars->theControllingDriver->initialPowerStateForDomainState(pm_vars->parentsCurrentPowerFlags);
+ computeDesiredState();
+ changeState();
+ priv->deviceDesire = tempDesire; // put this back like before
+ }
+ }
+ else {
+ pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogControllingDriverErr2,(unsigned long)numberOfStates,0);
+ }
+ }
+ else {
+ pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogControllingDriverErr4,0,0);
+ }
+ }
+ }
+ else {
+ pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogControllingDriverErr5,(unsigned long)numberOfStates,0);
+ }
+ return IOPMNoErr;
+}
+
+//*********************************************************************************
+// registerInterestedDriver
//
// Add the caller to our list of interested drivers and return our current
// power state. If we don't have a power-controlling driver yet, we will
@@ -1395,143 +723,61 @@
// out what the current power state of the device is.
//*********************************************************************************
-IOPMPowerFlags
-IOService::registerInterestedDriver( IOService * driver )
-{
- IOPMRequest * request;
- bool signal;
-
- if (!driver || !initialized || !fInterestedDrivers) {
- return 0;
- }
-
- PM_LOCK();
- signal = (!fInsertInterestSet && !fRemoveInterestSet);
- if (fInsertInterestSet == NULL) {
- fInsertInterestSet = OSSet::withCapacity(4);
- }
- if (fInsertInterestSet) {
- fInsertInterestSet->setObject(driver);
- if (fRemoveInterestSet) {
- fRemoveInterestSet->removeObject(driver);
- }
- }
- PM_UNLOCK();
-
- if (signal) {
- request = acquirePMRequest( this, kIOPMRequestTypeInterestChanged );
- if (request) {
- submitPMRequest( request );
- }
- }
-
- // This return value cannot be trusted, but return a value
- // for those clients that care.
-
- OUR_PMLog(kPMLogInterestedDriver, kIOPMDeviceUsable, 2);
- return kIOPMDeviceUsable;
-}
-
-//*********************************************************************************
-// [public] deRegisterInterestedDriver
-//*********************************************************************************
-
-IOReturn
-IOService::deRegisterInterestedDriver( IOService * driver )
-{
- IOPMinformee * item;
- IOPMRequest * request;
- bool signal;
-
- if (!driver) {
- return kIOReturnBadArgument;
- }
- if (!initialized || !fInterestedDrivers) {
- return IOPMNotPowerManaged;
- }
-
- PM_LOCK();
- if (fInsertInterestSet) {
- fInsertInterestSet->removeObject(driver);
- }
-
- item = fInterestedDrivers->findItem(driver);
- if (!item) {
- PM_UNLOCK();
- return kIOReturnNotFound;
- }
-
- signal = (!fRemoveInterestSet && !fInsertInterestSet);
- if (fRemoveInterestSet == NULL) {
- fRemoveInterestSet = OSSet::withCapacity(4);
- }
- if (fRemoveInterestSet) {
- fRemoveInterestSet->setObject(driver);
- if (item->active) {
- item->active = false;
- waitForPMDriverCall( driver );
- }
- }
- PM_UNLOCK();
-
- if (signal) {
- request = acquirePMRequest( this, kIOPMRequestTypeInterestChanged );
- if (request) {
- submitPMRequest( request );
- }
- }
-
- return IOPMNoErr;
-}
-
-//*********************************************************************************
-// [private] handleInterestChanged
-//
-// Handle interest added or removed.
-//*********************************************************************************
-
-void
-IOService::handleInterestChanged( IOPMRequest * request )
-{
- IOService * driver;
- IOPMinformee * informee;
- IOPMinformeeList * list = fInterestedDrivers;
-
- PM_LOCK();
-
- if (fInsertInterestSet) {
- while ((driver = (IOService *) fInsertInterestSet->getAnyObject())) {
- if (list->findItem(driver) == NULL) {
- list->appendNewInformee(driver);
- }
- fInsertInterestSet->removeObject(driver);
- }
- fInsertInterestSet->release();
- fInsertInterestSet = NULL;
- }
-
- if (fRemoveInterestSet) {
- while ((driver = (IOService *) fRemoveInterestSet->getAnyObject())) {
- informee = list->findItem(driver);
- if (informee) {
- // Clean-up async interest acknowledgement
- if (fHeadNotePendingAcks && informee->timer) {
- informee->timer = 0;
- fHeadNotePendingAcks--;
- }
- list->removeFromList(driver);
- }
- fRemoveInterestSet->removeObject(driver);
- }
- fRemoveInterestSet->release();
- fRemoveInterestSet = NULL;
- }
-
- PM_UNLOCK();
-}
-
-//*********************************************************************************
-// [public] acknowledgePowerChange
+IOPMPowerFlags IOService::registerInterestedDriver ( IOService * theDriver )
+{
+ IOPMinformee * newInformee;
+ IOPMPowerFlags futureCapability;
+
+ if (theDriver == NULL ) {
+ return 0;
+ }
+
+ newInformee = new IOPMinformee; // make new driver node
+ newInformee->initialize(theDriver);
+ priv->interestedDrivers->addToList(newInformee); // add it to list of drivers
+
+ if ( (pm_vars->theControllingDriver == NULL) ||
+ ! (inPlane(gIOPowerPlane)) ||
+ ! (pm_vars->parentsKnowState) ) {
+ pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogInterestedDriver,IOPMNotPowerManaged,0);
+ return IOPMNotPowerManaged; // can't tell it a state yet
+ }
+
+ switch (priv->machine_state) { // can we notify new driver of a change in progress?
+ case IOPMour_prechange_1:
+ case IOPMour_prechange_4:
+ case IOPMparent_down_4:
+ case IOPMparent_down_6:
+ case IOPMparent_up_0:
+ case IOPMparent_up_6:
+ futureCapability = priv->head_note_capabilityFlags; // yes, remember what we tell it
+ pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogInterestedDriver,(unsigned long)futureCapability,1);
+ add_driver_to_active_change(newInformee); // notify it
+ return futureCapability; // and return the same thing
+ }
+
+ pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogInterestedDriver,
+ (unsigned long) pm_vars->thePowerStates[pm_vars->myCurrentState].capabilityFlags,2);
+ return pm_vars->thePowerStates[pm_vars->myCurrentState].capabilityFlags; // no, return current capability
+}
+
+
+//*********************************************************************************
+// deRegisterInterestedDriver
+//
+//*********************************************************************************
+IOReturn IOService::deRegisterInterestedDriver ( IOService * theDriver )
+{
+ pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogRemoveDriver,0,0);
+
+ priv->interestedDrivers->removeFromList(theDriver); // remove the departing driver
+
+ return IOPMNoErr;
+}
+
+
+//*********************************************************************************
+// acknowledgePowerChange
//
// After we notified one of the interested drivers or a power-domain child
// of an impending change in power, it has called to say it is now
@@ -1544,338 +790,142 @@
// of a "current change note".)
//*********************************************************************************
-IOReturn
-IOService::acknowledgePowerChange( IOService * whichObject )
-{
- IOPMRequest * request;
-
- if (!initialized) {
- return IOPMNotYetInitialized;
+IOReturn IOService::acknowledgePowerChange ( IOService * whichObject )
+{
+ IOPMinformee * ackingObject;
+ unsigned long childPower = kIOPMUnknown;
+ IOService * theChild;
+
+ ackingObject = priv->interestedDrivers->findItem(whichObject); // one of our interested drivers?
+ if ( ackingObject == NULL ) {
+ if ( ! isChild(whichObject,gIOPowerPlane) ) {
+ pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogAcknowledgeErr1,0,0);
+ kprintf("errant driver: %s\n",whichObject->getName());
+ return IOPMNoErr; // no, just return
+ }
+ else {
+ pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogChildAcknowledge,priv->head_note_pendingAcks,0);
+ }
+ }
+ else {
+ pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogDriverAcknowledge,priv->head_note_pendingAcks,0);
+ }
+
+ if (! acquire_lock() ) {
+ return IOPMNoErr;
+ }
+
+ if (priv->head_note_pendingAcks != 0 ) { // yes, make sure we're expecting acks
+ if ( ackingObject != NULL ) { // it's an interested driver
+ if ( ackingObject->timer != 0 ) { // make sure we're expecting this ack
+ ackingObject->timer = 0; // mark it acked
+ priv->head_note_pendingAcks -= 1; // that's one fewer to worry about
+ if ( priv->head_note_pendingAcks == 0 ) { // is that the last?
+ stop_ack_timer(); // yes, stop the timer
+ IOUnlock(priv->our_lock);
+ all_acked(); // and now we can continue
+ return IOPMNoErr;
+ }
+ }
+ else {
+ pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogAcknowledgeErr2,0,0); // this driver has already acked
+ kprintf("errant driver: %s\n",whichObject->getName());
+ }
+ }
+ else { // it's a child
+ if ( ((IOPowerConnection *)whichObject)->getAwaitingAck() ) { // make sure we're expecting this ack
+ priv->head_note_pendingAcks -= 1; // that's one fewer to worry about
+ ((IOPowerConnection *)whichObject)->setAwaitingAck(false);
+ theChild = (IOService *)whichObject->copyChildEntry(gIOPowerPlane);
+ if ( theChild ) {
+ childPower = theChild->currentPowerConsumption();
+ theChild->release();
+ }
+ if ( childPower == kIOPMUnknown ) {
+ pm_vars->thePowerStates[priv->head_note_state].staticPower = kIOPMUnknown;
+ }
+ else {
+ if ( pm_vars->thePowerStates[priv->head_note_state].staticPower != kIOPMUnknown ) {
+ pm_vars->thePowerStates[priv->head_note_state].staticPower += childPower;
+ }
+ }
+ if ( priv->head_note_pendingAcks == 0 ) { // is that the last?
+ stop_ack_timer(); // yes, stop the timer
+ IOUnlock(priv->our_lock);
+ all_acked(); // and now we can continue
+ return IOPMNoErr;
+ }
+ }
}
- if (!whichObject) {
- return kIOReturnBadArgument;
- }
-
- request = acquirePMRequest( this, kIOPMRequestTypeAckPowerChange );
- if (!request) {
- return kIOReturnNoMemory;
- }
-
- whichObject->retain();
- request->fArg0 = whichObject;
-
- submitPMRequest( request );
- return IOPMNoErr;
-}
-
-//*********************************************************************************
-// [private] handleAcknowledgePowerChange
-//*********************************************************************************
-
-bool
-IOService::handleAcknowledgePowerChange( IOPMRequest * request )
-{
- IOPMinformee * informee;
- IOPMPowerStateIndex childPower = kIOPMUnknown;
- IOService * theChild;
- IOService * whichObject;
- bool all_acked = false;
-
- PM_ASSERT_IN_GATE();
- whichObject = (IOService *) request->fArg0;
- assert(whichObject);
-
- // one of our interested drivers?
- informee = fInterestedDrivers->findItem( whichObject );
- if (informee == NULL) {
- if (!isChild(whichObject, gIOPowerPlane)) {
- OUR_PMLog(kPMLogAcknowledgeErr1, 0, 0);
- goto no_err;
- } else {
- OUR_PMLog(kPMLogChildAcknowledge, fHeadNotePendingAcks, 0);
- }
- } else {
- OUR_PMLog(kPMLogDriverAcknowledge, fHeadNotePendingAcks, 0);
- }
-
- if (fHeadNotePendingAcks != 0) {
- assert(fPowerStates != NULL);
-
- // yes, make sure we're expecting acks
- if (informee != NULL) {
- // it's an interested driver
- // make sure we're expecting this ack
- if (informee->timer != 0) {
- SOCD_TRACE_XNU(PM_INFORM_POWER_CHANGE_ACK,
- SOCD_TRACE_MODE_NONE,
- ADDR(informee->whatObject->getMetaClass()),
- ADDR(this->getMetaClass()),
- PACK_2X32(VALUE(this->getRegistryEntryID()), VALUE(informee->whatObject->getRegistryEntryID())),
- PACK_2X32(VALUE(0), VALUE(fDriverCallReason)));
-
- if (informee->timer > 0) {
- uint64_t nsec = computeTimeDeltaNS(&informee->startTime);
- if (nsec > gIOPMSetPowerStateLogNS) {
- getPMRootDomain()->pmStatsRecordApplicationResponse(
- gIOPMStatsDriverPSChangeSlow, informee->whatObject->getName(),
- fDriverCallReason, NS_TO_MS(nsec), informee->whatObject->getRegistryEntryID(),
- NULL, fHeadNotePowerState, true);
- }
- }
-
- // mark it acked
- informee->timer = 0;
- // that's one fewer to worry about
- fHeadNotePendingAcks--;
- } else {
- // this driver has already acked
- OUR_PMLog(kPMLogAcknowledgeErr2, 0, 0);
- }
- } else {
- // it's a child
- // make sure we're expecting this ack
- if (((IOPowerConnection *)whichObject)->getAwaitingAck()) {
- // that's one fewer to worry about
- fHeadNotePendingAcks--;
- ((IOPowerConnection *)whichObject)->setAwaitingAck(false);
- theChild = (IOService *)whichObject->copyChildEntry(gIOPowerPlane);
- if (theChild) {
- childPower = theChild->currentPowerConsumption();
- theChild->release();
- }
- if (childPower == kIOPMUnknown) {
- fHeadNotePowerArrayEntry->staticPower = kIOPMUnknown;
- } else {
- if (fHeadNotePowerArrayEntry->staticPower != kIOPMUnknown) {
- fHeadNotePowerArrayEntry->staticPower += childPower;
- }
- }
- }
- }
-
- if (fHeadNotePendingAcks == 0) {
- // yes, stop the timer
- stop_ack_timer();
- // and now we can continue
- all_acked = true;
- getPMRootDomain()->reset_watchdog_timer(this, 0);
- }
- } else {
- OUR_PMLog(kPMLogAcknowledgeErr3, 0, 0); // not expecting anybody to ack
- }
-
-no_err:
- if (whichObject) {
- whichObject->release();
- }
-
- return all_acked;
-}
-
-//*********************************************************************************
-// [public] acknowledgeSetPowerState
+ }
+ else {
+ pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogAcknowledgeErr3,0,0); // not expecting anybody to ack
+ kprintf("errant driver: %s\n",whichObject->getName());
+ }
+ IOUnlock(priv->our_lock);
+ return IOPMNoErr;
+}
+
+//*********************************************************************************
+// acknowledgeSetPowerState
//
// After we instructed our controlling driver to change power states,
// it has called to say it has finished doing so.
// We continue to process the power state change.
//*********************************************************************************
-IOReturn
-IOService::acknowledgeSetPowerState( void )
-{
- IOPMRequest * request;
-
- if (!initialized) {
- return IOPMNotYetInitialized;
- }
-
- request = acquirePMRequest( this, kIOPMRequestTypeAckSetPowerState );
- if (!request) {
- return kIOReturnNoMemory;
- }
-
- submitPMRequest( request );
- return kIOReturnSuccess;
-}
-
-//*********************************************************************************
-// [private] handleAcknowledgeSetPowerState
-//*********************************************************************************
-
-bool
-IOService::handleAcknowledgeSetPowerState( IOPMRequest * request __unused)
-{
- const OSMetaClass *controllingDriverMetaClass = NULL;
- uint32_t controllingDriverRegistryEntryID = 0;
- bool more = false;
- bool trace_this_ack = true;
-
- 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();
-
- getPMRootDomain()->reset_watchdog_timer(this, 0);
-
- uint64_t nsec = computeTimeDeltaNS(&fDriverCallStartTime);
- if (nsec > gIOPMSetPowerStateLogNS) {
- getPMRootDomain()->pmStatsRecordApplicationResponse(
- gIOPMStatsDriverPSChangeSlow,
- fName, kDriverCallSetPowerState, NS_TO_MS(nsec), getRegistryEntryID(),
- NULL, fHeadNotePowerState, true);
- }
-
- OUR_PMLog(kPMLogDriverAcknowledgeSet, (uintptr_t) this, fDriverTimer);
- fDriverTimer = 0;
- more = true;
- } else {
- // unexpected ack
- OUR_PMLog(kPMLogAcknowledgeErr4, (uintptr_t) this, 0);
- trace_this_ack = false;
- }
-
- if (trace_this_ack) {
- if (fControllingDriver) {
- controllingDriverMetaClass = fControllingDriver->getMetaClass();
- controllingDriverRegistryEntryID = (uint32_t)fControllingDriver->getRegistryEntryID();
- }
-
- SOCD_TRACE_XNU(PM_SET_POWER_STATE_ACK,
- SOCD_TRACE_MODE_NONE,
- ADDR(controllingDriverMetaClass),
- ADDR(this->getMetaClass()),
- PACK_2X32(VALUE(this->getRegistryEntryID()), VALUE(controllingDriverRegistryEntryID)),
- PACK_2X32(VALUE(fHeadNotePowerState), VALUE(0)));
- }
-
- return more;
-}
-
-//*********************************************************************************
-// [private] adjustPowerState
-//*********************************************************************************
-
-void
-IOService::adjustPowerState( IOPMPowerStateIndex clamp )
-{
- 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
- // apps for permission to drop power. This is used by root domain
- // for demand sleep.
-
- if (getPMRequestType() == kIOPMRequestTypeRequestPowerStateOverride) {
- changeFlags |= (kIOPMIgnoreChildren | kIOPMSkipAskPowerDown);
- }
-
- startPowerChange(
- /* flags */ changeFlags,
- /* power state */ fDesiredPowerState,
- /* domain flags */ 0,
- /* connection */ NULL,
- /* parent flags */ 0);
- }
-}
-
-//*********************************************************************************
-// [public] synchronizePowerTree
-//*********************************************************************************
-
-IOReturn
-IOService::synchronizePowerTree(
- IOOptionBits options,
- IOService * notifyRoot )
-{
- IOPMRequest * request_c = NULL;
- IOPMRequest * request_s;
-
- if (this != getPMRootDomain()) {
- return kIOReturnBadArgument;
- }
- if (!initialized) {
- return kIOPMNotYetInitialized;
- }
-
- OUR_PMLog(kPMLogCSynchronizePowerTree, options, (notifyRoot != NULL));
-
- if (notifyRoot) {
- IOPMRequest * nr;
-
- // Cancels don't need to be synchronized.
- nr = acquirePMRequest(notifyRoot, kIOPMRequestTypeChildNotifyDelayCancel);
- if (nr) {
- submitPMRequest(nr);
- }
-
- // For display wrangler or any other delay-eligible (dark wake clamped)
- // drivers attached to root domain in the power plane.
- nr = acquirePMRequest(getPMRootDomain(), kIOPMRequestTypeChildNotifyDelayCancel);
- if (nr) {
- submitPMRequest(nr);
- }
- }
-
- request_s = acquirePMRequest( this, kIOPMRequestTypeSynchronizePowerTree );
- if (!request_s) {
- goto error_no_memory;
- }
-
- if (options & kIOPMSyncCancelPowerDown) {
- request_c = acquirePMRequest( this, kIOPMRequestTypeIdleCancel );
- }
- if (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:
- if (request_c) {
- releasePMRequest(request_c);
- }
- if (request_s) {
- releasePMRequest(request_s);
- }
- return kIOReturnNoMemory;
-}
-
-//*********************************************************************************
-// [private] handleSynchronizePowerTree
-//*********************************************************************************
-
-void
-IOService::handleSynchronizePowerTree( IOPMRequest * request )
-{
- PM_ASSERT_IN_GATE();
- if (fControllingDriver && fParentsKnowState && inPlane(gIOPowerPlane) &&
- (fCurrentPowerState == fHighestPowerState)) {
- IOPMPowerChangeFlags options = (IOPMPowerChangeFlags)(uintptr_t) request->fArg0;
-
- startPowerChange(
- /* flags */ kIOPMSelfInitiated | kIOPMSynchronize |
- (options & kIOPMSyncNoChildNotify),
- /* power state */ fCurrentPowerState,
- /* domain flags */ 0,
- /* connection */ NULL,
- /* parent flags */ 0);
- }
-}
-
-#ifndef __LP64__
-//*********************************************************************************
-// [deprecated] powerDomainWillChangeTo
+IOReturn IOService::acknowledgeSetPowerState ( void )
+{
+ if (! acquire_lock() ) {
+ return IOPMNoErr;
+ }
+ if ( priv->driver_timer == -1 ) {
+ priv->driver_timer = 0; // driver is acking instead of using return code
+ }
+ else {
+ if ( priv->driver_timer > 0 ) { // are we expecting this?
+ stop_ack_timer(); // yes, stop the timer
+ priv->driver_timer = 0;
+ IOUnlock(priv->our_lock);
+ pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogDriverAcknowledgeSet,0,0);
+ driver_acked();
+ return IOPMNoErr;
+ }
+ else {
+ pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogAcknowledgeErr4,0,0); // no
+ }
+ }
+ IOUnlock(priv->our_lock);
+ return IOPMNoErr;
+}
+
+
+//*********************************************************************************
+// driver_acked
+//
+// Either the controlling driver has called acknowledgeSetPowerState
+// or the acknowledgement timer has expired while waiting for that.
+// We carry on processing the current change note.
+//*********************************************************************************
+
+void IOService::driver_acked ( void )
+{
+ switch (priv->machine_state) {
+ case IOPMour_prechange_2:
+ our_prechange_2();
+ break;
+ case IOPMparent_down_5:
+ parent_down_5();
+ break;
+ case IOPMparent_up_4:
+ parent_up_4();
+ break;
+ }
+}
+
+
+//*********************************************************************************
+// powerDomainWillChangeTo
//
// Called by the power-hierarchy parent notifying of a new power state
// in the power domain.
@@ -1884,136 +934,65 @@
// kind of change is occuring in the domain.
//*********************************************************************************
-IOReturn
-IOService::powerDomainWillChangeTo(
- IOPMPowerFlags newPowerFlags,
- IOPowerConnection * whichParent )
-{
- assert(false);
- return kIOReturnUnsupported;
-}
-#endif /* !__LP64__ */
-
-//*********************************************************************************
-// [private] handlePowerDomainWillChangeTo
-//*********************************************************************************
-
-void
-IOService::handlePowerDomainWillChangeTo( IOPMRequest * request )
-{
- IOPMPowerFlags parentPowerFlags = (IOPMPowerFlags) request->fArg0;
- IOPowerConnection * whichParent = (IOPowerConnection *) request->fArg1;
- IOPMPowerChangeFlags parentChangeFlags = (IOPMPowerChangeFlags)(uintptr_t) request->fArg2;
- IOPMPowerChangeFlags myChangeFlags;
- OSIterator * iter;
- OSObject * next;
- IOPowerConnection * connection;
- IOPMPowerStateIndex maxPowerState;
- IOPMPowerFlags combinedPowerFlags;
- IOReturn result = IOPMAckImplied;
-
- PM_ASSERT_IN_GATE();
- OUR_PMLog(kPMLogWillChange, parentPowerFlags, 0);
-
- if (!inPlane(gIOPowerPlane) || !whichParent || !whichParent->getAwaitingAck()) {
- PM_LOG("%s::%s not in power tree\n", getName(), __FUNCTION__);
- goto exit_no_ack;
- }
-
- // Combine parents' output power flags.
-
- combinedPowerFlags = 0;
-
- iter = getParentIterator(gIOPowerPlane);
- if (iter) {
- while ((next = iter->getNextObject())) {
- if ((connection = OSDynamicCast(IOPowerConnection, next))) {
- if (connection == whichParent) {
- combinedPowerFlags |= parentPowerFlags;
- } else {
- combinedPowerFlags |= connection->parentCurrentPowerFlags();
- }
- }
- }
- iter->release();
- }
-
- // If our initial change has yet to occur, then defer the power change
- // until after the power domain has completed its power transition.
-
- if (fControllingDriver && !fInitialPowerChange) {
- maxPowerState = fControllingDriver->driverMaxCapabilityForDomainState(
- this, combinedPowerFlags);
-
- if (parentChangeFlags & kIOPMDomainPowerDrop) {
- // fMaxPowerState set a limit on self-initiated power changes.
- // Update it before a parent power drop.
- fMaxPowerState = maxPowerState;
- }
-
- // Use kIOPMSynchronize below instead of kIOPMRootBroadcastFlags
- // to avoid propagating the root change flags if any service must
- // change power state due to root's will-change notification.
- // Root does not change power state for kIOPMSynchronize.
-
- myChangeFlags = kIOPMParentInitiated | kIOPMDomainWillChange |
- (parentChangeFlags & kIOPMSynchronize);
-
- result = startPowerChange(
- /* flags */ myChangeFlags,
- /* power state */ maxPowerState,
- /* domain flags */ combinedPowerFlags,
- /* connection */ whichParent,
- /* parent flags */ parentPowerFlags);
- }
-
- // If parent is dropping power, immediately update the parent's
- // capability flags. Any future merging of parent(s) combined
- // power flags should account for this power drop.
-
- if (parentChangeFlags & kIOPMDomainPowerDrop) {
- if (fPMDriverClass && (0 == (kIOPMDriverClassDone & fPMDriverClass))) {
- // on first power drop, propagate driver class to its parents,
- // so they can come on if the driver is selected to be on
- // by considerRunMode()
- IOService * parent = whichParent;
- while (true) {
- parent = (IOService *) parent->getParentEntry(gIOPowerPlane);
- if (parent == getPMRootDomain()) {
- break;
- }
- parent->addPMDriverClass(fPMDriverClass);
- parent = (IOService *) parent->getParentEntry(gIOPowerPlane);
- }
- fPMDriverClass |= kIOPMDriverClassDone;
- }
- 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().
- if (whichParent) {
- whichParent->release();
- }
-}
-
-#ifndef __LP64__
-//*********************************************************************************
-// [deprecated] powerDomainDidChangeTo
+IOReturn IOService::powerDomainWillChangeTo ( IOPMPowerFlags newPowerStateFlags, IOPowerConnection * whichParent )
+{
+ OSIterator * iter;
+ OSObject * next;
+ IOPowerConnection * connection;
+ unsigned long newStateNumber;
+ IOPMPowerFlags combinedPowerFlags;
+
+ pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogWillChange,(unsigned long)newPowerStateFlags,0);
+
+ if ( ! inPlane(gIOPowerPlane) ) {
+ return IOPMAckImplied; // somebody goofed
+ }
+
+ IOLockLock(pm_vars->parentLock);
+
+ if ( (pm_vars->PMworkloop == NULL) || (pm_vars->PMcommandGate == NULL) ) {
+ getPMworkloop(); // we have a path to the root,
+ if ( pm_vars->PMworkloop != NULL ) { // so find out the workloop
+ if ( pm_vars->PMcommandGate == NULL ) { // and make our command gate
+ pm_vars->PMcommandGate = IOCommandGate::commandGate((OSObject *)this);
+ if ( pm_vars->PMcommandGate != NULL ) {
+ pm_vars->PMworkloop->addEventSource(pm_vars->PMcommandGate);
+ }
+ }
+ }
+ }
+
+ IOLockUnlock(pm_vars->parentLock);
+
+ combinedPowerFlags = 0; // combine parents' power states
+
+ iter = getParentIterator(gIOPowerPlane);
+
+ if ( iter ) {
+ while ( (next = iter->getNextObject()) ) {
+ if ( (connection = OSDynamicCast(IOPowerConnection,next)) ) {
+ if ( connection == whichParent ){
+ combinedPowerFlags |= newPowerStateFlags;
+ }
+ else {
+ combinedPowerFlags |= connection->parentCurrentPowerFlags();
+ }
+ }
+ }
+ iter->release();
+ }
+
+ if ( pm_vars->theControllingDriver == NULL ) { // we can't take any more action
+ return IOPMAckImplied;
+ }
+ newStateNumber = pm_vars->theControllingDriver->maxCapabilityForDomainState(combinedPowerFlags);
+ return enqueuePowerChange(IOPMParentInitiated | IOPMDomainWillChange,
+ newStateNumber,combinedPowerFlags,whichParent,newPowerStateFlags); //make the change
+}
+
+
+//*********************************************************************************
+// powerDomainDidChangeTo
//
// Called by the power-hierarchy parent after the power state of the power domain
// has settled at a new level.
@@ -2022,391 +1001,213 @@
// kind of change is occuring in the domain.
//*********************************************************************************
-IOReturn
-IOService::powerDomainDidChangeTo(
- IOPMPowerFlags newPowerFlags,
- IOPowerConnection * whichParent )
-{
- assert(false);
- return kIOReturnUnsupported;
-}
-#endif /* !__LP64__ */
-
-//*********************************************************************************
-// [private] handlePowerDomainDidChangeTo
-//*********************************************************************************
-void
-IOService::handlePowerDomainDidChangeTo( IOPMRequest * request )
-{
- IOPMPowerFlags parentPowerFlags = (IOPMPowerFlags) request->fArg0;
- IOPowerConnection * whichParent = (IOPowerConnection *) request->fArg1;
- IOPMPowerChangeFlags parentChangeFlags = (IOPMPowerChangeFlags)(uintptr_t) request->fArg2;
- IOPMPowerChangeFlags myChangeFlags;
- IOPMPowerStateIndex maxPowerState;
- IOPMPowerStateIndex initialDesire = kPowerStateZero;
- bool computeDesire = false;
- bool desireChanged = false;
- bool savedParentsKnowState;
- IOReturn result = IOPMAckImplied;
-
- PM_ASSERT_IN_GATE();
- OUR_PMLog(kPMLogDidChange, parentPowerFlags, 0);
-
- if (!inPlane(gIOPowerPlane) || !whichParent || !whichParent->getAwaitingAck()) {
- PM_LOG("%s::%s not in power tree\n", getName(), __FUNCTION__);
- goto exit_no_ack;
- }
-
- savedParentsKnowState = fParentsKnowState;
-
- setParentInfo(parentPowerFlags, whichParent, true);
-
- if (fControllingDriver) {
- maxPowerState = fControllingDriver->driverMaxCapabilityForDomainState(
- this, fParentsCurrentPowerFlags);
-
- if ((parentChangeFlags & kIOPMDomainPowerDrop) == 0) {
- // fMaxPowerState set a limit on self-initiated power changes.
- // Update it after a parent power rise.
- fMaxPowerState = maxPowerState;
- }
-
- if (fInitialPowerChange) {
- computeDesire = true;
- initialDesire = fControllingDriver->driverInitialPowerStateForDomainState(
- fParentsCurrentPowerFlags);
- } else if (parentChangeFlags & kIOPMRootChangeUp) {
- if (fAdvisoryTickleUsed) {
- // On system wake, re-compute the desired power state since
- // gIOPMAdvisoryTickleEnabled will change for a full wake,
- // which is an input to computeDesiredState(). This is not
- // necessary for a dark wake because powerChangeDone() will
- // handle the dark to full wake case, but it does no harm.
-
- desireChanged = true;
- }
-
- if (fResetPowerStateOnWake) {
- // Query the driver for the desired power state on system wake.
- // Default implementation returns the lowest power state.
-
- IOPMPowerStateIndex wakePowerState =
- fControllingDriver->driverInitialPowerStateForDomainState(
- kIOPMRootDomainState | kIOPMPowerOn );
-
- // fDesiredPowerState was adjusted before going to sleep
- // with fDeviceDesire at min.
-
- if (StateOrder(wakePowerState) > StateOrder(fDesiredPowerState)) {
- // Must schedule a power adjustment if we changed the
- // device desire. That will update the desired domain
- // power on the parent power connection and ping the
- // power parent if necessary.
-
- updatePowerClient(gIOPMPowerClientDevice, wakePowerState);
- desireChanged = true;
- }
- }
- }
-
- if (computeDesire || desireChanged) {
- computeDesiredState(initialDesire, false);
- }
-
- // Absorb and propagate parent's broadcast flags
- myChangeFlags = kIOPMParentInitiated | kIOPMDomainDidChange |
- (parentChangeFlags & kIOPMRootBroadcastFlags);
-
- if (kIOPMAOTPower & fParentsCurrentPowerFlags) {
- if (kIOPMAOTPower & fPowerStates[maxPowerState].inputPowerFlags) {
- if (gLPWFlags && reserved->uvars && reserved->uvars->userServer) {
- reserved->uvars->userServer->pageout();
- }
- }
- }
-
- if (getPMRootDomain()->isAOTMode() && (fCurrentPowerState != maxPowerState)) {
- IOLog("aotPS[%ld] %s0x%qx\n", maxPowerState, getName(), getRegistryEntryID());
- }
-
- result = startPowerChange(
- /* flags */ myChangeFlags,
- /* power state */ maxPowerState,
- /* domain flags */ fParentsCurrentPowerFlags,
- /* connection */ whichParent,
- /* parent flags */ 0);
- }
-
- // Parent is expecting an ACK from us. If we did not embark on a state
- // transition, i.e. startPowerChange() returned IOPMAckImplied. We are
- // still required to issue an ACK to our parent.
-
- if (IOPMAckImplied == result) {
- IOService * parent;
- parent = (IOService *) whichParent->copyParentEntry(gIOPowerPlane);
- assert(parent);
- if (parent) {
- parent->acknowledgePowerChange( whichParent );
- parent->release();
- }
- }
-
- // If the parent registers its power driver late, then this is the
- // first opportunity to tell our parent about our desire. Or if the
- // child's desire changed during a parent change notify.
-
- if (fControllingDriver &&
- ((!savedParentsKnowState && fParentsKnowState) || desireChanged)) {
- PM_LOG1("%s::powerDomainDidChangeTo parentsKnowState %d\n",
- getName(), fParentsKnowState);
- requestDomainPower( fDesiredPowerState );
- }
-
-exit_no_ack:
- // Drop the retain from notifyChild().
- if (whichParent) {
- whichParent->release();
- }
-}
-
-//*********************************************************************************
-// [private] setParentInfo
+IOReturn IOService::powerDomainDidChangeTo ( IOPMPowerFlags newPowerStateFlags, IOPowerConnection * whichParent )
+{
+ unsigned long newStateNumber;
+
+ pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogDidChange,newPowerStateFlags,0);
+
+ setParentInfo(newPowerStateFlags,whichParent);
+
+ if ( pm_vars->theControllingDriver == NULL ) {
+ return IOPMAckImplied;
+ }
+
+ newStateNumber = pm_vars->theControllingDriver->maxCapabilityForDomainState(pm_vars->parentsCurrentPowerFlags);
+ return enqueuePowerChange(IOPMParentInitiated | IOPMDomainDidChange,
+ newStateNumber,pm_vars->parentsCurrentPowerFlags,whichParent,0); // tell interested parties about it
+}
+
+
+//*********************************************************************************
+// setParentInfo
//
// Set our connection data for one specific parent, and then combine all the parent
// data together.
//*********************************************************************************
-void
-IOService::setParentInfo(
- IOPMPowerFlags newPowerFlags,
- IOPowerConnection * whichParent,
- bool knowsState )
-{
- OSIterator * iter;
- OSObject * next;
- IOPowerConnection * conn;
-
- PM_ASSERT_IN_GATE();
-
- // set our connection data
- whichParent->setParentCurrentPowerFlags(newPowerFlags);
- whichParent->setParentKnowsState(knowsState);
-
- // recompute our parent info
- fParentsCurrentPowerFlags = 0;
- fParentsKnowState = true;
-
- iter = getParentIterator(gIOPowerPlane);
- if (iter) {
- while ((next = iter->getNextObject())) {
- if ((conn = OSDynamicCast(IOPowerConnection, next))) {
- fParentsKnowState &= conn->parentKnowsState();
- fParentsCurrentPowerFlags |= conn->parentCurrentPowerFlags();
- }
- }
- iter->release();
- }
-}
-
-//******************************************************************************
-// [private] trackSystemSleepPreventers
-//******************************************************************************
-
-void
-IOService::trackSystemSleepPreventers(
- IOPMPowerStateIndex oldPowerState,
- IOPMPowerStateIndex newPowerState,
- IOPMPowerChangeFlags changeFlags __unused )
-{
- IOPMPowerFlags oldCapability, newCapability;
-
- oldCapability = fPowerStates[oldPowerState].capabilityFlags &
- (kIOPMPreventIdleSleep | kIOPMPreventSystemSleep);
- newCapability = fPowerStates[newPowerState].capabilityFlags &
- (kIOPMPreventIdleSleep | kIOPMPreventSystemSleep);
-
- if (fHeadNoteChangeFlags & kIOPMInitialPowerChange) {
- oldCapability = 0;
- }
- if (oldCapability == newCapability) {
- return;
- }
-
- if ((oldCapability ^ newCapability) & kIOPMPreventIdleSleep) {
- bool enablePrevention = ((oldCapability & kIOPMPreventIdleSleep) == 0);
- bool idleCancelAllowed = getPMRootDomain()->updatePreventIdleSleepList(
- this, enablePrevention);
-#if SUPPORT_IDLE_CANCEL
- if (idleCancelAllowed && enablePrevention) {
- cancelIdlePowerDown(getPMRootDomain());
- }
-#endif
- }
-
- if ((oldCapability ^ newCapability) & kIOPMPreventSystemSleep) {
- getPMRootDomain()->updatePreventSystemSleepList(this,
- ((oldCapability & kIOPMPreventSystemSleep) == 0));
- }
-}
-
-//*********************************************************************************
-// [public] requestPowerDomainState
-//
-// Called on a power parent when a child's power requirement changes.
-//*********************************************************************************
-
-IOReturn
-IOService::requestPowerDomainState(
- IOPMPowerFlags childRequestPowerFlags,
- IOPowerConnection * childConnection,
- unsigned long specification )
-{
- IOPMPowerStateIndex order, powerState;
- IOPMPowerFlags outputPowerFlags;
- IOService * child;
- IOPMRequest * subRequest;
- bool adjustPower = false;
-
- if (!initialized) {
- return IOPMNotYetInitialized;
- }
-
- if (gIOPMWorkLoop->onThread() == false) {
- PM_LOG("%s::requestPowerDomainState\n", getName());
- return kIOReturnSuccess;
- }
-
- OUR_PMLog(kPMLogRequestDomain, childRequestPowerFlags, specification);
-
- if (!isChild(childConnection, gIOPowerPlane)) {
- return kIOReturnNotAttached;
- }
-
- if (!fControllingDriver || !fNumberOfPowerStates) {
- return kIOReturnNotReady;
- }
-
- child = (IOService *) childConnection->getChildEntry(gIOPowerPlane);
- assert(child);
-
- // Remove flags from child request which we can't possibly supply
- childRequestPowerFlags &= fMergedOutputPowerFlags;
-
- // Merge in the power flags contributed by this power parent
- // at its current or impending power state.
-
- outputPowerFlags = fPowerStates[fCurrentPowerState].outputPowerFlags;
- if (fMachineState != kIOPM_Finished) {
- if (IS_POWER_DROP && !IS_ROOT_DOMAIN) {
- // Use the lower power state when dropping power.
- // Must be careful since a power drop can be cancelled
- // from the following states:
- // - kIOPM_OurChangeTellClientsPowerDown
- // - kIOPM_OurChangeTellPriorityClientsPowerDown
- //
- // The child must not wait for this parent to raise power
- // if the power drop was cancelled. The solution is to cancel
- // the power drop if possible, then schedule an adjustment to
- // re-evaluate the parent's power state.
- //
- // Root domain is excluded to avoid idle sleep issues. And allow
- // root domain children to pop up when system is going to sleep.
-
- if ((fMachineState == kIOPM_OurChangeTellClientsPowerDown) ||
- (fMachineState == kIOPM_OurChangeTellPriorityClientsPowerDown)) {
- fDoNotPowerDown = true; // cancel power drop
- adjustPower = true;// schedule an adjustment
- PM_LOG1("%s: power drop cancelled in state %u by %s\n",
- getName(), fMachineState, child->getName());
- } else {
- // Beyond cancellation point, report the impending state.
- outputPowerFlags =
- fPowerStates[fHeadNotePowerState].outputPowerFlags;
- }
- } else if (IS_POWER_RISE) {
- // When raising power, must report the output power flags from
- // child's perspective. A child power request may arrive while
- // parent is transitioning upwards. If a request arrives after
- // setParentInfo() has already recorded the output power flags
- // for the next power state, then using the power supplied by
- // fCurrentPowerState is incorrect, and might cause the child
- // to wait when it should not.
-
- outputPowerFlags = childConnection->parentCurrentPowerFlags();
- }
- }
- child->fHeadNoteDomainTargetFlags |= outputPowerFlags;
-
- // Map child's requested power flags to one of our power state.
-
- for (order = 0; order < fNumberOfPowerStates; order++) {
- powerState = fPowerStates[order].stateOrderToIndex;
- if ((fPowerStates[powerState].outputPowerFlags & childRequestPowerFlags)
- == childRequestPowerFlags) {
- break;
- }
- }
- if (order >= fNumberOfPowerStates) {
- powerState = kPowerStateZero;
- }
-
- // Conditions that warrants a power adjustment on this parent.
- // Adjust power will also propagate any changes to the child's
- // prevent idle/sleep flags towards the root domain.
-
- if (!childConnection->childHasRequestedPower() ||
- (powerState != childConnection->getDesiredDomainState())) {
- adjustPower = true;
- }
-
-#if ENABLE_DEBUG_LOGS
- if (adjustPower) {
- PM_LOG("requestPowerDomainState[%s]: %s, init %d, %u->%u\n",
- getName(), child->getName(),
- !childConnection->childHasRequestedPower(),
- (uint32_t) childConnection->getDesiredDomainState(),
- (uint32_t) powerState);
- }
-#endif
-
- // 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.
-
- if (adjustPower && !fDeviceOverrideEnabled &&
- (!fAdjustPowerScheduled || gIOPMRequest->getRootRequest())) {
- subRequest = acquirePMRequest(
- this, kIOPMRequestTypeAdjustPowerState, gIOPMRequest );
- if (subRequest) {
- submitPMRequest( subRequest );
- fAdjustPowerScheduled = true;
- }
- }
-
- return kIOReturnSuccess;
-}
-
-//*********************************************************************************
-// [public] temporaryPowerClampOn
-//
-// A power domain wants to be clamped to max power until it has children which
-// will then determine the power domain state.
+void IOService::setParentInfo ( IOPMPowerFlags newPowerStateFlags, IOPowerConnection * whichParent )
+{
+ OSIterator * iter;
+ OSObject * next;
+ IOPowerConnection * connection;
+
+ whichParent->setParentCurrentPowerFlags(newPowerStateFlags); // set our connection data
+ whichParent->setParentKnowsState(true);
+
+ IOLockLock(pm_vars->parentLock);
+
+ pm_vars->parentsCurrentPowerFlags = 0; // recompute our parent info
+ pm_vars->parentsKnowState = true;
+
+ iter = getParentIterator(gIOPowerPlane);
+
+ if ( iter ) {
+ while ( (next = iter->getNextObject()) ) {
+ if ( (connection = OSDynamicCast(IOPowerConnection,next)) ) {
+ pm_vars->parentsKnowState &= connection->parentKnowsState();
+ pm_vars->parentsCurrentPowerFlags |= connection->parentCurrentPowerFlags();
+ }
+ }
+ iter->release();
+ }
+ IOLockUnlock(pm_vars->parentLock);
+}
+
+
+//*********************************************************************************
+// requestPowerDomainState
+//
+// The kIOPMPreventIdleSleep and/or kIOPMPreventIdleSleep bits may be be set in the parameter.
+// It is not considered part of the state specification.
+//*********************************************************************************
+IOReturn IOService::requestPowerDomainState ( IOPMPowerFlags desiredState, IOPowerConnection * whichChild, unsigned long specification )
+{
+ unsigned long i;
+ unsigned long computedState;
+ unsigned long theDesiredState = desiredState & ~(kIOPMPreventIdleSleep | kIOPMPreventSystemSleep);
+ OSIterator * iter;
+ OSObject * next;
+ IOPowerConnection * connection;
+
+ pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogRequestDomain,
+ (unsigned long)desiredState,(unsigned long)specification);
+
+ if ( pm_vars->theControllingDriver == NULL) {
+ return IOPMNotYetInitialized;
+ }
+
+ switch (specification) {
+ case IOPMLowestState:
+ i = 0;
+ while ( i < pm_vars->theNumberOfPowerStates ) {
+ if ( ( pm_vars->thePowerStates[i].outputPowerCharacter & theDesiredState) == (theDesiredState & pm_vars->myCharacterFlags) ) {
+ break;
+ }
+ i++;
+ }
+ if ( i >= pm_vars->theNumberOfPowerStates ) {
+ return IOPMNoSuchState;
+ }
+ break;
+
+ case IOPMNextLowerState:
+ i = pm_vars->myCurrentState - 1;
+ while ( i >= 0 ) {
+ if ( ( pm_vars->thePowerStates[i].outputPowerCharacter & theDesiredState) == (theDesiredState & pm_vars->myCharacterFlags) ) {
+ break;
+ }
+ i--;
+ }
+ if ( i < 0 ) {
+ return IOPMNoSuchState;
+ }
+ break;
+
+ case IOPMHighestState:
+ i = pm_vars->theNumberOfPowerStates;
+ while ( i >= 0 ) {
+ i--;
+ if ( ( pm_vars->thePowerStates[i].outputPowerCharacter & theDesiredState) == (theDesiredState & pm_vars->myCharacterFlags) ) {
+ break;
+ }
+ }
+ if ( i < 0 ) {
+ return IOPMNoSuchState;
+ }
+ break;
+
+ case IOPMNextHigherState:
+ i = pm_vars->myCurrentState + 1;
+ while ( i < pm_vars->theNumberOfPowerStates ) {
+ if ( ( pm_vars->thePowerStates[i].outputPowerCharacter & theDesiredState) == (theDesiredState & pm_vars->myCharacterFlags) ) {
+ break;
+ }
+ i++;
+ }
+ if ( i == pm_vars->theNumberOfPowerStates ) {
+ return IOPMNoSuchState;
+ }
+ break;
+
+ default:
+ return IOPMBadSpecification;
+ }
+
+ computedState = i;
+
+ IOLockLock(pm_vars->childLock);
+
+// A child's desires has changed. We need to rebuild the child-clamp bits in our
+// power state array. Start by clearing the bits in each power state.
+
+ for ( i = 0; i < pm_vars->theNumberOfPowerStates; i++ ) {
+ pm_vars->thePowerStates[i].capabilityFlags &= ~(kIOPMChildClamp | kIOPMChildClamp2);
+ }
+
+// Now loop through the children. When we encounter the calling child, save
+// the computed state as this child's desire. And while we're at it, set the ChildClamp bits
+// in any of our states that some child has requested with clamp on.
+
+ iter = getChildIterator(gIOPowerPlane);
+
+ if ( iter ) {
+ while ( (next = iter->getNextObject()) ) {
+ if ( (connection = OSDynamicCast(IOPowerConnection,next)) ) {
+ if ( connection == whichChild ) {
+ connection->setDesiredDomainState(computedState);
+ connection->setPreventIdleSleepFlag(desiredState & kIOPMPreventIdleSleep);
+ connection->setPreventSystemSleepFlag(desiredState & kIOPMPreventSystemSleep);
+ connection->setChildHasRequestedPower();
+ }
+ if ( connection->getPreventIdleSleepFlag() ) {
+ pm_vars->thePowerStates[connection->getDesiredDomainState()].capabilityFlags |= kIOPMChildClamp;
+ }
+ if ( connection->getPreventSystemSleepFlag() ) {
+ pm_vars->thePowerStates[connection->getDesiredDomainState()].capabilityFlags |= kIOPMChildClamp2;
+ }
+ }
+ }
+ iter->release();
+ }
+
+ IOLockUnlock(pm_vars->childLock);
+
+ computeDesiredState(); // this may be different now
+
+ if ( inPlane(gIOPowerPlane) &&
+ (pm_vars->parentsKnowState) ) {
+ changeState(); // change state if all children can now tolerate lower power
+ }
+
+ if ( priv->clampOn ) { // are we clamped on, waiting for this child?
+ priv->clampOn = false; // yes, remove the clamp
+ changePowerStateToPriv(0);
+ }
+
+ return IOPMNoErr;
+}
+
+
+//*********************************************************************************
+// temporaryPowerClampOn
+//
+// A power domain wants to clamp its power on till it has children which
+// will thendetermine the power domain state.
//
// We enter the highest state until addPowerChild is called.
//*********************************************************************************
-IOReturn
-IOService::temporaryPowerClampOn( void )
-{
- return requestPowerState( gIOPMPowerClientChildProxy, kIOPMPowerStateMax );
-}
-
-//*********************************************************************************
-// [public] makeUsable
+IOReturn IOService::temporaryPowerClampOn ( void )
+{
+ priv->clampOn = true;
+ makeUsable();
+ return IOPMNoErr;
+}
+
+
+//*********************************************************************************
+// makeUsable
//
// Some client of our device is asking that we become usable. Although
// this has not come from a subclassed device object, treat it exactly
@@ -2417,3160 +1218,1516 @@
// highest power state.
//*********************************************************************************
-IOReturn
-IOService::makeUsable( void )
-{
- OUR_PMLog(kPMLogMakeUsable, 0, 0);
- return requestPowerState( gIOPMPowerClientDevice, kIOPMPowerStateMax );
-}
-
-//*********************************************************************************
-// [public] currentCapability
-//*********************************************************************************
-
-IOPMPowerFlags
-IOService::currentCapability( void )
-{
- if (!initialized) {
- return IOPMNotPowerManaged;
- }
-
- return fCurrentCapabilityFlags;
-}
-
-//*********************************************************************************
-// [public] changePowerStateTo
-//
-// Called by our power-controlling driver to change power state. The new desired
-// power state is computed and compared against the current power state. If those
-// power states differ, then a power state change is initiated.
-//*********************************************************************************
-
-IOReturn
-IOService::changePowerStateTo( unsigned long ordinal )
-{
- OUR_PMLog(kPMLogChangeStateTo, ordinal, 0);
- return requestPowerState( gIOPMPowerClientDriver, ordinal );
-}
-
-//*********************************************************************************
-// [protected] changePowerStateToPriv
-//
-// Called by our driver subclass to change power state. The new desired power
-// state is computed and compared against the current power state. If those
-// power states differ, then a power state change is initiated.
-//*********************************************************************************
-
-IOReturn
-IOService::changePowerStateToPriv( unsigned long ordinal )
-{
- OUR_PMLog(kPMLogChangeStateToPriv, ordinal, 0);
- return requestPowerState( gIOPMPowerClientDevice, ordinal );
-}
-
-//*********************************************************************************
-// [public] changePowerStateWithOverrideTo
-//
-// Called by our driver subclass to change power state. The new desired power
-// state is computed and compared against the current power state. If those
-// power states differ, then a power state change is initiated.
-// Override enforced - Children and Driver desires are ignored.
-//*********************************************************************************
-
-IOReturn
-IOService::changePowerStateWithOverrideTo( IOPMPowerStateIndex ordinal,
- IOPMRequestTag tag )
-{
- IOPMRequest * request;
-
- if (!initialized) {
- return kIOPMNotYetInitialized;
- }
-
- OUR_PMLog(kPMLogChangeStateToPriv, ordinal, 0);
-
- request = acquirePMRequest( this, kIOPMRequestTypeRequestPowerStateOverride );
- if (!request) {
- return kIOReturnNoMemory;
- }
-
- gIOPMPowerClientDevice->retain();
- request->fTag = tag;
- request->fArg0 = (void *) ordinal;
- request->fArg1 = (void *) gIOPMPowerClientDevice;
- request->fArg2 = NULL;
-#if NOT_READY
- if (action) {
- request->installCompletionAction( action, target, param );
- }
-#endif
-
- // Prevent needless downwards power transitions by clamping power
- // until the scheduled request is executed.
- //
- // TODO: review fOverrideMaxPowerState
-
- if (gIOPMWorkLoop->inGate() && (ordinal < fNumberOfPowerStates)) {
- fTempClampPowerState = StateMax(fTempClampPowerState, ordinal);
- fTempClampCount++;
- request->fArg2 = (void *)(uintptr_t) true;
-
- // Place a power state ceiling to prevent any transition to a
- // power state higher than fOverrideMaxPowerState.
- fOverrideMaxPowerState = ordinal;
- }
-
- submitPMRequest( request );
- return IOPMNoErr;
-}
-
-//*********************************************************************************
-// Tagged form of changePowerStateTo()
-//*********************************************************************************
-
-IOReturn
-IOService::changePowerStateWithTagTo( IOPMPowerStateIndex ordinal, IOPMRequestTag tag )
-{
- OUR_PMLog(kPMLogChangeStateTo, ordinal, tag);
- return requestPowerState(gIOPMPowerClientDriver, ordinal, tag);
-}
-
-//*********************************************************************************
-// Tagged form of changePowerStateToPriv()
-//*********************************************************************************
-
-IOReturn
-IOService::changePowerStateWithTagToPriv( unsigned long ordinal, IOPMRequestTag tag )
-{
- OUR_PMLog(kPMLogChangeStateToPriv, ordinal, tag);
- return requestPowerState(gIOPMPowerClientDevice, ordinal, tag);
-}
-
-//*********************************************************************************
-// [public] changePowerStateForRootDomain
-//
-// Adjust the root domain's power desire on the target
-//*********************************************************************************
-
-IOReturn
-IOService::changePowerStateForRootDomain( IOPMPowerStateIndex ordinal )
-{
- OUR_PMLog(kPMLogChangeStateForRootDomain, ordinal, 0);
- return requestPowerState( gIOPMPowerClientRootDomain, ordinal );
-}
-
-//*********************************************************************************
-// [public for PMRD] quiescePowerTree
-//
-// For root domain to issue a request to quiesce the power tree.
-// Supplied callback invoked upon completion.
-//*********************************************************************************
-
-IOReturn
-IOService::quiescePowerTree(
- void * target, IOPMCompletionAction action, void * param )
-{
- IOPMRequest * request;
-
- if (!initialized) {
- return kIOPMNotYetInitialized;
- }
- if (!target || !action) {
- return kIOReturnBadArgument;
- }
-
- OUR_PMLog(kPMLogQuiescePowerTree, 0, 0);
-
- // Target the root node instead of root domain. This is to avoid blocking
- // the quiesce request behind an existing root domain request in the work
- // queue. Root parent and root domain requests in the work queue must not
- // block the completion of the quiesce request.
-
- request = acquirePMRequest(gIOPMRootNode, kIOPMRequestTypeQuiescePowerTree);
- if (!request) {
- return kIOReturnNoMemory;
- }
-
- request->installCompletionAction(target, action, param);
-
- // Submit through the normal request flow. This will make sure any request
- // already in the request queue will get pushed over to the work queue for
- // execution. Any request submitted after this request may not be serviced.
-
- submitPMRequest( request );
- return kIOReturnSuccess;
-}
-
-//*********************************************************************************
-// [private] requestPowerState
-//*********************************************************************************
-
-IOReturn
-IOService::requestPowerState(
- const OSSymbol * client,
- IOPMPowerStateIndex state,
- IOPMRequestTag tag )
-{
- IOPMRequest * request;
-
- if (!client || (state > UINT_MAX)) {
- return kIOReturnBadArgument;
- }
- if (!initialized) {
- return kIOPMNotYetInitialized;
- }
-
- request = acquirePMRequest( this, kIOPMRequestTypeRequestPowerState );
- if (!request) {
- return kIOReturnNoMemory;
- }
-
- client->retain();
- request->fTag = tag;
- request->fArg0 = (void *)(uintptr_t) state;
- request->fArg1 = (void *) client;
- request->fArg2 = NULL;
-#if NOT_READY
- if (action) {
- request->installCompletionAction( action, target, param );
- }
-#endif
-
- // Prevent needless downwards power transitions by clamping power
- // until the scheduled request is executed.
-
- if (gIOPMWorkLoop->inGate() && (state < fNumberOfPowerStates)) {
- fTempClampPowerState = StateMax(fTempClampPowerState, state);
- fTempClampCount++;
- request->fArg2 = (void *)(uintptr_t) true;
- }
-
- submitPMRequest( request );
- return IOPMNoErr;
-}
-
-//*********************************************************************************
-// [private] handleRequestPowerState
-//*********************************************************************************
-
-void
-IOService::handleRequestPowerState( IOPMRequest * request )
-{
- const OSSymbol * client = (const OSSymbol *) request->fArg1;
- IOPMPowerStateIndex state = (IOPMPowerStateIndex) request->fArg0;
-
- PM_ASSERT_IN_GATE();
- if (request->fArg2) {
- assert(fTempClampCount != 0);
- if (fTempClampCount) {
- fTempClampCount--;
- }
- if (!fTempClampCount) {
- fTempClampPowerState = kPowerStateZero;
- }
- }
-
- if (fNumberOfPowerStates && (state >= fNumberOfPowerStates)) {
- state = fHighestPowerState;
- }
-
- // The power suppression due to changePowerStateWithOverrideTo() expires
- // upon the next "device" power request - changePowerStateToPriv().
-
- if ((getPMRequestType() != kIOPMRequestTypeRequestPowerStateOverride) &&
- (client == gIOPMPowerClientDevice)) {
- fOverrideMaxPowerState = kIOPMPowerStateMax;
- }
-
- if ((state == kPowerStateZero) &&
- (client != gIOPMPowerClientDevice) &&
- (client != gIOPMPowerClientDriver) &&
- (client != gIOPMPowerClientChildProxy)) {
- removePowerClient(client);
- } else {
- updatePowerClient(client, state);
- }
-
- adjustPowerState();
- client->release();
-}
-
-//*********************************************************************************
-// [private] Helper functions to update/remove power clients.
-//*********************************************************************************
-
-void
-IOService::updatePowerClient( const OSSymbol * client, IOPMPowerStateIndex powerState )
-{
- IOPMPowerStateIndex oldPowerState = kPowerStateZero;
-
- if (powerState > UINT_MAX) {
- assert(false);
- return;
- }
-
- if (!fPowerClients) {
- fPowerClients = OSDictionary::withCapacity(4);
- }
- if (fPowerClients && client) {
- OSNumber * num = (OSNumber *) fPowerClients->getObject(client);
- if (num) {
- oldPowerState = num->unsigned32BitValue();
- num->setValue(powerState);
- } else {
- num = OSNumber::withNumber(powerState, 32);
- if (num) {
- fPowerClients->setObject(client, num);
- num->release();
- }
- }
-
- PM_ACTION_CLIENT(actionUpdatePowerClient, client, oldPowerState, powerState);
- }
-}
-
-void
-IOService::removePowerClient( const OSSymbol * client )
-{
- if (fPowerClients && client) {
- fPowerClients->removeObject(client);
- }
-}
-
-IOPMPowerStateIndex
-IOService::getPowerStateForClient( const OSSymbol * client )
-{
- IOPMPowerStateIndex powerState = kPowerStateZero;
-
- if (fPowerClients && client) {
- OSNumber * num = (OSNumber *) fPowerClients->getObject(client);
- if (num) {
- powerState = num->unsigned32BitValue();
- }
- }
- return powerState;
-}
-
-//*********************************************************************************
-// [protected] powerOverrideOnPriv
-//*********************************************************************************
-
-IOReturn
-IOService::powerOverrideOnPriv( void )
-{
- IOPMRequest * request;
-
- if (!initialized) {
- return IOPMNotYetInitialized;
- }
-
- if (gIOPMWorkLoop->inGate()) {
- fDeviceOverrideEnabled = true;
- return IOPMNoErr;
- }
-
- request = acquirePMRequest( this, kIOPMRequestTypePowerOverrideOnPriv );
- if (!request) {
- return kIOReturnNoMemory;
- }
-
- submitPMRequest( request );
- return IOPMNoErr;
-}
-
-//*********************************************************************************
-// [protected] powerOverrideOffPriv
-//*********************************************************************************
-
-IOReturn
-IOService::powerOverrideOffPriv( void )
-{
- IOPMRequest * request;
-
- if (!initialized) {
- return IOPMNotYetInitialized;
- }
-
- if (gIOPMWorkLoop->inGate()) {
- fDeviceOverrideEnabled = false;
- return IOPMNoErr;
- }
-
- request = acquirePMRequest( this, kIOPMRequestTypePowerOverrideOffPriv );
- if (!request) {
- return kIOReturnNoMemory;
- }
-
- submitPMRequest( request );
- return IOPMNoErr;
-}
-
-//*********************************************************************************
-// [private] handlePowerOverrideChanged
-//*********************************************************************************
-
-void
-IOService::handlePowerOverrideChanged( IOPMRequest * request )
-{
- PM_ASSERT_IN_GATE();
- if (request->getType() == kIOPMRequestTypePowerOverrideOnPriv) {
- OUR_PMLog(kPMLogOverrideOn, 0, 0);
- fDeviceOverrideEnabled = true;
- } else {
- OUR_PMLog(kPMLogOverrideOff, 0, 0);
- fDeviceOverrideEnabled = false;
- }
-
- adjustPowerState();
-}
-
-//*********************************************************************************
-// [private] computeDesiredState
-//*********************************************************************************
-
-void
-IOService::computeDesiredState( unsigned long localClamp, bool computeOnly )
-{
- OSIterator * iter;
- OSObject * next;
- IOPowerConnection * connection;
- IOPMPowerStateIndex desiredState = kPowerStateZero;
- IOPMPowerStateIndex newPowerState = kPowerStateZero;
- bool hasChildren = false;
-
- // Desired power state is always 0 without a controlling driver.
-
- if (!fNumberOfPowerStates) {
- fDesiredPowerState = kPowerStateZero;
- return;
- }
-
- // Examine the children's desired power state.
-
- iter = getChildIterator(gIOPowerPlane);
- if (iter) {
- while ((next = iter->getNextObject())) {
- if ((connection = OSDynamicCast(IOPowerConnection, next))) {
- if (connection->getReadyFlag() == false) {
- PM_LOG3("[%s] %s: connection not ready\n",
- getName(), __FUNCTION__);
- continue;
- }
- if (connection->childHasRequestedPower()) {
- hasChildren = true;
- }
- desiredState = StateMax(connection->getDesiredDomainState(), desiredState);
- }
- }
- iter->release();
- }
- if (hasChildren) {
- updatePowerClient(gIOPMPowerClientChildren, desiredState);
- } else {
- removePowerClient(gIOPMPowerClientChildren);
- }
-
- // Iterate through all power clients to determine the min power state.
-
- iter = OSCollectionIterator::withCollection(fPowerClients);
- if (iter) {
- const OSSymbol * client;
- while ((client = (const OSSymbol *) iter->getNextObject())) {
- // Ignore child and driver when override is in effect.
- if ((fDeviceOverrideEnabled ||
- (getPMRequestType() == kIOPMRequestTypeRequestPowerStateOverride)) &&
- ((client == gIOPMPowerClientChildren) ||
- (client == gIOPMPowerClientDriver))) {
- continue;
- }
-
- // Ignore child proxy when children are present.
- if (hasChildren && (client == gIOPMPowerClientChildProxy)) {
- continue;
- }
-
- // Advisory tickles are irrelevant unless system is in full wake
- if (client == gIOPMPowerClientAdvisoryTickle &&
- !gIOPMAdvisoryTickleEnabled) {
- continue;
- }
-
- desiredState = getPowerStateForClient(client);
- assert(desiredState < fNumberOfPowerStates);
- PM_LOG1(" %u %s\n",
- (uint32_t) desiredState, client->getCStringNoCopy());
-
- newPowerState = StateMax(newPowerState, desiredState);
-
- if (client == gIOPMPowerClientDevice) {
- fDeviceDesire = desiredState;
- }
- }
- iter->release();
- }
-
- // Factor in the temporary power desires.
-
- newPowerState = StateMax(newPowerState, localClamp);
- newPowerState = StateMax(newPowerState, fTempClampPowerState);
-
- // Limit check against max power override.
-
- newPowerState = StateMin(newPowerState, fOverrideMaxPowerState);
-
- // Limit check against number of power states.
-
- if (newPowerState >= fNumberOfPowerStates) {
- newPowerState = fHighestPowerState;
- }
-
- if (getPMRootDomain()->isAOTMode()) {
- if ((kIOPMPreventIdleSleep & fPowerStates[newPowerState].capabilityFlags)
- && !(kIOPMPreventIdleSleep & fPowerStates[fDesiredPowerState].capabilityFlags)) {
- getPMRootDomain()->claimSystemWakeEvent(this, kIOPMWakeEventAOTExit, getName(), NULL);
- }
- }
-
- fDesiredPowerState = newPowerState;
-
- PM_LOG1(" temp %u, clamp %u, current %u, new %u\n",
- (uint32_t) localClamp, (uint32_t) fTempClampPowerState,
- (uint32_t) fCurrentPowerState, (uint32_t) newPowerState);
-
- if (!computeOnly) {
- // Restart idle timer if possible when device desire has increased.
- // Or if an advisory desire exists.
-
- if (fIdleTimerPeriod && fIdleTimerStopped) {
- restartIdleTimer();
- }
-
- // Invalidate cached tickle power state when desires change, and not
- // due to a tickle request. In case the driver has requested a lower
- // power state, but the tickle is caching a higher power state which
- // will drop future tickles until the cached value is lowered or in-
- // validated. The invalidation must occur before the power transition
- // to avoid dropping a necessary tickle.
-
- if ((getPMRequestType() != kIOPMRequestTypeActivityTickle) &&
- (fActivityTicklePowerState != kInvalidTicklePowerState)) {
- IOLockLock(fActivityLock);
- fActivityTicklePowerState = kInvalidTicklePowerState;
- IOLockUnlock(fActivityLock);
- }
- }
-}
-
-//*********************************************************************************
-// [public] currentPowerConsumption
-//
-//*********************************************************************************
-
-unsigned long
-IOService::currentPowerConsumption( void )
-{
- if (!initialized) {
- return kIOPMUnknown;
- }
-
- return fCurrentPowerConsumption;
-}
-
-//*********************************************************************************
-// [deprecated] getPMworkloop
-//*********************************************************************************
-
-#ifndef __LP64__
-IOWorkLoop *
-IOService::getPMworkloop( void )
-{
- return gIOPMWorkLoop;
-}
-#endif
-
-#if NOT_YET
-
-//*********************************************************************************
-// Power Parent/Children Applier
-//*********************************************************************************
-
-static void
-applyToPowerChildren(
- IOService * service,
- IOServiceApplierFunction applier,
- void * context,
- IOOptionBits options )
-{
- PM_ASSERT_IN_GATE();
-
- IORegistryEntry * entry;
- IORegistryIterator * iter;
- IOPowerConnection * connection;
- IOService * child;
-
- iter = IORegistryIterator::iterateOver(service, gIOPowerPlane, options);
- if (iter) {
- while ((entry = iter->getNextObject())) {
- // Get child of IOPowerConnection objects
- if ((connection = OSDynamicCast(IOPowerConnection, entry))) {
- child = (IOService *) connection->copyChildEntry(gIOPowerPlane);
- if (child) {
- (*applier)(child, context);
- child->release();
- }
- }
- }
- iter->release();
- }
-}
-
-static void
-applyToPowerParent(
- IOService * service,
- IOServiceApplierFunction applier,
- void * context,
- IOOptionBits options )
-{
- PM_ASSERT_IN_GATE();
-
- IORegistryEntry * entry;
- IORegistryIterator * iter;
- IOPowerConnection * connection;
- IOService * parent;
-
- iter = IORegistryIterator::iterateOver(service, gIOPowerPlane,
- options | kIORegistryIterateParents);
- if (iter) {
- while ((entry = iter->getNextObject())) {
- // Get child of IOPowerConnection objects
- if ((connection = OSDynamicCast(IOPowerConnection, entry))) {
- parent = (IOService *) connection->copyParentEntry(gIOPowerPlane);
- if (parent) {
- (*applier)(parent, context);
- parent->release();
- }
- }
- }
- iter->release();
- }
-}
-
-#endif /* NOT_YET */
-
-// MARK: -
-// MARK: Activity Tickle & Idle Timer
-
-void
-IOService::setAdvisoryTickleEnable( bool enable )
-{
- gIOPMAdvisoryTickleEnabled = enable;
-}
-
-//*********************************************************************************
-// [public] activityTickle
-//
+IOReturn IOService::makeUsable ( void )
+{
+ pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogMakeUsable,0,0);
+
+ if ( pm_vars->theControllingDriver == NULL ) {
+ priv->need_to_become_usable = true;
+ return IOPMNoErr;
+ }
+ priv->deviceDesire = pm_vars->theNumberOfPowerStates - 1;
+ computeDesiredState();
+ if ( inPlane(gIOPowerPlane) && (pm_vars->parentsKnowState) ) {
+ return changeState();
+ }
+ return IOPMNoErr;
+}
+
+
+//*********************************************************************************
+// currentCapability
+//
+//*********************************************************************************
+
+IOPMPowerFlags IOService::currentCapability ( void )
+{
+ if ( pm_vars->theControllingDriver == NULL ) {
+ return 0;
+ }
+ else {
+ return pm_vars->thePowerStates[pm_vars->myCurrentState].capabilityFlags;
+ }
+}
+
+
+//*********************************************************************************
+// changePowerStateTo
+//
+// For some reason, our power-controlling driver has decided it needs to change
+// power state. We enqueue the power change so that appropriate parties
+// will be notified, and then we will instruct the driver to make the change.
+//*********************************************************************************
+
+IOReturn IOService::changePowerStateTo ( unsigned long ordinal )
+{
+ pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogChangeStateTo,ordinal,0);
+
+ if ( ordinal >= pm_vars->theNumberOfPowerStates ) {
+ return IOPMParameterError;
+ }
+ priv->driverDesire = ordinal;
+ computeDesiredState();
+ if ( inPlane(gIOPowerPlane) && (pm_vars->parentsKnowState) ) {
+ return changeState();
+ }
+
+ return IOPMNoErr;
+}
+
+//*********************************************************************************
+// changePowerStateToPriv
+//
+// For some reason, a subclassed device object has decided it needs to change
+// power state. We enqueue the power change so that appropriate parties
+// will be notified, and then we will instruct the driver to make the change.
+//*********************************************************************************
+
+IOReturn IOService::changePowerStateToPriv ( unsigned long ordinal )
+{
+ pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogChangeStateToPriv,ordinal,0);
+
+ if ( pm_vars->theControllingDriver == NULL) {
+ return IOPMNotYetInitialized;
+ }
+ if ( ordinal >= pm_vars->theNumberOfPowerStates ) {
+ return IOPMParameterError;
+ }
+ priv->deviceDesire = ordinal;
+ computeDesiredState();
+ if ( inPlane(gIOPowerPlane) && (pm_vars->parentsKnowState) ) {
+ return changeState();
+ }
+
+ return IOPMNoErr;
+}
+
+
+//*********************************************************************************
+// computeDesiredState
+//
+//*********************************************************************************
+
+void IOService::computeDesiredState ( void )
+{
+ OSIterator * iter;
+ OSObject * next;
+ IOPowerConnection * connection;
+ unsigned long newDesiredState = 0;
+
+ // Compute the maximum of our children's desires, our controlling driver's desire, and the subclass device's desire.
+
+ if ( ! priv->device_overrides ) {
+ iter = getChildIterator(gIOPowerPlane);
+
+ if ( iter ) {
+ while ( (next = iter->getNextObject()) ) {
+ if ( (connection = OSDynamicCast(IOPowerConnection,next)) ) {
+ if ( connection->getDesiredDomainState() > newDesiredState ) {
+ newDesiredState = connection->getDesiredDomainState();
+ }
+ }
+ }
+ iter->release();
+ }
+
+ if ( priv->driverDesire > newDesiredState ) {
+ newDesiredState = priv->driverDesire;
+ }
+ }
+
+ if ( priv->deviceDesire > newDesiredState ) {
+ newDesiredState = priv->deviceDesire;
+ }
+
+ priv->ourDesiredPowerState = newDesiredState;
+}
+
+
+//*********************************************************************************
+// changeState
+//
+// A subclass object, our controlling driver, or a power domain child
+// has asked for a different power state. Here we compute what new
+// state we should enter and enqueue the change (or start it).
+//*********************************************************************************
+
+IOReturn IOService::changeState ( void )
+{
+ if ( (pm_vars->theControllingDriver == NULL) || // if not fully initialized
+ ! (inPlane(gIOPowerPlane)) ||
+ ! (pm_vars->parentsKnowState) ) {
+ return IOPMNoErr; // we can do no more
+ }
+
+ return enqueuePowerChange(IOPMWeInitiated,priv->ourDesiredPowerState,0,0,0);
+}
+
+
+//*********************************************************************************
+// currentPowerConsumption
+//
+//*********************************************************************************
+
+unsigned long IOService::currentPowerConsumption ( void )
+{
+ if ( pm_vars->theControllingDriver == NULL ) {
+ return kIOPMUnknown;
+ }
+ if ( pm_vars->thePowerStates[pm_vars->myCurrentState].capabilityFlags & kIOPMStaticPowerValid ) {
+ return pm_vars->thePowerStates[pm_vars->myCurrentState].staticPower;
+ }
+ return kIOPMUnknown;
+}
+
+//*********************************************************************************
+// activityTickle
+//
+// The activity tickle with parameter kIOPMSubclassPolicyis not handled
+// here and should have been intercepted by the subclass.
// The tickle with parameter kIOPMSuperclassPolicy1 causes the activity
// flag to be set, and the device state checked. If the device has been
// powered down, it is powered up again.
-// The tickle with parameter kIOPMSubclassPolicy is ignored here and
-// should be intercepted by a subclass.
-//*********************************************************************************
-
-bool
-IOService::activityTickle( unsigned long type, unsigned long stateNumber )
-{
- if (!initialized) {
- return true; // no power change
- }
-
- if (!fPowerStates) {
- // registerPowerDriver may not have completed
- IOPMRequest * request;
-
- request = acquirePMRequest( this, kIOPMRequestTypeDeferredActivityTickle );
- if (request) {
- request->fArg0 = (void *) type;
- request->fArg1 = (void *)(uintptr_t) stateNumber;
- submitPMRequest(request);
- }
- // Returns false if the activityTickle might cause a transition to a
- // higher powered state. We don't know, so this seems safest.
- return false;
- }
-
- return _activityTickle(type, stateNumber);
-}
-
-//*********************************************************************************
-// [private] handleDeferredActivityTickle
-//*********************************************************************************
-
-void
-IOService::handleDeferredActivityTickle( IOPMRequest * request )
-{
- unsigned long type = (unsigned long) request->fArg1;
- unsigned long stateNumber = (unsigned long) request->fArg2;
-
- if (!fPowerStates) {
- // registerPowerDriver was not called before activityTickle()
- return;
- }
- (void) _activityTickle(type, stateNumber);
-}
-
-//*********************************************************************************
-// [private] _activityTickle
-//
-// The tickle with parameter kIOPMSuperclassPolicy1 causes the activity
-// flag to be set, and the device state checked. If the device has been
-// powered down, it is powered up again.
-// The tickle with parameter kIOPMSubclassPolicy is ignored here and
-// should be intercepted by a subclass.
-//*********************************************************************************
-
-bool
-IOService::_activityTickle( unsigned long type, unsigned long stateNumber )
-{
- IOPMRequest * request;
- bool noPowerChange = true;
- uint32_t tickleFlags;
-
- if ((type == kIOPMSuperclassPolicy1) && StateOrder(stateNumber)) {
- IOLockLock(fActivityLock);
-
- // Record device activity for the idle timer handler.
-
- fDeviceWasActive = true;
- fActivityTickleCount++;
- clock_get_uptime(&fDeviceActiveTimestamp);
-
- PM_ACTION_TICKLE(actionActivityTickle);
-
- // Record the last tickle power state.
- // This helps to filter out redundant tickles as
- // this function may be called from the data path.
-
- if ((fActivityTicklePowerState == kInvalidTicklePowerState)
- || StateOrder(fActivityTicklePowerState) < StateOrder(stateNumber)) {
- fActivityTicklePowerState = stateNumber;
- noPowerChange = false;
-
- tickleFlags = kTickleTypeActivity | kTickleTypePowerRise;
- request = acquirePMRequest( this, kIOPMRequestTypeActivityTickle );
- if (request) {
- request->fArg0 = (void *) stateNumber;
- request->fArg1 = (void *)(uintptr_t) tickleFlags;
- request->fArg2 = (void *)(uintptr_t) gIOPMTickleGeneration;
- submitPMRequest(request);
- }
- }
-
- IOLockUnlock(fActivityLock);
- } else if ((type == kIOPMActivityTickleTypeAdvisory) &&
- ((stateNumber = fDeviceUsablePowerState) != kPowerStateZero)) {
- IOLockLock(fActivityLock);
-
- fAdvisoryTickled = true;
-
- if (fAdvisoryTicklePowerState != stateNumber) {
- fAdvisoryTicklePowerState = stateNumber;
- noPowerChange = false;
-
- tickleFlags = kTickleTypeAdvisory | kTickleTypePowerRise;
- request = acquirePMRequest( this, kIOPMRequestTypeActivityTickle );
- if (request) {
- request->fArg0 = (void *) stateNumber;
- request->fArg1 = (void *)(uintptr_t) tickleFlags;
- request->fArg2 = (void *)(uintptr_t) gIOPMTickleGeneration;
- submitPMRequest(request);
- }
- }
-
- IOLockUnlock(fActivityLock);
- }
-
- // Returns false if the activityTickle might cause a transition to a
- // higher powered state, true otherwise.
-
- return noPowerChange;
-}
-
-//*********************************************************************************
-// [private] handleActivityTickle
-//*********************************************************************************
-
-void
-IOService::handleActivityTickle( IOPMRequest * request )
-{
- IOPMPowerStateIndex ticklePowerState = (IOPMPowerStateIndex) request->fArg0;
- IOPMPowerStateIndex tickleFlags = (IOPMPowerStateIndex) request->fArg1;
- uint32_t tickleGeneration = (uint32_t)(uintptr_t) request->fArg2;
- bool adjustPower = false;
-
- PM_ASSERT_IN_GATE();
- if (fResetPowerStateOnWake && (tickleGeneration != gIOPMTickleGeneration)) {
- // Drivers that don't want power restored on wake will drop any
- // tickles that pre-dates the current system wake. The model is
- // that each wake is a fresh start, with power state depressed
- // until a new tickle or an explicit power up request from the
- // driver. It is possible for the PM work loop to enter the
- // system sleep path with tickle requests queued.
-
- return;
- }
-
- if (tickleFlags & kTickleTypeActivity) {
- IOPMPowerStateIndex deviceDesireOrder = StateOrder(fDeviceDesire);
- IOPMPowerStateIndex idleTimerGeneration = ticklePowerState; // kTickleTypePowerDrop
-
- if (tickleFlags & kTickleTypePowerRise) {
- if ((StateOrder(ticklePowerState) > deviceDesireOrder) &&
- (ticklePowerState < fNumberOfPowerStates)) {
- fIdleTimerMinPowerState = ticklePowerState;
- updatePowerClient(gIOPMPowerClientDevice, ticklePowerState);
- adjustPower = true;
- }
- } else if ((deviceDesireOrder > StateOrder(fIdleTimerMinPowerState)) &&
- (idleTimerGeneration == fIdleTimerGeneration)) {
- // Power drop due to idle timer expiration.
- // Do not allow idle timer to reduce power below tickle power.
- // This prevents the idle timer from decreasing the device desire
- // to zero and cancelling the effect of a pre-sleep tickle when
- // system wakes up to doze state, while the device is unable to
- // raise its power state to satisfy the tickle.
-
- deviceDesireOrder--;
- if (deviceDesireOrder < fNumberOfPowerStates) {
- ticklePowerState = fPowerStates[deviceDesireOrder].stateOrderToIndex;
- updatePowerClient(gIOPMPowerClientDevice, ticklePowerState);
- adjustPower = true;
- }
- }
- } else { // advisory tickle
- if (tickleFlags & kTickleTypePowerRise) {
- if ((ticklePowerState == fDeviceUsablePowerState) &&
- (ticklePowerState < fNumberOfPowerStates)) {
- updatePowerClient(gIOPMPowerClientAdvisoryTickle, ticklePowerState);
- fHasAdvisoryDesire = true;
- fAdvisoryTickleUsed = true;
- adjustPower = true;
- } else {
- IOLockLock(fActivityLock);
- fAdvisoryTicklePowerState = kInvalidTicklePowerState;
- IOLockUnlock(fActivityLock);
- }
- } else if (fHasAdvisoryDesire) {
- removePowerClient(gIOPMPowerClientAdvisoryTickle);
- fHasAdvisoryDesire = false;
- adjustPower = true;
- }
- }
-
- if (adjustPower) {
- adjustPowerState();
- }
-}
-
-//******************************************************************************
-// [public] setIdleTimerPeriod
-//
-// A subclass policy-maker is using our standard idleness detection service.
-// Start the idle timer. Period is in seconds.
-//******************************************************************************
-
-IOReturn
-IOService::setIdleTimerPeriod( unsigned long period )
-{
- if (!initialized) {
- return IOPMNotYetInitialized;
- }
-
- OUR_PMLog(kPMLogSetIdleTimerPeriod, period, fIdleTimerPeriod);
-
- if (period > INT_MAX) {
- return kIOReturnBadArgument;
- }
-
- IOPMRequest * request =
- acquirePMRequest( this, kIOPMRequestTypeSetIdleTimerPeriod );
- if (!request) {
- return kIOReturnNoMemory;
- }
-
- request->fArg0 = (void *) period;
- submitPMRequest( request );
-
- return kIOReturnSuccess;
-}
-
-IOReturn
-IOService::setIgnoreIdleTimer( bool ignore )
-{
- if (!initialized) {
- return IOPMNotYetInitialized;
- }
-
- OUR_PMLog(kIOPMRequestTypeIgnoreIdleTimer, ignore, 0);
-
- IOPMRequest * request =
- acquirePMRequest( this, kIOPMRequestTypeIgnoreIdleTimer );
- if (!request) {
- return kIOReturnNoMemory;
- }
-
- request->fArg0 = (void *) ignore;
- submitPMRequest( request );
-
- return kIOReturnSuccess;
-}
-
-//******************************************************************************
-// [public] nextIdleTimeout
-//
-// Returns how many "seconds from now" the device should idle into its
-// next lowest power state.
-//******************************************************************************
-
-SInt32
-IOService::nextIdleTimeout(
- AbsoluteTime currentTime,
- AbsoluteTime lastActivity,
- unsigned int powerState)
-{
- AbsoluteTime delta;
- UInt64 delta_ns;
- SInt32 delta_secs;
- SInt32 delay_secs;
-
- // Calculate time difference using funky macro from clock.h.
- delta = currentTime;
- SUB_ABSOLUTETIME(&delta, &lastActivity);
-
- // Figure it in seconds.
- absolutetime_to_nanoseconds(delta, &delta_ns);
- delta_secs = (SInt32)(delta_ns / NSEC_PER_SEC);
-
- // Be paranoid about delta somehow exceeding timer period.
- if (delta_secs < (int) fIdleTimerPeriod) {
- delay_secs = (int) fIdleTimerPeriod - delta_secs;
- } else {
- delay_secs = (int) fIdleTimerPeriod;
- }
-
- return (SInt32)delay_secs;
-}
-
-//*********************************************************************************
-// [public] start_PM_idle_timer
-//*********************************************************************************
-
-void
-IOService::start_PM_idle_timer( void )
-{
- static const int maxTimeout = 100000;
- static const int minTimeout = 1;
- AbsoluteTime uptime, deadline;
- SInt32 idle_in = 0;
- boolean_t pending;
-
- if (!initialized || !fIdleTimerPeriod ||
- ((unsigned int) fCurrentPowerState != fCurrentPowerState)) {
- return;
- }
-
- IOLockLock(fActivityLock);
-
- clock_get_uptime(&uptime);
-
- // Subclasses may modify idle sleep algorithm
- idle_in = nextIdleTimeout(uptime, fDeviceActiveTimestamp, (unsigned int) fCurrentPowerState);
-
- // Check for out-of range responses
- if (idle_in > maxTimeout) {
- // use standard implementation
- idle_in = IOService::nextIdleTimeout(uptime,
- fDeviceActiveTimestamp,
- (unsigned int) fCurrentPowerState);
- } else if (idle_in < minTimeout) {
- idle_in = fIdleTimerPeriod;
- }
-
- IOLockUnlock(fActivityLock);
-
- fNextIdleTimerPeriod = idle_in;
- fIdleTimerStartTime = uptime;
-
- retain();
- clock_interval_to_absolutetime_interval(idle_in, kSecondScale, &deadline);
- ADD_ABSOLUTETIME(&deadline, &uptime);
- pending = thread_call_enter_delayed(fIdleTimer, deadline);
- if (pending) {
- release();
- }
-}
-
-//*********************************************************************************
-// [private] restartIdleTimer
-//*********************************************************************************
-
-void
-IOService::restartIdleTimer( void )
-{
- if (fDeviceDesire != kPowerStateZero) {
- fIdleTimerStopped = false;
- fActivityTickleCount = 0;
- start_PM_idle_timer();
- } else if (fHasAdvisoryDesire) {
- fIdleTimerStopped = false;
- start_PM_idle_timer();
- } else {
- fIdleTimerStopped = true;
- }
-}
-
-//*********************************************************************************
-// idle_timer_expired
-//*********************************************************************************
-
-static void
-idle_timer_expired(
- thread_call_param_t arg0, thread_call_param_t arg1 )
-{
- IOService * me = (IOService *) arg0;
-
- if (gIOPMWorkLoop) {
- gIOPMWorkLoop->runAction(
- OSMemberFunctionCast(IOWorkLoop::Action, me,
- &IOService::idleTimerExpired),
- me);
- }
-
- me->release();
-}
-
-//*********************************************************************************
-// [private] idleTimerExpired
-//
-// The idle timer has expired. If there has been activity since the last
+//*********************************************************************************
+
+bool IOService::activityTickle ( unsigned long type, unsigned long stateNumber=0 )
+{
+ AbsoluteTime uptime;
+
+ if ( type == kIOPMSuperclassPolicy1 ) {
+ if ( (priv->activityLock == NULL) ||
+ (pm_vars->theControllingDriver == NULL) ||
+ (pm_vars->commandQueue == NULL) ) {
+ return true;
+ }
+ IOTakeLock(priv->activityLock);
+ priv->device_active = true;
+
+ clock_get_uptime(&uptime);
+ priv->device_active_timestamp = uptime;
+
+ if ( pm_vars->myCurrentState >= stateNumber) {
+ IOUnlock(priv->activityLock);
+ return true;
+ }
+ IOUnlock(priv->activityLock); // send a message on the command queue
+ pm_vars->commandQueue->enqueueCommand(true, (void *)kIOPMUnidleDevice, (void *)stateNumber);
+ return false;
+ }
+ return true;
+}
+
+//*********************************************************************************
+// getPMworkloop
+//
+// A child is calling to get a pointer to the Power Management workloop.
+// We got it or get it from one of our parents.
+//*********************************************************************************
+
+IOWorkLoop * IOService::getPMworkloop ( void )
+{
+IOService * nub;
+IOService * parent;
+
+ if ( ! inPlane(gIOPowerPlane) ) {
+ return NULL;
+ }
+ if ( pm_vars->PMworkloop == NULL ) { // we have no workloop yet
+ nub = (IOService *)copyParentEntry(gIOPowerPlane);
+ if ( nub ) {
+ parent = (IOService *)nub->copyParentEntry(gIOPowerPlane);
+ nub->release();
+ if ( parent ) { // ask one of our parents for the workloop
+ pm_vars->PMworkloop = parent->getPMworkloop();
+ parent->release();
+ }
+ }
+ }
+ return pm_vars->PMworkloop;
+}
+
+
+//*********************************************************************************
+// setIdleTimerPeriod
+//
+// A subclass policy-maker is going to use our standard idleness
+// detection service. Make a command queue and an idle timer and
+// connect them to the power management workloop. Finally,
+// start the timer.
+//*********************************************************************************
+
+IOReturn IOService::setIdleTimerPeriod ( unsigned long period )
+{
+ pm_vars->thePlatform->PMLog(pm_vars->ourName,PMsetIdleTimerPeriod,period, 0);
+
+ priv->idle_timer_period = period;
+
+ if ( period > 0 ) {
+ if ( getPMworkloop() == NULL ) {
+ return kIOReturnError;
+ }
+
+ if (pm_vars->commandQueue == NULL ) { // make the command queue
+ pm_vars->commandQueue = IOCommandQueue::commandQueue(this, PMreceiveCmd);
+ if (! pm_vars->commandQueue ||
+ ( pm_vars->PMworkloop->addEventSource( pm_vars->commandQueue) != kIOReturnSuccess) ) {
+ return kIOReturnError;
+ }
+ }
+ // make the timer event
+ if ( priv->timerEventSrc == NULL ) {
+ priv->timerEventSrc = IOTimerEventSource::timerEventSource(this,
+ PM_idle_timer_expired);
+ if ( ! priv->timerEventSrc ||
+ ( pm_vars->PMworkloop->addEventSource( priv->timerEventSrc) != kIOReturnSuccess) ) {
+ return kIOReturnError;
+ }
+ }
+
+ if ( priv->activityLock == NULL ) {
+ priv->activityLock = IOLockAlloc();
+ }
+
+ start_PM_idle_timer();
+ }
+ return IOPMNoErr;
+}
+
+
+//*********************************************************************************
+// start_PM_idle_timer
+//
+// The parameter is a pointer to us. Use it to call our timeout method.
+//*********************************************************************************
+void IOService::start_PM_idle_timer ( void )
+{
+ AbsoluteTime uptime;
+ AbsoluteTime delta;
+ UInt64 delta_ns;
+ UInt64 delta_secs;
+ UInt64 delay_secs;
+
+ IOLockLock(priv->activityLock);
+
+ clock_get_uptime(&uptime);
+
+ /* Calculate time difference using funky macro from clock.h.
+ */
+ delta = uptime;
+ SUB_ABSOLUTETIME(&delta, &(priv->device_active_timestamp));
+
+ /* Figure it in seconds.
+ */
+ absolutetime_to_nanoseconds(delta, &delta_ns);
+ delta_secs = delta_ns / NSEC_PER_SEC;
+
+ /* Be paranoid about delta somehow exceeding timer period.
+ */
+ if (delta_secs < priv->idle_timer_period ) {
+ delay_secs = priv->idle_timer_period - delta_secs;
+ } else {
+ delay_secs = priv->idle_timer_period;
+ }
+
+ priv->timerEventSrc->setTimeout(delay_secs, NSEC_PER_SEC);
+
+ IOLockUnlock(priv->activityLock);
+ return;
+}
+
+
+//*********************************************************************************
+// PM_idle_timer_expired
+//
+// The parameter is a pointer to us. Use it to call our timeout method.
+//*********************************************************************************
+
+void PM_idle_timer_expired(OSObject * ourSelves, IOTimerEventSource *)
+{
+ ((IOService *)ourSelves)->PM_idle_timer_expiration();
+}
+
+
+//*********************************************************************************
+// PM_idle_timer_expiration
+//
+// The idle timer has expired. If there has been activity since the last
// expiration, just restart the timer and return. If there has not been
// activity, switch to the next lower power state and restart the timer.
//*********************************************************************************
-void
-IOService::idleTimerExpired( void )
-{
- IOPMRequest * request;
- bool restartTimer = true;
- uint32_t tickleFlags;
-
- if (!initialized || !fIdleTimerPeriod || fIdleTimerStopped ||
- fLockedFlags.PMStop) {
- return;
- }
-
- fIdleTimerStartTime = 0;
-
- IOLockLock(fActivityLock);
-
- // Check for device activity (tickles) over last timer period.
-
- if (fDeviceWasActive) {
- // Device was active - do not drop power, restart timer.
- fDeviceWasActive = false;
- } else if (!fIdleTimerIgnored) {
- // No device activity - drop power state by one level.
- // Decrement the cached tickle power state when possible.
- // This value may be kInvalidTicklePowerState before activityTickle()
- // is called, but the power drop request must be issued regardless.
-
- if ((fActivityTicklePowerState != kInvalidTicklePowerState) &&
- (fActivityTicklePowerState != kPowerStateZero)) {
- fActivityTicklePowerState--;
- }
-
- tickleFlags = kTickleTypeActivity | kTickleTypePowerDrop;
- request = acquirePMRequest( this, kIOPMRequestTypeActivityTickle );
- if (request) {
- request->fArg0 = (void *)(uintptr_t) fIdleTimerGeneration;
- request->fArg1 = (void *)(uintptr_t) tickleFlags;
- request->fArg2 = (void *)(uintptr_t) gIOPMTickleGeneration;
- submitPMRequest( request );
-
- // Do not restart timer until after the tickle request has been
- // processed.
-
- restartTimer = false;
- }
- }
-
- if (fAdvisoryTickled) {
- fAdvisoryTickled = false;
- } else if (fHasAdvisoryDesire) {
- // Want new tickles to turn into pm request after we drop the lock
- fAdvisoryTicklePowerState = kInvalidTicklePowerState;
-
- tickleFlags = kTickleTypeAdvisory | kTickleTypePowerDrop;
- request = acquirePMRequest( this, kIOPMRequestTypeActivityTickle );
- if (request) {
- request->fArg0 = (void *)(uintptr_t) fIdleTimerGeneration;
- request->fArg1 = (void *)(uintptr_t) tickleFlags;
- request->fArg2 = (void *)(uintptr_t) gIOPMTickleGeneration;
- submitPMRequest( request );
-
- // Do not restart timer until after the tickle request has been
- // processed.
-
- restartTimer = false;
- }
- }
-
- IOLockUnlock(fActivityLock);
-
- if (restartTimer) {
- start_PM_idle_timer();
- }
-}
-
-#ifndef __LP64__
-//*********************************************************************************
-// [deprecated] PM_idle_timer_expiration
-//*********************************************************************************
-
-void
-IOService::PM_idle_timer_expiration( void )
-{
-}
-
-//*********************************************************************************
-// [deprecated] command_received
-//*********************************************************************************
-
-void
-IOService::command_received( void *statePtr, void *, void *, void * )
-{
-}
-#endif /* !__LP64__ */
-
-//*********************************************************************************
-// [public] setAggressiveness
+void IOService::PM_idle_timer_expiration ( void )
+{
+ if ( ! initialized ) {
+ return; // we're unloading
+ }
+
+ if ( priv->idle_timer_period > 0 ) {
+ IOTakeLock(priv->activityLock);
+ if ( priv->device_active ) {
+ priv->device_active = false;
+ IOUnlock(priv->activityLock);
+ start_PM_idle_timer();
+ return;
+ }
+ if ( pm_vars->myCurrentState > 0 ) {
+ IOUnlock(priv->activityLock);
+ changePowerStateToPriv(pm_vars->myCurrentState - 1);
+ start_PM_idle_timer();
+ return;
+ }
+ IOUnlock(priv->activityLock);
+ start_PM_idle_timer();
+ }
+}
+
+
+
+// **********************************************************************************
+// PMreceiveCmd
+//
+//
+//
+// **********************************************************************************
+void PMreceiveCmd ( OSObject * theDriver, void * command, void * param1, void * param2, void *param3 )
+{
+ ((IOService *)theDriver)->command_received(command,param1,param2,param3);
+}
+
+
+// **********************************************************************************
+// command_received
+//
+// We have received a command from ourselves on the command queue.
+// This is to prevent races with timer-expiration code.
+// **********************************************************************************
+void IOService::command_received ( void * command, void *stateNumber , void * , void *)
+{
+ if ( ! initialized ) {
+ return; // we're unloading
+ }
+
+ if ( command == (void *)kIOPMUnidleDevice ) {
+ if ( (pm_vars->myCurrentState < (unsigned long)stateNumber) &&
+ (priv->imminentState < (unsigned long)stateNumber) ) {
+ changePowerStateToPriv((unsigned long)stateNumber);
+ }
+ }
+}
+
+
+//*********************************************************************************
+// setAggressiveness
//
// Pass on the input parameters to all power domain children. All those which are
// power domains will pass it on to their children, etc.
//*********************************************************************************
-IOReturn
-IOService::setAggressiveness( unsigned long type, unsigned long newLevel )
-{
- return kIOReturnSuccess;
-}
-
-//*********************************************************************************
-// [public] getAggressiveness
+IOReturn IOService::setAggressiveness ( unsigned long type, unsigned long newLevel )
+{
+ OSIterator * iter;
+ OSObject * next;
+ IOPowerConnection * connection;
+ IOService * child;
+
+ pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogSetAggressiveness,type, newLevel);
+
+ if ( type <= kMaxType ) {
+ pm_vars->current_aggressiveness_values[type] = newLevel;
+ pm_vars->current_aggressiveness_valid[type] = true;
+ }
+
+ iter = getChildIterator(gIOPowerPlane);
+
+ if ( iter ) {
+ while ( (next = iter->getNextObject()) ) {
+ if ( (connection = OSDynamicCast(IOPowerConnection,next)) ) {
+ child = ((IOService *)(connection->copyChildEntry(gIOPowerPlane)));
+ if ( child ) {
+ child->setAggressiveness(type, newLevel);
+ child->release();
+ }
+ }
+ }
+ iter->release();
+ }
+
+ return IOPMNoErr;
+}
+
+//*********************************************************************************
+// getAggressiveness
//
// Called by the user client.
//*********************************************************************************
-IOReturn
-IOService::getAggressiveness( unsigned long type, unsigned long * currentLevel )
-{
- IOPMrootDomain * rootDomain = getPMRootDomain();
-
- if (!rootDomain) {
- return kIOReturnNotReady;
- }
-
- return rootDomain->getAggressiveness( type, currentLevel );
-}
-
-//*********************************************************************************
-// [public] getPowerState
-//
-//*********************************************************************************
-
-UInt32
-IOService::getPowerState( void )
-{
- if (!initialized) {
- return kPowerStateZero;
- }
-
- return (UInt32) fCurrentPowerState;
-}
-
-//*********************************************************************************
-// [public] getDesiredPowerState
-//
-//*********************************************************************************
-
-UInt32
-IOService::getDesiredPowerState( void )
-{
- if (!initialized) {
- return kPowerStateZero;
- }
-
- return (UInt32) fDesiredPowerState;
-}
-
-#ifndef __LP64__
-//*********************************************************************************
-// [deprecated] systemWake
+IOReturn IOService::getAggressiveness ( unsigned long type, unsigned long * currentLevel )
+{
+ if ( type <= kMaxType ) {
+ *currentLevel = pm_vars->current_aggressiveness_values[type];
+ }
+ return kIOReturnSuccess;
+}
+
+//*********************************************************************************
+// systemWake
//
// Pass this to all power domain children. All those which are
// power domains will pass it on to their children, etc.
//*********************************************************************************
-IOReturn
-IOService::systemWake( void )
-{
- OSIterator * iter;
- OSObject * next;
- IOPowerConnection * connection;
- IOService * theChild;
-
- iter = getChildIterator(gIOPowerPlane);
- if (iter) {
- while ((next = iter->getNextObject())) {
- if ((connection = OSDynamicCast(IOPowerConnection, next))) {
- if (connection->getReadyFlag() == false) {
- PM_LOG3("[%s] %s: connection not ready\n",
- getName(), __FUNCTION__);
- continue;
- }
-
- theChild = (IOService *)connection->copyChildEntry(gIOPowerPlane);
- if (theChild) {
- theChild->systemWake();
- theChild->release();
- }
- }
- }
- iter->release();
- }
-
- if (fControllingDriver != NULL) {
- if (fControllingDriver->didYouWakeSystem()) {
- makeUsable();
- }
- }
-
- return IOPMNoErr;
-}
-
-//*********************************************************************************
-// [deprecated] temperatureCriticalForZone
-//*********************************************************************************
-
-IOReturn
-IOService::temperatureCriticalForZone( IOService * whichZone )
-{
- IOService * theParent;
- IOService * theNub;
-
- OUR_PMLog(kPMLogCriticalTemp, 0, 0);
-
- if (inPlane(gIOPowerPlane) && !IS_PM_ROOT) {
- theNub = (IOService *)copyParentEntry(gIOPowerPlane);
- if (theNub) {
- theParent = (IOService *)theNub->copyParentEntry(gIOPowerPlane);
- theNub->release();
- if (theParent) {
- theParent->temperatureCriticalForZone(whichZone);
- theParent->release();
- }
- }
- }
- return IOPMNoErr;
-}
-#endif /* !__LP64__ */
-
-// MARK: -
-// MARK: Power Change (Common)
-
-//*********************************************************************************
-// [private] startPowerChange
-//
-// All power state changes starts here.
-//*********************************************************************************
-
-IOReturn
-IOService::startPowerChange(
- IOPMPowerChangeFlags changeFlags,
- IOPMPowerStateIndex powerState,
- IOPMPowerFlags domainFlags,
- IOPowerConnection * parentConnection,
- IOPMPowerFlags parentFlags )
-{
- uint32_t savedPMActionsState;
-
- PM_ASSERT_IN_GATE();
- assert( fMachineState == kIOPM_Finished );
- assert( powerState < fNumberOfPowerStates );
-
- if (powerState >= fNumberOfPowerStates) {
- return IOPMAckImplied;
- }
-
- fIsPreChange = true;
- savedPMActionsState = fPMActions.state;
- PM_ACTION_CHANGE(actionPowerChangeOverride, &powerState, &changeFlags);
-
- // rdar://problem/55040032
- // Schedule a power adjustment after removing the power clamp
- // to inform our power parent(s) about our latest desired domain
- // power state. For a self-initiated change, let OurChangeStart()
- // automatically request parent power when necessary.
- if (!fAdjustPowerScheduled &&
- ((changeFlags & kIOPMSelfInitiated) == 0) &&
- ((fPMActions.state & kPMActionsStatePowerClamped) == 0) &&
- ((savedPMActionsState & kPMActionsStatePowerClamped) != 0)) {
- IOPMRequest * request = acquirePMRequest(this, kIOPMRequestTypeAdjustPowerState);
- if (request) {
- submitPMRequest(request);
- fAdjustPowerScheduled = true;
- }
- }
-
- if (changeFlags & kIOPMExpireIdleTimer) {
- // Root domain requested removal of tickle influence
- if (StateOrder(fDeviceDesire) > StateOrder(powerState)) {
- // Reset device desire down to the clamped power state
- updatePowerClient(gIOPMPowerClientDevice, powerState);
- computeDesiredState(kPowerStateZero, true);
-
- // Invalidate tickle cache so the next tickle will issue a request
- IOLockLock(fActivityLock);
- fDeviceWasActive = false;
- fActivityTicklePowerState = kInvalidTicklePowerState;
- IOLockUnlock(fActivityLock);
-
- fIdleTimerMinPowerState = kPowerStateZero;
- }
- }
-
- // Root domain's override handler may cancel the power change by
- // setting the kIOPMNotDone flag.
-
- if (changeFlags & kIOPMNotDone) {
- return IOPMAckImplied;
- }
-
- // Forks to either Driver or Parent initiated power change paths.
-
- fHeadNoteChangeFlags = changeFlags;
- fHeadNotePowerState = powerState;
- fHeadNotePowerArrayEntry = &fPowerStates[powerState];
- fHeadNoteParentConnection = NULL;
-
- if (changeFlags & kIOPMSelfInitiated) {
- if (changeFlags & kIOPMSynchronize) {
- OurSyncStart();
- } else {
- OurChangeStart();
- }
- return 0;
- } else {
- assert(changeFlags & kIOPMParentInitiated);
- fHeadNoteDomainFlags = domainFlags;
- fHeadNoteParentFlags = parentFlags;
- fHeadNoteParentConnection = parentConnection;
- return ParentChangeStart();
- }
-}
-
-//*********************************************************************************
-// [private] notifyInterestedDrivers
-//*********************************************************************************
-
-bool
-IOService::notifyInterestedDrivers( void )
-{
- IOPMinformee * informee;
- IOPMinformeeList * list = fInterestedDrivers;
- DriverCallParam * param;
- unsigned long numItems;
- uint32_t count;
- uint32_t skipCnt = 0;
-
- PM_ASSERT_IN_GATE();
- assert( fDriverCallParamCount == 0 );
- assert( fHeadNotePendingAcks == 0 );
-
- fHeadNotePendingAcks = 0;
-
- numItems = list->numberOfItems();
- if (!numItems || ((uint32_t) numItems != numItems)) {
- goto done; // interested drivers count out of range
- }
- count = (uint32_t) numItems;
-
- // Allocate an array of interested drivers and their return values
- // for the callout thread. Everything else is still "owned" by the
- // PM work loop, which can run to process acknowledgePowerChange()
- // responses.
-
- param = (DriverCallParam *) fDriverCallParamPtr;
- if (count > fDriverCallParamSlots) {
- if (fDriverCallParamSlots) {
- assert(fDriverCallParamPtr);
- IODelete(fDriverCallParamPtr, DriverCallParam, fDriverCallParamSlots);
- fDriverCallParamPtr = NULL;
- fDriverCallParamSlots = 0;
- }
-
- param = IONew(DriverCallParam, count);
- if (!param) {
- goto done; // no memory
- }
- fDriverCallParamPtr = (void *) param;
- fDriverCallParamSlots = count;
- }
-
- informee = list->firstInList();
- assert(informee);
- for (IOItemCount i = 0, arrayIdx = 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[arrayIdx].Target = informee;
- informee->retain();
- informee = list->nextInList( informee );
- arrayIdx++;
- }
-
- count -= skipCnt;
- if (!count) {
- goto done;
- }
- fDriverCallParamCount = count;
- fHeadNotePendingAcks = count;
-
- // Block state machine and wait for callout completion.
- assert(!fDriverCallBusy);
- fDriverCallBusy = true;
- thread_call_enter( fDriverCallEntry );
+IOReturn IOService::systemWake ( void )
+{
+ OSIterator * iter;
+ OSObject * next;
+ IOPowerConnection * connection;
+ IOService * theChild;
+
+ pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogSystemWake,0, 0);
+
+ iter = getChildIterator(gIOPowerPlane);
+
+ if ( iter ) {
+ while ( (next = iter->getNextObject()) ) {
+ if ( (connection = OSDynamicCast(IOPowerConnection,next)) ) {
+ theChild = (IOService *)connection->copyChildEntry(gIOPowerPlane);
+ if ( theChild ) {
+ theChild->systemWake();
+ theChild->release();
+ }
+ }
+ }
+ iter->release();
+ }
+
+ if ( pm_vars->theControllingDriver != NULL ) {
+ if ( pm_vars->theControllingDriver->didYouWakeSystem() ) {
+ makeUsable();
+ }
+ }
+
+ return IOPMNoErr;
+}
+
+
+//*********************************************************************************
+// temperatureCriticalForZone
+//
+//*********************************************************************************
+
+IOReturn IOService::temperatureCriticalForZone ( IOService * whichZone )
+{
+ IOService * theParent;
+ IOService * theNub;
+
+ pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogCriticalTemp,0,0);
+
+ if ( inPlane(gIOPowerPlane) && ! (priv->we_are_root) ) {
+ theNub = (IOService *)copyParentEntry(gIOPowerPlane);
+ if ( theNub ) {
+ theParent = (IOService *)theNub->copyParentEntry(gIOPowerPlane);
+ theNub->release();
+ if ( theParent ) {
+ theParent->temperatureCriticalForZone(whichZone);
+ theParent->release();
+ }
+ }
+ }
+ return IOPMNoErr;
+}
+
+
+//*********************************************************************************
+// powerOverrideOnPriv
+//
+//*********************************************************************************
+
+
+IOReturn IOService::powerOverrideOnPriv ( void )
+{
+ pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogOverrideOn,0,0);
+
+ priv->device_overrides = true; // turn on the override
+ computeDesiredState();
+ return changeState(); // change state if that changed something
+}
+
+
+//*********************************************************************************
+// powerOverrideOffPriv
+//
+//*********************************************************************************
+IOReturn IOService::powerOverrideOffPriv ( void )
+{
+ pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogOverrideOff,0,0);
+
+ priv->device_overrides = false; // turn off the override
+ computeDesiredState();
+ if( priv->clampOn)
+ return makeUsable();
+ else
+ return changeState(); // change state if that changed something
+}
+
+
+//*********************************************************************************
+// enqueuePowerChange
+//
+// Allocate a new state change notification, initialize it with fields from the
+// caller, and add it to the tail of the list of pending power changes.
+//
+// If it is early enough in the list, and almost all the time it is the only one in
+// the list, start the power change.
+//
+// In rare instances, this change will preempt the previous change in the list.
+// If the previous change is un-actioned in any way (because we are still
+// processing an even earlier power change), and if both the previous change
+// in the list and this change are initiated by us (not the parent), then we
+// needn't perform the previous change, so we collapse the list a little.
+//*********************************************************************************
+
+IOReturn IOService::enqueuePowerChange ( unsigned long flags, unsigned long whatStateOrdinal, unsigned long domainState, IOPowerConnection * whichParent, unsigned long singleParentState )
+{
+ long newNote;
+ long previousNote;
+
+// Create and initialize the new change note
+
+ IOLockLock(priv->queue_lock);
+ newNote = priv->changeList->createChangeNote();
+ if ( newNote == -1 ) {
+ IOLockUnlock(priv->queue_lock);
+ pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogEnqueueErr,0,0);
+ return IOPMAckImplied; // uh-oh, our list is full
+ }
+
+ priv->changeList->changeNote[newNote].newStateNumber = whatStateOrdinal;
+ priv->changeList->changeNote[newNote].outputPowerCharacter = pm_vars->thePowerStates[whatStateOrdinal].outputPowerCharacter;
+ priv->changeList->changeNote[newNote].inputPowerRequirement = pm_vars->thePowerStates[whatStateOrdinal].inputPowerRequirement;
+ priv->changeList->changeNote[newNote].capabilityFlags = pm_vars->thePowerStates[whatStateOrdinal].capabilityFlags;
+ priv->changeList->changeNote[newNote].flags = flags;
+ if (flags & IOPMParentInitiated ) {
+ priv->changeList->changeNote[newNote].domainState = domainState;
+ priv->changeList->changeNote[newNote].parent = whichParent;
+ whichParent->retain();
+ priv->changeList->changeNote[newNote].singleParentState = singleParentState;
+ }
+
+ previousNote = priv->changeList->previousChangeNote(newNote);
+
+ if ( previousNote == -1 ) {
+
+ // Queue is empty, we can start this change.
+
+ if (flags & IOPMWeInitiated ) {
+ IOLockUnlock(priv->queue_lock);
+ start_our_change(newNote);
+ return 0;
+ }
+ else {
+ IOLockUnlock(priv->queue_lock);
+ return start_parent_change(newNote);
+ }
+ }
+
+ // The queue is not empty. Try to collapse this new change and the previous one in queue into one change.
+ // This is possible only if both changes are initiated by us, and neither has been started yet.
+ // Do this more than once if possible.
+
+ // (A change is started iff it is at the head of the queue)
+
+ while ( (previousNote != priv->head_note) && (previousNote != -1) &&
+ (priv->changeList->changeNote[newNote].flags & priv->changeList->changeNote[previousNote].flags & IOPMWeInitiated) ) {
+ priv->changeList->changeNote[previousNote].outputPowerCharacter = priv->changeList->changeNote[newNote].outputPowerCharacter;
+ priv->changeList->changeNote[previousNote].inputPowerRequirement = priv->changeList->changeNote[newNote].inputPowerRequirement;
+ priv->changeList->changeNote[previousNote].capabilityFlags =priv-> changeList->changeNote[newNote].capabilityFlags;
+ pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogCollapseQueue,priv->changeList->changeNote[newNote].newStateNumber,
+ priv->changeList->changeNote[previousNote].newStateNumber);
+ priv->changeList->changeNote[previousNote].newStateNumber = priv->changeList->changeNote[newNote].newStateNumber;
+ priv->changeList->releaseTailChangeNote();
+ newNote = previousNote;
+ previousNote = priv->changeList->previousChangeNote(newNote);
+ }
+ IOLockUnlock(priv->queue_lock);
+ return IOPMWillAckLater; // in any case, we can't start yet
+}
+
+//*********************************************************************************
+// notifyAll
+//
+// Notify all interested parties either that a change is impending or that the
+// previously-notified change is done and power has settled.
+// The parameter identifies whether this is the
+// pre-change notification or the post-change notification.
+//
+//*********************************************************************************
+
+IOReturn IOService::notifyAll ( bool is_prechange )
+{
+ IOPMinformee * nextObject;
+ OSIterator * iter;
+ OSObject * next;
+ IOPowerConnection * connection;
+
+ // To prevent acknowledgePowerChange from finishing the change note and removing it from the queue if
+ // some driver calls it, we inflate the number of pending acks so it cannot become zero. We'll fix it later.
+
+ priv->head_note_pendingAcks =1;
+
+ // OK, we will go through the lists of interested drivers and power domain children
+ // and notify each one of this change.
+ nextObject = priv->interestedDrivers->firstInList(); // notify interested drivers
+ while ( nextObject != NULL ) {
+ priv->head_note_pendingAcks +=1;
+ if (! inform(nextObject, is_prechange) ) {
+ }
+ nextObject = priv->interestedDrivers->nextInList(nextObject);
+ }
+
+ if (! acquire_lock() ) {
+ return IOPMNoErr;
+ }
+ if ( priv->head_note_pendingAcks > 1 ) { // did they all ack?
+ pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogStartAckTimer,0,0); // no
+ start_ack_timer();
+ }
+ IOUnlock(priv->our_lock); // either way
+
+ iter = getChildIterator(gIOPowerPlane); // notify children
+ pm_vars->thePowerStates[priv->head_note_state].staticPower = 0; // summing their power consumption
+
+ if ( iter ) {
+ while ( (next = iter->getNextObject()) ) {
+ if ( (connection = OSDynamicCast(IOPowerConnection,next)) ) {
+ priv->head_note_pendingAcks +=1;
+ notifyChild(connection, is_prechange);
+ }
+ }
+ iter->release();
+ }
+
+ if (! acquire_lock() ) {
+ return IOPMNoErr;
+ }
+ priv->head_note_pendingAcks -= 1; // now make this real
+ if (priv->head_note_pendingAcks == 0 ) { // is it all acked?
+ IOUnlock(priv->our_lock); // yes
+ return IOPMAckImplied; // return ack to parent
+ }
+ IOUnlock(priv->our_lock); // no
+ return IOPMWillAckLater;
+}
+
+
+//*********************************************************************************
+// notifyChild
+//
+// Notify a power domain child of an upcoming power change.
+//
+// If the object acknowledges the current change, we return TRUE.
+//*********************************************************************************
+
+bool IOService::notifyChild ( IOPowerConnection * theNub, bool is_prechange )
+{
+ IOReturn k = IOPMAckImplied;
+ unsigned long childPower;
+ IOService * theChild = (IOService *)(theNub->copyChildEntry(gIOPowerPlane));
+
+ theNub->setAwaitingAck(true); // in case they don't ack
+
+ if ( ! theChild ) {
+ return true;
+ }
+
+ if ( is_prechange ) {
+ k = theChild->powerDomainWillChangeTo(priv->head_note_outputFlags,theNub);
+ }
+ else {
+ k = theChild->powerDomainDidChangeTo(priv->head_note_outputFlags,theNub);
+ }
+
+ if ( k == IOPMAckImplied ) { // did the return code ack?
+ priv->head_note_pendingAcks -=1; // yes
+ theNub->setAwaitingAck(false);
+ childPower = theChild->currentPowerConsumption();
+ if ( childPower == kIOPMUnknown ) {
+ pm_vars->thePowerStates[priv->head_note_state].staticPower = kIOPMUnknown;
+ }
+ else {
+ if ( pm_vars->thePowerStates[priv->head_note_state].staticPower != kIOPMUnknown ) {
+ pm_vars->thePowerStates[priv->head_note_state].staticPower += childPower;
+ }
+ }
+ theChild->release();
return true;
-
-done:
- // Return false if there are no interested drivers or could not schedule
- // callout thread due to error.
- return false;
-}
-
-//*********************************************************************************
-// [private] notifyInterestedDriversDone
-//*********************************************************************************
-
-void
-IOService::notifyInterestedDriversDone( void )
-{
- IOPMinformee * informee;
- IOItemCount count;
- DriverCallParam * param;
- IOReturn result;
- int maxTimeout = 0;
-
- PM_ASSERT_IN_GATE();
- assert( fDriverCallBusy == false );
- assert( fMachineState == kIOPM_DriverThreadCallDone );
-
- param = (DriverCallParam *) fDriverCallParamPtr;
- count = fDriverCallParamCount;
-
- 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 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) {
- fHeadNotePendingAcks--;
- }
-
- informee->timer = 0;
- } else if (informee->timer) {
- assert(informee->timer == -1);
-
- // Driver has not acked, and has returned a positive result.
- // Enforce a minimum permissible timeout value.
- // Make the min value large enough so timeout is less likely
- // to occur if a driver misinterpreted that the return value
- // should be in microsecond units. And make it large enough
- // to be noticeable if a driver neglects to ack.
-
- if (result < kMinAckTimeoutTicks) {
- result = kMinAckTimeoutTicks;
- }
-
- informee->timer = (result / (ACK_TIMER_PERIOD / ns_per_us)) + 1;
- if (result > maxTimeout) {
- maxTimeout = result;
- }
- }
- // else, child has already acked or driver has removed interest,
- // and head_note_pendingAcks decremented.
- // informee may have been removed from the interested drivers list,
- // thus the informee must be retained across the callout.
-
- informee->release();
- }
-
- fDriverCallParamCount = 0;
-
- if (fHeadNotePendingAcks) {
- OUR_PMLog(kPMLogStartAckTimer, 0, 0);
- start_ack_timer();
- getPMRootDomain()->reset_watchdog_timer(this, maxTimeout / USEC_PER_SEC + 1);
- }
- }
-
- MS_POP(); // pop the machine state passed to notifyAll()
-
- // If interest acks are outstanding, block the state machine until
- // fHeadNotePendingAcks drops to zero before notifying root domain.
- // Otherwise notify root domain directly.
-
- if (!fHeadNotePendingAcks) {
- notifyRootDomain();
- } else {
- MS_PUSH(fMachineState);
- fMachineState = kIOPM_NotifyChildrenStart;
- }
-}
-
-//*********************************************************************************
-// [private] notifyRootDomain
-//*********************************************************************************
-
-void
-IOService::notifyRootDomain( void )
-{
- assert( fDriverCallBusy == false );
-
- // Only for root domain in the will-change phase.
- // On a power up, don't notify children right after the interested drivers.
- // Perform setPowerState() first, then notify the children.
- if (!IS_ROOT_DOMAIN || (fMachineState != kIOPM_OurChangeSetPowerState)) {
- notifyChildren();
- return;
- }
-
- MS_PUSH(fMachineState); // push notifyAll() machine state
- fMachineState = kIOPM_DriverThreadCallDone;
-
- // Call IOPMrootDomain::willNotifyPowerChildren() on a thread call
- // to avoid a deadlock.
- fDriverCallReason = kRootDomainInformPreChange;
- fDriverCallBusy = true;
- thread_call_enter( fDriverCallEntry );
-}
-
-void
-IOService::notifyRootDomainDone( void )
-{
- assert( fDriverCallBusy == false );
- assert( fMachineState == kIOPM_DriverThreadCallDone );
-
- if (IS_ROOT_DOMAIN) {
- // Reset in case watchdog was adjusted for hibernation
- reset_watchdog_timer();
- }
-
- MS_POP(); // pop notifyAll() machine state
- notifyChildren();
-}
-
-//*********************************************************************************
-// [private] notifyChildren
-//*********************************************************************************
-
-void
-IOService::notifyChildren( void )
-{
- OSIterator * iter;
- OSObject * next;
- IOPowerConnection * connection;
- OSArray * children = NULL;
- IOPMrootDomain * rootDomain;
- bool delayNotify = false;
-
- if ((fHeadNotePowerState != fCurrentPowerState) &&
- (IS_POWER_DROP == fIsPreChange) &&
- ((rootDomain = getPMRootDomain()) == this)) {
- rootDomain->tracePoint( IS_POWER_DROP ?
- kIOPMTracePointSleepPowerPlaneDrivers :
- kIOPMTracePointWakePowerPlaneDrivers );
- }
-
- if (fStrictTreeOrder) {
- children = OSArray::withCapacity(8);
- }
-
- // Sum child power consumption in notifyChild()
- fHeadNotePowerArrayEntry->staticPower = 0;
-
- iter = getChildIterator(gIOPowerPlane);
- if (iter) {
- while ((next = iter->getNextObject())) {
- if ((connection = OSDynamicCast(IOPowerConnection, next))) {
- if (connection->getReadyFlag() == false) {
- PM_LOG3("[%s] %s: connection not ready\n",
- getName(), __FUNCTION__);
- continue;
- }
-
- // Mechanism to postpone the did-change notification to
- // certain power children to order those children last.
- // Cannot be used together with strict tree ordering.
-
- if (!fIsPreChange &&
- connection->delayChildNotification &&
- getPMRootDomain()->shouldDelayChildNotification(this)) {
- if (!children) {
- children = OSArray::withCapacity(8);
- if (children) {
- delayNotify = true;
- }
- }
- if (delayNotify) {
- children->setObject( connection );
- continue;
- }
- }
-
- if (!delayNotify && children) {
- children->setObject( connection );
- } else {
- notifyChild( connection );
- }
- }
- }
- iter->release();
- }
-
- if (children && (children->getCount() == 0)) {
- children->release();
- children = NULL;
- }
- if (children) {
- assert(fNotifyChildArray == NULL);
- fNotifyChildArray = children;
- MS_PUSH(fMachineState);
-
- if (delayNotify) {
- // Block until all non-delayed children have acked their
- // notification. Then notify the remaining delayed child
- // in the array. This is used to hold off graphics child
- // notification while the rest of the system powers up.
- // If a hid tickle arrives during this time, the delayed
- // children are immediately notified and root domain will
- // not clamp power for dark wake.
-
- fMachineState = kIOPM_NotifyChildrenDelayed;
- PM_LOG2("%s: %d children in delayed array\n",
- getName(), children->getCount());
- } else {
- // Child array created to support strict notification order.
- // Notify children in the array one at a time.
-
- fMachineState = kIOPM_NotifyChildrenOrdered;
- }
- }
-}
-
-//*********************************************************************************
-// [private] notifyChildrenOrdered
-//*********************************************************************************
-
-void
-IOService::notifyChildrenOrdered( void )
-{
- PM_ASSERT_IN_GATE();
- assert(fNotifyChildArray);
- assert(fMachineState == kIOPM_NotifyChildrenOrdered);
-
- // Notify one child, wait for it to ack, then repeat for next child.
- // This is a workaround for some drivers with multiple instances at
- // the same branch in the power tree, but the driver is slow to power
- // up unless the tree ordering is observed. Problem observed only on
- // system wake, not on system sleep.
- //
- // We have the ability to power off in reverse child index order.
- // That works nicely on some machines, but not on all HW configs.
-
- if (fNotifyChildArray->getCount()) {
- IOPowerConnection * connection;
- connection = (IOPowerConnection *) fNotifyChildArray->getObject(0);
- notifyChild( connection );
- fNotifyChildArray->removeObject(0);
- } else {
- fNotifyChildArray->release();
- fNotifyChildArray = NULL;
-
- MS_POP(); // pushed by notifyChildren()
- }
-}
-
-//*********************************************************************************
-// [private] notifyChildrenDelayed
-//*********************************************************************************
-
-void
-IOService::notifyChildrenDelayed( void )
-{
- IOPowerConnection * connection;
-
- PM_ASSERT_IN_GATE();
- assert(fNotifyChildArray);
- assert(fMachineState == kIOPM_NotifyChildrenDelayed);
-
- // Wait after all non-delayed children and interested drivers have ack'ed,
- // then notify all delayed children. If notify delay is canceled, child
- // acks may be outstanding with PM blocked on fHeadNotePendingAcks != 0.
- // But the handling for either case is identical.
-
- for (int i = 0;; i++) {
- connection = (IOPowerConnection *) fNotifyChildArray->getObject(i);
- if (!connection) {
- break;
- }
-
- notifyChild( connection );
- }
-
- PM_LOG2("%s: notified delayed children\n", getName());
- fNotifyChildArray->release();
- fNotifyChildArray = NULL;
-
- MS_POP(); // pushed by notifyChildren()
-}
-
-//*********************************************************************************
-// [private] notifyAll
-//*********************************************************************************
-
-IOReturn
-IOService::notifyAll( uint32_t nextMS )
-{
- // Save the machine state to be restored by notifyInterestedDriversDone()
-
- PM_ASSERT_IN_GATE();
- MS_PUSH(nextMS);
- fMachineState = kIOPM_DriverThreadCallDone;
- fDriverCallReason = fIsPreChange ?
- kDriverCallInformPreChange : kDriverCallInformPostChange;
-
- if (!notifyInterestedDrivers()) {
- notifyInterestedDriversDone();
- }
-
- return IOPMWillAckLater;
-}
-
-//*********************************************************************************
-// [private, static] pmDriverCallout
-//
-// Thread call context
-//*********************************************************************************
-
-IOReturn
-IOService::actionDriverCalloutDone(
- OSObject * target,
- void * arg0, void * arg1,
- void * arg2, void * arg3 )
-{
- IOServicePM * pwrMgt = (IOServicePM *) arg0;
-
- assert( fDriverCallBusy );
- fDriverCallBusy = false;
-
- assert(gIOPMWorkQueue);
- gIOPMWorkQueue->signalWorkAvailable();
-
- return kIOReturnSuccess;
-}
-
-void
-IOService::pmDriverCallout( IOService * from,
- __unused thread_call_param_t p)
-{
- assert(from);
- from->startDriverCalloutTimer();
- switch (from->fDriverCallReason) {
- case kDriverCallSetPowerState:
- from->driverSetPowerState();
- break;
-
- case kDriverCallInformPreChange:
- if (from == getPMRootDomain()) {
- getPMRootDomain()->willNotifyInterested(from->fHeadNotePowerState);
- }
- OS_FALLTHROUGH;
- case kDriverCallInformPostChange:
- from->driverInformPowerChange();
- break;
-
- case kRootDomainInformPreChange:
- getPMRootDomain()->willNotifyPowerChildren(from->fHeadNotePowerState);
- break;
-
- default:
- panic("IOService::pmDriverCallout bad machine state %x",
- from->fDriverCallReason);
- }
- from->stopDriverCalloutTimer();
-
- gIOPMWorkLoop->runAction(actionDriverCalloutDone,
- /* target */ from,
- /* arg0 */ (void *) from->pwrMgt );
-}
-
-//*********************************************************************************
-// [private] driverSetPowerState
-//
-// Thread call context
-//*********************************************************************************
-
-void
-IOService::driverSetPowerState( void )
-{
- IOPMPowerStateIndex powerState;
- DriverCallParam * param;
- IOPMDriverCallEntry callEntry;
- AbsoluteTime end;
- IOReturn result;
- uint32_t oldPowerState = getPowerState();
- const OSMetaClass *controllingDriverMetaClass = NULL;
- uint32_t controllingDriverRegistryEntryID = 0;
-
- assert( fDriverCallBusy );
- assert( fDriverCallParamPtr );
- assert( fDriverCallParamCount == 1 );
-
- param = (DriverCallParam *) fDriverCallParamPtr;
- powerState = fHeadNotePowerState;
- if (fControllingDriver) {
- controllingDriverMetaClass = fControllingDriver->getMetaClass();
- controllingDriverRegistryEntryID = (uint32_t)fControllingDriver->getRegistryEntryID();
- }
-
- if (assertPMDriverCall(&callEntry, kIOPMDriverCallMethodSetPowerState)) {
- SOCD_TRACE_XNU_START(PM_SET_POWER_STATE,
- ADDR(controllingDriverMetaClass),
- ADDR(this->getMetaClass()),
- PACK_2X32(VALUE(this->getRegistryEntryID()), VALUE(controllingDriverRegistryEntryID)),
- PACK_2X32(VALUE(powerState), VALUE(oldPowerState)));
-
- OUR_PMLogFuncStart(kPMLogProgramHardware, (uintptr_t) this, powerState);
- clock_get_uptime(&fDriverCallStartTime);
-
- if (reserved && reserved->uvars && reserved->uvars->userServer) {
- result = reserved->uvars->userServer->serviceSetPowerState(fControllingDriver, this, fHeadNotePowerArrayEntry->capabilityFlags, powerState);
- } else {
- result = fControllingDriver->setPowerState( powerState, this );
- }
- clock_get_uptime(&end);
- OUR_PMLogFuncEnd(kPMLogProgramHardware, (uintptr_t) this, (UInt32) result);
- SOCD_TRACE_XNU_END(PM_SET_POWER_STATE,
- ADDR(controllingDriverMetaClass),
- ADDR(this->getMetaClass()),
- PACK_2X32(VALUE(this->getRegistryEntryID()), VALUE(controllingDriverRegistryEntryID)),
- PACK_2X32(VALUE(powerState), VALUE(result)));
-
- deassertPMDriverCall(&callEntry);
-
- // Record the most recent max power state residency timings.
- // Use with DeviceActiveTimestamp to diagnose tickle issues.
- if (powerState == fHighestPowerState) {
- fMaxPowerStateEntryTime = end;
- } else if (oldPowerState == fHighestPowerState) {
- fMaxPowerStateExitTime = end;
- }
-
- if (result < 0) {
- PM_LOG("%s::setPowerState(%p, %lu -> %lu) returned 0x%x\n",
- fName, OBFUSCATE(this), fCurrentPowerState, powerState, result);
- }
-
-
- if ((result == IOPMAckImplied) || (result < 0)) {
- uint64_t nsec;
-
- SUB_ABSOLUTETIME(&end, &fDriverCallStartTime);
- absolutetime_to_nanoseconds(end, &nsec);
- if (nsec > gIOPMSetPowerStateLogNS) {
- getPMRootDomain()->pmStatsRecordApplicationResponse(
- gIOPMStatsDriverPSChangeSlow,
- fName, kDriverCallSetPowerState, NS_TO_MS(nsec), getRegistryEntryID(),
- NULL, powerState);
- }
- }
- } else {
- result = kIOPMAckImplied;
- }
-
- param->Result = result;
-}
-
-//*********************************************************************************
-// [private] driverInformPowerChange
-//
-// Thread call context
-//*********************************************************************************
-
-void
-IOService::driverInformPowerChange( void )
-{
- IOPMinformee * informee;
- IOService * driver;
- DriverCallParam * param;
- IOPMDriverCallEntry callEntry;
- IOPMPowerFlags powerFlags;
- IOPMPowerStateIndex powerState;
- AbsoluteTime end;
- IOReturn result;
- IOItemCount count;
- IOOptionBits callMethod = (fDriverCallReason == kDriverCallInformPreChange) ?
- kIOPMDriverCallMethodWillChange : kIOPMDriverCallMethodDidChange;
-
- assert( fDriverCallBusy );
- assert( fDriverCallParamPtr );
- assert( fDriverCallParamCount );
-
- param = (DriverCallParam *) fDriverCallParamPtr;
- count = fDriverCallParamCount;
-
- powerFlags = fHeadNotePowerArrayEntry->capabilityFlags;
- powerState = fHeadNotePowerState;
-
- for (IOItemCount i = 0; i < count; i++) {
- informee = (IOPMinformee *) param->Target;
- driver = informee->whatObject;
-
- if (assertPMDriverCall(&callEntry, callMethod, informee)) {
- SOCD_TRACE_XNU_START(PM_INFORM_POWER_CHANGE,
- ADDR(driver->getMetaClass()),
- ADDR(this->getMetaClass()),
- PACK_2X32(VALUE(this->getRegistryEntryID()), VALUE(driver->getRegistryEntryID())),
- PACK_2X32(VALUE(powerState), VALUE(fDriverCallReason)));
-
- if (fDriverCallReason == kDriverCallInformPreChange) {
- OUR_PMLogFuncStart(kPMLogInformDriverPreChange, (uintptr_t) this, powerState);
- clock_get_uptime(&informee->startTime);
- result = driver->powerStateWillChangeTo(powerFlags, powerState, this);
- clock_get_uptime(&end);
- OUR_PMLogFuncEnd(kPMLogInformDriverPreChange, (uintptr_t) this, result);
- } else {
- OUR_PMLogFuncStart(kPMLogInformDriverPostChange, (uintptr_t) this, powerState);
- clock_get_uptime(&informee->startTime);
- result = driver->powerStateDidChangeTo(powerFlags, powerState, this);
- clock_get_uptime(&end);
- OUR_PMLogFuncEnd(kPMLogInformDriverPostChange, (uintptr_t) this, result);
- }
-
- SOCD_TRACE_XNU_END(PM_INFORM_POWER_CHANGE,
- ADDR(driver->getMetaClass()),
- ADDR(this->getMetaClass()),
- PACK_2X32(VALUE(this->getRegistryEntryID()), VALUE(driver->getRegistryEntryID())),
- PACK_2X32(VALUE(result), VALUE(fDriverCallReason)));
-
- deassertPMDriverCall(&callEntry);
-
-
- if ((result == IOPMAckImplied) || (result < 0)) {
- uint64_t nsec;
-
- SUB_ABSOLUTETIME(&end, &informee->startTime);
- absolutetime_to_nanoseconds(end, &nsec);
- if (nsec > gIOPMSetPowerStateLogNS) {
- getPMRootDomain()->pmStatsRecordApplicationResponse(
- gIOPMStatsDriverPSChangeSlow, driver->getName(),
- fDriverCallReason, NS_TO_MS(nsec), driver->getRegistryEntryID(),
- NULL, powerState);
- }
- }
- } else {
- result = kIOPMAckImplied;
- }
-
- param->Result = result;
- param++;
- }
-}
-
-//*********************************************************************************
-// [private, static] pmDriverCalloutTimer
-//
-// Thread call context.
-//*********************************************************************************
-
-void
-IOService::startDriverCalloutTimer( void )
-{
- AbsoluteTime deadline;
- boolean_t pending;
-
- clock_interval_to_deadline(gDriverCalloutTimer, kMillisecondScale, &deadline);
-
- retain();
- pending = thread_call_enter_delayed(fDriverCallTimer, deadline);
- if (pending) {
- release();
- }
-}
-
-void
-IOService::stopDriverCalloutTimer( void )
-{
- boolean_t pending;
-
- pending = thread_call_cancel(fDriverCallTimer);
- if (pending) {
- release();
- }
-}
-
-void
-IOService::pmDriverCalloutTimer( thread_call_param_t arg0,
- __unused thread_call_param_t arg1)
-{
- assert(arg0);
- IOService *from = (IOService *) arg0;
- PM_LOG("PM waiting on pmDriverCallout(0x%x) to %s (%u ms)\n", from->fDriverCallReason, from->fName, gDriverCalloutTimer);
- from->release();
-}
-
-//*********************************************************************************
-// [private] notifyChild
-//
-// Notify a power domain child of an upcoming power change.
+ }
+ theChild->release();
+ return false;
+}
+
+
+//*********************************************************************************
+// inform
+//
+// Notify an interested driver of an upcoming power change.
+//
// If the object acknowledges the current change, we return TRUE.
//*********************************************************************************
-bool
-IOService::notifyChild( IOPowerConnection * theNub )
-{
- IOReturn ret = IOPMAckImplied;
- unsigned long childPower;
- IOService * theChild;
- IOPMRequest * childRequest;
- IOPMPowerChangeFlags requestArg2;
- int requestType;
-
- PM_ASSERT_IN_GATE();
- theChild = (IOService *)(theNub->copyChildEntry(gIOPowerPlane));
- if (!theChild) {
- return true;
- }
-
- // Unless the child handles the notification immediately and returns
- // kIOPMAckImplied, we'll be awaiting their acknowledgement later.
- fHeadNotePendingAcks++;
- theNub->setAwaitingAck(true);
-
- requestArg2 = fHeadNoteChangeFlags;
- if (StateOrder(fHeadNotePowerState) < StateOrder(fCurrentPowerState)) {
- requestArg2 |= kIOPMDomainPowerDrop;
- }
-
- requestType = fIsPreChange ?
- kIOPMRequestTypePowerDomainWillChange :
- kIOPMRequestTypePowerDomainDidChange;
-
- childRequest = acquirePMRequest( theChild, requestType );
- if (childRequest) {
- theNub->retain();
- childRequest->fArg0 = (void *) fHeadNotePowerArrayEntry->outputPowerFlags;
- childRequest->fArg1 = (void *) theNub;
- childRequest->fArg2 = (void *)(uintptr_t) requestArg2;
- theChild->submitPMRequest( childRequest );
- ret = IOPMWillAckLater;
- } else {
- ret = IOPMAckImplied;
- fHeadNotePendingAcks--;
- theNub->setAwaitingAck(false);
- childPower = theChild->currentPowerConsumption();
- if (childPower == kIOPMUnknown) {
- fHeadNotePowerArrayEntry->staticPower = kIOPMUnknown;
- } else {
- if (fHeadNotePowerArrayEntry->staticPower != kIOPMUnknown) {
- fHeadNotePowerArrayEntry->staticPower += childPower;
- }
- }
- }
-
- theChild->release();
- return IOPMAckImplied == ret;
-}
-
-//*********************************************************************************
-// [private] notifyControllingDriver
-//*********************************************************************************
-
-bool
-IOService::notifyControllingDriver( void )
-{
- DriverCallParam * param;
-
- PM_ASSERT_IN_GATE();
- assert( fDriverCallParamCount == 0 );
- assert( fControllingDriver );
-
- if (fInitialSetPowerState) {
- fInitialSetPowerState = false;
- fHeadNoteChangeFlags |= kIOPMInitialPowerChange;
-
- // Driver specified flag to skip the inital setPowerState()
- if (fHeadNotePowerArrayEntry->capabilityFlags & kIOPMInitialDeviceState) {
- return false;
- }
- }
-
- param = (DriverCallParam *) fDriverCallParamPtr;
- if (!param) {
- param = IONew(DriverCallParam, 1);
- if (!param) {
- return false; // no memory
- }
- fDriverCallParamPtr = (void *) param;
- fDriverCallParamSlots = 1;
- }
-
- param->Target = fControllingDriver;
- fDriverCallParamCount = 1;
- fDriverTimer = -1;
-
- // Block state machine and wait for callout completion.
- assert(!fDriverCallBusy);
- fDriverCallBusy = true;
- thread_call_enter( fDriverCallEntry );
-
- return true;
-}
-
-//*********************************************************************************
-// [private] notifyControllingDriverDone
-//*********************************************************************************
-
-void
-IOService::notifyControllingDriverDone( void )
-{
- DriverCallParam * param;
- IOReturn result;
-
- PM_ASSERT_IN_GATE();
- param = (DriverCallParam *) fDriverCallParamPtr;
-
- assert( fDriverCallBusy == false );
- assert( fMachineState == kIOPM_DriverThreadCallDone );
-
- if (param && fDriverCallParamCount) {
- assert(fDriverCallParamCount == 1);
-
- // the return value from setPowerState()
- result = param->Result;
-
- if ((result == IOPMAckImplied) || (result < 0)) {
- fDriverTimer = 0;
- } else if (fDriverTimer) {
- assert(fDriverTimer == -1);
-
- // Driver has not acked, and has returned a positive result.
- // Enforce a minimum permissible timeout value.
- // Make the min value large enough so timeout is less likely
- // to occur if a driver misinterpreted that the return value
- // should be in microsecond units. And make it large enough
- // to be noticeable if a driver neglects to ack.
-
- if (result < kMinAckTimeoutTicks) {
- result = kMinAckTimeoutTicks;
- }
-
- fDriverTimer = (result / (ACK_TIMER_PERIOD / ns_per_us)) + 1;
- }
- // else, child has already acked and driver_timer reset to 0.
-
- fDriverCallParamCount = 0;
-
- if (fDriverTimer) {
- OUR_PMLog(kPMLogStartAckTimer, 0, 0);
- start_ack_timer();
- getPMRootDomain()->reset_watchdog_timer(this, result / USEC_PER_SEC + 1);
- }
- }
-
- MS_POP(); // pushed by OurChangeSetPowerState()
- fIsPreChange = false;
-}
-
-//*********************************************************************************
-// [private] all_done
-//
-// A power change is done.
-//*********************************************************************************
-
-void
-IOService::all_done( void )
-{
- IOPMPowerStateIndex prevPowerState;
- const IOPMPSEntry * powerStatePtr;
- IOPMDriverCallEntry callEntry;
- uint32_t prevMachineState = fMachineState;
- bool actionCalled = false;
- uint64_t ts;
-
- fMachineState = kIOPM_Finished;
-
- if ((fHeadNoteChangeFlags & kIOPMSynchronize) &&
- ((prevMachineState == kIOPM_Finished) ||
- (prevMachineState == kIOPM_SyncFinish))) {
- // Sync operation and no power change occurred.
- // Do not inform driver and clients about this request completion,
- // except for the originator (root domain).
-
- PM_ACTION_CHANGE(actionPowerChangeDone,
- fHeadNotePowerState, fHeadNoteChangeFlags);
-
- if (getPMRequestType() == kIOPMRequestTypeSynchronizePowerTree) {
- powerChangeDone(fCurrentPowerState);
- } else if (fAdvisoryTickleUsed) {
- // Not root domain and advisory tickle target.
- // Re-adjust power after power tree sync at the 'did' pass
- // to recompute desire and adjust power state between dark
- // and full wake transitions. Root domain is responsible
- // for calling setAdvisoryTickleEnable() before starting
- // the kIOPMSynchronize power change.
-
- if (!fAdjustPowerScheduled &&
- (fHeadNoteChangeFlags & kIOPMDomainDidChange)) {
- IOPMRequest * request;
- request = acquirePMRequest( this, kIOPMRequestTypeAdjustPowerState );
- if (request) {
- submitPMRequest( request );
- fAdjustPowerScheduled = true;
- }
- }
- }
-
- return;
- }
-
- // our power change
- if (fHeadNoteChangeFlags & kIOPMSelfInitiated) {
- // power state changed
- if ((fHeadNoteChangeFlags & kIOPMNotDone) == 0) {
- trackSystemSleepPreventers(
- fCurrentPowerState, fHeadNotePowerState, fHeadNoteChangeFlags);
-
- // we changed, tell our parent
- requestDomainPower(fHeadNotePowerState);
-
- // yes, did power raise?
- if (StateOrder(fCurrentPowerState) < StateOrder(fHeadNotePowerState)) {
- // yes, inform clients and apps
- tellChangeUp(fHeadNotePowerState);
- }
- prevPowerState = fCurrentPowerState;
- // either way
- fCurrentPowerState = fHeadNotePowerState;
- PM_LOCK();
- if (fReportBuf) {
- ts = mach_absolute_time();
- STATEREPORT_SETSTATE(fReportBuf, (uint16_t) fCurrentPowerState, ts);
- }
- PM_UNLOCK();
-#if PM_VARS_SUPPORT
- fPMVars->myCurrentState = fCurrentPowerState;
-#endif
- OUR_PMLog(kPMLogChangeDone, fCurrentPowerState, prevPowerState);
- PM_ACTION_CHANGE(actionPowerChangeDone,
- prevPowerState, fHeadNoteChangeFlags);
- actionCalled = true;
-
- powerStatePtr = &fPowerStates[fCurrentPowerState];
- fCurrentCapabilityFlags = powerStatePtr->capabilityFlags;
- if (fCurrentCapabilityFlags & kIOPMStaticPowerValid) {
- fCurrentPowerConsumption = powerStatePtr->staticPower;
- }
-
- if (fHeadNoteChangeFlags & kIOPMRootChangeDown) {
- // Bump tickle generation count once the entire tree is down
- gIOPMTickleGeneration++;
- }
-
- // inform subclass policy-maker
- if (fPCDFunctionOverride && fParentsKnowState &&
- assertPMDriverCall(&callEntry, kIOPMDriverCallMethodChangeDone, NULL, kIOPMDriverCallNoInactiveCheck)) {
- powerChangeDone(prevPowerState);
- deassertPMDriverCall(&callEntry);
- }
- } else if (getPMRequestType() == kIOPMRequestTypeRequestPowerStateOverride) {
- // changePowerStateWithOverrideTo() was cancelled
- fOverrideMaxPowerState = kIOPMPowerStateMax;
- }
- }
-
- // parent-initiated power change
- if (fHeadNoteChangeFlags & kIOPMParentInitiated) {
- if (fHeadNoteChangeFlags & kIOPMRootChangeDown) {
- ParentChangeRootChangeDown();
- }
-
- // power state changed
- if ((fHeadNoteChangeFlags & kIOPMNotDone) == 0) {
- trackSystemSleepPreventers(
- fCurrentPowerState, fHeadNotePowerState, fHeadNoteChangeFlags);
-
- // did power raise?
- if (StateOrder(fCurrentPowerState) < StateOrder(fHeadNotePowerState)) {
- // yes, inform clients and apps
- tellChangeUp(fHeadNotePowerState);
- }
- // either way
- prevPowerState = fCurrentPowerState;
- fCurrentPowerState = fHeadNotePowerState;
- PM_LOCK();
- if (fReportBuf) {
- ts = mach_absolute_time();
- STATEREPORT_SETSTATE(fReportBuf, (uint16_t) fCurrentPowerState, ts);
- }
- PM_UNLOCK();
-#if PM_VARS_SUPPORT
- fPMVars->myCurrentState = fCurrentPowerState;
-#endif
-
- OUR_PMLog(kPMLogChangeDone, fCurrentPowerState, prevPowerState);
- PM_ACTION_CHANGE(actionPowerChangeDone,
- prevPowerState, fHeadNoteChangeFlags);
- actionCalled = true;
-
- powerStatePtr = &fPowerStates[fCurrentPowerState];
- fCurrentCapabilityFlags = powerStatePtr->capabilityFlags;
- if (fCurrentCapabilityFlags & kIOPMStaticPowerValid) {
- fCurrentPowerConsumption = powerStatePtr->staticPower;
- }
-
- // inform subclass policy-maker
- if (fPCDFunctionOverride && fParentsKnowState &&
- assertPMDriverCall(&callEntry, kIOPMDriverCallMethodChangeDone, NULL, kIOPMDriverCallNoInactiveCheck)) {
- powerChangeDone(prevPowerState);
- deassertPMDriverCall(&callEntry);
- }
- }
- }
-
- // When power rises enough to satisfy the tickle's desire for more power,
- // the condition preventing idle-timer from dropping power is removed.
-
- if (StateOrder(fCurrentPowerState) >= StateOrder(fIdleTimerMinPowerState)) {
- fIdleTimerMinPowerState = kPowerStateZero;
- }
-
- if (!actionCalled) {
- PM_ACTION_CHANGE(actionPowerChangeDone,
- fHeadNotePowerState, fHeadNoteChangeFlags);
- }
-}
-
-// MARK: -
-// MARK: Power Change Initiated by Driver
-
-//*********************************************************************************
-// [private] OurChangeStart
-//
-// Begin the processing of a power change initiated by us.
-//*********************************************************************************
-
-void
-IOService::OurChangeStart( void )
-{
- PM_ASSERT_IN_GATE();
- OUR_PMLog( kPMLogStartDeviceChange, fHeadNotePowerState, fCurrentPowerState );
-
- // fMaxPowerState is our maximum possible power state based on the current
- // power state of our parents. If we are trying to raise power beyond the
- // maximum, send an async request for more power to all parents.
-
- if (!IS_PM_ROOT && (StateOrder(fMaxPowerState) < StateOrder(fHeadNotePowerState))) {
- fHeadNoteChangeFlags |= kIOPMNotDone;
- requestDomainPower(fHeadNotePowerState);
- OurChangeFinish();
- return;
- }
-
- // Redundant power changes skips to the end of the state machine.
-
- if (!fInitialPowerChange && (fHeadNotePowerState == fCurrentPowerState)) {
- OurChangeFinish();
- return;
- }
- fInitialPowerChange = false;
-
- // Change started, but may not complete...
- // Can be canceled (power drop) or deferred (power rise).
-
- PM_ACTION_CHANGE(actionPowerChangeStart, fHeadNotePowerState, &fHeadNoteChangeFlags);
-
- // Two separate paths, depending if power is being raised or lowered.
- // Lowering power is subject to approval by clients of this service.
-
- if (IS_POWER_DROP) {
- fDoNotPowerDown = false;
-
- // Ask for persmission to drop power state
- fMachineState = kIOPM_OurChangeTellClientsPowerDown;
- fOutOfBandParameter = kNotifyApps;
- askChangeDown(fHeadNotePowerState);
- } else {
- // This service is raising power and parents are able to support the
- // new power state. However a parent may have already committed to
- // drop power, which might force this object to temporarily drop power.
- // This results in "oscillations" before the state machines converge
- // to a steady state.
- //
- // To prevent this, a child must make a power reservation against all
- // parents before raising power. If the reservation fails, indicating
- // that the child will be unable to sustain the higher power state,
- // then the child will signal the parent to adjust power, and the child
- // will defer its power change.
-
- IOReturn ret;
-
- // Reserve parent power necessary to achieve fHeadNotePowerState.
- ret = requestDomainPower( fHeadNotePowerState, kReserveDomainPower );
- if (ret != kIOReturnSuccess) {
- // Reservation failed, defer power rise.
- fHeadNoteChangeFlags |= kIOPMNotDone;
- OurChangeFinish();
- return;
- }
-
- OurChangeTellCapabilityWillChange();
- }
-}
-
-//*********************************************************************************
-// [private] requestDomainPowerApplier
-//
-// Call requestPowerDomainState() on all power parents.
-//*********************************************************************************
-
-struct IOPMRequestDomainPowerContext {
- IOService * child; // the requesting child
- IOPMPowerFlags requestPowerFlags;// power flags requested by child
-};
-
-static void
-requestDomainPowerApplier(
- IORegistryEntry * entry,
- void * inContext )
-{
- IOPowerConnection * connection;
- IOService * parent;
- IOPMRequestDomainPowerContext * context;
-
- if ((connection = OSDynamicCast(IOPowerConnection, entry)) == NULL) {
- return;
- }
- parent = (IOService *) connection->copyParentEntry(gIOPowerPlane);
- if (!parent) {
- return;
- }
-
- assert(inContext);
- context = (IOPMRequestDomainPowerContext *) inContext;
-
- if (connection->parentKnowsState() && connection->getReadyFlag()) {
- parent->requestPowerDomainState(
- context->requestPowerFlags,
- connection,
- IOPMLowestState);
- }
-
- parent->release();
-}
-
-//*********************************************************************************
-// [private] requestDomainPower
-//
-// Called by a power child to broadcast its desired power state to all parents.
-// If the child self-initiates a power change, it must call this function to
-// allow its parents to adjust power state.
-//*********************************************************************************
-
-IOReturn
-IOService::requestDomainPower(
- IOPMPowerStateIndex ourPowerState,
- IOOptionBits options )
-{
- IOPMPowerFlags requestPowerFlags;
- IOPMPowerStateIndex maxPowerState;
- IOPMRequestDomainPowerContext context;
-
- PM_ASSERT_IN_GATE();
- assert(ourPowerState < fNumberOfPowerStates);
- if (ourPowerState >= fNumberOfPowerStates) {
- return kIOReturnBadArgument;
- }
- if (IS_PM_ROOT) {
- return kIOReturnSuccess;
- }
-
- // Fetch our input power flags for the requested power state.
- // Parent request is stated in terms of required power flags.
-
- requestPowerFlags = fPowerStates[ourPowerState].inputPowerFlags;
-
- // Disregard the "previous request" for power reservation.
-
- if (((options & kReserveDomainPower) == 0) &&
- (fPreviousRequestPowerFlags == requestPowerFlags)) {
- // skip if domain already knows our requirements
- goto done;
- }
- fPreviousRequestPowerFlags = requestPowerFlags;
-
- // The results will be collected by fHeadNoteDomainTargetFlags
- context.child = this;
- context.requestPowerFlags = requestPowerFlags;
- fHeadNoteDomainTargetFlags = 0;
- applyToParents(requestDomainPowerApplier, &context, gIOPowerPlane);
-
- if (options & kReserveDomainPower) {
- maxPowerState = fControllingDriver->driverMaxCapabilityForDomainState(
- this, fHeadNoteDomainTargetFlags );
-
- if (StateOrder(maxPowerState) < StateOrder(ourPowerState)) {
- PM_LOG1("%s: power desired %u:0x%x got %u:0x%x\n",
- getName(),
- (uint32_t) ourPowerState, (uint32_t) requestPowerFlags,
- (uint32_t) maxPowerState, (uint32_t) fHeadNoteDomainTargetFlags);
- return kIOReturnNoPower;
- }
- }
-
-done:
- return kIOReturnSuccess;
-}
-
-//*********************************************************************************
-// [private] OurSyncStart
-//*********************************************************************************
-
-void
-IOService::OurSyncStart( void )
-{
- PM_ASSERT_IN_GATE();
-
- if (fInitialPowerChange) {
- return;
- }
-
- PM_ACTION_CHANGE(actionPowerChangeStart, fHeadNotePowerState, &fHeadNoteChangeFlags);
-
- if (fHeadNoteChangeFlags & kIOPMNotDone) {
- OurChangeFinish();
- return;
- }
-
- if (fHeadNoteChangeFlags & kIOPMSyncTellPowerDown) {
- fDoNotPowerDown = false;
-
- // Ask for permission to drop power state
- fMachineState = kIOPM_SyncTellClientsPowerDown;
- fOutOfBandParameter = kNotifyApps;
- askChangeDown(fHeadNotePowerState);
- } else {
- // Only inform capability app and clients.
- tellSystemCapabilityChange( kIOPM_SyncNotifyWillChange );
- }
-}
-
-//*********************************************************************************
-// [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.
-//*********************************************************************************
-
-void
-IOService::OurChangeTellClientsPowerDown( void )
-{
- if (!IS_ROOT_DOMAIN) {
- fMachineState = kIOPM_OurChangeTellPriorityClientsPowerDown;
- } else {
- fMachineState = kIOPM_OurChangeTellUserPMPolicyPowerDown;
- }
- tellChangeDown1(fHeadNotePowerState);
-}
-
-//*********************************************************************************
-// [private] OurChangeTellUserPMPolicyPowerDown
-//
-// All applications and kernel clients have acknowledged our permission to drop
-// power. Here we notify power management policy in user-space and wait for acks
-// one last time before we lower power
-//*********************************************************************************
-void
-IOService::OurChangeTellUserPMPolicyPowerDown( void )
-{
- fMachineState = kIOPM_OurChangeTellPriorityClientsPowerDown;
- fOutOfBandParameter = kNotifyApps;
-
- tellClientsWithResponse(kIOPMMessageLastCallBeforeSleep);
-}
-
-//*********************************************************************************
-// [private] OurChangeTellPriorityClientsPowerDown
-//
-// All applications and kernel clients have acknowledged our intention to drop
-// power. Here we notify "priority" clients that we are lowering power.
-//*********************************************************************************
-
-void
-IOService::OurChangeTellPriorityClientsPowerDown( void )
-{
- fMachineState = kIOPM_OurChangeNotifyInterestedDriversWillChange;
- tellChangeDown2(fHeadNotePowerState);
-}
-
-//*********************************************************************************
-// [private] OurChangeTellCapabilityWillChange
-//
-// Extra stage for root domain to notify apps and drivers about the
-// system capability change when raising power state.
-//*********************************************************************************
-
-void
-IOService::OurChangeTellCapabilityWillChange( void )
-{
- if (!IS_ROOT_DOMAIN) {
- return OurChangeNotifyInterestedDriversWillChange();
- }
-
- tellSystemCapabilityChange( kIOPM_OurChangeNotifyInterestedDriversWillChange );
-}
-
-//*********************************************************************************
-// [private] OurChangeNotifyInterestedDriversWillChange
-//
-// All applications and kernel clients have acknowledged our power state change.
-// Here we notify interested drivers pre-change.
-//*********************************************************************************
-
-void
-IOService::OurChangeNotifyInterestedDriversWillChange( void )
-{
- IOPMrootDomain * rootDomain;
- if ((rootDomain = getPMRootDomain()) == this) {
- if (IS_POWER_DROP) {
- rootDomain->tracePoint( kIOPMTracePointSleepWillChangeInterests );
- } else {
- rootDomain->tracePoint( kIOPMTracePointWakeWillChangeInterests );
- }
- }
-
- notifyAll( kIOPM_OurChangeSetPowerState );
-}
-
-//*********************************************************************************
-// [private] OurChangeSetPowerState
-//
-// Instruct our controlling driver to program the hardware for the power state
-// change. Wait for async completions.
-//*********************************************************************************
-
-void
-IOService::OurChangeSetPowerState( void )
-{
- MS_PUSH( kIOPM_OurChangeWaitForPowerSettle );
- fMachineState = kIOPM_DriverThreadCallDone;
- fDriverCallReason = kDriverCallSetPowerState;
-
- if (notifyControllingDriver() == false) {
- notifyControllingDriverDone();
- }
-}
-
-//*********************************************************************************
-// [private] OurChangeWaitForPowerSettle
-//
-// Our controlling driver has completed the power state change we initiated.
-// Wait for the driver specified settle time to expire.
-//*********************************************************************************
-
-void
-IOService::OurChangeWaitForPowerSettle( void )
-{
- fMachineState = kIOPM_OurChangeNotifyInterestedDriversDidChange;
- startSettleTimer();
-}
-
-//*********************************************************************************
-// [private] OurChangeNotifyInterestedDriversDidChange
-//
-// Power has settled on a power change we initiated. Here we notify
-// all our interested drivers post-change.
-//*********************************************************************************
-
-void
-IOService::OurChangeNotifyInterestedDriversDidChange( void )
-{
- IOPMrootDomain * rootDomain;
- if ((rootDomain = getPMRootDomain()) == this) {
- rootDomain->tracePoint( IS_POWER_DROP ?
- kIOPMTracePointSleepDidChangeInterests :
- kIOPMTracePointWakeDidChangeInterests );
- }
-
- notifyAll( kIOPM_OurChangeTellCapabilityDidChange );
-}
-
-//*********************************************************************************
-// [private] OurChangeTellCapabilityDidChange
-//
-// For root domain to notify capability power-change.
-//*********************************************************************************
-
-void
-IOService::OurChangeTellCapabilityDidChange( void )
-{
- if (!IS_ROOT_DOMAIN) {
- return OurChangeFinish();
- }
-
- if (!IS_POWER_DROP) {
- // Notify root domain immediately after notifying interested
- // drivers and power children.
- getPMRootDomain()->willTellSystemCapabilityDidChange();
- }
-
- getPMRootDomain()->tracePoint( IS_POWER_DROP ?
- kIOPMTracePointSleepCapabilityClients :
- kIOPMTracePointWakeCapabilityClients );
-
- tellSystemCapabilityChange( kIOPM_OurChangeFinish );
-}
-
-//*********************************************************************************
-// [private] OurChangeFinish
-//
-// Done with this self-induced power state change.
-//*********************************************************************************
-
-void
-IOService::OurChangeFinish( void )
-{
- all_done();
-}
-
-// MARK: -
-// MARK: Power Change Initiated by Parent
-
-//*********************************************************************************
-// [private] ParentChangeStart
-//
-// Here we begin the processing of a power change initiated by our parent.
-//*********************************************************************************
-
-IOReturn
-IOService::ParentChangeStart( void )
-{
- PM_ASSERT_IN_GATE();
- OUR_PMLog( kPMLogStartParentChange, fHeadNotePowerState, fCurrentPowerState );
-
- // Root power domain has transitioned to its max power state
- if ((fHeadNoteChangeFlags & (kIOPMDomainDidChange | kIOPMRootChangeUp)) ==
- (kIOPMDomainDidChange | kIOPMRootChangeUp)) {
- // Restart the idle timer stopped by ParentChangeRootChangeDown()
- if (fIdleTimerPeriod && fIdleTimerStopped) {
- restartIdleTimer();
- }
- }
-
- // Power domain is forcing us to lower power
- if (StateOrder(fHeadNotePowerState) < StateOrder(fCurrentPowerState)) {
- PM_ACTION_CHANGE(actionPowerChangeStart, fHeadNotePowerState, &fHeadNoteChangeFlags);
-
- // Tell apps and kernel clients
- fInitialPowerChange = false;
- fMachineState = kIOPM_ParentChangeTellPriorityClientsPowerDown;
- tellChangeDown1(fHeadNotePowerState);
- return IOPMWillAckLater;
- }
-
- // Power domain is allowing us to raise power up to fHeadNotePowerState
- if (StateOrder(fHeadNotePowerState) > StateOrder(fCurrentPowerState)) {
- if (StateOrder(fDesiredPowerState) > StateOrder(fCurrentPowerState)) {
- if (StateOrder(fDesiredPowerState) < StateOrder(fHeadNotePowerState)) {
- // We power up, but not all the way
- fHeadNotePowerState = fDesiredPowerState;
- fHeadNotePowerArrayEntry = &fPowerStates[fDesiredPowerState];
- OUR_PMLog(kPMLogAmendParentChange, fHeadNotePowerState, 0);
- }
- } else {
- // We don't need to change
- fHeadNotePowerState = fCurrentPowerState;
- fHeadNotePowerArrayEntry = &fPowerStates[fCurrentPowerState];
- OUR_PMLog(kPMLogAmendParentChange, fHeadNotePowerState, 0);
- }
- }
-
- if (fHeadNoteChangeFlags & kIOPMDomainDidChange) {
- if (StateOrder(fHeadNotePowerState) > StateOrder(fCurrentPowerState)) {
- PM_ACTION_CHANGE(actionPowerChangeStart,
- fHeadNotePowerState, &fHeadNoteChangeFlags);
-
- // Parent did change up - start our change up
- fInitialPowerChange = false;
- ParentChangeTellCapabilityWillChange();
- return IOPMWillAckLater;
- } else if (fHeadNoteChangeFlags & kIOPMRootBroadcastFlags) {
- // No need to change power state, but broadcast change
- // to our children.
- fMachineState = kIOPM_SyncNotifyDidChange;
- fDriverCallReason = kDriverCallInformPreChange;
- fHeadNoteChangeFlags |= kIOPMNotDone;
- notifyChildren();
- return IOPMWillAckLater;
- }
- }
-
- // No power state change necessary
- fHeadNoteChangeFlags |= kIOPMNotDone;
-
- all_done();
- return IOPMAckImplied;
-}
-
-//******************************************************************************
-// [private] ParentChangeRootChangeDown
-//
-// Root domain has finished the transition to the system sleep state. And all
-// drivers in the power plane should have powered down. Cancel the idle timer,
-// and also reset the device desire for those drivers that don't want power
-// automatically restored on wake.
-//******************************************************************************
-
-void
-IOService::ParentChangeRootChangeDown( void )
-{
- // Always stop the idle timer before root power down
- if (fIdleTimerPeriod && !fIdleTimerStopped) {
- fIdleTimerStopped = true;
- if (fIdleTimer && thread_call_cancel(fIdleTimer)) {
- release();
- }
- }
-
- if (fResetPowerStateOnWake) {
- // Reset device desire down to the lowest power state.
- // Advisory tickle desire is intentionally untouched since
- // it has no effect until system is promoted to full wake.
-
- if (fDeviceDesire != kPowerStateZero) {
- updatePowerClient(gIOPMPowerClientDevice, kPowerStateZero);
- computeDesiredState(kPowerStateZero, true);
- requestDomainPower( fDesiredPowerState );
- PM_LOG1("%s: tickle desire removed\n", fName);
- }
-
- // Invalidate tickle cache so the next tickle will issue a request
- IOLockLock(fActivityLock);
- fDeviceWasActive = false;
- fActivityTicklePowerState = kInvalidTicklePowerState;
- IOLockUnlock(fActivityLock);
-
- fIdleTimerMinPowerState = kPowerStateZero;
- } else if (fAdvisoryTickleUsed) {
- // Less aggressive mechanism to accelerate idle timer expiration
- // before system sleep. May not always allow the driver to wake
- // up from system sleep in the min power state.
-
- AbsoluteTime now;
- uint64_t nsec;
- bool dropTickleDesire = false;
-
- if (fIdleTimerPeriod && !fIdleTimerIgnored &&
- (fIdleTimerMinPowerState == kPowerStateZero) &&
- (fDeviceDesire != kPowerStateZero)) {
- IOLockLock(fActivityLock);
-
- if (!fDeviceWasActive) {
- // No tickles since the last idle timer expiration.
- // Safe to drop the device desire to zero.
- dropTickleDesire = true;
- } else {
- // Was tickled since the last idle timer expiration,
- // but not in the last minute.
- clock_get_uptime(&now);
- SUB_ABSOLUTETIME(&now, &fDeviceActiveTimestamp);
- absolutetime_to_nanoseconds(now, &nsec);
- if (nsec >= kNoTickleCancelWindow) {
- dropTickleDesire = true;
- }
- }
-
- if (dropTickleDesire) {
- // Force the next tickle to raise power state
- fDeviceWasActive = false;
- fActivityTicklePowerState = kInvalidTicklePowerState;
- }
-
- IOLockUnlock(fActivityLock);
- }
-
- if (dropTickleDesire) {
- // Advisory tickle desire is intentionally untouched since
- // it has no effect until system is promoted to full wake.
-
- updatePowerClient(gIOPMPowerClientDevice, kPowerStateZero);
- computeDesiredState(kPowerStateZero, true);
- PM_LOG1("%s: tickle desire dropped\n", fName);
- }
- }
-}
-
-//*********************************************************************************
-// [private] ParentChangeTellPriorityClientsPowerDown
-//
-// All applications and kernel clients have acknowledged our intention to drop
-// power. Here we notify "priority" clients that we are lowering power.
-//*********************************************************************************
-
-void
-IOService::ParentChangeTellPriorityClientsPowerDown( void )
-{
- fMachineState = kIOPM_ParentChangeNotifyInterestedDriversWillChange;
- tellChangeDown2(fHeadNotePowerState);
-}
-
-//*********************************************************************************
-// [private] ParentChangeTellCapabilityWillChange
-//
-// All (legacy) applications and kernel clients have acknowledged, extra stage for
-// root domain to notify apps and drivers about the system capability change.
-//*********************************************************************************
-
-void
-IOService::ParentChangeTellCapabilityWillChange( void )
-{
- if (!IS_ROOT_DOMAIN) {
- return ParentChangeNotifyInterestedDriversWillChange();
- }
-
- tellSystemCapabilityChange( kIOPM_ParentChangeNotifyInterestedDriversWillChange );
-}
-
-//*********************************************************************************
-// [private] ParentChangeNotifyInterestedDriversWillChange
-//
-// All applications and kernel clients have acknowledged our power state change.
-// Here we notify interested drivers pre-change.
-//*********************************************************************************
-
-void
-IOService::ParentChangeNotifyInterestedDriversWillChange( void )
-{
- notifyAll( kIOPM_ParentChangeSetPowerState );
-}
-
-//*********************************************************************************
-// [private] ParentChangeSetPowerState
-//
-// Instruct our controlling driver to program the hardware for the power state
-// change. Wait for async completions.
-//*********************************************************************************
-
-void
-IOService::ParentChangeSetPowerState( void )
-{
- MS_PUSH( kIOPM_ParentChangeWaitForPowerSettle );
- fMachineState = kIOPM_DriverThreadCallDone;
- fDriverCallReason = kDriverCallSetPowerState;
-
- if (notifyControllingDriver() == false) {
- notifyControllingDriverDone();
- }
-}
-
-//*********************************************************************************
-// [private] ParentChangeWaitForPowerSettle
-//
-// Our controlling driver has completed the power state change initiated by our
-// parent. Wait for the driver specified settle time to expire.
-//*********************************************************************************
-
-void
-IOService::ParentChangeWaitForPowerSettle( void )
-{
- fMachineState = kIOPM_ParentChangeNotifyInterestedDriversDidChange;
- startSettleTimer();
-}
-
-//*********************************************************************************
-// [private] ParentChangeNotifyInterestedDriversDidChange
-//
-// Power has settled on a power change initiated by our parent. Here we notify
-// all our interested drivers post-change.
-//*********************************************************************************
-
-void
-IOService::ParentChangeNotifyInterestedDriversDidChange( void )
-{
- notifyAll( kIOPM_ParentChangeTellCapabilityDidChange );
-}
-
-//*********************************************************************************
-// [private] ParentChangeTellCapabilityDidChange
-//
-// For root domain to notify capability power-change.
-//*********************************************************************************
-
-void
-IOService::ParentChangeTellCapabilityDidChange( void )
-{
- if (!IS_ROOT_DOMAIN) {
- return ParentChangeAcknowledgePowerChange();
- }
-
- tellSystemCapabilityChange( kIOPM_ParentChangeAcknowledgePowerChange );
-}
-
-//*********************************************************************************
-// [private] ParentAcknowledgePowerChange
-//
-// Acknowledge our power parent that our power change is done.
-//*********************************************************************************
-
-void
-IOService::ParentChangeAcknowledgePowerChange( void )
-{
- IORegistryEntry * nub;
- IOService * parent;
-
- nub = fHeadNoteParentConnection;
- nub->retain();
- all_done();
- parent = (IOService *)nub->copyParentEntry(gIOPowerPlane);
- if (parent) {
- parent->acknowledgePowerChange((IOService *)nub);
- parent->release();
- }
- nub->release();
-}
-
-// MARK: -
-// MARK: Ack and Settle timers
-
-//*********************************************************************************
-// [private] settleTimerExpired
+bool IOService::inform ( IOPMinformee * nextObject, bool is_prechange )
+{
+ IOReturn k = IOPMAckImplied;
+
+ nextObject->timer = -1; // initialize this
+
+ if ( is_prechange ) {
+ pm_vars->thePlatform->PMLog (pm_vars->ourName,PMlogInformDriverPreChange,
+ (unsigned long)priv->head_note_capabilityFlags,(unsigned long)priv->head_note_state);
+ k = nextObject->whatObject->powerStateWillChangeTo( priv->head_note_capabilityFlags,priv->head_note_state,this);
+ }
+ else {
+ pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogInformDriverPostChange,
+ (unsigned long)priv->head_note_capabilityFlags,(unsigned long)priv->head_note_state);
+ k = nextObject->whatObject->powerStateDidChangeTo(priv->head_note_capabilityFlags,priv->head_note_state,this);
+ }
+ if ( nextObject->timer == 0 ) { // did it ack behind our back?
+ return true; // yes
+ }
+ if ( k ==IOPMAckImplied ) { // no, did the return code ack?
+ nextObject->timer = 0; // yes
+ priv->head_note_pendingAcks -= 1;
+ return true;
+ }
+ if ( k < 0 ) {
+ nextObject->timer = 0; // somebody goofed
+ priv-> head_note_pendingAcks -= 1;
+ return true;
+ }
+ nextObject->timer = (k * ns_per_us / ACK_TIMER_PERIOD) + 1; // no, it's a timer
+ return false;
+}
+
+
+//*********************************************************************************
+// our_prechange_03
+//
+// All registered applications and kernel clients have positively acknowledged our
+// intention of lowering power. Here we notify them all that we will definitely
+// lower the power. If we don't have to wait for any of them to acknowledge, we
+// carry on by notifying interested drivers. Otherwise, we do wait.
+//*********************************************************************************
+
+void IOService::our_prechange_03 ( void )
+{
+ priv->machine_state = IOPMour_prechange_04; // next state
+ if ( tellChangeDown1(priv->head_note_state) ) { // are we waiting for responses?
+ our_prechange_04(); // no, notify priority clients
+ }
+}
+
+
+//*********************************************************************************
+// our_prechange_04
+//
+// All registered applications and kernel clients have positively acknowledged our
+// intention of lowering power. Here we notify "priority" clients that we are
+// lowering power. If we don't have to wait for any of them to acknowledge, we
+// carry on by notifying interested drivers. Otherwise, we do wait.
+//*********************************************************************************
+
+void IOService::our_prechange_04 ( void )
+{
+ priv->machine_state = IOPMour_prechange_05; // next state
+ if ( tellChangeDown2(priv->head_note_state) ) { // are we waiting for responses?
+ return our_prechange_05(); // no, notify interested drivers
+ }
+}
+
+
+//*********************************************************************************
+// our_prechange_05
+//
+// All registered applications and kernel clients have acknowledged our notification
+// that we are lowering power. Here we notify interested drivers. If we don't have
+// to wait for any of them to acknowledge, we instruct our power driver to make the change.
+// Otherwise, we do wait.
+//*********************************************************************************
+
+void IOService::our_prechange_05 ( void )
+{
+ priv->machine_state = IOPMour_prechange_1; // no, in case they don't all ack
+ if ( notifyAll(true) == IOPMAckImplied ) {
+ our_prechange_1();
+ }
+}
+
+
+//*********************************************************************************
+// our_prechange_1
+//
+// All interested drivers have acknowledged our pre-change notification of a power
+// change we initiated. Here we instruct our controlling driver to make
+// the change to the hardware. If it does so, we continue processing
+// (waiting for settle and notifying interested parties post-change.)
+// If it doesn't, we have to wait for it to acknowledge and then continue.
+//*********************************************************************************
+
+void IOService::our_prechange_1 ( void )
+{
+ if ( instruct_driver(priv->head_note_state) == IOPMAckImplied ) {
+ our_prechange_2(); // it's done, carry on
+ }
+ else {
+ priv->machine_state = IOPMour_prechange_2; // it's not, wait for it
+ pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogStartAckTimer,0,0);
+ start_ack_timer();
+ }
+}
+
+
+//*********************************************************************************
+// our_prechange_2
+//
+// Our controlling driver has changed power state on the hardware
+// during a power change we initiated. Here we see if we need to wait
+// for power to settle before continuing. If not, we continue processing
+// (notifying interested parties post-change). If so, we wait and
+// continue later.
+//*********************************************************************************
+
+void IOService::our_prechange_2 ( void )
+{
+ priv->settle_time = compute_settle_time();
+ if ( priv->settle_time == 0 ) {
+ our_prechange_3();
+ }
+ else {
+ priv->machine_state = IOPMour_prechange_3;
+ startSettleTimer(priv->settle_time);
+ }
+}
+
+
+//*********************************************************************************
+// our_prechange_3
+//
+// Power has settled on a power change we initiated. Here we notify
+// all our interested parties post-change. If they all acknowledge, we're
+// done with this change note, and we can start on the next one.
+// Otherwise we have to wait for acknowledgements and finish up later.
+//*********************************************************************************
+
+void IOService::our_prechange_3 ( void )
+{
+ priv->machine_state = IOPMour_prechange_4; // in case they don't all ack
+ if ( notifyAll(false) == IOPMAckImplied ) {
+ our_prechange_4();
+ }
+}
+
+
+//*********************************************************************************
+// our_prechange_4
+//
+// Power has settled on a power change we initiated, and
+// all our interested parties have acknowledged. We're
+// done with this change note, and we can start on the next one.
+//*********************************************************************************
+
+void IOService::our_prechange_4 ( void )
+{
+ all_done();
+}
+
+
+//*********************************************************************************
+// parent_down_0
+//
+// All applications and kernel clients have been notified of a power lowering
+// initiated by the parent and we didn't have to wait for any responses. Here
+// we notify any priority clients. If they all ack, we continue with the power change.
+// If at least one doesn't, we have to wait for it to acknowledge and then continue.
+//*********************************************************************************
+
+IOReturn IOService::parent_down_0 ( void )
+{
+ priv->machine_state = IOPMparent_down_05; // in case they don't all ack
+ if ( tellChangeDown2(priv->head_note_state) ) { // are we waiting for responses?
+ return parent_down_02(); // no, notify interested drivers
+ }
+ return IOPMWillAckLater; // they didn't
+}
+
+
+//*********************************************************************************
+// parent_down_02
+//
+// All priority kernel clients have been notified of a power lowering
+// initiated by the parent and we didn't have to wait for any responses. Here
+// we notify any interested drivers and power domain children. If they all ack,
+// we continue with the power change.
+// If at least one doesn't, we have to wait for it to acknowledge and then continue.
+//*********************************************************************************
+
+IOReturn IOService::parent_down_02 ( void )
+{
+ priv->machine_state = IOPMparent_down_4; // in case they don't all ack
+ if ( notifyAll(true) == IOPMAckImplied ) {
+ return parent_down_1(); // they did
+ }
+ return IOPMWillAckLater; // they didn't
+}
+
+
+//*********************************************************************************
+// parent_down_04
+//
+// All applications and kernel clients have been notified of a power lowering
+// initiated by the parent and we had to wait for responses. Here
+// we notify any priority clients. If they all ack, we continue with the power change.
+// If at least one doesn't, we have to wait for it to acknowledge and then continue.
+//*********************************************************************************
+
+void IOService::parent_down_04 ( void )
+{
+ priv->machine_state = IOPMparent_down_05; // in case they don't all ack
+ if ( tellChangeDown2(priv->head_note_state) ) { // are we waiting for responses?
+ parent_down_05(); // no, notify interested drivers
+ }
+}
+
+
+//*********************************************************************************
+// parent_down_05
+//
+// All applications and kernel clients have been notified of a power lowering
+// initiated by the parent and we had to wait for their responses. Here we notify
+// any interested drivers and power domain children. If they all ack, we continue
+// with the power change.
+// If at least one doesn't, we have to wait for it to acknowledge and then continue.
+//*********************************************************************************
+
+void IOService::parent_down_05 ( void )
+{
+ priv->machine_state = IOPMparent_down_4; // in case they don't all ack
+ if ( notifyAll(true) == IOPMAckImplied ) {
+ parent_down_4(); // they did
+ }
+}
+
+
+//*********************************************************************************
+// parent_down_1
+//
+// All parties have acknowledged our pre-change notification of a power
+// lowering initiated by the parent. Here we instruct our controlling driver
+// to put the hardware in the state it needs to be in when the domain is
+// lowered. If it does so, we continue processing
+// (waiting for settle and acknowledging the parent.)
+// If it doesn't, we have to wait for it to acknowledge and then continue.
+//*********************************************************************************
+
+IOReturn IOService::parent_down_1 ( void )
+{
+ if ( instruct_driver(priv->head_note_state) == IOPMAckImplied ) {
+ return parent_down_2(); // it's done, carry on
+ }
+ priv->machine_state = IOPMparent_down_5; // it's not, wait for it
+ pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogStartAckTimer,0,0);
+ start_ack_timer();
+ return IOPMWillAckLater;
+}
+
+
+//*********************************************************************************
+// parent_down_4
+//
+// We had to wait for it, but all parties have acknowledged our pre-change
+// notification of a power lowering initiated by the parent.
+// Here we instruct our controlling driver
+// to put the hardware in the state it needs to be in when the domain is
+// lowered. If it does so, we continue processing
+// (waiting for settle and acknowledging the parent.)
+// If it doesn't, we have to wait for it to acknowledge and then continue.
+//*********************************************************************************
+
+void IOService::parent_down_4 ( void )
+{
+ if ( instruct_driver(priv->head_note_state) == IOPMAckImplied ) {
+ parent_down_5(); // it's done, carry on
+ }
+ else {
+ priv-> machine_state = IOPMparent_down_5; // it's not, wait for it
+ pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogStartAckTimer,0,0);
+ start_ack_timer();
+ }
+}
+
+
+//*********************************************************************************
+// parent_down_2
+//
+// Our controlling driver has changed power state on the hardware
+// during a power change initiated by our parent. Here we see if we need
+// to wait for power to settle before continuing. If not, we continue
+// processing (acknowledging our preparedness to the parent).
+// If so, we wait and continue later.
+//*********************************************************************************
+
+IOReturn IOService::parent_down_2 ( void )
+{
+ IOService * nub;
+
+ priv->settle_time = compute_settle_time();
+ if ( priv->settle_time == 0 ) {
+ priv->machine_state = IOPMparent_down_6; // in case they don't all ack
+ if ( notifyAll(false) == IOPMAckImplied ) {
+ nub = priv->head_note_parent;
+ all_done();
+ nub->release();
+ return IOPMAckImplied;
+ }
+ return IOPMWillAckLater; // they didn't
+ }
+ else {
+ priv->machine_state = IOPMparent_down_3;
+ startSettleTimer(priv->settle_time);
+ return IOPMWillAckLater;
+ }
+}
+
+
+//*********************************************************************************
+// parent_down_5
+//
+// Our controlling driver has changed power state on the hardware
+// during a power change initiated by our parent. We have had to wait
+// for acknowledgement from interested parties, or we have had to wait
+// for the controlling driver to change the state. Here we see if we need
+// to wait for power to settle before continuing. If not, we continue
+// processing (acknowledging our preparedness to the parent).
+// If so, we wait and continue later.
+//*********************************************************************************
+
+void IOService::parent_down_5 ( void )
+{
+ priv->settle_time = compute_settle_time();
+ if ( priv->settle_time == 0 ) {
+ parent_down_3();
+ }
+ else {
+ priv->machine_state = IOPMparent_down_3;
+ startSettleTimer(priv->settle_time);
+ }
+}
+
+
+//*********************************************************************************
+// parent_down_3
+//
+// Power has settled on a power change initiated by our parent. Here we
+// notify interested parties.
+//*********************************************************************************
+
+void IOService::parent_down_3 ( void )
+{
+ IORegistryEntry * nub;
+ IOService * parent;
+
+ priv->machine_state = IOPMparent_down_6; // in case they don't all ack
+ if ( notifyAll(false) == IOPMAckImplied ) {
+ nub = priv->head_note_parent;
+ all_done();
+ parent = (IOService *)nub->copyParentEntry(gIOPowerPlane);
+ if ( parent ) {
+ parent->acknowledgePowerChange((IOService *)nub);
+ parent->release();
+ }
+ nub->release();
+ }
+}
+
+
+//*********************************************************************************
+// parent_down_6
+//
+// We had to wait for it, but all parties have acknowledged our post-change
+// notification of a power lowering initiated by the parent.
+// Here we acknowledge the parent.
+// We are done with this change note, and we can start on the next one.
+//*********************************************************************************
+
+void IOService::parent_down_6 ( void )
+{
+ IORegistryEntry * nub;
+ IOService * parent;
+
+ nub = priv->head_note_parent;
+ all_done();
+ parent = (IOService *)nub->copyParentEntry(gIOPowerPlane);
+ if ( parent ) {
+ parent->acknowledgePowerChange((IOService *)nub);
+ parent->release();
+ }
+ nub->release();
+}
+
+
+//*********************************************************************************
+// parent_up_0
+//
+// Our parent has informed us via powerStateDidChange that it has
+// raised the power in our power domain, and we have had to wait
+// for some interested party to acknowledge our notification.
+// Here we instruct our controlling
+// driver to program the hardware to take advantage of the higher domain
+// power. If it does so, we continue processing
+// (waiting for settle and notifying interested parties post-change.)
+// If it doesn't, we have to wait for it to acknowledge and then continue.
+//*********************************************************************************
+
+void IOService::parent_up_0 ( void )
+{
+ if ( instruct_driver(priv->head_note_state) == IOPMAckImplied ) {
+ parent_up_4(); // it did it, carry on
+ }
+ else {
+ priv->machine_state = IOPMparent_up_4; // it didn't, wait for it
+ pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogStartAckTimer,0,0);
+ start_ack_timer();
+ }
+}
+
+
+//*********************************************************************************
+// parent_up_1
+//
+// Our parent has informed us via powerStateDidChange that it has
+// raised the power in our power domain. Here we instruct our controlling
+// driver to program the hardware to take advantage of the higher domain
+// power. If it does so, we continue processing
+// (waiting for settle and notifying interested parties post-change.)
+// If it doesn't, we have to wait for it to acknowledge and then continue.
+//*********************************************************************************
+
+IOReturn IOService::parent_up_1 ( void )
+{
+ if ( instruct_driver(priv->head_note_state) == IOPMAckImplied ) {
+ return parent_up_2(); // it did it, carry on
+ }
+ else {
+ priv->machine_state = IOPMparent_up_4; // it didn't, wait for it
+ pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogStartAckTimer,0,0);
+ start_ack_timer();
+ return IOPMWillAckLater;
+ }
+}
+
+
+//*********************************************************************************
+// parent_up_2
+//
+// Our controlling driver has changed power state on the hardware
+// during a power raise initiated by the parent. Here we see if we need to wait
+// for power to settle before continuing. If not, we continue processing
+// (notifying interested parties post-change). If so, we wait and
+// continue later.
+//*********************************************************************************
+
+IOReturn IOService::parent_up_2 ( void )
+{
+ priv->settle_time = compute_settle_time();
+ if ( priv->settle_time == 0 ) {
+ return parent_up_3();
+ }
+ else {
+ priv->machine_state = IOPMparent_up_5;
+ startSettleTimer(priv->settle_time);
+ return IOPMWillAckLater;
+ }
+}
+
+
+//*********************************************************************************
+// parent_up_4
+//
+// Our controlling driver has changed power state on the hardware
+// during a power raise initiated by the parent, but we had to wait for it.
+// Here we see if we need to wait for power to settle before continuing.
+// If not, we continue processing (notifying interested parties post-change).
+// If so, we wait and continue later.
+//*********************************************************************************
+
+void IOService::parent_up_4 ( void )
+{
+ priv->settle_time = compute_settle_time();
+ if ( priv->settle_time == 0 ) {
+ parent_up_5();
+ }
+ else {
+ priv->machine_state = IOPMparent_up_5;
+ startSettleTimer(priv->settle_time);
+ }
+}
+
+
+//*********************************************************************************
+// parent_up_3
+//
+// No power settling was required on a power raise initiated by the parent.
+// Here we notify all our interested parties post-change. If they all acknowledge,
+// we're done with this change note, and we can start on the next one.
+// Otherwise we have to wait for acknowledgements and finish up later.
+//*********************************************************************************
+
+IOReturn IOService::parent_up_3 ( void )
+{
+ IOService * nub;
+
+ priv->machine_state = IOPMparent_up_6; // in case they don't all ack
+ if ( notifyAll(false) == IOPMAckImplied ) {
+ nub = priv->head_note_parent;
+ all_done();
+ nub->release();
+ return IOPMAckImplied;
+ }
+ return IOPMWillAckLater; // they didn't
+}
+
+
+//*********************************************************************************
+// parent_up_5
+//
+// Power has settled on a power raise initiated by the parent.
+// Here we notify all our interested parties post-change. If they all acknowledge,
+// we're done with this change note, and we can start on the next one.
+// Otherwise we have to wait for acknowledgements and finish up later.
+//*********************************************************************************
+
+void IOService::parent_up_5 ( void )
+{
+ priv->machine_state = IOPMparent_up_6; // in case they don't all ack
+ if ( notifyAll(false) == IOPMAckImplied ) {
+ parent_up_6();
+ }
+}
+
+
+//*********************************************************************************
+// parent_up_6
+//
+// All parties have acknowledged our post-change notification of a power
+// raising initiated by the parent. Here we acknowledge the parent.
+// We are done with this change note, and we can start on the next one.
+//*********************************************************************************
+
+void IOService::parent_up_6 ( void )
+{
+ IORegistryEntry * nub;
+ IOService * parent;
+
+ nub = priv->head_note_parent;
+ all_done();
+ parent = (IOService *)nub->copyParentEntry(gIOPowerPlane);
+ if ( parent ) {
+ parent->acknowledgePowerChange((IOService *)nub);
+ parent->release();
+ }
+ nub->release();
+}
+
+
+//*********************************************************************************
+// all_done
+//
+// A power change is complete, and the used post-change note is at
+// the head of the queue. Remove it and set myCurrentState to the result
+// of the change. Start up the next change in queue.
+//*********************************************************************************
+
+void IOService::all_done ( void )
+{
+ unsigned long previous_state;
+ IORegistryEntry * nub;
+ IOService * parent;
+
+ priv->machine_state = IOPMfinished;
+
+ if ( priv->head_note_flags & IOPMWeInitiated ) { // our power change
+ if ( !( priv->head_note_flags & IOPMNotDone) ) { // could our driver switch to the new state?
+ if ( pm_vars->myCurrentState < priv->head_note_state ) { // yes, did power raise?
+ tellChangeUp (priv->head_note_state); // yes, inform clients and apps
+ }
+ else {
+ if ( ! priv->we_are_root ) { // no, if this lowers our
+ ask_parent(priv->head_note_state); // power requirements, tell the parent
+ }
+ }
+ previous_state = pm_vars->myCurrentState;
+ pm_vars->myCurrentState = priv->head_note_state; // either way
+ priv->imminentState = pm_vars->myCurrentState;
+ pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogChangeDone,(unsigned long)pm_vars->myCurrentState,0);
+ powerChangeDone(previous_state); // inform subclass policy-maker
+ }
+// else { // no
+// pm_vars->myCurrentState = pm_vars->theControllingDriver->powerStateForDomainState(pm_vars->parentsCurrentPowerFlags);
+// }
+ }
+ if ( priv->head_note_flags & IOPMParentInitiated) { // parent's power change
+ if ( ((priv->head_note_flags & IOPMDomainWillChange) && (pm_vars->myCurrentState >= priv->head_note_state)) ||
+ ((priv->head_note_flags & IOPMDomainDidChange) && (pm_vars->myCurrentState < priv->head_note_state)) ) {
+ if ( pm_vars->myCurrentState < priv->head_note_state ) { // did power raise?
+ tellChangeUp (priv->head_note_state); // yes, inform clients and apps
+ }
+ previous_state = pm_vars->myCurrentState; // either way
+ pm_vars->myCurrentState = priv->head_note_state;
+ priv->imminentState = pm_vars->myCurrentState;
+ pm_vars->maxCapability = pm_vars->theControllingDriver->maxCapabilityForDomainState(priv->head_note_domainState);
+
+ pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogChangeDone,(unsigned long)pm_vars->myCurrentState,0);
+ powerChangeDone(previous_state); // inform subclass policy-maker
+ }
+ }
+
+ IOLockLock(priv->queue_lock);
+ priv->changeList->releaseHeadChangeNote(); // we're done with this
+
+ priv->head_note = priv->changeList->currentChange(); // start next one in queue
+ if ( priv->head_note != -1 ) {
+
+ IOLockUnlock(priv->queue_lock);
+ if (priv->changeList->changeNote[priv->head_note].flags & IOPMWeInitiated ) {
+ start_our_change(priv->head_note);
+ }
+ else {
+ nub = priv->changeList->changeNote[priv->head_note].parent;
+ if ( start_parent_change(priv->head_note) == IOPMAckImplied ) {
+ parent = (IOService *)nub->copyParentEntry(gIOPowerPlane);
+ if ( parent ) {
+ parent->acknowledgePowerChange((IOService *)nub);
+ parent->release();
+ }
+ }
+ }
+ }
+ IOLockUnlock(priv->queue_lock);
+}
+
+
+
+//*********************************************************************************
+// all_acked
+//
+// A driver or child has acknowledged our notification of an upcoming power
+// change, and this acknowledgement is the last one pending
+// before we change power or after changing power.
+//
+//*********************************************************************************
+
+void IOService::all_acked ( void )
+{
+ switch (priv->machine_state) {
+ case IOPMour_prechange_1:
+ our_prechange_1();
+ break;
+ case IOPMour_prechange_4:
+ our_prechange_4();
+ break;
+ case IOPMparent_down_4:
+ parent_down_4();
+ break;
+ case IOPMparent_down_6:
+ parent_down_6();
+ break;
+ case IOPMparent_up_0:
+ parent_up_0();
+ break;
+ case IOPMparent_up_6:
+ parent_up_6();
+ break;
+ }
+}
+
+
+//*********************************************************************************
+// settleTimerExpired
//
// Power has settled after our last change. Notify interested parties that
// there is a new power state.
//*********************************************************************************
-void
-IOService::settleTimerExpired( void )
-{
-#if USE_SETTLE_TIMER
- fSettleTimeUS = 0;
- gIOPMWorkQueue->signalWorkAvailable();
-#endif
-}
-
-//*********************************************************************************
-// settle_timer_expired
-//
-// Holds a retain while the settle timer callout is in flight.
-//*********************************************************************************
-
-#if USE_SETTLE_TIMER
-static void
-settle_timer_expired( thread_call_param_t arg0, thread_call_param_t arg1 )
-{
- IOService * me = (IOService *) arg0;
-
- if (gIOPMWorkLoop && gIOPMWorkQueue) {
- gIOPMWorkLoop->runAction(
- OSMemberFunctionCast(IOWorkLoop::Action, me, &IOService::settleTimerExpired),
- me);
- }
- me->release();
-}
-#endif
-
-//*********************************************************************************
-// [private] startSettleTimer
-//
-// Calculate a power-settling delay in microseconds and start a timer.
-//*********************************************************************************
-
-void
-IOService::startSettleTimer( void )
-{
-#if USE_SETTLE_TIMER
- // This function is broken and serves no useful purpose since it never
- // updates fSettleTimeUS to a non-zero value to stall the state machine,
- // yet it starts a delay timer. It appears no driver relies on a delay
- // from settleUpTime and settleDownTime in the power state table.
-
- AbsoluteTime deadline;
- IOPMPowerStateIndex stateIndex;
- IOPMPowerStateIndex currentOrder, newOrder, i;
- uint32_t settleTime = 0;
- boolean_t pending;
-
- PM_ASSERT_IN_GATE();
-
- currentOrder = StateOrder(fCurrentPowerState);
- newOrder = StateOrder(fHeadNotePowerState);
-
- i = currentOrder;
-
- // lowering power
- if (newOrder < currentOrder) {
- while (i > newOrder) {
- stateIndex = fPowerStates[i].stateOrderToIndex;
- settleTime += (uint32_t) fPowerStates[stateIndex].settleDownTime;
- i--;
- }
- }
-
- // raising power
- if (newOrder > currentOrder) {
- while (i < newOrder) {
- stateIndex = fPowerStates[i + 1].stateOrderToIndex;
- settleTime += (uint32_t) fPowerStates[stateIndex].settleUpTime;
- i++;
- }
- }
-
- if (settleTime) {
- retain();
- clock_interval_to_deadline(settleTime, kMicrosecondScale, &deadline);
- pending = thread_call_enter_delayed(fSettleTimer, deadline);
- if (pending) {
- release();
- }
- }
-#endif
-}
-
-//*********************************************************************************
-// [private] ackTimerTick
+void IOService::settleTimerExpired ( void )
+{
+ if ( ! initialized ) {
+ return; // we're unloading
+ }
+
+ switch (priv->machine_state) {
+ case IOPMour_prechange_3:
+ our_prechange_3();
+ break;
+ case IOPMparent_down_3:
+ parent_down_3();
+ break;
+ case IOPMparent_up_5:
+ parent_up_5();
+ break;
+ }
+}
+
+
+//*********************************************************************************
+// compute_settle_time
+//
+// Compute the power-settling delay in microseconds for the
+// change from myCurrentState to head_note_state.
+//*********************************************************************************
+
+unsigned long IOService::compute_settle_time ( void )
+{
+ unsigned long totalTime;
+ unsigned long i;
+
+ totalTime = 0; // compute total time to attain the new state
+ i = pm_vars->myCurrentState;
+ if ( priv->head_note_state < pm_vars->myCurrentState ) { // we're lowering power
+ while ( i > priv->head_note_state ) {
+ totalTime += pm_vars->thePowerStates[i].settleDownTime;
+ i--;
+ }
+ }
+
+ if ( priv->head_note_state > pm_vars->myCurrentState ) { // we're raising power
+ while ( i < priv->head_note_state ) {
+ totalTime += pm_vars->thePowerStates[i+1].settleUpTime;
+ i++;
+ }
+ }
+
+ return totalTime;
+}
+
+
+//*********************************************************************************
+// startSettleTimer
+//
+// Enter with a power-settling delay in microseconds and start a nano-second
+// timer for that delay.
+//*********************************************************************************
+
+IOReturn IOService::startSettleTimer ( unsigned long delay )
+{
+ AbsoluteTime deadline;
+
+ clock_interval_to_deadline(delay, kMicrosecondScale, &deadline);
+
+ thread_call_enter_delayed(priv->settleTimer, deadline);
+
+ return IOPMNoErr;
+}
+
+//*********************************************************************************
+// ack_timer_ticked
//
// The acknowledgement timeout periodic timer has ticked.
// If we are awaiting acks for a power change notification,
@@ -5579,492 +2736,579 @@
// If we are waiting for the controlling driver to change the power
// state of the hardware, we decrement its timer word, and if it becomes
// zero, we pretend the driver acknowledged.
-//
-// Returns true if the timer tick made it possible to advance to the next
-// machine state, false otherwise.
-//*********************************************************************************
-
-#ifndef __LP64__
-#if MACH_ASSERT
-__dead2
-#endif
-void
-IOService::ack_timer_ticked( void )
-{
- assert(false);
-}
-#endif /* !__LP64__ */
-
-bool
-IOService::ackTimerTick( void )
-{
- IOPMinformee * nextObject;
- bool done = false;
-
- PM_ASSERT_IN_GATE();
- switch (fMachineState) {
- case kIOPM_OurChangeWaitForPowerSettle:
- case kIOPM_ParentChangeWaitForPowerSettle:
- // are we waiting for controlling driver to acknowledge?
- if (fDriverTimer > 0) {
- // yes, decrement timer tick
- fDriverTimer--;
- if (fDriverTimer == 0) {
- // controlling driver is tardy
- uint64_t nsec = computeTimeDeltaNS(&fDriverCallStartTime);
- OUR_PMLog(kPMLogCtrlDriverTardy, 0, 0);
- setProperty(kIOPMTardyAckSPSKey, kOSBooleanTrue);
- PM_ERROR("%s::setPowerState(%p, %lu -> %lu) timed out after %d ms\n",
- fName, OBFUSCATE(this), fCurrentPowerState, fHeadNotePowerState, NS_TO_MS(nsec));
-
-#if DEBUG || DEVELOPMENT || !defined(XNU_TARGET_OS_OSX)
- bool panic_allowed = false;
- uint32_t setpowerstate_panic = -1;
- PE_parse_boot_argn("setpowerstate_panic", &setpowerstate_panic, sizeof(setpowerstate_panic));
- panic_allowed = setpowerstate_panic != 0;
-#ifdef CONFIG_XNUPOST
- uint64_t kernel_post_args = 0;
- PE_parse_boot_argn("kernPOST", &kernel_post_args, sizeof(kernel_post_args));
- if (kernel_post_args != 0) {
- panic_allowed = false;
- }
-#endif /* CONFIG_XNUPOST */
- if (panic_allowed) {
- // rdar://problem/48743340 - excluding AppleSEPManager from panic
- const char *allowlist = "AppleSEPManager";
- if (strncmp(fName, allowlist, strlen(allowlist))) {
- panic("%s::setPowerState(%p, %lu -> %lu) timed out after %d ms",
- fName, this, fCurrentPowerState, fHeadNotePowerState, NS_TO_MS(nsec));
- }
- } else {
-#ifdef CONFIG_XNUPOST
- if (kernel_post_args != 0) {
- PM_ERROR("setPowerState panic disabled by kernPOST boot-arg\n");
- }
-#endif /* CONFIG_XNUPOST */
- if (setpowerstate_panic != 0) {
- PM_ERROR("setPowerState panic disabled by setpowerstate_panic boot-arg\n");
- }
- }
-#else /* !(DEBUG || DEVELOPMENT || !defined(XNU_TARGET_OS_OSX)) */
- if (gIOKitDebug & kIOLogDebugPower) {
- panic("%s::setPowerState(%p, %lu -> %lu) timed out after %d ms",
- fName, this, fCurrentPowerState, fHeadNotePowerState, NS_TO_MS(nsec));
- } else {
- // panic for first party kexts
- const void *function_addr = NULL;
- OSKext *kext = NULL;
- function_addr = OSMemberFunctionCast(const void *, fControllingDriver, &IOService::setPowerState);
- kext = OSKext::lookupKextWithAddress((vm_address_t)function_addr);
- if (kext) {
-#if __has_feature(ptrauth_calls)
- function_addr = (const void*)VM_KERNEL_STRIP_PTR(function_addr);
-#endif /* __has_feature(ptrauth_calls) */
- const char *bundleID = kext->getIdentifierCString();
- const char *apple_prefix = "com.apple";
- const char *kernel_prefix = "__kernel__";
- if (strncmp(bundleID, apple_prefix, strlen(apple_prefix)) == 0 || strncmp(bundleID, kernel_prefix, strlen(kernel_prefix)) == 0) {
- // first party client
- panic("%s::setPowerState(%p : %p, %lu -> %lu) timed out after %d ms",
- fName, this, function_addr, fCurrentPowerState, fHeadNotePowerState, NS_TO_MS(nsec));
- }
- kext->release();
- }
- }
-#endif /* !(DEBUG || DEVELOPMENT || !defined(XNU_TARGET_OS_OSX)) */
- // Unblock state machine and pretend driver has acked.
- done = true;
- getPMRootDomain()->reset_watchdog_timer(this, 0);
- } else {
- // still waiting, set timer again
- start_ack_timer();
- }
- }
- break;
-
- case kIOPM_NotifyChildrenStart:
- // are we waiting for interested parties to acknowledge?
- if (fHeadNotePendingAcks != 0) {
- // yes, go through the list of interested drivers
- nextObject = fInterestedDrivers->firstInList();
- // and check each one
- while (nextObject != NULL) {
- if (nextObject->timer > 0) {
- nextObject->timer--;
- // this one should have acked by now
- if (nextObject->timer == 0) {
- uint64_t nsec = computeTimeDeltaNS(&nextObject->startTime);
- OUR_PMLog(kPMLogIntDriverTardy, 0, 0);
- nextObject->whatObject->setProperty(kIOPMTardyAckPSCKey, kOSBooleanTrue);
- PM_ERROR("%s::powerState%sChangeTo(%p, %s, %lu -> %lu) timed out after %d ms\n",
- nextObject->whatObject->getName(),
- (fDriverCallReason == kDriverCallInformPreChange) ? "Will" : "Did",
- OBFUSCATE(nextObject->whatObject), fName, fCurrentPowerState, fHeadNotePowerState,
- NS_TO_MS(nsec));
-
- // Pretend driver has acked.
- fHeadNotePendingAcks--;
- }
- }
- nextObject = fInterestedDrivers->nextInList(nextObject);
- }
-
- // is that the last?
- if (fHeadNotePendingAcks == 0) {
- // yes, we can continue
- done = true;
- getPMRootDomain()->reset_watchdog_timer(this, 0);
- } else {
- // no, set timer again
- start_ack_timer();
- }
- }
- break;
-
- // TODO: aggreggate this
- case kIOPM_OurChangeTellClientsPowerDown:
- case kIOPM_OurChangeTellUserPMPolicyPowerDown:
- case kIOPM_OurChangeTellPriorityClientsPowerDown:
- case kIOPM_OurChangeNotifyInterestedDriversWillChange:
- case kIOPM_ParentChangeTellPriorityClientsPowerDown:
- case kIOPM_ParentChangeNotifyInterestedDriversWillChange:
- case kIOPM_SyncTellClientsPowerDown:
- case kIOPM_SyncTellPriorityClientsPowerDown:
- case kIOPM_SyncNotifyWillChange:
- case kIOPM_TellCapabilityChangeDone:
- // apps didn't respond in time
- cleanClientResponses(true);
- OUR_PMLog(kPMLogClientTardy, 0, 1);
- // tardy equates to approval
- done = true;
- break;
-
- default:
- PM_LOG1("%s: unexpected ack timer tick (state = %d)\n",
- getName(), fMachineState);
- break;
+//*********************************************************************************
+
+void IOService::ack_timer_ticked ( void )
+{
+ IOPMinformee * nextObject;
+
+ if ( ! initialized ) {
+ return; // we're unloading
+ }
+
+ if (! acquire_lock() ) {
+ return;
+ }
+
+ switch (priv->machine_state) {
+ case IOPMour_prechange_2:
+ case IOPMparent_down_5:
+ case IOPMparent_up_4:
+ if ( priv->driver_timer != 0 ) { // are we waiting for our driver to make its change?
+ priv->driver_timer -= 1; // yes, tick once
+ if ( priv->driver_timer == 0 ) { // it's tardy, we'll go on without it
+ IOUnlock(priv->our_lock);
+ pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogCtrlDriverTardy,0,0);
+ driver_acked();
+ }
+ else { // still waiting, set timer again
+ start_ack_timer();
+ IOUnlock(priv->our_lock);
+ }
+ }
+ else {
+ IOUnlock(priv->our_lock);
+ }
+ break;
+
+ case IOPMour_prechange_1:
+ case IOPMour_prechange_4:
+ case IOPMparent_down_4:
+ case IOPMparent_down_6:
+ case IOPMparent_up_0:
+ case IOPMparent_up_6:
+ if (priv->head_note_pendingAcks != 0 ) { // are we waiting for interested parties to acknowledge?
+ nextObject = priv->interestedDrivers->firstInList(); // yes, go through the list of interested drivers
+ while ( nextObject != NULL ) { // and check each one
+ if ( nextObject->timer > 0 ) {
+ nextObject->timer -= 1;
+ if ( nextObject->timer == 0 ) { // this one should have acked by now
+ pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogIntDriverTardy,0,0);
+ kprintf("interested driver tardy: %s\n",nextObject->whatObject->getName());
+ priv->head_note_pendingAcks -= 1;
+ }
+ }
+ nextObject = priv->interestedDrivers->nextInList(nextObject);
+ }
+ if ( priv->head_note_pendingAcks == 0 ) { // is that the last?
+ IOUnlock(priv->our_lock);
+ all_acked(); // yes, we can continue
+ }
+ else { // no, set timer again
+ start_ack_timer();
+ IOUnlock(priv->our_lock);
+ }
+ }
+ else {
+ IOUnlock(priv->our_lock);
+ }
+ break;
+
+ case IOPMparent_down_0: // apps didn't respond to parent-down notification
+ IOUnlock(priv->our_lock);
+ IOLockLock(priv->flags_lock);
+ if (pm_vars->responseFlags) {
+ pm_vars->responseFlags->release(); // get rid of this stuff
+ pm_vars->responseFlags = NULL;
+ }
+ IOLockUnlock(priv->flags_lock);
+ pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogClientTardy,0,5);
+ parent_down_04(); // carry on with the change
+ break;
+
+ case IOPMparent_down_05:
+ IOUnlock(priv->our_lock);
+ IOLockLock(priv->flags_lock);
+ if (pm_vars->responseFlags) {
+ pm_vars->responseFlags->release(); // get rid of this stuff
+ pm_vars->responseFlags = NULL;
+ }
+ IOLockUnlock(priv->flags_lock);
+ pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogClientTardy,0,1);
+ parent_down_05(); // carry on with the change
+ break;
+
+ case IOPMour_prechange_03: // apps didn't respond to our power-down request
+ IOUnlock(priv->our_lock);
+ IOLockLock(priv->flags_lock);
+ if (pm_vars->responseFlags) {
+ pm_vars->responseFlags->release(); // get rid of this stuff
+ pm_vars->responseFlags = NULL;
+ }
+ IOLockUnlock(priv->flags_lock);
+ pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogClientTardy,0,2);
+ tellNoChangeDown(priv->head_note_state); // rescind the request
+ priv->head_note_flags |= IOPMNotDone; // mark the change note un-actioned
+ all_done(); // and we're done
+ break;
+
+ case IOPMour_prechange_04: // clients didn't respond to our power-down note
+ IOUnlock(priv->our_lock);
+ IOLockLock(priv->flags_lock);
+ if (pm_vars->responseFlags) {
+ pm_vars->responseFlags->release(); // get rid of this stuff
+ pm_vars->responseFlags = NULL;
+ }
+ IOLockUnlock(priv->flags_lock);
+ pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogClientTardy,0,4);
+ our_prechange_04(); // carry on with the change
+ break;
+
+ case IOPMour_prechange_05: // apps didn't respond to our power-down notification
+ IOUnlock(priv->our_lock);
+ IOLockLock(priv->flags_lock);
+ if (pm_vars->responseFlags) {
+ pm_vars->responseFlags->release(); // get rid of this stuff
+ pm_vars->responseFlags = NULL;
+ }
+ IOLockUnlock(priv->flags_lock);
+ pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogClientTardy,0,3);
+ our_prechange_05(); // carry on with the change
+ break;
+
+ default:
+ IOUnlock(priv->our_lock); // not waiting for acks
+ break;
+ }
+}
+
+
+//*********************************************************************************
+// start_ack_timer
+//
+//*********************************************************************************
+
+void IOService::start_ack_timer ( void )
+{
+ AbsoluteTime deadline;
+
+ clock_interval_to_deadline(ACK_TIMER_PERIOD, kNanosecondScale, &deadline);
+
+ thread_call_enter_delayed(priv->ackTimer, deadline);
+}
+
+
+//*********************************************************************************
+// stop_ack_timer
+//
+//*********************************************************************************
+
+void IOService::stop_ack_timer ( void )
+{
+ thread_call_cancel(priv->ackTimer);
+}
+
+
+//*********************************************************************************
+// c-language timer expiration functions
+//
+//*********************************************************************************
+
+static void ack_timer_expired ( thread_call_param_t us)
+{
+ ((IOService *)us)->ack_timer_ticked();
+}
+
+
+static void settle_timer_expired ( thread_call_param_t us)
+{
+ ((IOService *)us)->settleTimerExpired();
+}
+
+
+//*********************************************************************************
+// add_child_to_active_change
+//
+// A child has just registered with us. If there is
+// currently a change in progress, get the new party involved: if we
+// have notified all parties and are waiting for acks, notify the new
+// party.
+//*********************************************************************************
+
+IOReturn IOService::add_child_to_active_change ( IOPowerConnection * newObject )
+{
+ if (! acquire_lock() ) {
+ return IOPMNoErr;
+ }
+
+ switch (priv->machine_state) {
+ case IOPMour_prechange_1:
+ case IOPMparent_down_4:
+ case IOPMparent_up_0:
+ priv->head_note_pendingAcks += 2; // one for this child and one to prevent
+ IOUnlock(priv->our_lock); // incoming acks from changing our state
+ notifyChild(newObject, true);
+ if (! acquire_lock() ) {
+ --priv->head_note_pendingAcks; // put it back
+ return IOPMNoErr;
+ }
+ if ( --priv->head_note_pendingAcks == 0 ) { // are we still waiting for acks?
+ stop_ack_timer(); // no, stop the timer
+ IOUnlock(priv->our_lock);
+ all_acked(); // and now we can continue
+ return IOPMNoErr;
+ }
+ break;
+ case IOPMour_prechange_4:
+ case IOPMparent_down_6:
+ case IOPMparent_up_6:
+ priv->head_note_pendingAcks += 2; // one for this child and one to prevent
+ IOUnlock(priv->our_lock); // incoming acks from changing our state
+ notifyChild(newObject, false);
+ if (! acquire_lock() ) {
+ --priv->head_note_pendingAcks; // put it back
+ return IOPMNoErr;
+ }
+ if ( --priv->head_note_pendingAcks == 0 ) { // are we still waiting for acks?
+ stop_ack_timer(); // no, stop the timer
+ IOUnlock(priv->our_lock);
+ all_acked(); // and now we can continue
+ return IOPMNoErr;
+ }
+ break;
+ }
+ IOUnlock(priv->our_lock);
+ return IOPMNoErr;
+}
+
+
+//*********************************************************************************
+// add_driver_to_active_change
+//
+// An interested driver has just registered with us. If there is
+// currently a change in progress, get the new party involved: if we
+// have notified all parties and are waiting for acks, notify the new
+// party.
+//*********************************************************************************
+
+IOReturn IOService::add_driver_to_active_change ( IOPMinformee * newObject )
+{
+ if (! acquire_lock() ) {
+ return IOPMNoErr;
+ }
+
+ switch (priv->machine_state) {
+ case IOPMour_prechange_1:
+ case IOPMparent_down_4:
+ case IOPMparent_up_0:
+ priv->head_note_pendingAcks += 2; // one for this driver and one to prevent
+ IOUnlock(priv->our_lock); // incoming acks from changing our state
+ inform(newObject, true); // inform the driver
+ if (! acquire_lock() ) {
+ --priv->head_note_pendingAcks; // put it back
+ return IOPMNoErr;
+ }
+ if ( --priv->head_note_pendingAcks == 0 ) { // are we still waiting for acks?
+ stop_ack_timer(); // no, stop the timer
+ IOUnlock(priv->our_lock);
+ all_acked(); // and now we can continue
+ return IOPMNoErr;
+ }
+ break;
+ case IOPMour_prechange_4:
+ case IOPMparent_down_6:
+ case IOPMparent_up_6:
+ priv->head_note_pendingAcks += 2; // one for this driver and one to prevent
+ IOUnlock(priv->our_lock); // incoming acks from changing our state
+ inform(newObject, false); // inform the driver
+ if (! acquire_lock() ) {
+ --priv->head_note_pendingAcks; // put it back
+ return IOPMNoErr;
+ }
+ if ( --priv->head_note_pendingAcks == 0 ) { // are we still waiting for acks?
+ stop_ack_timer(); // no, stop the timer
+ IOUnlock(priv->our_lock);
+ all_acked(); // and now we can continue
+ return IOPMNoErr;
+ }
+ break;
+ }
+ IOUnlock(priv->our_lock);
+ return IOPMNoErr;
+}
+
+
+//*********************************************************************************
+// start_parent_change
+//
+// Here we begin the processing of a change note initiated by our parent
+// which is at the head of the queue.
+//
+// It is possible for the change to be processed to completion and removed from the queue.
+// There are several possible interruptions to the processing, though, and they are:
+// we may have to wait for interested parties to acknowledge our pre-change notification,
+// we may have to wait for our controlling driver to change the hardware power state,
+// there may be a settling time after changing the hardware power state,
+// we may have to wait for interested parties to acknowledge our post-change notification,
+// we may have to wait for the acknowledgement timer expiration to substitute for the
+// acknowledgement from a failing driver.
+//*********************************************************************************
+
+IOReturn IOService::start_parent_change ( unsigned long queue_head )
+{
+ priv->head_note = queue_head;
+ priv->head_note_flags = priv-> changeList->changeNote[priv->head_note].flags;
+ priv->head_note_state = priv->changeList->changeNote[priv->head_note].newStateNumber;
+ priv->imminentState = priv->head_note_state;
+ priv->head_note_outputFlags = priv->changeList->changeNote[priv->head_note].outputPowerCharacter;
+ priv->head_note_domainState = priv->changeList->changeNote[priv->head_note].domainState;
+ priv->head_note_parent = priv->changeList->changeNote[priv->head_note].parent;
+ priv->head_note_capabilityFlags = priv->changeList->changeNote[priv->head_note].capabilityFlags;
+
+ pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogStartParentChange,
+ (unsigned long)priv->head_note_state,(unsigned long)pm_vars->myCurrentState);
+
+ ask_parent( priv->ourDesiredPowerState); // if we need something and haven't told the parent, do so
+
+ if ( priv->head_note_state < pm_vars->myCurrentState ) { // power domain is lowering
+ setParentInfo(priv->changeList->changeNote[priv->head_note].singleParentState,priv->head_note_parent);
+ priv->initial_change = false;
+ priv->machine_state = IOPMparent_down_0; // tell apps and kernel clients
+ if ( tellChangeDown1(priv->head_note_state) ) { // are we waiting for responses?
+ return parent_down_0(); // no, notify priority clients
+ }
+ return IOPMWillAckLater; // yes
+ }
+
+ if ( priv->head_note_state > pm_vars->myCurrentState ) { // parent is raising power, we may or may not
+ if ( priv->ourDesiredPowerState > pm_vars->myCurrentState ) {
+ if ( priv->ourDesiredPowerState < priv->head_note_state ) {
+ priv->head_note_state = priv->ourDesiredPowerState; // we do, but not all the way
+ priv->imminentState = priv->head_note_state;
+ priv->head_note_outputFlags = pm_vars->thePowerStates[priv->head_note_state].outputPowerCharacter;
+ priv->head_note_capabilityFlags = pm_vars->thePowerStates[priv->head_note_state].capabilityFlags;
+ pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogAmendParentChange,(unsigned long)priv->head_note_state,0);
+ }
+ }
+ else {
+ priv->head_note_state = pm_vars->myCurrentState; // we don't
+ priv->imminentState = priv->head_note_state;
+ priv->head_note_outputFlags = pm_vars->thePowerStates[priv->head_note_state].outputPowerCharacter;
+ priv->head_note_capabilityFlags = pm_vars->thePowerStates[priv->head_note_state].capabilityFlags;
+ pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogAmendParentChange,(unsigned long)priv->head_note_state,0);
+ }
+ }
+
+ if ( (priv->head_note_state > pm_vars->myCurrentState) &&
+ (priv->head_note_flags & IOPMDomainDidChange) ) { // changing up
+ priv->initial_change = false;
+ priv->machine_state = IOPMparent_up_0;
+ if ( notifyAll(true) == IOPMAckImplied ) {
+ return parent_up_1();
}
- return done;
-}
-
-//*********************************************************************************
-// [private] start_watchdog_timer
-//*********************************************************************************
-void
-IOService::start_watchdog_timer( void )
-{
- int timeout;
- uint64_t deadline;
-
- if (!fWatchdogTimer || (kIOSleepWakeWdogOff & gIOKitDebug)) {
- return;
- }
-
- IOLockLock(fWatchdogLock);
-
- timeout = getPMRootDomain()->getWatchdogTimeout();
-
- clock_interval_to_deadline(timeout, kSecondScale, &deadline);
- start_watchdog_timer(deadline);
- IOLockUnlock(fWatchdogLock);
-}
-
-void
-IOService::start_watchdog_timer(uint64_t deadline)
-{
- IOLockAssert(fWatchdogLock, kIOLockAssertOwned);
-
- fWatchdogStart = mach_absolute_time();
- fWatchdogDeadline = deadline;
-
- if (!thread_call_isactive(fWatchdogTimer)) {
- thread_call_enter_delayed(fWatchdogTimer, deadline);
- }
-}
-
-//*********************************************************************************
-// [private] stop_watchdog_timer
-//*********************************************************************************
-
-void
-IOService::stop_watchdog_timer( void )
-{
- if (!fWatchdogTimer || (kIOSleepWakeWdogOff & gIOKitDebug)) {
- return;
- }
-
- IOLockLock(fWatchdogLock);
-
- thread_call_cancel(fWatchdogTimer);
- fWatchdogDeadline = 0;
-
- while (fBlockedArray->getCount()) {
- IOService *obj = OSDynamicCast(IOService, fBlockedArray->getObject(0));
- if (obj) {
- PM_ERROR("WDOG:Object %s unexpected in blocked array\n", obj->fName);
- fBlockedArray->removeObject(0);
- }
- }
-
- IOLockUnlock(fWatchdogLock);
-}
-
-//*********************************************************************************
-// reset_watchdog_timer
-//*********************************************************************************
-
-void
-IOService::reset_watchdog_timer(IOService *blockedObject, int pendingResponseTimeout)
-{
- unsigned int i;
- uint64_t deadline;
- IOService *obj;
-
- if (!fWatchdogTimer || (kIOSleepWakeWdogOff & gIOKitDebug)) {
- return;
- }
-
-
- IOLockLock(fWatchdogLock);
- if (!fWatchdogDeadline) {
- goto exit;
- }
-
- i = fBlockedArray->getNextIndexOfObject(blockedObject, 0);
- if (pendingResponseTimeout == 0) {
- blockedObject->fPendingResponseDeadline = 0;
- if (i == (unsigned int)-1) {
- goto exit;
- }
- fBlockedArray->removeObject(i);
- } else {
- // Set deadline 2secs after the expected response timeout to allow
- // ack timer to handle the timeout.
- clock_interval_to_deadline(pendingResponseTimeout + 2, kSecondScale, &deadline);
-
- if (i != (unsigned int)-1) {
- PM_ERROR("WDOG:Object %s is already blocked for responses. Ignoring timeout %d\n",
- fName, pendingResponseTimeout);
- goto exit;
- }
-
- for (i = 0; i < fBlockedArray->getCount(); i++) {
- obj = OSDynamicCast(IOService, fBlockedArray->getObject(i));
- if (obj && (obj->fPendingResponseDeadline < deadline)) {
- blockedObject->fPendingResponseDeadline = deadline;
- fBlockedArray->setObject(i, blockedObject);
- break;
- }
- }
- if (i == fBlockedArray->getCount()) {
- blockedObject->fPendingResponseDeadline = deadline;
- fBlockedArray->setObject(blockedObject);
- }
- }
-
- obj = OSDynamicCast(IOService, fBlockedArray->getObject(0));
- if (!obj) {
- int timeout = getPMRootDomain()->getWatchdogTimeout();
- clock_interval_to_deadline(timeout, kSecondScale, &deadline);
- } else {
- deadline = obj->fPendingResponseDeadline;
- }
-
- thread_call_cancel(fWatchdogTimer);
- start_watchdog_timer(deadline);
-
-exit:
- IOLockUnlock(fWatchdogLock);
-}
-
-void
-IOService::reset_watchdog_timer(int timeout)
-{
- uint64_t deadline;
-
- if (!fWatchdogTimer || (kIOSleepWakeWdogOff & gIOKitDebug)) {
- return;
- }
-
- IOLockLock(fWatchdogLock);
- if (!fWatchdogDeadline) {
- goto exit;
- }
-
- if (timeout == 0) {
- int defaultTimeout = getPMRootDomain()->getWatchdogTimeout();
- clock_interval_to_deadline(defaultTimeout, kSecondScale, &deadline);
- } else {
- clock_interval_to_deadline(timeout, kSecondScale, &deadline);
- }
-
- thread_call_cancel(fWatchdogTimer);
- start_watchdog_timer(deadline);
-
-exit:
- IOLockUnlock(fWatchdogLock);
-}
-
-uint64_t
-IOService::get_watchdog_elapsed_time(void)
-{
- uint64_t delta;
- absolutetime_to_nanoseconds(mach_absolute_time() - fWatchdogStart, &delta);
- delta /= kSecondScale;
- return delta;
-}
-
-
-//*********************************************************************************
-// [static] watchdog_timer_expired
-//
-// Inside PM work loop's gate.
-//*********************************************************************************
-
-void
-IOService::watchdog_timer_expired( thread_call_param_t arg0, thread_call_param_t arg1 )
-{
- IOService * me = (IOService *) arg0;
- bool expired;
-
- IOLockLock(me->fWatchdogLock);
- expired = me->fWatchdogDeadline && (me->fWatchdogDeadline <= mach_absolute_time());
- IOLockUnlock(me->fWatchdogLock);
- if (!expired) {
- return;
- }
-
- gIOPMWatchDogThread = current_thread();
- getPMRootDomain()->sleepWakeDebugTrig(true);
- gIOPMWatchDogThread = NULL;
- thread_call_free(me->fWatchdogTimer);
- me->fWatchdogTimer = NULL;
-
- return;
-}
-
-
-IOWorkLoop *
-IOService::getIOPMWorkloop( void )
-{
- return gIOPMWorkLoop;
-}
-
-
-
-//*********************************************************************************
-// [private] start_ack_timer
-//*********************************************************************************
-
-void
-IOService::start_ack_timer( void )
-{
- start_ack_timer( ACK_TIMER_PERIOD, kNanosecondScale );
-}
-
-void
-IOService::start_ack_timer( UInt32 interval, UInt32 scale )
-{
- AbsoluteTime deadline;
- boolean_t pending;
-
- clock_interval_to_deadline(interval, scale, &deadline);
-
- retain();
- pending = thread_call_enter_delayed(fAckTimer, deadline);
- if (pending) {
- release();
- }
-}
-
-//*********************************************************************************
-// [private] stop_ack_timer
-//*********************************************************************************
-
-void
-IOService::stop_ack_timer( void )
-{
- boolean_t pending;
-
- pending = thread_call_cancel(fAckTimer);
- if (pending) {
- release();
- }
-}
-
-//*********************************************************************************
-// [static] actionAckTimerExpired
-//
-// Inside PM work loop's gate.
-//*********************************************************************************
-
-IOReturn
-IOService::actionAckTimerExpired(
- OSObject * target,
- void * arg0, void * arg1,
- void * arg2, void * arg3 )
-{
- IOService * me = (IOService *) target;
- bool done;
-
- // done will be true if the timer tick unblocks the machine state,
- // otherwise no need to signal the work loop.
-
- done = me->ackTimerTick();
- if (done && gIOPMWorkQueue) {
- gIOPMWorkQueue->signalWorkAvailable();
- }
-
- return kIOReturnSuccess;
-}
-
-//*********************************************************************************
-// ack_timer_expired
-//
-// Thread call function. Holds a retain while the callout is in flight.
-//*********************************************************************************
-
-void
-IOService::ack_timer_expired( thread_call_param_t arg0, thread_call_param_t arg1 )
-{
- IOService * me = (IOService *) arg0;
-
- if (gIOPMWorkLoop) {
- gIOPMWorkLoop->runAction(&actionAckTimerExpired, me);
- }
- me->release();
-}
-
-
-// MARK: -
-// MARK: Client Messaging
-
-//*********************************************************************************
-// [private] tellSystemCapabilityChange
-//*********************************************************************************
-
-void
-IOService::tellSystemCapabilityChange( uint32_t nextMS )
-{
- assert(IS_ROOT_DOMAIN);
-
- MS_PUSH( nextMS );
- fMachineState = kIOPM_TellCapabilityChangeDone;
- fOutOfBandMessage = kIOMessageSystemCapabilityChange;
-
- if (fIsPreChange) {
- // Notify app first on pre-change.
- fOutOfBandParameter = kNotifyCapabilityChangeApps;
- } else {
- // Notify kernel clients first on post-change.
- fOutOfBandParameter = kNotifyCapabilityChangePriority;
- }
-
- tellClientsWithResponse( fOutOfBandMessage );
-}
-
-//*********************************************************************************
-// [public] askChangeDown
+ return IOPMWillAckLater; // they didn't all ack
+ }
+
+ all_done();
+ return IOPMAckImplied; // a null change or power will go up
+}
+
+
+//*********************************************************************************
+// start_our_change
+//
+// Here we begin the processing of a change note initiated by us
+// which is at the head of the queue.
+//
+// It is possible for the change to be processed to completion and removed from the queue.
+// There are several possible interruptions to the processing, though, and they are:
+// we may have to wait for interested parties to acknowledge our pre-change notification,
+// changes initiated by the parent will wait in the middle for powerStateDidChange,
+// we may have to wait for our controlling driver to change the hardware power state,
+// there may be a settling time after changing the hardware power state,
+// we may have to wait for interested parties to acknowledge our post-change notification,
+// we may have to wait for the acknowledgement timer expiration to substitute for the
+// acknowledgement from a failing driver.
+//*********************************************************************************
+
+void IOService::start_our_change ( unsigned long queue_head )
+{
+ priv->head_note = queue_head;
+ priv->head_note_flags = priv->changeList->changeNote[priv->head_note].flags;
+ priv->head_note_state = priv->changeList->changeNote[priv->head_note].newStateNumber;
+ priv->imminentState = priv->head_note_state;
+ priv->head_note_outputFlags = priv->changeList->changeNote[priv->head_note].outputPowerCharacter;
+ priv->head_note_capabilityFlags = priv->changeList->changeNote[priv->head_note].capabilityFlags;
+
+ pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogStartDeviceChange,
+ (unsigned long)priv->head_note_state,(unsigned long)pm_vars->myCurrentState);
+
+ if ( priv->head_note_capabilityFlags & IOPMNotAttainable ) { // can our driver switch to the new state?
+ if ( ! priv->we_are_root ) { // no, ask the parent to do it then
+ ask_parent(priv->head_note_state);
+ }
+ priv-> head_note_flags |= IOPMNotDone; // mark the change note un-actioned
+ all_done(); // and we're done
+ return;
+ }
+ // is there enough power in the domain?
+ if ( (pm_vars->maxCapability < priv->head_note_state) && (! priv->we_are_root) ) {
+ if ( ! priv->we_are_root ) { // no, ask the parent to raise it
+ ask_parent(priv->head_note_state);
+ }
+ priv->head_note_flags |= IOPMNotDone; // no, mark the change note un-actioned
+ all_done(); // and we're done
+ return; // till the parent raises power
+ }
+
+ if ( ! priv->initial_change ) {
+ if ( priv->head_note_state == pm_vars->myCurrentState ) {
+ all_done(); // we initiated a null change; forget it
+ return;
+ }
+ }
+ priv->initial_change = false;
+
+ if ( priv->head_note_state < pm_vars->myCurrentState ) { // dropping power?
+ priv->machine_state = IOPMour_prechange_03; // yes, in case we have to wait for acks
+ pm_vars->doNotPowerDown = false;
+ if ( askChangeDown(priv->head_note_state) ) { // ask apps and kernel clients if we can drop power
+ if ( pm_vars->doNotPowerDown ) { // don't have to wait, did any clients veto?
+ tellNoChangeDown(priv->head_note_state); // yes, rescind the warning
+ priv-> head_note_flags |= IOPMNotDone; // mark the change note un-actioned
+ all_done(); // and we're done
+ }
+ else {
+ our_prechange_03(); // no, tell'em we're dropping power
+ }
+ }
+ }
+ else {
+ if ( ! priv->we_are_root ) { // we are raising power
+ ask_parent(priv->head_note_state); // if this changes our power requirement, tell the parent
+ }
+ priv->machine_state = IOPMour_prechange_1; // in case they don't all ack
+ if ( notifyAll(true) == IOPMAckImplied ) { // notify interested drivers and children
+ our_prechange_1();
+ }
+ }
+}
+
+
+//*********************************************************************************
+// ask_parent
+//
+// Call the power domain parent to ask for a higher power state in the domain
+// or to suggest a lower power state.
+//*********************************************************************************
+
+IOReturn IOService::ask_parent ( unsigned long requestedState )
+{
+ OSIterator * iter;
+ OSObject * next;
+ IOPowerConnection * connection;
+ IOService * parent;
+ unsigned long ourRequest = pm_vars->thePowerStates[requestedState].inputPowerRequirement;
+
+ if ( pm_vars->thePowerStates[requestedState].capabilityFlags & (kIOPMChildClamp | kIOPMPreventIdleSleep) ) {
+ ourRequest |= kIOPMPreventIdleSleep;
+ }
+ if ( pm_vars->thePowerStates[requestedState].capabilityFlags & (kIOPMChildClamp2 | kIOPMPreventSystemSleep) ) {
+ ourRequest |= kIOPMPreventSystemSleep;
+ }
+
+ if ( priv->previousRequest == ourRequest ) { // is this a new desire?
+ return IOPMNoErr; // no, the parent knows already, just return
+ }
+
+ if ( priv->we_are_root ) {
+ return IOPMNoErr;
+ }
+ priv->previousRequest = ourRequest;
+
+ iter = getParentIterator(gIOPowerPlane);
+
+ if ( iter ) {
+ while ( (next = iter->getNextObject()) ) {
+ if ( (connection = OSDynamicCast(IOPowerConnection,next)) ) {
+ parent = (IOService *)connection->copyParentEntry(gIOPowerPlane);
+ if ( parent ) {
+ if ( parent->requestPowerDomainState(ourRequest,connection,IOPMLowestState)!= IOPMNoErr ) {
+ pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogRequestDenied,
+ (unsigned long)priv->previousRequest,0);
+ }
+ parent->release();
+ }
+ }
+ }
+ iter->release();
+ }
+
+ return IOPMNoErr;
+}
+
+
+//*********************************************************************************
+// instruct_driver
+//
+// Call the controlling driver and have it change the power state of the
+// hardware. If it returns IOPMAckImplied, the change is complete, and
+// we return IOPMAckImplied. Otherwise, it will ack when the change
+// is done; we return IOPMWillAckLater.
+//*********************************************************************************
+IOReturn IOService::instruct_driver ( unsigned long newState )
+{
+ IOReturn return_code;
+
+ if ( pm_vars->thePowerStates[newState].capabilityFlags & IOPMNotAttainable ) { // can our driver switch to the desired state?
+ return IOPMAckImplied; // no, so don't try
+ }
+ priv->driver_timer = -1;
+
+ pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogProgramHardware,newState,0);
+
+ return_code = pm_vars->theControllingDriver->setPowerState( newState,this ); // yes, instruct it
+ if ( return_code == IOPMAckImplied ) { // it finished
+ priv->driver_timer = 0;
+ return IOPMAckImplied;
+ }
+
+ if ( priv->driver_timer == 0 ) { // it acked behind our back
+ return IOPMAckImplied;
+ }
+
+ if ( return_code < 0 ) { // somebody goofed
+ return IOPMAckImplied;
+ }
+ priv->driver_timer = (return_code * ns_per_us / ACK_TIMER_PERIOD) + 1; // it didn't finish
+ return IOPMWillAckLater;
+}
+
+
+//*********************************************************************************
+// acquire_lock
+//
+// We are acquiring the lock we use to protect our queue head from
+// simutaneous access by a thread which calls acknowledgePowerStateChange
+// or acknowledgeSetPowerState and the ack timer expiration thread.
+// Return TRUE if we acquire the lock, and the queue head didn't change
+// while we were acquiring the lock (and maybe blocked).
+// If there is no queue head, or it changes while we are blocked,
+// return FALSE with the lock unlocked.
+//*********************************************************************************
+
+bool IOService::acquire_lock ( void )
+{
+ long current_change_note;
+
+ current_change_note = priv->head_note;
+ if ( current_change_note == -1 ) {
+ return FALSE;
+ }
+
+ IOTakeLock(priv->our_lock);
+ if ( current_change_note == priv->head_note ) {
+ return TRUE;
+ }
+ else { // we blocked and something changed radically
+ IOUnlock(priv->our_lock); // so there's nothing to do any more
+ return FALSE;
+ }
+}
+
+
+//*********************************************************************************
+// askChangeDown
//
// Ask registered applications and kernel clients if we can change to a lower
// power state.
@@ -6075,14 +3319,14 @@
// Return true if we don't have to wait for acknowledgements
//*********************************************************************************
-bool
-IOService::askChangeDown( unsigned long stateNum )
-{
- return tellClientsWithResponse( kIOMessageCanDevicePowerOff );
-}
-
-//*********************************************************************************
-// [private] tellChangeDown1
+bool IOService::askChangeDown ( unsigned long stateNum )
+{
+ return tellClientsWithResponse(kIOMessageCanDevicePowerOff);
+}
+
+
+//*********************************************************************************
+// tellChangeDown1
//
// Notify registered applications and kernel clients that we are definitely
// dropping power.
@@ -6090,30 +3334,30 @@
// Return true if we don't have to wait for acknowledgements
//*********************************************************************************
-bool
-IOService::tellChangeDown1( unsigned long stateNum )
-{
- fOutOfBandParameter = kNotifyApps;
- return tellChangeDown(stateNum);
-}
-
-//*********************************************************************************
-// [private] tellChangeDown2
+bool IOService::tellChangeDown1 ( unsigned long stateNum )
+{
+ pm_vars->outofbandparameter = kNotifyApps;
+ return tellChangeDown(stateNum);
+}
+
+
+//*********************************************************************************
+// tellChangeDown2
//
// Notify priority clients that we are definitely dropping power.
//
// Return true if we don't have to wait for acknowledgements
//*********************************************************************************
-bool
-IOService::tellChangeDown2( unsigned long stateNum )
-{
- fOutOfBandParameter = kNotifyPriority;
- return tellChangeDown(stateNum);
-}
-
-//*********************************************************************************
-// [public] tellChangeDown
+bool IOService::tellChangeDown2 ( unsigned long stateNum )
+{
+ pm_vars->outofbandparameter = kNotifyPriority;
+ return tellChangeDown(stateNum);
+}
+
+
+//*********************************************************************************
+// tellChangeDown
//
// Notify registered applications and kernel clients that we are definitely
// dropping power.
@@ -6124,155 +3368,14 @@
// Return true if we don't have to wait for acknowledgements
//*********************************************************************************
-bool
-IOService::tellChangeDown( unsigned long stateNum )
-{
- return tellClientsWithResponse( kIOMessageDeviceWillPowerOff );
-}
-
-//*********************************************************************************
-// cleanClientResponses
-//
-//*********************************************************************************
-
-static void
-logAppTimeouts( OSObject * object, void * arg )
-{
- IOPMInterestContext * context = (IOPMInterestContext *) arg;
- OSObject * flag;
- unsigned int clientIndex;
- int pid = 0;
- char name[128];
-
- if (OSDynamicCast(_IOServiceInterestNotifier, object)) {
- // Discover the 'counter' value or index assigned to this client
- // when it was notified, by searching for the array index of the
- // client in an array holding the cached interested clients.
-
- clientIndex = context->notifyClients->getNextIndexOfObject(object, 0);
-
- if ((clientIndex != (unsigned int) -1) &&
- (flag = context->responseArray->getObject(clientIndex)) &&
- (flag != kOSBooleanTrue)) {
- OSNumber *clientID = copyClientIDForNotification(object, context);
-
- name[0] = '\0';
- if (clientID) {
- pid = clientID->unsigned32BitValue();
- proc_name(pid, name, sizeof(name));
- clientID->release();
- }
-
- PM_ERROR("PM notification timeout (pid %d, %s)\n", pid, name);
-
- // TODO: record message type if possible
- IOService::getPMRootDomain()->pmStatsRecordApplicationResponse(
- gIOPMStatsResponseTimedOut,
- name, 0, (30 * 1000), pid, object);
- }
- }
-}
-
-static void
-logClientTimeouts( OSObject * object, void * arg )
-{
- IOPMInterestContext * context = (IOPMInterestContext *) arg;
- unsigned int clientIndex, startIndex = 0;
- OSObject * flag;
- bool isPriorityClient;
-
- isPriorityClient = (context->notifyType == kNotifyPriority) || (context->notifyType == kNotifyCapabilityChangePriority);
-
- // notifyClients can contain multiple instances of a client if we have notified
- // them multiple times in one tellClientsWithResponse cycle.
- while ((clientIndex = context->notifyClients->getNextIndexOfObject(object, startIndex)) != (unsigned int) -1) {
- // Check for client timeouts
- bool timeout = (flag = context->responseArray->getObject(clientIndex)) && (flag != kOSBooleanTrue);
- if (timeout) {
- if (context->us == IOService::getPMRootDomain()) {
- // Root domain clients
- PM_ERROR("PM %snotification timeout (%s)\n",
- isPriorityClient ? "priority " : "",
- IOService::getPMRootDomain()->getNotificationClientName(object));
- } else {
- // Non root domain clients
- char id[30];
- IOService * clientService;
- _IOServiceInterestNotifier * notifier;
-
- if ((notifier = OSDynamicCast(_IOServiceInterestNotifier, object))) {
- // _IOServiceInterestNotifier clients
- snprintf(id, sizeof(id), "%p", OBFUSCATE(notifier->handler));
- } else if ((clientService = OSDynamicCast(IOService, object))) {
- // IOService clients (e.g. power plane children)
- snprintf(id, sizeof(id), "%s", clientService->getName());
- } else {
- snprintf(id, sizeof(id), "%p", OBFUSCATE(object));
- }
-
- PM_ERROR("PM %snotification timeout (service: %s, client: %s)\n",
- isPriorityClient ? "priority " : "", context->us->getName(), id);
- }
- }
-
- startIndex = clientIndex + 1;
- }
-}
-
-void
-IOService::cleanClientResponses( bool logErrors )
-{
- if (logErrors && fResponseArray) {
- if (fNotifyClientArray) {
- IOPMInterestContext context;
-
- context.responseArray = fResponseArray;
- context.notifyClients = fNotifyClientArray;
- context.serialNumber = fSerialNumber;
- context.messageType = kIOMessageCopyClientID;
- context.notifyType = fOutOfBandParameter;
- context.isPreChange = fIsPreChange;
- context.enableTracing = false;
- context.us = this;
- context.maxTimeRequested = 0;
- context.stateNumber = fHeadNotePowerState;
- context.stateFlags = fHeadNotePowerArrayEntry->capabilityFlags;
- context.changeFlags = fHeadNoteChangeFlags;
-
- switch (fOutOfBandParameter) {
- case kNotifyApps:
- // kNotifyApps informs in-kernel clients as well
- applyToInterested(gIOGeneralInterest, logClientTimeouts, (void *) &context);
- OS_FALLTHROUGH;
- case kNotifyCapabilityChangeApps:
- applyToInterested(gIOAppPowerStateInterest, logAppTimeouts, (void *) &context);
- break;
- case kNotifyPriority:
- OS_FALLTHROUGH;
- case kNotifyCapabilityChangePriority:
- applyToInterested(gIOPriorityPowerStateInterest, logClientTimeouts, (void *) &context);
- break;
- default:
- break;
- }
- }
- }
-
- if (IS_ROOT_DOMAIN) {
- getPMRootDomain()->reset_watchdog_timer(this, 0);
- }
- if (fResponseArray) {
- fResponseArray->release();
- fResponseArray = NULL;
- }
- if (fNotifyClientArray) {
- fNotifyClientArray->release();
- fNotifyClientArray = NULL;
- }
-}
-
-//*********************************************************************************
-// [protected] tellClientsWithResponse
+bool IOService::tellChangeDown ( unsigned long stateNum )
+{
+ return tellClientsWithResponse(kIOMessageDeviceWillPowerOff);
+}
+
+
+//*********************************************************************************
+// tellClientsWithResponse
//
// Notify registered applications and kernel clients that we are definitely
// dropping power.
@@ -6280,601 +3383,170 @@
// Return true if we don't have to wait for acknowledgements
//*********************************************************************************
-bool
-IOService::tellClientsWithResponse( int messageType )
-{
- IOPMInterestContext context;
- bool isRootDomain = IS_ROOT_DOMAIN;
- uint32_t maxTimeOut = kMaxTimeRequested;
-
- PM_ASSERT_IN_GATE();
- assert( fResponseArray == NULL );
- assert( fNotifyClientArray == NULL );
-
- RD_LOG("tellClientsWithResponse( %s, %s )\n", getIOMessageString(messageType),
- getNotificationPhaseString(fOutOfBandParameter));
-
- fResponseArray = OSArray::withCapacity( 1 );
- if (!fResponseArray) {
- goto exit;
- }
-
- fResponseArray->setCapacityIncrement(8);
- if (++fSerialNumber == 0) {
- fSerialNumber++;
- }
-
- context.responseArray = fResponseArray;
- context.notifyClients = NULL;
- context.serialNumber = fSerialNumber;
- context.messageType = messageType;
- context.notifyType = fOutOfBandParameter;
- context.skippedInDark = 0;
- context.notSkippedInDark = 0;
- context.isPreChange = fIsPreChange;
- context.enableTracing = false;
- context.us = this;
- context.maxTimeRequested = 0;
- context.stateNumber = fHeadNotePowerState;
- context.stateFlags = fHeadNotePowerArrayEntry->capabilityFlags;
- context.changeFlags = fHeadNoteChangeFlags;
- context.messageFilter = (isRootDomain) ?
- OSMemberFunctionCast(
- IOPMMessageFilter,
- (IOPMrootDomain *)this,
- &IOPMrootDomain::systemMessageFilter) : NULL;
-
- switch (fOutOfBandParameter) {
- case kNotifyApps:
- applyToInterested( gIOAppPowerStateInterest,
- pmTellAppWithResponse, (void *) &context );
-
- if (isRootDomain &&
- (fMachineState != kIOPM_OurChangeTellClientsPowerDown) &&
- (fMachineState != kIOPM_SyncTellClientsPowerDown) &&
- (context.messageType != kIOPMMessageLastCallBeforeSleep)) {
- // Notify capability app for tellChangeDown1()
- // but not for askChangeDown().
- context.notifyType = kNotifyCapabilityChangeApps;
- context.messageType = kIOMessageSystemCapabilityChange;
- applyToInterested( gIOAppPowerStateInterest,
- pmTellCapabilityAppWithResponse, (void *) &context );
- context.notifyType = fOutOfBandParameter;
- context.messageType = messageType;
- }
- if (context.messageType == kIOMessageCanSystemSleep) {
- maxTimeOut = kCanSleepMaxTimeReq;
- if (gSleepAckTimeout) {
- maxTimeOut = (gSleepAckTimeout * us_per_s);
- }
- }
- if (context.messageType == kIOMessageSystemWillSleep) {
- maxTimeOut = kWillSleepMaxTimeReq;
- if (gSleepAckTimeout) {
- maxTimeOut = (gSleepAckTimeout * us_per_s);
- }
- }
- context.maxTimeRequested = maxTimeOut;
- context.enableTracing = isRootDomain;
- applyToInterested( gIOGeneralInterest,
- pmTellClientWithResponse, (void *) &context );
-
- break;
-
- case kNotifyPriority:
- context.enableTracing = isRootDomain;
- applyToInterested( gIOPriorityPowerStateInterest,
- pmTellClientWithResponse, (void *) &context );
-
- if (isRootDomain) {
- // Notify capability clients for tellChangeDown2().
- context.notifyType = kNotifyCapabilityChangePriority;
- context.messageType = kIOMessageSystemCapabilityChange;
- applyToInterested( gIOPriorityPowerStateInterest,
- pmTellCapabilityClientWithResponse, (void *) &context );
- }
- break;
-
- case kNotifyCapabilityChangeApps:
- context.enableTracing = isRootDomain;
- applyToInterested( gIOAppPowerStateInterest,
- pmTellCapabilityAppWithResponse, (void *) &context );
- if (context.messageType == kIOMessageCanSystemSleep) {
- maxTimeOut = kCanSleepMaxTimeReq;
- if (gSleepAckTimeout) {
- maxTimeOut = (gSleepAckTimeout * us_per_s);
- }
- }
- context.maxTimeRequested = maxTimeOut;
- break;
-
- case kNotifyCapabilityChangePriority:
- context.enableTracing = isRootDomain;
- applyToInterested( gIOPriorityPowerStateInterest,
- pmTellCapabilityClientWithResponse, (void *) &context );
- break;
- }
- fNotifyClientArray = context.notifyClients;
-
- if (context.skippedInDark) {
- IOLog("tellClientsWithResponse(%s, %s) %d of %d skipped in dark\n",
- getIOMessageString(messageType), getNotificationPhaseString(fOutOfBandParameter),
- context.skippedInDark, context.skippedInDark + context.notSkippedInDark);
- }
-
- // do we have to wait for somebody?
- if (!checkForDone()) {
- OUR_PMLog(kPMLogStartAckTimer, context.maxTimeRequested, 0);
- if (context.enableTracing) {
- getPMRootDomain()->traceDetail(context.messageType, 0, context.maxTimeRequested / 1000);
- getPMRootDomain()->reset_watchdog_timer(this, context.maxTimeRequested / USEC_PER_SEC + 1);
- }
- start_ack_timer( context.maxTimeRequested / 1000, kMillisecondScale );
- return false;
- }
-
-exit:
- // everybody responded
- if (fResponseArray) {
- fResponseArray->release();
- fResponseArray = NULL;
- }
- if (fNotifyClientArray) {
- fNotifyClientArray->release();
- fNotifyClientArray = NULL;
- }
-
- return true;
-}
-
-//*********************************************************************************
-// [static private] pmTellAppWithResponse
+bool IOService::tellClientsWithResponse ( int messageType )
+{
+ struct context theContext;
+ AbsoluteTime deadline;
+ OSBoolean * aBool;
+
+ pm_vars->responseFlags = OSArray::withCapacity( 1 );
+ pm_vars->serialNumber += 1;
+
+ theContext.responseFlags = pm_vars->responseFlags;
+ theContext.serialNumber = pm_vars->serialNumber;
+ theContext.flags_lock = priv->flags_lock;
+ theContext.counter = 1;
+ theContext.msgType = messageType;
+ theContext.us = this;
+ theContext.maxTimeRequested = 0;
+ theContext.stateNumber = priv->head_note_state;
+ theContext.stateFlags = priv->head_note_capabilityFlags;
+
+ IOLockLock(priv->flags_lock);
+ aBool = OSBoolean::withBoolean(false); // position zero is false to
+ theContext.responseFlags->setObject(0,aBool); // prevent allowCancelCommon from succeeding
+ aBool->release();
+ IOLockUnlock(priv->flags_lock);
+
+ switch ( pm_vars->outofbandparameter ) {
+ case kNotifyApps:
+ applyToInterested(gIOAppPowerStateInterest,tellAppWithResponse,(void *)&theContext);
+ applyToInterested(gIOGeneralInterest,tellClientWithResponse,(void *)&theContext);
+ break;
+ case kNotifyPriority:
+ applyToInterested(gIOPriorityPowerStateInterest,tellClientWithResponse,(void *)&theContext);
+ break;
+ }
+
+ if (! acquire_lock() ) {
+ return true;
+ }
+ IOLockLock(priv->flags_lock);
+ aBool = OSBoolean::withBoolean(true); // now fix position zero
+ theContext.responseFlags->replaceObject(0,aBool);
+ aBool->release();
+ IOLockUnlock(priv->flags_lock);
+
+ if ( ! checkForDone() ) { // we have to wait for somebody
+ pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogStartAckTimer,theContext.maxTimeRequested,0);
+ clock_interval_to_deadline(theContext.maxTimeRequested / 1000, kMillisecondScale, &deadline);
+
+ thread_call_enter_delayed(priv->ackTimer, deadline);
+
+ IOUnlock(priv->our_lock); // yes
+ return false;
+ }
+
+ IOUnlock(priv->our_lock);
+ IOLockLock(priv->flags_lock);
+ pm_vars->responseFlags->release(); // everybody responded
+ pm_vars->responseFlags = NULL;
+ IOLockUnlock(priv->flags_lock);
+
+ return true;
+}
+
+
+//*********************************************************************************
+// tellAppWithResponse
//
// We send a message to an application, and we expect a response, so we compute a
// cookie we can identify the response with.
//*********************************************************************************
-
-void
-IOService::pmTellAppWithResponse( OSObject * object, void * arg )
-{
- IOPMInterestContext * context = (IOPMInterestContext *) arg;
- IOServicePM * pwrMgt = context->us->pwrMgt;
- uint32_t msgIndex, msgRef, msgType;
- OSNumber *clientID = NULL;
- proc_t proc = NULL;
- boolean_t proc_suspended = FALSE;
- OSObject * waitForReply = kOSBooleanTrue;
-#if LOG_APP_RESPONSE_TIMES
- AbsoluteTime now;
-#endif
-
- if (!OSDynamicCast(_IOServiceInterestNotifier, object)) {
- return;
- }
-
- if (context->us == getPMRootDomain()) {
- if ((clientID = copyClientIDForNotification(object, context))) {
- uint32_t clientPID = clientID->unsigned32BitValue();
- clientID->release();
- proc = proc_find(clientPID);
-
- if (proc) {
- proc_suspended = get_task_pidsuspended((task_t) proc_task(proc));
- if (proc_suspended) {
- logClientIDForNotification(object, context, "PMTellAppWithResponse - Suspended");
- } else if (getPMRootDomain()->isAOTMode() && get_task_suspended((task_t) proc_task(proc))) {
- proc_suspended = true;
- context->skippedInDark++;
- }
- proc_rele(proc);
- if (proc_suspended) {
- return;
- }
- }
- }
- }
-
- if (context->messageFilter &&
- !context->messageFilter(context->us, object, context, NULL, &waitForReply)) {
- if (kIOLogDebugPower & gIOKitDebug) {
- logClientIDForNotification(object, context, "DROP App");
- }
- return;
- }
- context->notSkippedInDark++;
-
- // Create client array (for tracking purposes) only if the service
- // has app clients. Usually only root domain does.
- if (NULL == context->notifyClients) {
- context->notifyClients = OSArray::withCapacity( 32 );
- }
-
- msgType = context->messageType;
- msgIndex = context->responseArray->getCount();
- msgRef = ((context->serialNumber & 0xFFFF) << 16) + (msgIndex & 0xFFFF);
-
- OUR_PMLog(kPMLogAppNotify, msgType, msgRef);
- if (kIOLogDebugPower & gIOKitDebug) {
- logClientIDForNotification(object, context, "MESG App");
- }
-
- if (waitForReply == kOSBooleanTrue) {
- OSNumber * num;
- clock_get_uptime(&now);
- num = OSNumber::withNumber(AbsoluteTime_to_scalar(&now), sizeof(uint64_t) * 8);
- if (num) {
- context->responseArray->setObject(msgIndex, num);
- num->release();
- } else {
- context->responseArray->setObject(msgIndex, kOSBooleanFalse);
- }
- } else {
- context->responseArray->setObject(msgIndex, kOSBooleanTrue);
- if (kIOLogDebugPower & gIOKitDebug) {
- logClientIDForNotification(object, context, "App response ignored");
- }
- }
-
- if (context->notifyClients) {
- context->notifyClients->setObject(msgIndex, object);
- }
-
- context->us->messageClient(msgType, object, (void *)(uintptr_t) msgRef);
-}
-
-//*********************************************************************************
-// [static private] pmTellClientWithResponse
-//
-// We send a message to an in-kernel client, and we expect a response,
-// so we compute a cookie we can identify the response with.
-//*********************************************************************************
-
-void
-IOService::pmTellClientWithResponse( OSObject * object, void * arg )
-{
- IOPowerStateChangeNotification notify;
- IOPMInterestContext * context = (IOPMInterestContext *) arg;
- OSObject * replied = kOSBooleanTrue;
- _IOServiceInterestNotifier * notifier;
- uint32_t msgIndex, msgRef, msgType;
- IOReturn retCode;
- AbsoluteTime start, end;
- uint64_t nsec;
- bool enableTracing;
-
- if (context->messageFilter &&
- !context->messageFilter(context->us, object, context, NULL, NULL)) {
- getPMRootDomain()->traceFilteredNotification(object);
- return;
- }
-
- // Besides interest notifiers this applier function can also be invoked against
- // IOService clients of context->us, so notifier can be NULL. But for tracing
- // purposes the IOService clients can be ignored but each will still consume
- // an entry in the responseArray and also advance msgIndex.
- notifier = OSDynamicCast(_IOServiceInterestNotifier, object);
- msgType = context->messageType;
- msgIndex = context->responseArray->getCount();
- msgRef = ((context->serialNumber & 0xFFFF) << 16) + (msgIndex & 0xFFFF);
- enableTracing = context->enableTracing && (notifier != NULL);
-
- IOServicePM * pwrMgt = context->us->pwrMgt;
- if (gIOKitDebug & kIOLogPower) {
- OUR_PMLog(kPMLogClientNotify, msgRef, msgType);
- if (OSDynamicCast(IOService, object)) {
- const char *who = ((IOService *) object)->getName();
- gPlatform->PMLog(who, kPMLogClientNotify, (uintptr_t) object, 0);
- } else if (notifier) {
- OUR_PMLog(kPMLogClientNotify, (uintptr_t) notifier->handler, 0);
- }
- }
-
- if (NULL == context->notifyClients) {
- context->notifyClients = OSArray::withCapacity(32);
- assert(context->notifyClients != NULL);
- }
-
- notify.powerRef = (void *)(uintptr_t) msgRef;
- notify.returnValue = 0;
- notify.stateNumber = context->stateNumber;
- notify.stateFlags = context->stateFlags;
-
- clock_get_uptime(&start);
- if (enableTracing) {
- getPMRootDomain()->traceNotification(notifier, true, start, msgIndex);
- }
-
- retCode = context->us->messageClient(msgType, object, (void *) ¬ify, sizeof(notify));
-
- clock_get_uptime(&end);
- if (enableTracing) {
- getPMRootDomain()->traceNotification(notifier, false, end);
- }
-
- if (kIOReturnSuccess == retCode) {
- if (0 == notify.returnValue) {
- OUR_PMLog(kPMLogClientAcknowledge, msgRef, (uintptr_t) object);
- context->responseArray->setObject(msgIndex, replied);
- } else {
- replied = kOSBooleanFalse;
- uint32_t ackTimeRequested = (uint32_t) notify.returnValue;
- if (notify.returnValue > context->maxTimeRequested) {
- if (notify.returnValue > kPriorityClientMaxWait) {
- context->maxTimeRequested = ackTimeRequested = kPriorityClientMaxWait;
- PM_ERROR("%s: client %p returned %llu for %s\n",
- context->us->getName(),
- notifier ? (void *) OBFUSCATE(notifier->handler) : OBFUSCATE(object),
- (uint64_t) notify.returnValue,
- getIOMessageString(msgType));
- } else {
- context->maxTimeRequested = (typeof(context->maxTimeRequested))notify.returnValue;
- }
- }
-
- // Track acknowledgements by storing the timestamp of
- // callback completion and requested ack time.
- IOPMClientAck *ackState = new IOPMClientAck;
- if (ackState) {
- ackState->completionTimestamp = AbsoluteTime_to_scalar(&end);
- ackState->maxTimeRequested = ackTimeRequested;
- context->responseArray->setObject(msgIndex, ackState);
- OSSafeReleaseNULL(ackState);
- } else {
- context->responseArray->setObject(msgIndex, replied);
- }
- }
-
- if (enableTracing) {
- SUB_ABSOLUTETIME(&end, &start);
- absolutetime_to_nanoseconds(end, &nsec);
-
- if ((nsec > LOG_KEXT_RESPONSE_TIMES) || (notify.returnValue != 0)) {
- getPMRootDomain()->traceNotificationResponse(notifier, NS_TO_MS(nsec), (uint32_t) notify.returnValue);
- }
- }
- } else {
- // not a client of ours
- // so we won't be waiting for response
- OUR_PMLog(kPMLogClientAcknowledge, msgRef, 0);
- context->responseArray->setObject(msgIndex, replied);
- }
- if (context->notifyClients) {
- context->notifyClients->setObject(msgIndex, object);
- }
-}
-
-//*********************************************************************************
-// [static private] pmTellCapabilityAppWithResponse
-//*********************************************************************************
-
-void
-IOService::pmTellCapabilityAppWithResponse( OSObject * object, void * arg )
-{
- IOPMSystemCapabilityChangeParameters msgArg;
- IOPMInterestContext * context = (IOPMInterestContext *) arg;
- OSObject * waitForReply = kOSBooleanFalse;
- IOServicePM * pwrMgt = context->us->pwrMgt;
- uint32_t msgIndex, msgRef, msgType;
-#if LOG_APP_RESPONSE_TIMES
- AbsoluteTime now;
-#endif
-
- if (!OSDynamicCast(_IOServiceInterestNotifier, object)) {
- return;
- }
-
- memset(&msgArg, 0, sizeof(msgArg));
- if (context->messageFilter &&
- !context->messageFilter(context->us, object, context, &msgArg, &waitForReply)) {
- return;
- }
-
- if (context->us == getPMRootDomain() &&
- getPMRootDomain()->isAOTMode()
- ) {
- OSNumber *clientID = NULL;
- boolean_t proc_suspended = FALSE;
- proc_t proc = NULL;
- if ((clientID = copyClientIDForNotification(object, context))) {
- uint32_t clientPID = clientID->unsigned32BitValue();
- clientID->release();
- proc = proc_find(clientPID);
- if (proc) {
- proc_suspended = get_task_pidsuspended((task_t) proc_task(proc));
- if (proc_suspended) {
- logClientIDForNotification(object, context, "PMTellCapablityAppWithResponse - Suspended");
- } else if (get_task_suspended((task_t) proc_task(proc))) {
- proc_suspended = true;
- context->skippedInDark++;
- }
- proc_rele(proc);
- if (proc_suspended) {
- return;
- }
- }
- }
- }
- context->notSkippedInDark++;
-
- // Create client array (for tracking purposes) only if the service
- // has app clients. Usually only root domain does.
- if (NULL == context->notifyClients) {
- context->notifyClients = OSArray::withCapacity(32);
- assert(context->notifyClients != NULL);
- }
-
- msgType = context->messageType;
- msgIndex = context->responseArray->getCount();
- msgRef = ((context->serialNumber & 0xFFFF) << 16) + (msgIndex & 0xFFFF);
-
- OUR_PMLog(kPMLogAppNotify, msgType, msgRef);
- if (kIOLogDebugPower & gIOKitDebug) {
- // Log client pid/name and client array index.
- OSNumber * clientID = NULL;
- OSString * clientIDString = NULL;
- context->us->messageClient(kIOMessageCopyClientID, object, &clientID);
- if (clientID) {
- clientIDString = IOCopyLogNameForPID(clientID->unsigned32BitValue());
- }
-
- PM_LOG("%s MESG App(%u) %s, wait %u, %s\n",
- context->us->getName(),
- msgIndex, getIOMessageString(msgType),
- (waitForReply == kOSBooleanTrue),
- clientIDString ? clientIDString->getCStringNoCopy() : "");
- if (clientID) {
- clientID->release();
- }
- if (clientIDString) {
- clientIDString->release();
- }
- }
-
- msgArg.notifyRef = msgRef;
- msgArg.maxWaitForReply = 0;
-
- if (waitForReply == kOSBooleanFalse) {
- msgArg.notifyRef = 0;
- context->responseArray->setObject(msgIndex, kOSBooleanTrue);
- if (context->notifyClients) {
- context->notifyClients->setObject(msgIndex, kOSBooleanTrue);
- }
- } else {
- OSNumber * num;
- clock_get_uptime(&now);
- num = OSNumber::withNumber(AbsoluteTime_to_scalar(&now), sizeof(uint64_t) * 8);
- if (num) {
- context->responseArray->setObject(msgIndex, num);
- num->release();
- } else {
- context->responseArray->setObject(msgIndex, kOSBooleanFalse);
- }
-
- if (context->notifyClients) {
- context->notifyClients->setObject(msgIndex, object);
- }
- }
-
- context->us->messageClient(msgType, object, (void *) &msgArg, sizeof(msgArg));
-}
-
-//*********************************************************************************
-// [static private] pmTellCapabilityClientWithResponse
-//*********************************************************************************
-
-void
-IOService::pmTellCapabilityClientWithResponse(
- OSObject * object, void * arg )
-{
- IOPMSystemCapabilityChangeParameters msgArg;
- IOPMInterestContext * context = (IOPMInterestContext *) arg;
- OSObject * replied = kOSBooleanTrue;
- _IOServiceInterestNotifier * notifier;
- uint32_t msgIndex, msgRef, msgType;
- IOReturn retCode;
- AbsoluteTime start, end;
- uint64_t nsec;
- bool enableTracing;
-
- memset(&msgArg, 0, sizeof(msgArg));
- if (context->messageFilter &&
- !context->messageFilter(context->us, object, context, &msgArg, NULL)) {
- getPMRootDomain()->traceFilteredNotification(object);
- return;
- }
-
- if (NULL == context->notifyClients) {
- context->notifyClients = OSArray::withCapacity(32);
- assert(context->notifyClients != NULL);
- }
-
- notifier = OSDynamicCast(_IOServiceInterestNotifier, object);
- msgType = context->messageType;
- msgIndex = context->responseArray->getCount();
- msgRef = ((context->serialNumber & 0xFFFF) << 16) + (msgIndex & 0xFFFF);
- enableTracing = context->enableTracing && (notifier != NULL);
-
- IOServicePM * pwrMgt = context->us->pwrMgt;
- if (gIOKitDebug & kIOLogPower) {
- OUR_PMLog(kPMLogClientNotify, msgRef, msgType);
- if (OSDynamicCast(IOService, object)) {
- const char *who = ((IOService *) object)->getName();
- gPlatform->PMLog(who, kPMLogClientNotify, (uintptr_t) object, 0);
- } else if (notifier) {
- OUR_PMLog(kPMLogClientNotify, (uintptr_t) notifier->handler, 0);
- }
- }
-
- msgArg.notifyRef = msgRef;
- msgArg.maxWaitForReply = 0;
-
- clock_get_uptime(&start);
- if (enableTracing) {
- getPMRootDomain()->traceNotification(notifier, true, start, msgIndex);
- }
-
- retCode = context->us->messageClient(msgType, object, (void *) &msgArg, sizeof(msgArg));
-
- clock_get_uptime(&end);
- if (enableTracing) {
- getPMRootDomain()->traceNotification(notifier, false, end, msgIndex);
- }
-
- if (kIOReturnSuccess == retCode) {
- if (0 == msgArg.maxWaitForReply) {
- // client doesn't want time to respond
- OUR_PMLog(kPMLogClientAcknowledge, msgRef, (uintptr_t) object);
- context->responseArray->setObject(msgIndex, replied);
- } else {
- replied = kOSBooleanFalse;
- uint32_t ackTimeRequested = msgArg.maxWaitForReply;
- if (msgArg.maxWaitForReply > context->maxTimeRequested) {
- if (msgArg.maxWaitForReply > kCapabilityClientMaxWait) {
- context->maxTimeRequested = ackTimeRequested = kCapabilityClientMaxWait;
- PM_ERROR("%s: client %p returned %u for %s\n",
- context->us->getName(),
- notifier ? (void *) OBFUSCATE(notifier->handler) : OBFUSCATE(object),
- msgArg.maxWaitForReply,
- getIOMessageString(msgType));
- } else {
- context->maxTimeRequested = msgArg.maxWaitForReply;
- }
- }
-
- // Track acknowledgements by storing the timestamp of
- // callback completion and requested ack time.
- IOPMClientAck *ackState = new IOPMClientAck;
- if (ackState) {
- ackState->completionTimestamp = AbsoluteTime_to_scalar(&end);
- ackState->maxTimeRequested = ackTimeRequested;
- context->responseArray->setObject(msgIndex, ackState);
- OSSafeReleaseNULL(ackState);
- } else {
- context->responseArray->setObject(msgIndex, replied);
- }
- }
-
- if (enableTracing) {
- SUB_ABSOLUTETIME(&end, &start);
- absolutetime_to_nanoseconds(end, &nsec);
-
- if ((nsec > LOG_KEXT_RESPONSE_TIMES) || (msgArg.maxWaitForReply != 0)) {
- getPMRootDomain()->traceNotificationResponse(notifier, NS_TO_MS(nsec), msgArg.maxWaitForReply);
- }
- }
- } else {
- // not a client of ours
- // so we won't be waiting for response
- OUR_PMLog(kPMLogClientAcknowledge, msgRef, 0);
- context->responseArray->setObject(msgIndex, replied);
- }
- if (context->notifyClients) {
- context->notifyClients->setObject(msgIndex, object);
- }
-}
-
-//*********************************************************************************
-// [public] tellNoChangeDown
+void tellAppWithResponse ( OSObject * object, void * context)
+{
+ struct context * theContext = (struct context *)context;
+ UInt32 refcon;
+ OSBoolean * aBool;
+
+ if( OSDynamicCast( IOService, object) ) {
+ IOLockLock(theContext->flags_lock);
+ aBool = OSBoolean::withBoolean(true);
+ theContext->responseFlags->setObject(theContext->counter,aBool);
+ aBool->release();
+ IOLockUnlock(theContext->flags_lock);
+ }
+ else {
+ refcon = ((theContext->serialNumber & 0xFFFF)<<16) + (theContext->counter & 0xFFFF);
+ IOLockLock(theContext->flags_lock);
+ aBool = OSBoolean::withBoolean(false);
+ theContext->responseFlags->setObject(theContext->counter,aBool);
+ aBool->release();
+ IOLockUnlock(theContext->flags_lock);
+ theContext->us->messageClient(theContext->msgType,object,(void *)refcon);
+ if ( theContext->maxTimeRequested < k30seconds ) {
+ theContext->maxTimeRequested = k30seconds;
+ }
+ }
+ theContext->counter += 1;
+}
+
+
+//*********************************************************************************
+// tellClientWithResponse
+//
+// We send a message to an in-kernel client, and we expect a response, so we compute a
+// cookie we can identify the response with.
+// If it doesn't understand the notification (it is not power-management savvy)
+// we won't wait for it to prepare for sleep. If it tells us via a return code
+// in the passed struct that it is currently ready, we won't wait for it to prepare.
+// If it tells us via the return code in the struct that it does need time, we will chill.
+//*********************************************************************************
+void tellClientWithResponse ( OSObject * object, void * context)
+{
+ struct context * theContext = (struct context *)context;
+ IOPowerStateChangeNotification notify;
+ UInt32 refcon;
+ IOReturn retCode;
+ OSBoolean * aBool;
+ OSObject * theFlag;
+
+ refcon = ((theContext->serialNumber & 0xFFFF)<<16) + (theContext->counter & 0xFFFF);
+ IOLockLock(theContext->flags_lock);
+ aBool = OSBoolean::withBoolean(false);
+ theContext->responseFlags->setObject(theContext->counter,aBool);
+ aBool->release();
+ IOLockUnlock(theContext->flags_lock);
+
+ notify.powerRef = (void *)refcon;
+ notify.returnValue = 0;
+ notify.stateNumber = theContext->stateNumber;
+ notify.stateFlags = theContext->stateFlags;
+ retCode = theContext->us->messageClient(theContext->msgType,object,(void *)¬ify);
+ if ( retCode == kIOReturnSuccess ) {
+ if ( notify.returnValue == 0 ) { // client doesn't want time to respond
+ IOLockLock(theContext->flags_lock);
+ aBool = OSBoolean::withBoolean(true);
+ theContext->responseFlags->replaceObject(theContext->counter,aBool); // so set its flag true
+ aBool->release();
+ IOLockUnlock(theContext->flags_lock);
+ }
+ else {
+ IOLockLock(theContext->flags_lock);
+ theFlag = theContext->responseFlags->getObject(theContext->counter); // it does want time, and it hasn't
+ if ( theFlag != 0 ) { // responded yet
+ if ( ((OSBoolean *)theFlag)->isFalse() ) { // so note its time requirement
+ if ( theContext->maxTimeRequested < notify.returnValue ) {
+ theContext->maxTimeRequested = notify.returnValue;
+ }
+ }
+ }
+ IOLockUnlock(theContext->flags_lock);
+ }
+ }
+ else { // not a client of ours
+ IOLockLock(theContext->flags_lock);
+ aBool = OSBoolean::withBoolean(true); // so we won't be waiting for response
+ theContext->responseFlags->replaceObject(theContext->counter,aBool);
+ aBool->release();
+ IOLockUnlock(theContext->flags_lock);
+ }
+ theContext->counter += 1;
+}
+
+
+//*********************************************************************************
+// tellNoChangeDown
//
// Notify registered applications and kernel clients that we are not
// dropping power.
@@ -6883,14 +3555,14 @@
// the aborted destination state number.
//*********************************************************************************
-void
-IOService::tellNoChangeDown( unsigned long )
-{
- return tellClients( kIOMessageDeviceWillNotPowerOff );
-}
-
-//*********************************************************************************
-// [public] tellChangeUp
+void IOService::tellNoChangeDown ( unsigned long )
+{
+ return tellClients(kIOMessageDeviceWillNotPowerOff);
+}
+
+
+//*********************************************************************************
+// tellChangeUp
//
// Notify registered applications and kernel clients that we are raising power.
//
@@ -6898,500 +3570,274 @@
// the aborted destination state number.
//*********************************************************************************
-void
-IOService::tellChangeUp( unsigned long )
-{
- return tellClients( kIOMessageDeviceHasPoweredOn );
-}
-
-//*********************************************************************************
-// [protected] tellClients
+void IOService::tellChangeUp ( unsigned long )
+{
+ return tellClients(kIOMessageDeviceHasPoweredOn);
+}
+
+
+//*********************************************************************************
+// tellClients
//
// Notify registered applications and kernel clients of something.
//*********************************************************************************
-void
-IOService::tellClients( int messageType )
-{
- IOPMInterestContext context;
-
- RD_LOG("tellClients( %s )\n", getIOMessageString(messageType));
-
- memset(&context, 0, sizeof(context));
- context.messageType = messageType;
- context.isPreChange = fIsPreChange;
- context.us = this;
- context.stateNumber = fHeadNotePowerState;
- context.stateFlags = fHeadNotePowerArrayEntry->capabilityFlags;
- context.changeFlags = fHeadNoteChangeFlags;
- context.enableTracing = IS_ROOT_DOMAIN;
- context.messageFilter = (IS_ROOT_DOMAIN) ?
- OSMemberFunctionCast(
- IOPMMessageFilter,
- (IOPMrootDomain *)this,
- &IOPMrootDomain::systemMessageFilter) : NULL;
-
- context.notifyType = kNotifyPriority;
- applyToInterested( gIOPriorityPowerStateInterest,
- tellKernelClientApplier, (void *) &context );
-
- context.notifyType = kNotifyApps;
- applyToInterested( gIOAppPowerStateInterest,
- tellAppClientApplier, (void *) &context );
-
- applyToInterested( gIOGeneralInterest,
- tellKernelClientApplier, (void *) &context );
-}
-
-//*********************************************************************************
-// [private] tellKernelClientApplier
-//
-// Message a kernel client.
-//*********************************************************************************
-
-static void
-tellKernelClientApplier( OSObject * object, void * arg )
-{
- IOPowerStateChangeNotification notify;
- IOPMInterestContext * context = (IOPMInterestContext *) arg;
- bool enableTracing = context->enableTracing;
-
- if (context->messageFilter &&
- !context->messageFilter(context->us, object, context, NULL, NULL)) {
- IOService::getPMRootDomain()->traceFilteredNotification(object);
- return;
- }
-
- notify.powerRef = (void *) NULL;
- notify.returnValue = 0;
- notify.stateNumber = context->stateNumber;
- notify.stateFlags = context->stateFlags;
-
- if (enableTracing) {
- IOService::getPMRootDomain()->traceNotification(object, true);
- }
-
- context->us->messageClient(context->messageType, object, ¬ify, sizeof(notify));
-
- if (enableTracing) {
- IOService::getPMRootDomain()->traceNotification(object, false);
- }
-}
-
-static OSNumber *
-copyClientIDForNotification(
- OSObject *object,
- IOPMInterestContext *context)
-{
- OSNumber *clientID = NULL;
- context->us->messageClient(kIOMessageCopyClientID, object, &clientID);
- return clientID;
-}
-
-static void
-logClientIDForNotification(
- OSObject *object,
- IOPMInterestContext *context,
- const char *logString)
-{
- OSString *logClientID = NULL;
- OSNumber *clientID = copyClientIDForNotification(object, context);
-
- if (logString) {
- if (clientID) {
- logClientID = IOCopyLogNameForPID(clientID->unsigned32BitValue());
- }
-
- PM_LOG("%s %s %s, %s\n",
- context->us->getName(), logString,
- IOService::getIOMessageString(context->messageType),
- logClientID ? logClientID->getCStringNoCopy() : "");
-
- if (logClientID) {
- logClientID->release();
- }
- }
-
- if (clientID) {
- clientID->release();
- }
-
- return;
-}
-
-static void
-tellAppClientApplier( OSObject * object, void * arg )
-{
- IOPMInterestContext * context = (IOPMInterestContext *) arg;
- OSNumber * clientID = NULL;
- proc_t proc = NULL;
- boolean_t proc_suspended = FALSE;
-
- if (context->us == IOService::getPMRootDomain()) {
- if ((clientID = copyClientIDForNotification(object, context))) {
- uint32_t clientPID = clientID->unsigned32BitValue();
- clientID->release();
- proc = proc_find(clientPID);
-
- if (proc) {
- proc_suspended = get_task_pidsuspended((task_t) proc_task(proc));
- if (proc_suspended) {
- logClientIDForNotification(object, context, "tellAppClientApplier - Suspended");
- } else if (IOService::getPMRootDomain()->isAOTMode() && get_task_suspended((task_t) proc_task(proc))) {
- proc_suspended = true;
- context->skippedInDark++;
- }
- proc_rele(proc);
- if (proc_suspended) {
- return;
- }
- }
- }
- }
-
- if (context->messageFilter &&
- !context->messageFilter(context->us, object, context, NULL, NULL)) {
- if (kIOLogDebugPower & gIOKitDebug) {
- logClientIDForNotification(object, context, "DROP App");
- }
- return;
- }
- context->notSkippedInDark++;
-
- if (kIOLogDebugPower & gIOKitDebug) {
- logClientIDForNotification(object, context, "MESG App");
- }
-
- context->us->messageClient(context->messageType, object, NULL);
-}
-
-//*********************************************************************************
-// [private] checkForDone
-//*********************************************************************************
-
-bool
-IOService::checkForDone( void )
-{
- int i = 0;
- OSObject * theFlag;
-
- if (fResponseArray == NULL) {
- return true;
- }
-
- for (i = 0;; i++) {
- theFlag = fResponseArray->getObject(i);
-
- if (NULL == theFlag) {
- break;
- }
-
- if (kOSBooleanTrue != theFlag) {
- return false;
- }
- }
- return true;
-}
-
-//*********************************************************************************
-// [public] responseValid
-//*********************************************************************************
-
-bool
-IOService::responseValid( uint32_t refcon, int pid )
-{
- UInt16 serialComponent;
- UInt16 ordinalComponent;
- OSObject * theFlag;
- OSObject *object = NULL;
-
- serialComponent = (refcon >> 16) & 0xFFFF;
- ordinalComponent = (refcon & 0xFFFF);
-
- if (serialComponent != fSerialNumber) {
- return false;
- }
-
- if (fResponseArray == NULL) {
- return false;
- }
-
- theFlag = fResponseArray->getObject(ordinalComponent);
-
- if (theFlag == NULL) {
- return false;
- }
-
- if (fNotifyClientArray) {
- object = fNotifyClientArray->getObject(ordinalComponent);
- }
-
- OSNumber * num;
- IOPMClientAck *ack;
- if ((num = OSDynamicCast(OSNumber, theFlag)) || (ack = OSDynamicCast(IOPMClientAck, theFlag))) {
- AbsoluteTime now;
- AbsoluteTime start;
- uint64_t nsec;
- char name[128];
-
- clock_get_uptime(&now);
- AbsoluteTime_to_scalar(&start) = num ? num->unsigned64BitValue() : ack->completionTimestamp;
- SUB_ABSOLUTETIME(&now, &start);
- absolutetime_to_nanoseconds(now, &nsec);
-
- if (pid != 0) {
- name[0] = '\0';
- proc_name(pid, name, sizeof(name));
-
- if (nsec > LOG_APP_RESPONSE_TIMES) {
- IOLog("PM response took %d ms (%d, %s)\n", NS_TO_MS(nsec),
- pid, name);
- }
-
- if (nsec > LOG_APP_RESPONSE_MSG_TRACER) {
- // TODO: populate the messageType argument
- getPMRootDomain()->pmStatsRecordApplicationResponse(
- gIOPMStatsResponseSlow,
- name, 0, NS_TO_MS(nsec), pid, object);
- } else {
- getPMRootDomain()->pmStatsRecordApplicationResponse(
- gIOPMStatsResponsePrompt,
- name, 0, NS_TO_MS(nsec), pid, object);
- }
- } else {
- getPMRootDomain()->traceNotificationAck(object, NS_TO_MS(nsec));
- }
-
- if (kIOLogDebugPower & gIOKitDebug) {
- PM_LOG("Ack(%u) %u ms\n",
- (uint32_t) ordinalComponent,
- NS_TO_MS(nsec));
- }
- theFlag = kOSBooleanFalse;
- } else if (object) {
- getPMRootDomain()->pmStatsRecordApplicationResponse(
- gIOPMStatsResponsePrompt,
- NULL, 0, 0, pid, object);
- }
-
- if (kOSBooleanFalse == theFlag) {
- fResponseArray->replaceObject(ordinalComponent, kOSBooleanTrue);
- }
-
- return true;
-}
-
-//*********************************************************************************
-// [private] updateClientResponses
-//
-// Only affects clients informed in pmTellClientWithResponse() and
-// pmTellCapabilityClientWithResponse().
-//
-// Called upon every client acknowledgement to scan through the response array and
-// update the ack timer based on which clients have yet to acknowledge the power
-// change. If a client hasn't acknowledged by their requested time, make sure not
-// to wait on that client.
-//*********************************************************************************
-
-OSDefineMetaClassAndStructors( IOPMClientAck, OSObject );
-
-void
-IOService::updateClientResponses( void )
-{
- int i = 0;
- uint32_t maxTimeToAckMS = 0;
- bool editTimer = false;
- OSObject *obj;
- IOPMClientAck *ack;
-
- for (i = 0;; i++) {
- obj = fResponseArray->getObject(i);
- if (obj == NULL) {
- break;
- }
-
- // IOPMClientAck is used for pmTellClientWithResponse and
- // pmTellCapabilityClientWithResponse, no-op otherwise
- if ((ack = OSDynamicCast(IOPMClientAck, obj))) {
- AbsoluteTime now;
- AbsoluteTime start;
- uint64_t nsec;
- uint64_t timeRequestedNS = ack->maxTimeRequested * NSEC_PER_USEC;
-
- editTimer = true;
-
- // Calculate time since completion
- clock_get_uptime(&now);
- AbsoluteTime_to_scalar(&start) = ack->completionTimestamp;
- SUB_ABSOLUTETIME(&now, &start);
- absolutetime_to_nanoseconds(now, &nsec);
- if (nsec >= timeRequestedNS) {
- // Tardy; do not wait for this client
- fResponseArray->replaceObject(i, kOSBooleanTrue);
- } else {
- // Calculate time left to ack
- uint32_t timeToAckMS = NS_TO_MS(timeRequestedNS - nsec);
- maxTimeToAckMS = timeToAckMS > maxTimeToAckMS ? timeToAckMS : maxTimeToAckMS;
- }
- }
- }
-
- if (editTimer) {
- // Reset ack timer, but leave the PM watchdog set at the max client request
- // time.
- RD_LOG("resetting ack timer to %u ms\n", maxTimeToAckMS);
- stop_ack_timer();
- start_ack_timer(maxTimeToAckMS, kMillisecondScale);
- }
-}
-
-//*********************************************************************************
-// [public] allowPowerChange
+void IOService::tellClients ( int messageType )
+{
+ struct context theContext;
+
+ theContext.msgType = messageType;
+ theContext.us = this;
+ theContext.stateNumber = priv->head_note_state;
+ theContext.stateFlags = priv->head_note_capabilityFlags;
+
+ applyToInterested(gIOAppPowerStateInterest,tellClient,(void *)&theContext);
+ applyToInterested(gIOGeneralInterest,tellClient,(void *)&theContext);
+}
+
+
+//*********************************************************************************
+// tellClient
+//
+// Notify a registered application or kernel client of something.
+//*********************************************************************************
+void tellClient ( OSObject * object, void * context)
+{
+ struct context * theContext = (struct context *)context;
+ IOPowerStateChangeNotification notify;
+
+ notify.powerRef = (void *) 0;
+ notify.returnValue = 0;
+ notify.stateNumber = theContext->stateNumber;
+ notify.stateFlags = theContext->stateFlags;
+
+ theContext->us->messageClient(theContext->msgType,object, ¬ify);
+}
+
+
+// **********************************************************************************
+// checkForDone
+//
+// **********************************************************************************
+bool IOService::checkForDone ( void )
+{
+ int i = 0;
+ OSObject * theFlag;
+
+ IOLockLock(priv->flags_lock);
+ if ( pm_vars->responseFlags == NULL ) {
+ IOLockUnlock(priv->flags_lock);
+ return true;
+ }
+ for ( i = 0; ; i++ ) {
+ theFlag = pm_vars->responseFlags->getObject(i);
+ if ( theFlag == NULL ) {
+ break;
+ }
+ if ( ((OSBoolean *)theFlag)->isFalse() ) {
+ IOLockUnlock(priv->flags_lock);
+ return false;
+ }
+ }
+ IOLockUnlock(priv->flags_lock);
+ return true;
+}
+
+
+// **********************************************************************************
+// responseValid
+//
+// **********************************************************************************
+bool IOService::responseValid ( unsigned long x )
+{
+ UInt16 serialComponent;
+ UInt16 ordinalComponent;
+ OSObject * theFlag;
+ unsigned long refcon = (unsigned long)x;
+ OSBoolean * aBool;
+
+ serialComponent = (refcon>>16) & 0xFFFF;
+ ordinalComponent = refcon & 0xFFFF;
+
+ if ( serialComponent != pm_vars->serialNumber ) {
+ return false;
+ }
+
+ IOLockLock(priv->flags_lock);
+ if ( pm_vars->responseFlags == NULL ) {
+ IOLockUnlock(priv->flags_lock);
+ return false;
+ }
+
+ theFlag = pm_vars->responseFlags->getObject(ordinalComponent);
+
+ if ( theFlag == 0 ) {
+ IOLockUnlock(priv->flags_lock);
+ return false;
+ }
+
+ if ( ((OSBoolean *)theFlag)->isFalse() ) {
+ aBool = OSBoolean::withBoolean(true);
+ pm_vars->responseFlags->replaceObject(ordinalComponent,aBool);
+ aBool->release();
+ }
+
+ IOLockUnlock(priv->flags_lock);
+ return true;
+}
+
+
+// **********************************************************************************
+// allowPowerChange
//
// Our power state is about to lower, and we have notified applications
// and kernel clients, and one of them has acknowledged. If this is the last to do
// so, and all acknowledgements are positive, we continue with the power change.
-//*********************************************************************************
-
-IOReturn
-IOService::allowPowerChange( unsigned long refcon )
-{
- IOPMRequest * request;
-
- if (!initialized) {
- // we're unloading
- return kIOReturnSuccess;
- }
-
- request = acquirePMRequest( this, kIOPMRequestTypeAllowPowerChange );
- if (!request) {
- return kIOReturnNoMemory;
- }
-
- request->fArg0 = (void *) refcon;
- request->fArg1 = (void *)(uintptr_t) proc_selfpid();
- request->fArg2 = (void *) NULL;
- submitPMRequest( request );
-
- return kIOReturnSuccess;
-}
-
-#ifndef __LP64__
-IOReturn
-IOService::serializedAllowPowerChange2( unsigned long refcon )
-{
- // [deprecated] public
- return kIOReturnUnsupported;
-}
-#endif /* !__LP64__ */
-
-//*********************************************************************************
-// [public] cancelPowerChange
+//
+// We serialize this processing with timer expiration with a command gate on the
+// power management workloop, which the timer expiration is command gated to as well.
+// **********************************************************************************
+IOReturn IOService::allowPowerChange ( unsigned long refcon )
+{
+ if ( ! initialized ) {
+ return kIOReturnSuccess; // we're unloading
+ }
+
+ return pm_vars->PMcommandGate->runAction(serializedAllowPowerChange,(void *)refcon);
+}
+
+
+IOReturn serializedAllowPowerChange ( OSObject *owner, void * refcon, void *, void *, void *)
+{
+ return ((IOService *)owner)->serializedAllowPowerChange2((unsigned long)refcon);
+}
+
+IOReturn IOService::serializedAllowPowerChange2 ( unsigned long refcon )
+{
+ if ( ! responseValid(refcon) ) { // response valid?
+ pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogAcknowledgeErr5,refcon,0);
+ return kIOReturnSuccess; // no, just return
+ }
+ pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogClientAcknowledge,refcon,0);
+
+ return allowCancelCommon();
+}
+
+
+// **********************************************************************************
+// cancelPowerChange
//
// Our power state is about to lower, and we have notified applications
// and kernel clients, and one of them has vetoed the change. If this is the last
// client to respond, we abandon the power change.
-//*********************************************************************************
-
-IOReturn
-IOService::cancelPowerChange( unsigned long refcon )
-{
- IOPMRequest * request;
- char name[128];
- pid_t pid = proc_selfpid();
-
- if (!initialized) {
- // we're unloading
- return kIOReturnSuccess;
- }
-
- name[0] = '\0';
- proc_name(pid, name, sizeof(name));
- if (pid == 0) {
- const char *serviceName = this->getName();
- size_t len = strlen(name);
- snprintf(name + len, sizeof(name) - len, " (%s)", serviceName ? serviceName : "");
- }
- PM_ERROR("PM notification cancel (pid %d, %s)\n", pid, name);
-
- request = acquirePMRequest( this, kIOPMRequestTypeCancelPowerChange );
- if (!request) {
- return kIOReturnNoMemory;
- }
-
- request->fArg0 = (void *) refcon;
- request->fArg1 = (void *)(uintptr_t) proc_selfpid();
- request->fArg2 = (void *) OSString::withCString(name);
- submitPMRequest( request );
-
- return kIOReturnSuccess;
-}
-
-//*********************************************************************************
-// cancelIdlePowerDown
-//
-// Internal method to trigger an idle cancel or revert
-//*********************************************************************************
-
-void
-IOService::cancelIdlePowerDown( IOService * service )
-{
- IOPMRequest * request;
-
- request = acquirePMRequest(service, kIOPMRequestTypeIdleCancel);
- if (request) {
- submitPMRequest(request);
- }
-}
-
-//*********************************************************************************
-// cancelIdlePowerDownSync
-//
-// Internal method to cancel sleep synchronously to avoid races on power down path
-//*********************************************************************************
-
-void
-IOService::cancelIdlePowerDownSync( void )
-{
- handleCancelIdlePowerDown();
-}
-
-
-//*********************************************************************************
-// [private] handleCancelIdlePowerDown
-//*********************************************************************************
-
-bool
-IOService::handleCancelIdlePowerDown( void )
-{
- bool more = false;
- if ((fMachineState == kIOPM_OurChangeTellClientsPowerDown)
- || (fMachineState == kIOPM_OurChangeTellUserPMPolicyPowerDown)
- || (fMachineState == kIOPM_OurChangeTellPriorityClientsPowerDown)
- || (fMachineState == kIOPM_SyncTellClientsPowerDown)
- || (fMachineState == kIOPM_SyncTellPriorityClientsPowerDown)) {
- OUR_PMLog(kPMLogIdleCancel, (uintptr_t) this, fMachineState);
- PM_LOG2("%s: cancel from machine state %d\n",
- getName(), fMachineState);
- fDoNotPowerDown = true;
- // Stop waiting for app replys.
- if ((fMachineState == kIOPM_OurChangeTellPriorityClientsPowerDown) ||
- (fMachineState == kIOPM_OurChangeTellUserPMPolicyPowerDown) ||
- (fMachineState == kIOPM_SyncTellPriorityClientsPowerDown) ||
- (fMachineState == kIOPM_SyncTellClientsPowerDown)) {
- cleanClientResponses(false);
- }
- more = true;
- }
- return more;
-}
-
-#ifndef __LP64__
-IOReturn
-IOService::serializedCancelPowerChange2( unsigned long refcon )
-{
- // [deprecated] public
- return kIOReturnUnsupported;
+//
+// We serialize this processing with timer expiration with a command gate on the
+// power management workloop, which the timer expiration is command gated to as well.
+// **********************************************************************************
+IOReturn IOService::cancelPowerChange ( unsigned long refcon )
+{
+ if ( ! initialized ) {
+ return kIOReturnSuccess; // we're unloading
+ }
+
+ return pm_vars->PMcommandGate->runAction(serializedCancelPowerChange,(void *)refcon);
+}
+
+
+IOReturn serializedCancelPowerChange ( OSObject *owner, void * refcon, void *, void *, void *)
+{
+ return ((IOService *)owner)->serializedCancelPowerChange2((unsigned long)refcon);
+}
+
+IOReturn IOService::serializedCancelPowerChange2 ( unsigned long refcon )
+{
+ if ( ! responseValid(refcon) ) { // response valid?
+ pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogAcknowledgeErr5,refcon,0);
+ return kIOReturnSuccess; // no, just return
+ }
+ pm_vars->thePlatform->PMLog(pm_vars->ourName,PMlogClientCancel,refcon,0);
+
+ pm_vars->doNotPowerDown = true;
+
+ return allowCancelCommon();
+}
+
+
+// **********************************************************************************
+// allowCancelCommon
+//
+// **********************************************************************************
+IOReturn IOService::allowCancelCommon ( void )
+{
+ if (! acquire_lock() ) {
+ return kIOReturnSuccess;
+ }
+
+ if ( checkForDone() ) { // is this the last response?
+ stop_ack_timer(); // yes, stop the timer
+ IOUnlock(priv->our_lock);
+ IOLockLock(priv->flags_lock);
+ if ( pm_vars->responseFlags ) {
+ pm_vars->responseFlags->release();
+ pm_vars->responseFlags = NULL;
+ }
+ IOLockUnlock(priv->flags_lock);
+ switch (priv->machine_state) {
+ case IOPMour_prechange_03: // our change, was it vetoed?
+ if ( ! pm_vars->doNotPowerDown ) {
+ our_prechange_03(); // no, we can continue
+ }
+ else {
+ tellNoChangeDown(priv->head_note_state); // yes, rescind the warning
+ priv->head_note_flags |= IOPMNotDone; // mark the change note un-actioned
+ all_done(); // and we're done
+ }
+ break;
+ case IOPMour_prechange_04:
+ our_prechange_04();
+ break;
+ case IOPMour_prechange_05:
+ our_prechange_05(); // our change, continue
+ break;
+ case IOPMparent_down_0:
+ parent_down_04(); // parent change, continue
+ break;
+ case IOPMparent_down_05:
+ parent_down_05(); // parent change, continue
+ break;
+ }
+ }
+
+ IOUnlock(priv->our_lock); // not done yet
+ return kIOReturnSuccess;
+}
+
+
+//*********************************************************************************
+// clampPowerOn
+//
+// Set to highest available power state for a minimum of duration milliseconds
+//*********************************************************************************
+
+#define kFiveMinutesInNanoSeconds (300 * NSEC_PER_SEC)
+
+void IOService::clampPowerOn (unsigned long duration)
+{
+ changePowerStateToPriv (pm_vars->theNumberOfPowerStates-1);
+
+ if ( priv->clampTimerEventSrc == NULL ) {
+ priv->clampTimerEventSrc = IOTimerEventSource::timerEventSource(this,
+ c_PM_Clamp_Timer_Expired);
+
+ IOWorkLoop * workLoop = getPMworkloop ();
+
+ if ( !priv->clampTimerEventSrc || !workLoop ||
+ ( workLoop->addEventSource( priv->clampTimerEventSrc) != kIOReturnSuccess) ) {
+
+ }
+ }
+
+ priv->clampTimerEventSrc->setTimeout(kFiveMinutesInNanoSeconds, NSEC_PER_SEC);
}
//*********************************************************************************
@@ -7400,2223 +3846,288 @@
// called when clamp timer expires...set power state to 0.
//*********************************************************************************
-void
-IOService::PM_Clamp_Timer_Expired( void )
-{
-}
-
-//*********************************************************************************
-// clampPowerOn
-//
-// Set to highest available power state for a minimum of duration milliseconds
-//*********************************************************************************
-
-void
-IOService::clampPowerOn( unsigned long duration )
-{
-}
-#endif /* !__LP64__ */
-
-//*********************************************************************************
-// configurePowerStateReport
-//
-// Configures the IOStateReport for kPMPowerStateChannel
-//*********************************************************************************
-IOReturn
-IOService::configurePowerStatesReport( IOReportConfigureAction action, void *result )
-{
- IOReturn rc = kIOReturnSuccess;
- size_t reportSize;
- unsigned long i;
- uint64_t ts;
-
- if (!pwrMgt) {
- return kIOReturnUnsupported;
- }
-
- if (!fNumberOfPowerStates) {
- return kIOReturnSuccess; // For drivers which are in power plane, but haven't called registerPowerDriver()
- }
-
- if (fNumberOfPowerStates > INT16_MAX) {
- return kIOReturnOverrun;
- }
- PM_LOCK();
-
- switch (action) {
- case kIOReportEnable:
- if (fReportBuf) {
- fReportClientCnt++;
- break;
- }
- reportSize = STATEREPORT_BUFSIZE(fNumberOfPowerStates);
- fReportBuf = IOMallocZeroData(reportSize);
- if (!fReportBuf) {
- rc = kIOReturnNoMemory;
- break;
- }
-
- STATEREPORT_INIT((uint16_t) fNumberOfPowerStates, fReportBuf, reportSize,
- getRegistryEntryID(), kPMPowerStatesChID, kIOReportCategoryPower);
-
- for (i = 0; i < fNumberOfPowerStates; i++) {
- unsigned bits = 0;
-
- if (fPowerStates[i].capabilityFlags & kIOPMPowerOn) {
- bits |= kPMReportPowerOn;
- }
- if (fPowerStates[i].capabilityFlags & kIOPMDeviceUsable) {
- bits |= kPMReportDeviceUsable;
- }
- if (fPowerStates[i].capabilityFlags & kIOPMLowPower) {
- bits |= kPMReportLowPower;
- }
-
- STATEREPORT_SETSTATEID(fReportBuf, i, ((bits & 0xff) << 8) |
- ((StateOrder(fMaxPowerState) & 0xf) << 4) | (StateOrder(i) & 0xf));
- }
- ts = mach_absolute_time();
- STATEREPORT_SETSTATE(fReportBuf, (uint16_t) fCurrentPowerState, ts);
- break;
-
- case kIOReportDisable:
- if (fReportClientCnt == 0) {
- rc = kIOReturnBadArgument;
- break;
- }
- if (fReportClientCnt == 1) {
- IOFreeData(fReportBuf, STATEREPORT_BUFSIZE(fNumberOfPowerStates));
- fReportBuf = NULL;
- }
- fReportClientCnt--;
- break;
-
- case kIOReportGetDimensions:
- if (fReportBuf) {
- STATEREPORT_UPDATERES(fReportBuf, kIOReportGetDimensions, result);
- }
- break;
- }
-
- PM_UNLOCK();
-
- return rc;
-}
-
-//*********************************************************************************
-// updatePowerStateReport
-//
-// Updates the IOStateReport for kPMPowerStateChannel
-//*********************************************************************************
-IOReturn
-IOService::updatePowerStatesReport( IOReportConfigureAction action, void *result, void *destination )
-{
- uint32_t size2cpy;
- void *data2cpy;
- uint64_t ts;
- IOReturn rc = kIOReturnSuccess;
- IOBufferMemoryDescriptor *dest = OSDynamicCast(IOBufferMemoryDescriptor, (OSObject *)destination);
-
-
- if (!pwrMgt) {
- return kIOReturnUnsupported;
- }
- if (!fNumberOfPowerStates) {
- return kIOReturnSuccess;
- }
-
- if (!result || !dest) {
- return kIOReturnBadArgument;
- }
- PM_LOCK();
-
- switch (action) {
- case kIOReportCopyChannelData:
- if (!fReportBuf) {
- rc = kIOReturnNotOpen;
- break;
- }
-
- ts = mach_absolute_time();
- STATEREPORT_UPDATEPREP(fReportBuf, ts, data2cpy, size2cpy);
- if (size2cpy > (dest->getCapacity() - dest->getLength())) {
- rc = kIOReturnOverrun;
- break;
- }
-
- STATEREPORT_UPDATERES(fReportBuf, kIOReportCopyChannelData, result);
- dest->appendBytes(data2cpy, size2cpy);
- break;
-
- default:
- break;
- }
-
- PM_UNLOCK();
-
- return rc;
-}
-
-//*********************************************************************************
-// configureSimplePowerReport
-//
-// Configures the IOSimpleReport for given channel id
-//*********************************************************************************
-IOReturn
-IOService::configureSimplePowerReport(IOReportConfigureAction action, void *result )
-{
- IOReturn rc = kIOReturnSuccess;
-
- if (!pwrMgt) {
- return kIOReturnUnsupported;
- }
-
- if (!fNumberOfPowerStates) {
- return rc;
- }
-
- switch (action) {
- case kIOReportEnable:
- case kIOReportDisable:
- break;
-
- case kIOReportGetDimensions:
- SIMPLEREPORT_UPDATERES(kIOReportGetDimensions, result);
- break;
- }
-
-
- return rc;
-}
-
-//*********************************************************************************
-// updateSimplePowerReport
-//
-// Updates the IOSimpleReport for the given chanel id
-//*********************************************************************************
-IOReturn
-IOService::updateSimplePowerReport( IOReportConfigureAction action, void *result, void *destination )
-{
- uint32_t size2cpy;
- void *data2cpy;
- uint64_t buf[SIMPLEREPORT_BUFSIZE / sizeof(uint64_t) + 1]; // Force a 8-byte alignment
- IOBufferMemoryDescriptor *dest = OSDynamicCast(IOBufferMemoryDescriptor, (OSObject *)destination);
- IOReturn rc = kIOReturnSuccess;
- unsigned bits = 0;
-
-
- if (!pwrMgt) {
- return kIOReturnUnsupported;
- }
- if (!result || !dest) {
- return kIOReturnBadArgument;
- }
-
- if (!fNumberOfPowerStates) {
- return rc;
- }
- PM_LOCK();
-
- switch (action) {
- case kIOReportCopyChannelData:
-
- SIMPLEREPORT_INIT(buf, sizeof(buf), getRegistryEntryID(), kPMCurrStateChID, kIOReportCategoryPower);
-
- if (fPowerStates[fCurrentPowerState].capabilityFlags & kIOPMPowerOn) {
- bits |= kPMReportPowerOn;
- }
- if (fPowerStates[fCurrentPowerState].capabilityFlags & kIOPMDeviceUsable) {
- bits |= kPMReportDeviceUsable;
- }
- if (fPowerStates[fCurrentPowerState].capabilityFlags & kIOPMLowPower) {
- bits |= kPMReportLowPower;
- }
-
-
- SIMPLEREPORT_SETVALUE(buf, ((bits & 0xff) << 8) | ((StateOrder(fMaxPowerState) & 0xf) << 4) |
- (StateOrder(fCurrentPowerState) & 0xf));
-
- SIMPLEREPORT_UPDATEPREP(buf, data2cpy, size2cpy);
- if (size2cpy > (dest->getCapacity() - dest->getLength())) {
- rc = kIOReturnOverrun;
- break;
- }
-
- SIMPLEREPORT_UPDATERES(kIOReportCopyChannelData, result);
- dest->appendBytes(data2cpy, size2cpy);
- break;
-
- default:
- break;
- }
-
- PM_UNLOCK();
-
- return rc;
-}
-
-
-
-// MARK: -
-// MARK: Driver Overrides
-
-//*********************************************************************************
-// [public] setPowerState
+void IOService::PM_Clamp_Timer_Expired (void)
+{
+ if ( ! initialized ) {
+ return; // we're unloading
+ }
+
+ changePowerStateToPriv (0);
+}
+
+//*********************************************************************************
+// c_PM_clamp_Timer_Expired (C Func)
+//
+// Called when our clamp timer expires...we will call the object method.
+//*********************************************************************************
+
+void c_PM_Clamp_Timer_Expired (OSObject * client, IOTimerEventSource *)
+{
+ if (client)
+ ((IOService *)client)->PM_Clamp_Timer_Expired ();
+}
+
+
+//*********************************************************************************
+// setPowerState
//
// Does nothing here. This should be implemented in a subclass driver.
//*********************************************************************************
-IOReturn
-IOService::setPowerState(
- unsigned long powerStateOrdinal, IOService * whatDevice )
-{
- return IOPMNoErr;
-}
-
-//*********************************************************************************
-// [public]cmaxCapabilityForDomainState
-//
-// Finds the highest power state in the array whose input power requirement
-// is equal to the input parameter. Where a more intelligent decision is
-// possible, override this in the subclassed driver.
-//*********************************************************************************
-
-IOPMPowerStateIndex
-IOService::getPowerStateForDomainFlags( IOPMPowerFlags flags )
-{
- IOPMPowerStateIndex stateIndex;
-
- if (!fNumberOfPowerStates) {
- return kPowerStateZero;
- }
-
- for (long order = fNumberOfPowerStates - 1; order >= 0; order--) {
- stateIndex = fPowerStates[order].stateOrderToIndex;
-
- if ((flags & fPowerStates[stateIndex].inputPowerFlags) ==
- fPowerStates[stateIndex].inputPowerFlags) {
- return stateIndex;
- }
- }
- return kPowerStateZero;
-}
-
-unsigned long
-IOService::maxCapabilityForDomainState( IOPMPowerFlags domainState )
-{
- return getPowerStateForDomainFlags(domainState);
-}
-
-unsigned long
-IOService::serviceMaxCapabilityForDomainState( IOPMPowerFlags domainState )
-{
- IOPMDriverCallEntry callEntry;
- IOPMPowerStateIndex powerState = kPowerStateZero;
- int32_t promote;
-
- promote = getPMRootDomain()->considerRunMode(this, fPMDriverClass);
-
- if ((promote < 0) && (0 == (kIOPMAOTPower & domainState))) {
- return kPowerStateZero;
- }
-
- if (!assertPMDriverCall(&callEntry, kIOPMDriverCallMethodMaxCapabilityForDomainState)) {
- return kPowerStateZero;
- }
-
- if ((promote > 0) && (0 != (kIOPMPowerOn & domainState))) {
- IOPMPowerFlags newDomainState = (domainState & ~kIOPMPowerOn) | kIOPMAOTPower;
- powerState = maxCapabilityForDomainState(newDomainState);
- }
-
- if (kPowerStateZero == powerState) {
- powerState = maxCapabilityForDomainState(domainState);
- }
-
- if ((promote > 0) && (kPowerStateZero == powerState)
- && (0 != (kIOPMAOTPower & domainState))) {
- IOPMPowerFlags newDomainState = (domainState & ~kIOPMAOTPower) | kIOPMPowerOn;
- powerState = maxCapabilityForDomainState(newDomainState);
- }
- deassertPMDriverCall(&callEntry);
-
- return powerState;
-}
-
-unsigned long
-IOService::driverMaxCapabilityForDomainState( IOService * service, IOPMPowerFlags domainState )
-{
- if OSDynamicCast(IOUserServer, this) {
- return service->serviceMaxCapabilityForDomainState(domainState);
- } else {
- return serviceMaxCapabilityForDomainState(domainState);
- }
-}
-
-//*********************************************************************************
-// [public] initialPowerStateForDomainState
-//
-// Called to query the power state for the initial power transition.
-//*********************************************************************************
-
-unsigned long
-IOService::initialPowerStateForDomainState( IOPMPowerFlags domainState )
-{
- if (fResetPowerStateOnWake && (domainState & kIOPMRootDomainState)) {
- // Return lowest power state for any root power domain changes
- return kPowerStateZero;
- }
-
- return getPowerStateForDomainFlags(domainState);
-}
-
-unsigned long
-IOService::driverInitialPowerStateForDomainState( IOPMPowerFlags domainState )
-{
- IOPMDriverCallEntry callEntry;
- IOPMPowerStateIndex powerState = kPowerStateZero;
-
- if (assertPMDriverCall(&callEntry, kIOPMDriverCallMethodInitialPowerStateForDomainState)) {
- powerState = initialPowerStateForDomainState(domainState);
- deassertPMDriverCall(&callEntry);
- }
- return powerState;
-}
-
-//*********************************************************************************
-// [public] powerStateForDomainState
-//
-// This method is not called from PM.
-//*********************************************************************************
-
-unsigned long
-IOService::powerStateForDomainState( IOPMPowerFlags domainState )
-{
- return getPowerStateForDomainFlags(domainState);
-}
-
-#ifndef __LP64__
-//*********************************************************************************
-// [deprecated] didYouWakeSystem
+IOReturn IOService::setPowerState ( unsigned long powerStateOrdinal, IOService* whatDevice )
+{
+ return IOPMNoErr;
+}
+
+
+//*********************************************************************************
+// maxCapabilityForDomainState
+//
+// Finds the highest power state in the array whose input power
+// requirement is equal to the input parameter. Where a more intelligent
+// decision is possible, override this in the subclassed driver.
+//*********************************************************************************
+
+unsigned long IOService::maxCapabilityForDomainState ( IOPMPowerFlags domainState )
+{
+ int i;
+
+ if (pm_vars->theNumberOfPowerStates == 0 ) {
+ return 0;
+ }
+ for ( i = (pm_vars->theNumberOfPowerStates)-1; i >= 0; i-- ) {
+ if ( (domainState & pm_vars->thePowerStates[i].inputPowerRequirement) == pm_vars->thePowerStates[i].inputPowerRequirement ) {
+ return i;
+ }
+ }
+ return 0;
+}
+
+
+//*********************************************************************************
+// initialPowerStateForDomainState
+//
+// Finds the highest power state in the array whose input power
+// requirement is equal to the input parameter. Where a more intelligent
+// decision is possible, override this in the subclassed driver.
+//*********************************************************************************
+
+unsigned long IOService::initialPowerStateForDomainState ( IOPMPowerFlags domainState )
+{
+ int i;
+
+ if (pm_vars->theNumberOfPowerStates == 0 ) {
+ return 0;
+ }
+ for ( i = (pm_vars->theNumberOfPowerStates)-1; i >= 0; i-- ) {
+ if ( (domainState & pm_vars->thePowerStates[i].inputPowerRequirement) == pm_vars->thePowerStates[i].inputPowerRequirement ) {
+ return i;
+ }
+ }
+ return 0;
+}
+
+
+//*********************************************************************************
+// powerStateForDomainState
+//
+// Finds the highest power state in the array whose input power
+// requirement is equal to the input parameter. Where a more intelligent
+// decision is possible, override this in the subclassed driver.
+//*********************************************************************************
+
+unsigned long IOService::powerStateForDomainState ( IOPMPowerFlags domainState )
+{
+ int i;
+
+ if (pm_vars->theNumberOfPowerStates == 0 ) {
+ return 0;
+ }
+ for ( i = (pm_vars->theNumberOfPowerStates)-1; i >= 0; i-- ) {
+ if ( (domainState & pm_vars->thePowerStates[i].inputPowerRequirement) == pm_vars->thePowerStates[i].inputPowerRequirement ) {
+ return i;
+ }
+ }
+ return 0;
+}
+
+
+//*********************************************************************************
+// didYouWakeSystem
//
// Does nothing here. This should be implemented in a subclass driver.
//*********************************************************************************
-bool
-IOService::didYouWakeSystem( void )
-{
- return false;
-}
-#endif /* !__LP64__ */
-
-//*********************************************************************************
-// [public] powerStateWillChangeTo
+bool IOService::didYouWakeSystem ( void )
+{
+ return false;
+}
+
+
+//*********************************************************************************
+// powerStateWillChangeTo
//
// Does nothing here. This should be implemented in a subclass driver.
//*********************************************************************************
-IOReturn
-IOService::powerStateWillChangeTo( IOPMPowerFlags, unsigned long, IOService * )
-{
- return kIOPMAckImplied;
-}
-
-//*********************************************************************************
-// [public] powerStateDidChangeTo
+IOReturn IOService::powerStateWillChangeTo ( IOPMPowerFlags, unsigned long, IOService*)
+{
+ return 0;
+}
+
+
+//*********************************************************************************
+// powerStateDidChangeTo
//
// Does nothing here. This should be implemented in a subclass driver.
//*********************************************************************************
-IOReturn
-IOService::powerStateDidChangeTo( IOPMPowerFlags, unsigned long, IOService * )
-{
- return kIOPMAckImplied;
-}
-
-//*********************************************************************************
-// [protected] powerChangeDone
-//
-// Called from PM work loop thread.
+IOReturn IOService::powerStateDidChangeTo ( IOPMPowerFlags, unsigned long, IOService*)
+{
+ return 0;
+}
+
+
+//*********************************************************************************
+// powerChangeDone
+//
// Does nothing here. This should be implemented in a subclass policy-maker.
//*********************************************************************************
-void
-IOService::powerChangeDone( unsigned long )
-{
-}
-
-#ifndef __LP64__
-//*********************************************************************************
-// [deprecated] newTemperature
+void IOService::powerChangeDone ( unsigned long )
+{
+}
+
+
+//*********************************************************************************
+// newTemperature
//
// Does nothing here. This should be implemented in a subclass driver.
//*********************************************************************************
-IOReturn
-IOService::newTemperature( long currentTemp, IOService * whichZone )
-{
- return IOPMNoErr;
-}
-#endif /* !__LP64__ */
-
-//*********************************************************************************
-// [public] systemWillShutdown
-//
-// System shutdown and restart notification.
-//*********************************************************************************
-
-void
-IOService::systemWillShutdown( IOOptionBits specifier )
-{
- IOPMrootDomain * rootDomain = IOService::getPMRootDomain();
- if (rootDomain) {
- rootDomain->acknowledgeSystemWillShutdown( this );
- }
-}
-
-// MARK: -
-// MARK: PM State Machine
-
-//*********************************************************************************
-// [private static] acquirePMRequest
-//*********************************************************************************
-
-IOPMRequest *
-IOService::acquirePMRequest( IOService * target, IOOptionBits requestType,
- IOPMRequest * active )
-{
- IOPMRequest * request;
-
- assert(target);
-
- request = IOPMRequest::create();
- if (request) {
- request->init( target, requestType );
- if (active) {
- IOPMRequest * root = active->getRootRequest();
- if (root) {
- request->attachRootRequest(root);
- }
- }
- } else {
- PM_ERROR("%s: No memory for PM request type 0x%x\n",
- target->getName(), (uint32_t) requestType);
- }
- return request;
-}
-
-//*********************************************************************************
-// [private static] releasePMRequest
-//*********************************************************************************
-
-void
-IOService::releasePMRequest( IOPMRequest * request )
-{
- if (request) {
- request->reset();
- request->release();
- }
-}
-
-//*********************************************************************************
-// [private static] submitPMRequest
-//*********************************************************************************
-
-void
-IOService::submitPMRequest( IOPMRequest * request )
-{
- assert( request );
- assert( gIOPMReplyQueue );
- assert( gIOPMRequestQueue );
-
- PM_LOG1("[+ %02lx] %p [%p %s] %p %p %p\n",
- (long)request->getType(), OBFUSCATE(request),
- OBFUSCATE(request->getTarget()), request->getTarget()->getName(),
- OBFUSCATE(request->fArg0),
- OBFUSCATE(request->fArg1), OBFUSCATE(request->fArg2));
-
- if (request->isReplyType()) {
- gIOPMReplyQueue->queuePMRequest( request );
- } else {
- gIOPMRequestQueue->queuePMRequest( request );
- }
-}
-
-void
-IOService::submitPMRequests( IOPMRequest ** requests, IOItemCount count )
-{
- assert( requests );
- assert( count > 0 );
- assert( gIOPMRequestQueue );
-
- for (IOItemCount i = 0; i < count; i++) {
- IOPMRequest * req = requests[i];
- PM_LOG1("[+ %02lx] %p [%p %s] %p %p %p\n",
- (long)req->getType(), OBFUSCATE(req),
- OBFUSCATE(req->getTarget()), req->getTarget()->getName(),
- OBFUSCATE(req->fArg0),
- OBFUSCATE(req->fArg1), OBFUSCATE(req->fArg2));
- }
-
- gIOPMRequestQueue->queuePMRequestChain( requests, count );
-}
-
-//*********************************************************************************
-// [private] actionPMRequestQueue
-//
-// IOPMRequestQueue::checkForWork() passing a new request to the request target.
-//*********************************************************************************
-
-bool
-IOService::actionPMRequestQueue(
- IOPMRequest * request,
- IOPMRequestQueue * queue )
-{
- bool more;
-
- if (initialized) {
- // Work queue will immediately execute the request if the per-service
- // request queue is empty. Note pwrMgt is the target's IOServicePM.
-
- more = gIOPMWorkQueue->queuePMRequest(request, pwrMgt);
- } else {
- // Calling PM without PMinit() is not allowed, fail the request.
- // Need to signal more when completing attached requests.
-
- PM_LOG("%s: PM not initialized\n", getName());
- PM_LOG1("[- %02x] %p [%p %s] !initialized\n",
- request->getType(), OBFUSCATE(request),
- OBFUSCATE(this), getName());
-
- more = gIOPMCompletionQueue->queuePMRequest(request);
- if (more) {
- gIOPMWorkQueue->incrementProducerCount();
- }
- }
-
- return more;
-}
-
-//*********************************************************************************
-// [private] actionPMCompletionQueue
-//
-// IOPMCompletionQueue::checkForWork() passing a completed request to the
-// request target.
-//*********************************************************************************
-
-bool
-IOService::actionPMCompletionQueue(
- IOPMRequest * request,
- IOPMCompletionQueue * queue )
-{
- bool more = (request->getNextRequest() != NULL);
- IOPMRequest * root = request->getRootRequest();
-
- if (root && (root != request)) {
- more = true;
- }
- if (more) {
- gIOPMWorkQueue->incrementProducerCount();
- }
-
- releasePMRequest( request );
- return more;
-}
-
-//*********************************************************************************
-// [private] actionPMWorkQueueRetire
-//
-// IOPMWorkQueue::checkForWork() passing a retired request to the request target.
-//*********************************************************************************
-
-bool
-IOService::actionPMWorkQueueRetire( IOPMRequest * request, IOPMWorkQueue * queue )
-{
- assert(request && queue);
-
- PM_LOG1("[- %02x] %p [%p %s] state %d, busy %d\n",
- request->getType(), OBFUSCATE(request),
- OBFUSCATE(this), getName(),
- fMachineState, gIOPMBusyRequestCount);
-
- // Catch requests created by idleTimerExpired()
- if (request->getType() == kIOPMRequestTypeActivityTickle) {
- uint32_t tickleFlags = (uint32_t)(uintptr_t) request->fArg1;
-
- if ((tickleFlags & kTickleTypePowerDrop) && fIdleTimerPeriod) {
- restartIdleTimer();
- } else if (tickleFlags == (kTickleTypeActivity | kTickleTypePowerRise)) {
- // Invalidate any idle power drop that got queued while
- // processing this request.
- fIdleTimerGeneration++;
- }
- }
-
- // When the completed request is linked, tell work queue there is
- // more work pending.
-
- return gIOPMCompletionQueue->queuePMRequest( request );
-}
-
-//*********************************************************************************
-// [private] isPMBlocked
-//
-// Check if machine state transition is blocked.
-//*********************************************************************************
-
-bool
-IOService::isPMBlocked( IOPMRequest * request, int count )
-{
- int reason = 0;
-
- do {
- if (kIOPM_Finished == fMachineState) {
- break;
- }
-
- if (kIOPM_DriverThreadCallDone == fMachineState) {
- // 5 = kDriverCallInformPreChange
- // 6 = kDriverCallInformPostChange
- // 7 = kDriverCallSetPowerState
- // 8 = kRootDomainInformPreChange
- if (fDriverCallBusy) {
- reason = 5 + fDriverCallReason;
- }
- break;
- }
-
- // Waiting on driver's setPowerState() timeout.
- if (fDriverTimer) {
- reason = 1; break;
- }
-
- // Child or interested driver acks pending.
- if (fHeadNotePendingAcks) {
- reason = 2; break;
- }
-
- // Waiting on apps or priority power interest clients.
- if (fResponseArray) {
- reason = 3; break;
- }
-
-#if USE_SETTLE_TIMER
- // Waiting on settle timer expiration.
- if (fSettleTimeUS) {
- reason = 4; break;
- }
-#endif
- } while (false);
-
- fWaitReason = reason;
-
- if (reason) {
- if (count) {
- PM_LOG1("[B %02x] %p [%p %s] state %d, reason %d\n",
- request->getType(), OBFUSCATE(request),
- OBFUSCATE(this), getName(),
- fMachineState, reason);
- }
-
- return true;
- }
-
- return false;
-}
-
-//*********************************************************************************
-// [private] actionPMWorkQueueInvoke
-//
-// IOPMWorkQueue::checkForWork() passing a request to the
-// request target for execution.
-//*********************************************************************************
-
-bool
-IOService::actionPMWorkQueueInvoke( IOPMRequest * request, IOPMWorkQueue * queue )
-{
- bool done = false;
- int loop = 0;
-
- assert(request && queue);
-
- while (isPMBlocked(request, loop++) == false) {
- PM_LOG1("[W %02x] %p [%p %s] state %d\n",
- request->getType(), OBFUSCATE(request),
- OBFUSCATE(this), getName(), fMachineState);
-
- gIOPMRequest = request;
- gIOPMWorkInvokeCount++;
-
- // Every PM machine states must be handled in one of the cases below.
-
- switch (fMachineState) {
- case kIOPM_Finished:
- start_watchdog_timer();
-
- executePMRequest( request );
- break;
-
- case kIOPM_OurChangeTellClientsPowerDown:
- // Root domain might self cancel due to assertions.
- if (IS_ROOT_DOMAIN) {
- bool cancel = (bool) fDoNotPowerDown;
- getPMRootDomain()->askChangeDownDone(
- &fHeadNoteChangeFlags, &cancel);
- fDoNotPowerDown = cancel;
- }
-
- // askChangeDown() done, was it vetoed?
- if (!fDoNotPowerDown) {
- // no, we can continue
- OurChangeTellClientsPowerDown();
- } else {
- OUR_PMLog(kPMLogIdleCancel, (uintptr_t) this, fMachineState);
- PM_ERROR("%s: idle cancel, state %u\n", fName, fMachineState);
-#if DEVELOPMENT || DEBUG
- record_system_event(SYSTEM_EVENT_TYPE_INFO,
- SYSTEM_EVENT_SUBSYSTEM_PMRD,
- "Idle Sleep", "%s idle cancel, state %u", fName, fMachineState
- );
-#endif /* DEVELOPMENT || DEBUG */
- if (IS_ROOT_DOMAIN) {
- // RootDomain already sent "WillSleep" to its clients
- tellChangeUp(fCurrentPowerState);
- } else {
- tellNoChangeDown(fHeadNotePowerState);
- }
- // mark the change note un-actioned
- fHeadNoteChangeFlags |= kIOPMNotDone;
- // and we're done
- OurChangeFinish();
- }
- break;
-
- case kIOPM_OurChangeTellUserPMPolicyPowerDown:
- // PMRD: tellChangeDown/kNotifyApps done, was it cancelled?
- if (fDoNotPowerDown) {
- OUR_PMLog(kPMLogIdleCancel, (uintptr_t) this, fMachineState);
- PM_ERROR("%s: idle cancel, state %u\n", fName, fMachineState);
-#if DEVELOPMENT || DEBUG
- record_system_event(SYSTEM_EVENT_TYPE_INFO,
- SYSTEM_EVENT_SUBSYSTEM_PMRD,
- "Idle Sleep", "%s idle cancel, state %u", fName, fMachineState
- );
-#endif /* DEVELOPMENT || DEBUG */
- if (IS_ROOT_DOMAIN) {
- // RootDomain already sent "WillSleep" to its clients
- tellChangeUp(fCurrentPowerState);
- } else {
- tellNoChangeDown(fHeadNotePowerState);
- }
- // mark the change note un-actioned
- fHeadNoteChangeFlags |= kIOPMNotDone;
- // and we're done
- OurChangeFinish();
- } else {
- OurChangeTellUserPMPolicyPowerDown();
- }
- break;
-
- case kIOPM_OurChangeTellPriorityClientsPowerDown:
- // PMRD: LastCallBeforeSleep notify done
- // Non-PMRD: tellChangeDown/kNotifyApps done
-
- // Root domain might self cancel due to assertions.
- if (IS_ROOT_DOMAIN) {
- bool cancel = (bool) fDoNotPowerDown;
- getPMRootDomain()->askChangeDownDone(
- &fHeadNoteChangeFlags, &cancel);
- fDoNotPowerDown = cancel;
- }
-
- 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
- if (IS_ROOT_DOMAIN) {
- // Can no longer revert idle sleep
- getPMRootDomain()->setIdleSleepRevertible(false);
- }
- OurChangeTellPriorityClientsPowerDown();
- }
- break;
-
- case kIOPM_OurChangeNotifyInterestedDriversWillChange:
- OurChangeNotifyInterestedDriversWillChange();
- break;
-
- case kIOPM_OurChangeSetPowerState:
- OurChangeSetPowerState();
- break;
-
- case kIOPM_OurChangeWaitForPowerSettle:
- OurChangeWaitForPowerSettle();
- break;
-
- case kIOPM_OurChangeNotifyInterestedDriversDidChange:
- OurChangeNotifyInterestedDriversDidChange();
- break;
-
- case kIOPM_OurChangeTellCapabilityDidChange:
- OurChangeTellCapabilityDidChange();
- break;
-
- case kIOPM_OurChangeFinish:
- OurChangeFinish();
- break;
-
- case kIOPM_ParentChangeTellPriorityClientsPowerDown:
- ParentChangeTellPriorityClientsPowerDown();
- break;
-
- case kIOPM_ParentChangeNotifyInterestedDriversWillChange:
- ParentChangeNotifyInterestedDriversWillChange();
- break;
-
- case kIOPM_ParentChangeSetPowerState:
- ParentChangeSetPowerState();
- break;
-
- case kIOPM_ParentChangeWaitForPowerSettle:
- ParentChangeWaitForPowerSettle();
- break;
-
- case kIOPM_ParentChangeNotifyInterestedDriversDidChange:
- ParentChangeNotifyInterestedDriversDidChange();
- break;
-
- case kIOPM_ParentChangeTellCapabilityDidChange:
- ParentChangeTellCapabilityDidChange();
- break;
-
- case kIOPM_ParentChangeAcknowledgePowerChange:
- ParentChangeAcknowledgePowerChange();
- break;
-
- case kIOPM_DriverThreadCallDone:
- switch (fDriverCallReason) {
- case kDriverCallInformPreChange:
- case kDriverCallInformPostChange:
- notifyInterestedDriversDone();
- break;
- case kDriverCallSetPowerState:
- notifyControllingDriverDone();
- break;
- case kRootDomainInformPreChange:
- notifyRootDomainDone();
- break;
- default:
- panic("%s: bad call reason %x",
- getName(), fDriverCallReason);
- }
- break;
-
- case kIOPM_NotifyChildrenOrdered:
- notifyChildrenOrdered();
- break;
-
- case kIOPM_NotifyChildrenDelayed:
- notifyChildrenDelayed();
- break;
-
- case kIOPM_NotifyChildrenStart:
- // pop notifyAll() state saved by notifyInterestedDriversDone()
- MS_POP();
- notifyRootDomain();
- break;
-
- case kIOPM_SyncTellClientsPowerDown:
- // Root domain might self cancel due to assertions.
- if (IS_ROOT_DOMAIN) {
- bool cancel = (bool) fDoNotPowerDown;
- getPMRootDomain()->askChangeDownDone(
- &fHeadNoteChangeFlags, &cancel);
- fDoNotPowerDown = cancel;
- }
- if (!fDoNotPowerDown) {
- fMachineState = kIOPM_SyncTellPriorityClientsPowerDown;
- fOutOfBandParameter = kNotifyApps;
- tellChangeDown(fHeadNotePowerState);
- } else {
- // Cancelled by IOPMrootDomain::askChangeDownDone() or
- // askChangeDown/kNotifyApps
- OUR_PMLog(kPMLogIdleCancel, (uintptr_t) this, fMachineState);
- PM_ERROR("%s: idle cancel, state %u\n", fName, fMachineState);
-#if DEVELOPMENT || DEBUG
- record_system_event(SYSTEM_EVENT_TYPE_INFO,
- SYSTEM_EVENT_SUBSYSTEM_PMRD,
- "Idle Sleep", "%s idle cancel, state %u", fName, fMachineState
- );
-#endif /* DEVELOPMENT || DEBUG */
- tellNoChangeDown(fHeadNotePowerState);
- fHeadNoteChangeFlags |= kIOPMNotDone;
- OurChangeFinish();
- }
- break;
-
- case kIOPM_SyncTellPriorityClientsPowerDown:
- // PMRD: tellChangeDown/kNotifyApps done, was it cancelled?
- if (!fDoNotPowerDown) {
- fMachineState = kIOPM_SyncNotifyWillChange;
- fOutOfBandParameter = kNotifyPriority;
- tellChangeDown(fHeadNotePowerState);
- } else {
- OUR_PMLog(kPMLogIdleCancel, (uintptr_t) this, fMachineState);
- PM_ERROR("%s: idle revert, state %u\n", fName, fMachineState);
- tellChangeUp(fCurrentPowerState);
- fHeadNoteChangeFlags |= kIOPMNotDone;
- OurChangeFinish();
- }
- break;
-
- case kIOPM_SyncNotifyWillChange:
- if (kIOPMSyncNoChildNotify & fHeadNoteChangeFlags) {
- fMachineState = kIOPM_SyncFinish;
- continue;
- }
- fMachineState = kIOPM_SyncNotifyDidChange;
- fDriverCallReason = kDriverCallInformPreChange;
- notifyChildren();
- break;
-
- case kIOPM_SyncNotifyDidChange:
- fIsPreChange = false;
-
- if (fHeadNoteChangeFlags & kIOPMParentInitiated) {
- fMachineState = kIOPM_SyncFinish;
- } else {
- assert(IS_ROOT_DOMAIN);
- fMachineState = kIOPM_SyncTellCapabilityDidChange;
- }
-
- fDriverCallReason = kDriverCallInformPostChange;
- notifyChildren();
- break;
-
- case kIOPM_SyncTellCapabilityDidChange:
- tellSystemCapabilityChange( kIOPM_SyncFinish );
- break;
-
- case kIOPM_SyncFinish:
- if (fHeadNoteChangeFlags & kIOPMParentInitiated) {
- ParentChangeAcknowledgePowerChange();
- } else {
- OurChangeFinish();
- }
- break;
-
- case kIOPM_TellCapabilityChangeDone:
- if (fIsPreChange) {
- if (fOutOfBandParameter == kNotifyCapabilityChangePriority) {
- MS_POP(); // MS passed to tellSystemCapabilityChange()
- continue;
- }
- fOutOfBandParameter = kNotifyCapabilityChangePriority;
- } else {
- if (fOutOfBandParameter == kNotifyCapabilityChangeApps) {
- MS_POP(); // MS passed to tellSystemCapabilityChange()
- continue;
- }
- fOutOfBandParameter = kNotifyCapabilityChangeApps;
- }
- tellClientsWithResponse( fOutOfBandMessage );
- break;
-
- default:
- panic("PMWorkQueueInvoke: unknown machine state %x",
- fMachineState);
- }
-
- gIOPMRequest = NULL;
-
- if (fMachineState == kIOPM_Finished) {
- stop_watchdog_timer();
- done = true;
- break;
- }
- }
-
- return done;
-}
-
-//*********************************************************************************
-// [private] executePMRequest
-//*********************************************************************************
-
-void
-IOService::executePMRequest( IOPMRequest * request )
-{
- assert( kIOPM_Finished == fMachineState );
-
- switch (request->getType()) {
- case kIOPMRequestTypePMStop:
- handlePMstop( request );
- break;
-
- case kIOPMRequestTypeAddPowerChild1:
- addPowerChild1( request );
- break;
-
- case kIOPMRequestTypeAddPowerChild2:
- addPowerChild2( request );
- break;
-
- case kIOPMRequestTypeAddPowerChild3:
- addPowerChild3( request );
- break;
-
- case kIOPMRequestTypeRegisterPowerDriver:
- handleRegisterPowerDriver( request );
- break;
-
- case kIOPMRequestTypeAdjustPowerState:
- fAdjustPowerScheduled = false;
- adjustPowerState();
- break;
-
- case kIOPMRequestTypePowerDomainWillChange:
- handlePowerDomainWillChangeTo( request );
- break;
-
- case kIOPMRequestTypePowerDomainDidChange:
- handlePowerDomainDidChangeTo( request );
- break;
-
- case kIOPMRequestTypeRequestPowerState:
- case kIOPMRequestTypeRequestPowerStateOverride:
- handleRequestPowerState( request );
- break;
-
- case kIOPMRequestTypePowerOverrideOnPriv:
- case kIOPMRequestTypePowerOverrideOffPriv:
- handlePowerOverrideChanged( request );
- break;
-
- case kIOPMRequestTypeActivityTickle:
- handleActivityTickle( request );
- break;
-
- case kIOPMRequestTypeSynchronizePowerTree:
- handleSynchronizePowerTree( request );
- break;
-
- case kIOPMRequestTypeSetIdleTimerPeriod:
- {
- fIdleTimerPeriod = (typeof(fIdleTimerPeriod))(uintptr_t) request->fArg0;
- fNextIdleTimerPeriod = fIdleTimerPeriod;
- if ((false == fLockedFlags.PMStop) && (fIdleTimerPeriod > 0)) {
- restartIdleTimer();
- }
- }
- break;
-
- case kIOPMRequestTypeIgnoreIdleTimer:
- fIdleTimerIgnored = request->fArg0 ? 1 : 0;
- break;
-
- case kIOPMRequestTypeQuiescePowerTree:
- gIOPMWorkQueue->finishQuiesceRequest(request);
- break;
-
- case kIOPMRequestTypeDeferredActivityTickle:
- handleDeferredActivityTickle(request);
- break;
-
- default:
- panic("executePMRequest: unknown request type %x", request->getType());
- }
-}
-
-//*********************************************************************************
-// [private] actionPMReplyQueue
-//
-// IOPMRequestQueue::checkForWork() passing a reply-type request to the
-// request target.
-//*********************************************************************************
-
-bool
-IOService::actionPMReplyQueue( IOPMRequest * request, IOPMRequestQueue * queue )
-{
- bool more = false;
-
- assert( request && queue );
- assert( request->isReplyType());
-
- PM_LOG1("[A %02x] %p [%p %s] state %d\n",
- request->getType(), OBFUSCATE(request),
- OBFUSCATE(this), getName(), fMachineState);
-
- switch (request->getType()) {
- case kIOPMRequestTypeAllowPowerChange:
- case kIOPMRequestTypeCancelPowerChange:
- // Check if we are expecting this response.
- if (responseValid((uint32_t)(uintptr_t) request->fArg0,
- (int)(uintptr_t) request->fArg1)) {
- if (kIOPMRequestTypeCancelPowerChange == request->getType()) {
- // Clients are not allowed to cancel when kIOPMSkipAskPowerDown
- // flag is set. Only root domain will set this flag.
- // However, there is one exception to this rule. User-space PM
- // policy may choose to cancel sleep even after all clients have
- // been notified that we will lower power.
-
- if ((fMachineState == kIOPM_OurChangeTellUserPMPolicyPowerDown)
- || (fMachineState == kIOPM_OurChangeTellPriorityClientsPowerDown)
- || ((fHeadNoteChangeFlags & kIOPMSkipAskPowerDown) == 0)) {
- fDoNotPowerDown = true;
-
- OSString * name = (OSString *) request->fArg2;
- getPMRootDomain()->pmStatsRecordApplicationResponse(
- gIOPMStatsResponseCancel,
- name ? name->getCStringNoCopy() : "", 0,
- 0, (int)(uintptr_t) request->fArg1, NULL);
- }
- }
-
- // Update any clients that have exceeded their requested ack periods.
- updateClientResponses();
-
- if (checkForDone()) {
- stop_ack_timer();
- cleanClientResponses(false);
- more = true;
- }
- }
- // OSString containing app name in Arg2 must be released.
- if (request->getType() == kIOPMRequestTypeCancelPowerChange) {
- OSObject * obj = (OSObject *) request->fArg2;
- if (obj) {
- obj->release();
- }
- }
- break;
-
- case kIOPMRequestTypeAckPowerChange:
- more = handleAcknowledgePowerChange( request );
- break;
-
- case kIOPMRequestTypeAckSetPowerState:
- more = handleAcknowledgeSetPowerState( request );
- break;
-
- case kIOPMRequestTypeInterestChanged:
- handleInterestChanged( request );
- more = true;
- break;
-
- case kIOPMRequestTypeIdleCancel:
- more = handleCancelIdlePowerDown();
- break;
-
- case kIOPMRequestTypeChildNotifyDelayCancel:
- if (fMachineState == kIOPM_NotifyChildrenDelayed) {
- PM_LOG2("%s: delay notify cancelled\n", getName());
- notifyChildrenDelayed();
- }
- break;
-
- default:
- panic("PMReplyQueue: unknown reply type %x", request->getType());
- }
-
- more |= gIOPMCompletionQueue->queuePMRequest(request);
- if (more) {
- gIOPMWorkQueue->incrementProducerCount();
- }
-
- return more;
-}
-
-//*********************************************************************************
-// [private] assertPMDriverCall / deassertPMDriverCall
-//*********************************************************************************
-
-bool
-IOService::assertPMDriverCall(
- IOPMDriverCallEntry * entry,
- IOOptionBits method,
- const IOPMinformee * inform,
- IOOptionBits options )
-{
- IOService * target = NULL;
- bool ok = false;
-
- if (!initialized) {
- return false;
- }
-
- PM_LOCK();
-
- if (fLockedFlags.PMStop) {
- goto fail;
- }
-
- if (((options & kIOPMDriverCallNoInactiveCheck) == 0) && isInactive()) {
- goto fail;
- }
-
- if (inform) {
- if (!inform->active) {
- goto fail;
- }
- target = inform->whatObject;
- if (target->isInactive()) {
- goto fail;
- }
- }
-
- // Record calling address for sleep failure diagnostics
- switch (method) {
- case kIOPMDriverCallMethodSetPowerState:
- entry->callMethod = OSMemberFunctionCast(const void *, fControllingDriver, &IOService::setPowerState);
- break;
- case kIOPMDriverCallMethodWillChange:
- entry->callMethod = OSMemberFunctionCast(const void *, target, &IOService::powerStateWillChangeTo);
- break;
- case kIOPMDriverCallMethodDidChange:
- entry->callMethod = OSMemberFunctionCast(const void *, target, &IOService::powerStateDidChangeTo);
- break;
- case kIOPMDriverCallMethodUnknown:
- case kIOPMDriverCallMethodSetAggressive:
- case kIOPMDriverCallMethodMaxCapabilityForDomainState:
- case kIOPMDriverCallMethodInitialPowerStateForDomainState:
- default:
- entry->callMethod = NULL;
- break;
- }
-
- entry->thread = current_thread();
- entry->target = target;
- queue_enter(&fPMDriverCallQueue, entry, IOPMDriverCallEntry *, link);
- ok = true;
-
-fail:
- PM_UNLOCK();
-
- return ok;
-}
-
-void
-IOService::deassertPMDriverCall( IOPMDriverCallEntry * entry )
-{
- bool wakeup = false;
-
- PM_LOCK();
-
- assert( !queue_empty(&fPMDriverCallQueue));
- queue_remove(&fPMDriverCallQueue, entry, IOPMDriverCallEntry *, link);
- if (fLockedFlags.PMDriverCallWait) {
- wakeup = true;
- }
-
- PM_UNLOCK();
-
- if (wakeup) {
- PM_LOCK_WAKEUP(&fPMDriverCallQueue);
- }
-}
-
-bool
-IOService::getBlockingDriverCall(thread_t *thread, const void **callMethod)
-{
- const IOPMDriverCallEntry * entry = NULL;
- bool blocked = false;
-
- if (!initialized) {
- return false;
- }
-
- if (current_thread() != gIOPMWatchDogThread) {
- // Meant to be accessed only from watchdog thread
- return false;
- }
-
- PM_LOCK();
- entry = qe_queue_first(&fPMDriverCallQueue, IOPMDriverCallEntry, link);
- if (entry) {
- *thread = entry->thread;
- *callMethod = entry->callMethod;
- blocked = true;
- }
- PM_UNLOCK();
-
- return blocked;
-}
-
-
-void
-IOService::waitForPMDriverCall( IOService * target )
-{
- const IOPMDriverCallEntry * entry;
- thread_t thread = current_thread();
- AbsoluteTime deadline;
- int waitResult;
- bool log = true;
- bool wait;
-
- do {
- wait = false;
- queue_iterate(&fPMDriverCallQueue, entry, const IOPMDriverCallEntry *, link)
- {
- // Target of interested driver call
- if (target && (target != entry->target)) {
- continue;
- }
-
- if (entry->thread == thread) {
- if (log) {
- PM_LOG("%s: %s(%s) on PM thread\n",
- fName, __FUNCTION__, target ? target->getName() : "");
- OSReportWithBacktrace("%s: %s(%s) on PM thread\n",
- fName, __FUNCTION__, target ? target->getName() : "");
- log = false;
- }
- continue;
- }
-
- wait = true;
- break;
- }
-
- if (wait) {
- fLockedFlags.PMDriverCallWait = true;
- clock_interval_to_deadline(15, kSecondScale, &deadline);
- waitResult = PM_LOCK_SLEEP(&fPMDriverCallQueue, deadline);
- fLockedFlags.PMDriverCallWait = false;
- if (THREAD_TIMED_OUT == waitResult) {
- PM_ERROR("%s: waitForPMDriverCall timeout\n", fName);
- wait = false;
- }
- }
- } while (wait);
-}
-
-//*********************************************************************************
-// [private] Debug helpers
-//*********************************************************************************
-
-const char *
-IOService::getIOMessageString( uint32_t msg )
-{
-#define MSG_ENTRY(x) {(int) x, #x}
-
- static const IONamedValue msgNames[] = {
- MSG_ENTRY( kIOMessageCanDevicePowerOff ),
- MSG_ENTRY( kIOMessageDeviceWillPowerOff ),
- MSG_ENTRY( kIOMessageDeviceWillNotPowerOff ),
- MSG_ENTRY( kIOMessageDeviceHasPoweredOn ),
- MSG_ENTRY( kIOMessageCanSystemPowerOff ),
- MSG_ENTRY( kIOMessageSystemWillPowerOff ),
- MSG_ENTRY( kIOMessageSystemWillNotPowerOff ),
- MSG_ENTRY( kIOMessageCanSystemSleep ),
- MSG_ENTRY( kIOMessageSystemWillSleep ),
- MSG_ENTRY( kIOMessageSystemWillNotSleep ),
- MSG_ENTRY( kIOMessageSystemHasPoweredOn ),
- MSG_ENTRY( kIOMessageSystemWillRestart ),
- MSG_ENTRY( kIOMessageSystemWillPowerOn ),
- MSG_ENTRY( kIOMessageSystemCapabilityChange ),
- MSG_ENTRY( kIOPMMessageLastCallBeforeSleep ),
- MSG_ENTRY( kIOMessageSystemPagingOff ),
- { 0, NULL }
- };
-
- return IOFindNameForValue(msg, msgNames);
-}
-
-static const char *
-getNotificationPhaseString( uint32_t phase )
-{
-#define PHASE_ENTRY(x) {(int) x, #x}
-
- static const IONamedValue phaseNames[] = {
- PHASE_ENTRY( kNotifyApps ),
- PHASE_ENTRY( kNotifyPriority ),
- PHASE_ENTRY( kNotifyCapabilityChangeApps ),
- PHASE_ENTRY( kNotifyCapabilityChangePriority ),
- { 0, NULL }
- };
-
- return IOFindNameForValue(phase, phaseNames);
-}
-
-// MARK: -
-// MARK: IOPMRequest
-
-//*********************************************************************************
-// IOPMRequest Class
-//
-// Requests from PM clients, and also used for inter-object messaging within PM.
-//*********************************************************************************
-
-OSDefineMetaClassAndStructors( IOPMRequest, IOCommand );
-
-IOPMRequest *
-IOPMRequest::create( void )
-{
- IOPMRequest * me = OSTypeAlloc(IOPMRequest);
- if (me && !me->init(NULL, kIOPMRequestTypeInvalid)) {
- me->release();
- me = NULL;
- }
- return me;
-}
-
-bool
-IOPMRequest::init( IOService * target, IOOptionBits type )
-{
- if (!IOCommand::init()) {
- return false;
- }
-
- fRequestType = type;
- fTarget = target;
-
- if (fTarget) {
- fTarget->retain();
- }
-
- // Root node and root domain requests does not prevent the power tree from
- // becoming quiescent.
-
- fIsQuiesceBlocker = ((fTarget != gIOPMRootNode) &&
- (fTarget != IOService::getPMRootDomain()));
-
- return true;
-}
-
-void
-IOPMRequest::reset( void )
-{
- assert( fWorkWaitCount == 0 );
- assert( fFreeWaitCount == 0 );
-
- detachNextRequest();
- detachRootRequest();
-
- if (fCompletionAction && (fRequestType == kIOPMRequestTypeQuiescePowerTree)) {
- // Call the completion on PM work loop context
- fCompletionAction(fCompletionTarget, fCompletionParam);
- fCompletionAction = NULL;
- }
-
- fRequestType = kIOPMRequestTypeInvalid;
-
- if (fTarget) {
- fTarget->release();
- fTarget = NULL;
- }
-}
-
-bool
-IOPMRequest::attachNextRequest( IOPMRequest * next )
-{
- bool ok = false;
-
- if (!fRequestNext) {
- // Postpone the execution of the next request after
- // this request.
- fRequestNext = next;
- fRequestNext->fWorkWaitCount++;
-#if LOG_REQUEST_ATTACH
- PM_LOG("Attached next: %p [0x%x] -> %p [0x%x, %u] %s\n",
- OBFUSCATE(this), fRequestType, OBFUSCATE(fRequestNext),
- fRequestNext->fRequestType,
- (uint32_t) fRequestNext->fWorkWaitCount,
- fTarget->getName());
-#endif
- ok = true;
- }
- return ok;
-}
-
-bool
-IOPMRequest::detachNextRequest( void )
-{
- bool ok = false;
-
- if (fRequestNext) {
- assert(fRequestNext->fWorkWaitCount);
- if (fRequestNext->fWorkWaitCount) {
- fRequestNext->fWorkWaitCount--;
- }
-#if LOG_REQUEST_ATTACH
- PM_LOG("Detached next: %p [0x%x] -> %p [0x%x, %u] %s\n",
- OBFUSCATE(this), fRequestType, OBFUSCATE(fRequestNext),
- fRequestNext->fRequestType,
- (uint32_t) fRequestNext->fWorkWaitCount,
- fTarget->getName());
-#endif
- fRequestNext = NULL;
- ok = true;
- }
- return ok;
-}
-
-bool
-IOPMRequest::attachRootRequest( IOPMRequest * root )
-{
- bool ok = false;
-
- if (!fRequestRoot) {
- // Delay the completion of the root request after
- // this request.
- fRequestRoot = root;
- fRequestRoot->fFreeWaitCount++;
-#if LOG_REQUEST_ATTACH
- PM_LOG("Attached root: %p [0x%x] -> %p [0x%x, %u] %s\n",
- OBFUSCATE(this), (uint32_t) fType, OBFUSCATE(fRequestRoot),
- (uint32_t) fRequestRoot->fType,
- (uint32_t) fRequestRoot->fFreeWaitCount,
- fTarget->getName());
-#endif
- ok = true;
- }
- return ok;
-}
-
-bool
-IOPMRequest::detachRootRequest( void )
-{
- bool ok = false;
-
- if (fRequestRoot) {
- assert(fRequestRoot->fFreeWaitCount);
- if (fRequestRoot->fFreeWaitCount) {
- fRequestRoot->fFreeWaitCount--;
- }
-#if LOG_REQUEST_ATTACH
- PM_LOG("Detached root: %p [0x%x] -> %p [0x%x, %u] %s\n",
- OBFUSCATE(this), (uint32_t) fType, OBFUSCATE(fRequestRoot),
- (uint32_t) fRequestRoot->fType,
- (uint32_t) fRequestRoot->fFreeWaitCount,
- fTarget->getName());
-#endif
- fRequestRoot = NULL;
- ok = true;
- }
- return ok;
-}
-
-// MARK: -
-// MARK: IOPMRequestQueue
-
-//*********************************************************************************
-// IOPMRequestQueue Class
-//
-// Global queues. Queues are created once and never released.
-//*********************************************************************************
-
-OSDefineMetaClassAndStructors( IOPMRequestQueue, IOEventSource );
-
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wcast-function-type"
-
-IOPMRequestQueue *
-IOPMRequestQueue::create( IOService * inOwner, Action inAction )
-{
- IOPMRequestQueue * me = OSTypeAlloc(IOPMRequestQueue);
- if (me && !me->init(inOwner, inAction)) {
- me->release();
- me = NULL;
- }
- return me;
-}
-
-bool
-IOPMRequestQueue::init( IOService * inOwner, Action inAction )
-{
- if (!inAction || !IOEventSource::init(inOwner, (IOEventSourceAction)inAction)) {
- return false;
- }
-
- queue_init(&fQueue);
- fLock = IOLockAlloc();
- return fLock != NULL;
-}
-
-#pragma clang diagnostic pop
-
-void
-IOPMRequestQueue::free( void )
-{
- if (fLock) {
- IOLockFree(fLock);
- fLock = NULL;
- }
- return IOEventSource::free();
-}
-
-void
-IOPMRequestQueue::queuePMRequest( IOPMRequest * request )
-{
- uint64_t now = mach_continuous_time();
-
- assert(request);
- request->setTimestamp(now);
- IOLockLock(fLock);
- queue_enter(&fQueue, request, typeof(request), fCommandChain);
- IOLockUnlock(fLock);
- if (workLoop) {
- signalWorkAvailable();
- }
-}
-
-void
-IOPMRequestQueue::queuePMRequestChain( IOPMRequest ** requests, IOItemCount count )
-{
- IOPMRequest * next;
- uint64_t now = mach_continuous_time();
-
- assert(requests && count);
- IOLockLock(fLock);
- while (count--) {
- next = *requests;
- next->setTimestamp(now);
- requests++;
- queue_enter(&fQueue, next, typeof(next), fCommandChain);
- }
- IOLockUnlock(fLock);
- if (workLoop) {
- signalWorkAvailable();
- }
-}
-
-bool
-IOPMRequestQueue::checkForWork( void )
-{
- Action dqAction = (Action) (void (*)(void))action;
- IOPMRequest * request;
- IOService * target;
- int dequeueCount = 0;
- bool more = false;
-
- 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;
-}
-
-// MARK: -
-// MARK: IOPMWorkQueue
-
-//*********************************************************************************
-// IOPMWorkQueue Class
-//
-// Queue of IOServicePM objects, each with a queue of IOPMRequest sharing the
-// same target.
-//*********************************************************************************
-
-OSDefineMetaClassAndStructors( IOPMWorkQueue, IOEventSource );
-
-IOPMWorkQueue *
-IOPMWorkQueue::create( IOService * inOwner, Action invoke, Action retire )
-{
- IOPMWorkQueue * me = OSTypeAlloc(IOPMWorkQueue);
- if (me && !me->init(inOwner, invoke, retire)) {
- me->release();
- me = NULL;
- }
- return me;
-}
-
-bool
-IOPMWorkQueue::init( IOService * inOwner, Action invoke, Action retire )
-{
- if (!invoke || !retire ||
- !IOEventSource::init(inOwner, (IOEventSourceAction)NULL)) {
- return false;
- }
-
- queue_init(&fWorkQueue);
-
- fInvokeAction = invoke;
- fRetireAction = retire;
- fConsumerCount = fProducerCount = 0;
-
- return true;
-}
-
-bool
-IOPMWorkQueue::queuePMRequest( IOPMRequest * request, IOServicePM * pwrMgt )
-{
- queue_head_t * requestQueue;
- bool more = false;
- bool empty;
-
- assert( request );
- assert( pwrMgt );
- assert( onThread());
- assert( queue_next(&request->fCommandChain) ==
- queue_prev(&request->fCommandChain));
-
- gIOPMBusyRequestCount++;
-
- if (request->isQuiesceType()) {
- 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.
-
- requestQueue = &pwrMgt->RequestHead;
- empty = queue_empty(requestQueue);
- queue_enter(requestQueue, request, typeof(request), fCommandChain);
- if (empty) {
- more = checkRequestQueue(requestQueue, &empty);
- if (!empty) {
- // Request just added is blocked, add its target IOServicePM
- // to the work queue.
- assert( queue_next(&pwrMgt->WorkChain) ==
- queue_prev(&pwrMgt->WorkChain));
-
- queue_enter(&fWorkQueue, pwrMgt, typeof(pwrMgt), WorkChain);
- fQueueLength++;
- PM_LOG3("IOPMWorkQueue: [%u] added %s@%p to queue\n",
- fQueueLength, pwrMgt->Name, OBFUSCATE(pwrMgt));
- }
- }
-
- return more;
-}
-
-bool
-IOPMWorkQueue::checkRequestQueue( queue_head_t * requestQueue, bool * empty )
-{
- IOPMRequest * request;
- IOService * target;
- bool more = false;
- bool done = false;
-
- assert(!queue_empty(requestQueue));
- do {
- request = (typeof(request))queue_first(requestQueue);
- if (request->isWorkBlocked()) {
- break; // request dispatch blocked on attached request
- }
- target = request->getTarget();
- if (fInvokeAction) {
- done = (*fInvokeAction)( target, request, this );
- } else {
- PM_LOG("PM request 0x%x dropped\n", request->getType());
- done = true;
- }
- if (!done) {
- break; // PM state machine blocked
- }
- assert(gIOPMBusyRequestCount > 0);
- if (gIOPMBusyRequestCount) {
- gIOPMBusyRequestCount--;
- }
-
- if (request == fQuiesceRequest) {
- fQuiesceRequest = NULL;
- }
-
- queue_remove_first(requestQueue, request, typeof(request), fCommandChain);
- more |= (*fRetireAction)( target, request, this );
- done = queue_empty(requestQueue);
- } while (!done);
-
- *empty = done;
-
- if (more) {
- // Retired a request that may unblock a previously visited request
- // that is still waiting on the work queue. Must trigger another
- // queue check.
- fProducerCount++;
- }
-
- return more;
-}
-
-bool
-IOPMWorkQueue::checkForWork( void )
-{
- IOServicePM * entry;
- IOServicePM * next;
- bool more = false;
- bool empty;
-
-#if WORK_QUEUE_STATS
- fStatCheckForWork++;
-#endif
-
- // Iterate over all IOServicePM entries in the work queue,
- // and check each entry's request queue.
-
- while (fConsumerCount != fProducerCount) {
- PM_LOG3("IOPMWorkQueue: checkForWork %u %u\n",
- fProducerCount, fConsumerCount);
-
- fConsumerCount = fProducerCount;
-
-#if WORK_QUEUE_STATS
- if (queue_empty(&fWorkQueue)) {
- fStatQueueEmpty++;
- break;
- }
- fStatScanEntries++;
- uint32_t cachedWorkCount = gIOPMWorkInvokeCount;
-#endif
-
- __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.
- __IGNORE_WCASTALIGN(next = (typeof(next))queue_next(&entry->WorkChain));
-
- // if request queue is empty, remove IOServicePM from work queue.
- if (empty) {
- assert(fQueueLength);
- if (fQueueLength) {
- fQueueLength--;
- }
- PM_LOG3("IOPMWorkQueue: [%u] removed %s@%p from queue\n",
- fQueueLength, entry->Name, OBFUSCATE(entry));
- queue_remove(&fWorkQueue, entry, typeof(entry), WorkChain);
- }
- entry = next;
- }
-
-#if WORK_QUEUE_STATS
- if (cachedWorkCount == gIOPMWorkInvokeCount) {
- fStatNoWorkDone++;
- }
-#endif
- }
-
- return more;
-}
-
-void
-IOPMWorkQueue::signalWorkAvailable( void )
-{
- fProducerCount++;
- IOEventSource::signalWorkAvailable();
-}
-
-void
-IOPMWorkQueue::incrementProducerCount( void )
-{
- fProducerCount++;
-}
-
-void
-IOPMWorkQueue::attachQuiesceRequest( IOPMRequest * quiesceRequest )
-{
- IOServicePM * entry;
- IOPMRequest * request;
-
- if (queue_empty(&fWorkQueue)) {
- return;
- }
-
- queue_iterate(&fWorkQueue, entry, typeof(entry), WorkChain)
- {
- queue_iterate(&entry->RequestHead, request, typeof(request), fCommandChain)
- {
- // Attach the quiesce request to any request in the queue that
- // is not linked to a next request. These requests will block
- // the quiesce request.
-
- if (request->isQuiesceBlocker()) {
- request->attachNextRequest(quiesceRequest);
- }
- }
- }
-}
-
-void
-IOPMWorkQueue::finishQuiesceRequest( IOPMRequest * quiesceRequest )
-{
- if (fQuiesceRequest && (quiesceRequest == fQuiesceRequest) &&
- (fQuiesceStartTime != 0)) {
- fInvokeAction = NULL;
- fQuiesceFinishTime = mach_absolute_time();
- }
-}
-
-// MARK: -
-// MARK: IOPMCompletionQueue
-
-//*********************************************************************************
-// IOPMCompletionQueue Class
-//*********************************************************************************
-
-OSDefineMetaClassAndStructors( IOPMCompletionQueue, IOEventSource );
-
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wcast-function-type"
-
-IOPMCompletionQueue *
-IOPMCompletionQueue::create( IOService * inOwner, Action inAction )
-{
- IOPMCompletionQueue * me = OSTypeAlloc(IOPMCompletionQueue);
- if (me && !me->init(inOwner, inAction)) {
- me->release();
- me = NULL;
- }
- return me;
-}
-
-bool
-IOPMCompletionQueue::init( IOService * inOwner, Action inAction )
-{
- if (!inAction || !IOEventSource::init(inOwner, (IOEventSourceAction)inAction)) {
- return false;
- }
-
- queue_init(&fQueue);
- return true;
-}
-
-
-bool
-IOPMCompletionQueue::queuePMRequest( IOPMRequest * request )
-{
- bool more;
-
- assert(request);
- // unblock dependent request
- more = request->detachNextRequest();
- queue_enter(&fQueue, request, typeof(request), fCommandChain);
- return more;
-}
-
-bool
-IOPMCompletionQueue::checkForWork( void )
-{
- Action dqAction = (Action) action;
- IOPMRequest * request;
- IOPMRequest * next;
- IOService * target;
- bool more = false;
-
- request = (typeof(request))queue_first(&fQueue);
- while (!queue_end(&fQueue, (queue_entry_t) request)) {
- next = (typeof(next))queue_next(&request->fCommandChain);
- if (!request->isFreeBlocked()) {
- queue_remove(&fQueue, request, typeof(request), fCommandChain);
- target = request->getTarget();
- assert(target);
- more |= (*dqAction)( target, request, this );
- }
- request = next;
- }
-
- return more;
-}
-
-#pragma clang diagnostic pop
-
-// MARK: -
-// MARK: IOServicePM
-
-OSDefineMetaClassAndStructors(IOServicePM, OSObject)
-
+IOReturn IOService::newTemperature ( long currentTemp, IOService * whichZone )
+
+{
+ return IOPMNoErr;
+}
+
+
+#undef super
+#define super OSObject
+
+OSDefineMetaClassAndStructors(IOPMprot, OSObject)
//*********************************************************************************
// serialize
//
-// Serialize IOServicePM for debugging.
-//*********************************************************************************
-
-static void
-setPMProperty( OSDictionary * dict, const char * key, uint64_t value )
-{
- OSNumber * num = OSNumber::withNumber(value, sizeof(value) * 8);
- if (num) {
- dict->setObject(key, num);
- num->release();
- }
-}
-
-IOReturn
-IOServicePM::gatedSerialize( OSSerialize * s ) const
-{
- OSDictionary * dict;
- bool ok = false;
- int powerClamp = -1;
- int dictSize = 6;
-
- if (IdleTimerPeriod) {
- dictSize += 4;
- }
-
- if (PMActions.state & kPMActionsStatePowerClamped) {
- dictSize += 1;
- powerClamp = 0;
- if (PMActions.flags &
- (kPMActionsFlagIsDisplayWrangler | kPMActionsFlagIsGraphicsDriver)) {
- powerClamp++;
- }
- }
-
-#if WORK_QUEUE_STATS
- if (gIOPMRootNode == ControllingDriver) {
- dictSize += 4;
- }
-#endif
-
- if (PowerClients) {
- dict = OSDictionary::withDictionary(
- PowerClients, PowerClients->getCount() + dictSize);
- } else {
- dict = OSDictionary::withCapacity(dictSize);
- }
-
- if (dict) {
- setPMProperty(dict, "CurrentPowerState", CurrentPowerState);
- setPMProperty(dict, "CapabilityFlags", CurrentCapabilityFlags);
- if (NumberOfPowerStates) {
- setPMProperty(dict, "MaxPowerState", NumberOfPowerStates - 1);
- }
- if (DesiredPowerState != CurrentPowerState) {
- setPMProperty(dict, "DesiredPowerState", DesiredPowerState);
- }
- if (kIOPM_Finished != MachineState) {
- setPMProperty(dict, "MachineState", MachineState);
- }
- if (DeviceOverrideEnabled) {
- dict->setObject("PowerOverrideOn", kOSBooleanTrue);
- }
- if (powerClamp >= 0) {
- setPMProperty(dict, "PowerClamp", powerClamp);
- }
-
- if (IdleTimerPeriod) {
- AbsoluteTime now;
- AbsoluteTime delta;
- uint64_t nsecs;
-
- clock_get_uptime(&now);
-
- // The idle timer period in milliseconds
- setPMProperty(dict, "IdleTimerPeriod", NextIdleTimerPeriod * 1000ULL);
-
- // Number of tickles since the last idle timer expiration
- setPMProperty(dict, "ActivityTickles", ActivityTickleCount);
-
- if (AbsoluteTime_to_scalar(&DeviceActiveTimestamp)) {
- // Milliseconds since the last activity tickle
- delta = now;
- SUB_ABSOLUTETIME(&delta, &DeviceActiveTimestamp);
- absolutetime_to_nanoseconds(delta, &nsecs);
- setPMProperty(dict, "TimeSinceLastTickle", NS_TO_MS(nsecs));
- }
-
- if (!IdleTimerStopped && AbsoluteTime_to_scalar(&IdleTimerStartTime)) {
- // Idle timer elapsed time in milliseconds
- delta = now;
- SUB_ABSOLUTETIME(&delta, &IdleTimerStartTime);
- absolutetime_to_nanoseconds(delta, &nsecs);
- setPMProperty(dict, "IdleTimerElapsedTime", NS_TO_MS(nsecs));
- }
- }
-
-#if WORK_QUEUE_STATS
- if (gIOPMRootNode == Owner) {
- setPMProperty(dict, "WQ-CheckForWork",
- gIOPMWorkQueue->fStatCheckForWork);
- setPMProperty(dict, "WQ-ScanEntries",
- gIOPMWorkQueue->fStatScanEntries);
- setPMProperty(dict, "WQ-QueueEmpty",
- gIOPMWorkQueue->fStatQueueEmpty);
- setPMProperty(dict, "WQ-NoWorkDone",
- gIOPMWorkQueue->fStatNoWorkDone);
- }
-#endif
-
- if (HasAdvisoryDesire && !gIOPMAdvisoryTickleEnabled) {
- // Don't report advisory tickle when it has no influence
- dict->removeObject(gIOPMPowerClientAdvisoryTickle);
- }
-
- ok = dict->serialize(s);
- dict->release();
- }
-
- return ok ? kIOReturnSuccess : kIOReturnNoMemory;
-}
-
-bool
-IOServicePM::serialize( OSSerialize * s ) const
-{
- IOReturn ret = kIOReturnNotReady;
-
- if (gIOPMWatchDogThread == current_thread()) {
- // Calling without lock as this data is collected for debug purpose, before reboot.
- // The workloop is probably already hung in state machine.
- ret = gatedSerialize(s);
- } else if (gIOPMWorkLoop) {
- ret = gIOPMWorkLoop->runAction(
- OSMemberFunctionCast(IOWorkLoop::Action, this, &IOServicePM::gatedSerialize),
- (OSObject *) this, (void *) s);
- }
-
- return kIOReturnSuccess == ret;
-}
-
-void
-IOServicePM::pmPrint(
- uint32_t event,
- uintptr_t param1,
- uintptr_t param2 ) const
-{
- gPlatform->PMLog(Name, event, param1, param2);
-}
-
-void
-IOServicePM::pmTrace(
- uint32_t event,
- uint32_t eventFunc,
- uintptr_t param1,
- uintptr_t param2 ) const
-{
- uintptr_t nameAsArg = 0;
-
- assert(event < KDBG_CODE_MAX);
- assert((eventFunc & ~KDBG_FUNC_MASK) == 0);
-
- // Copy the first characters of the name into an uintptr_t.
- // NULL termination is not required.
- strncpy((char*)&nameAsArg, Name, sizeof(nameAsArg));
-
-#if defined(XNU_TARGET_OS_OSX)
- KERNEL_DEBUG_CONSTANT_IST(KDEBUG_TRACE, IODBG_POWER(event) | eventFunc, nameAsArg,
- (uintptr_t)Owner->getRegistryEntryID(), (uintptr_t)(OBFUSCATE(param1)),
- (uintptr_t)(OBFUSCATE(param2)), 0);
-#else
- IOTimeStampConstant(IODBG_POWER(event) | eventFunc, nameAsArg, (uintptr_t)Owner->getRegistryEntryID(), (uintptr_t)(OBFUSCATE(param1)), (uintptr_t)(OBFUSCATE(param2)));
-#endif
-}
+// Serialize protected instance variables for debug output.
+//*********************************************************************************
+bool IOPMprot::serialize(OSSerialize *s) const
+{
+ OSString * theOSString;
+ char * buffer;
+ char * ptr;
+ int i;
+ bool rtn_code;
+
+ buffer = ptr = IONew(char, 2000);
+ if(!buffer)
+ return false;
+
+ ptr += sprintf(ptr,"{ theNumberOfPowerStates = %d, ",(unsigned int)theNumberOfPowerStates);
+
+ if ( theNumberOfPowerStates != 0 ) {
+ ptr += sprintf(ptr,"version %d, ",(unsigned int)thePowerStates[0].version);
+ }
+
+ if ( theNumberOfPowerStates != 0 ) {
+ for ( i = 0; i < (int)theNumberOfPowerStates; i++ ) {
+ ptr += sprintf(ptr,"power state %d = { ",i);
+ ptr += sprintf(ptr,"capabilityFlags %08x, ",(unsigned int)thePowerStates[i].capabilityFlags);
+ ptr += sprintf(ptr,"outputPowerCharacter %08x, ",(unsigned int)thePowerStates[i].outputPowerCharacter);
+ ptr += sprintf(ptr,"inputPowerRequirement %08x, ",(unsigned int)thePowerStates[i].inputPowerRequirement);
+ ptr += sprintf(ptr,"staticPower %d, ",(unsigned int)thePowerStates[i].staticPower);
+ ptr += sprintf(ptr,"unbudgetedPower %d, ",(unsigned int)thePowerStates[i].unbudgetedPower);
+ ptr += sprintf(ptr,"powerToAttain %d, ",(unsigned int)thePowerStates[i].powerToAttain);
+ ptr += sprintf(ptr,"timeToAttain %d, ",(unsigned int)thePowerStates[i].timeToAttain);
+ ptr += sprintf(ptr,"settleUpTime %d, ",(unsigned int)thePowerStates[i].settleUpTime);
+ ptr += sprintf(ptr,"timeToLower %d, ",(unsigned int)thePowerStates[i].timeToLower);
+ ptr += sprintf(ptr,"settleDownTime %d, ",(unsigned int)thePowerStates[i].settleDownTime);
+ ptr += sprintf(ptr,"powerDomainBudget %d }, ",(unsigned int)thePowerStates[i].powerDomainBudget);
+ }
+ }
+
+ ptr += sprintf(ptr,"aggressiveness = %d, ",(unsigned int)aggressiveness);
+ ptr += sprintf(ptr,"myCurrentState = %d, ",(unsigned int)myCurrentState);
+ ptr += sprintf(ptr,"parentsCurrentPowerFlags = %08x, ",(unsigned int)parentsCurrentPowerFlags);
+ ptr += sprintf(ptr,"maxCapability = %d }",(unsigned int)maxCapability);
+
+ theOSString = OSString::withCString(buffer);
+ rtn_code = theOSString->serialize(s);
+ theOSString->release();
+ IODelete(buffer, char, 2000);
+
+ return rtn_code;
+}
+
+
+#undef super
+#define super OSObject
+
+OSDefineMetaClassAndStructors(IOPMpriv, OSObject)
+//*********************************************************************************
+// serialize
+//
+// Serialize private instance variables for debug output.
+//*********************************************************************************
+bool IOPMpriv::serialize(OSSerialize *s) const
+{
+ OSString * theOSString;
+ bool rtn_code;
+ char * buffer;
+ char * ptr;
+ IOPMinformee * nextObject;
+
+ buffer = ptr = IONew(char, 2000);
+ if(!buffer)
+ return false;
+
+ ptr += sprintf(ptr,"{ this object = %08x",(unsigned int)owner);
+ if ( we_are_root ) {
+ ptr += sprintf(ptr," (root)");
+ }
+ ptr += sprintf(ptr,", ");
+
+ nextObject = interestedDrivers->firstInList(); // display interested drivers
+ while ( nextObject != NULL ) {
+ ptr += sprintf(ptr,"interested driver = %08x, ",(unsigned int)nextObject->whatObject);
+ nextObject = interestedDrivers->nextInList(nextObject);
+ }
+
+ if ( machine_state != IOPMfinished ) {
+ ptr += sprintf(ptr,"machine_state = %d, ",(unsigned int)machine_state);
+ ptr += sprintf(ptr,"driver_timer = %d, ",(unsigned int)driver_timer);
+ ptr += sprintf(ptr,"settle_time = %d, ",(unsigned int)settle_time);
+ ptr += sprintf(ptr,"head_note_flags = %08x, ",(unsigned int)head_note_flags);
+ ptr += sprintf(ptr,"head_note_state = %d, ",(unsigned int)head_note_state);
+ ptr += sprintf(ptr,"head_note_outputFlags = %08x, ",(unsigned int)head_note_outputFlags);
+ ptr += sprintf(ptr,"head_note_domainState = %08x, ",(unsigned int)head_note_domainState);
+ ptr += sprintf(ptr,"head_note_capabilityFlags = %08x, ",(unsigned int)head_note_capabilityFlags);
+ ptr += sprintf(ptr,"head_note_pendingAcks = %d, ",(unsigned int)head_note_pendingAcks);
+ }
+
+ if ( device_overrides ) {
+ ptr += sprintf(ptr,"device overrides, ");
+ }
+ ptr += sprintf(ptr,"driverDesire = %d, ",(unsigned int)driverDesire);
+ ptr += sprintf(ptr,"deviceDesire = %d, ",(unsigned int)deviceDesire);
+ ptr += sprintf(ptr,"ourDesiredPowerState = %d, ",(unsigned int)ourDesiredPowerState);
+ ptr += sprintf(ptr,"previousRequest = %d }",(unsigned int)previousRequest);
+
+ theOSString = OSString::withCString(buffer);
+ rtn_code = theOSString->serialize(s);
+ theOSString->release();
+ IODelete(buffer, char, 2000);
+
+ return rtn_code;
+}
+