+ evaluateSystemSleepPolicyFinal();
+#else
+ LOG("System Sleep\n");
+#endif
+ if (thermalWarningState) {
+ OSSharedPtr<const OSSymbol> event = OSSymbol::withCString(kIOPMThermalLevelWarningKey);
+ if (event) {
+ systemPowerEventOccurred(event.get(), kIOPMThermalLevelUnknown);
+ }
+ }
+ assertOnWakeSecs = 0;
+ lowBatteryCondition = false;
+ thermalEmergencyState = false;
+
+#if DEVELOPMENT || DEBUG
+ extern int g_should_log_clock_adjustments;
+ if (g_should_log_clock_adjustments) {
+ clock_sec_t secs = 0;
+ clock_usec_t microsecs = 0;
+ uint64_t now_b = mach_absolute_time();
+
+ secs = 0;
+ microsecs = 0;
+ PEGetUTCTimeOfDay(&secs, µsecs);
+
+ uint64_t now_a = mach_absolute_time();
+ os_log(OS_LOG_DEFAULT, "%s PMU before going to sleep %lu s %d u %llu abs_b_PEG %llu abs_a_PEG \n",
+ __func__, (unsigned long)secs, microsecs, now_b, now_a);
+ }
+#endif
+
+ getPlatform()->sleepKernel();
+
+ // The CPU(s) are off at this point,
+ // Code will resume execution here upon wake.
+
+ clock_get_uptime(&gIOLastWakeAbsTime);
+ IOLog("gIOLastWakeAbsTime: %lld\n", gIOLastWakeAbsTime);
+ _highestCapability = 0;
+
+#if HIBERNATION
+ IOHibernateSystemWake();
+#endif
+
+ // sleep transition complete
+ gSleepOrShutdownPending = 0;
+
+ // trip the reset of the calendar clock
+ clock_wakeup_calendar();
+ clock_get_calendar_microtime(&secs, µsecs);
+ gIOLastWakeTime.tv_sec = secs;
+ gIOLastWakeTime.tv_usec = microsecs;
+
+ // aot
+ if (_aotWakeTimeCalendar.selector != kPMCalendarTypeInvalid) {
+ _aotWakeTimeCalendar.selector = kPMCalendarTypeInvalid;
+ secs = 0;
+ microsecs = 0;
+ PEGetUTCTimeOfDay(&secs, µsecs);
+ IOPMConvertSecondsToCalendar(secs, &nowCalendar);
+ IOLog("aotWake at " YMDTF " sched: " YMDTF "\n", YMDT(&nowCalendar), YMDT(&_aotWakeTimeCalendar));
+ _aotMetrics->sleepCount++;
+ _aotLastWakeTime = gIOLastWakeAbsTime;
+ if (_aotMetrics->sleepCount <= kIOPMAOTMetricsKernelWakeCountMax) {
+ _aotMetrics->kernelSleepTime[_aotMetrics->sleepCount - 1]
+ = (((uint64_t) gIOLastSleepTime.tv_sec) << 10) + (gIOLastSleepTime.tv_usec / 1000);
+ _aotMetrics->kernelWakeTime[_aotMetrics->sleepCount - 1]
+ = (((uint64_t) gIOLastWakeTime.tv_sec) << 10) + (gIOLastWakeTime.tv_usec / 1000);
+ }
+
+ if (_aotTestTime) {
+ if (_aotWakeTimeUTC <= secs) {
+ _aotTestTime = _aotTestTime + _aotTestInterval;
+ }
+ setWakeTime(_aotTestTime);
+ }
+ }
+
+#if HIBERNATION
+ LOG("System %sWake\n", gIOHibernateState ? "SafeSleep " : "");
+#endif
+
+ lastSleepReason = 0;
+
+ lastDebugWakeSeconds = _debugWakeSeconds;
+ _debugWakeSeconds = 0;
+ _scheduledAlarmMask = 0;
+ _nextScheduledAlarmType = NULL;
+
+ darkWakeExit = false;
+ darkWakePowerClamped = false;
+ darkWakePostTickle = false;
+ darkWakeHibernateError = false;
+ darkWakeToSleepASAP = true;
+ darkWakeLogClamp = true;
+ sleepTimerMaintenance = false;
+ sleepToStandby = false;
+ wranglerTickled = false;
+ userWasActive = false;
+ isRTCAlarmWake = false;
+ clamshellIgnoreClose = false;
+ fullWakeReason = kFullWakeReasonNone;
+
+#if defined(__i386__) || defined(__x86_64__)
+ kdebugTrace(kPMLogSystemWake, 0, 0, 0);
+
+ OSSharedPtr<OSObject> wakeTypeProp = copyProperty(kIOPMRootDomainWakeTypeKey);
+ OSSharedPtr<OSObject> wakeReasonProp = copyProperty(kIOPMRootDomainWakeReasonKey);
+ OSString * wakeType = OSDynamicCast(OSString, wakeTypeProp.get());
+ OSString * wakeReason = OSDynamicCast(OSString, wakeReasonProp.get());
+
+ if (wakeReason && (wakeReason->getLength() >= 2) &&
+ gWakeReasonString[0] == '\0') {
+ WAKEEVENT_LOCK();
+ // Until the platform driver can claim its wake reasons
+ strlcat(gWakeReasonString, wakeReason->getCStringNoCopy(),
+ sizeof(gWakeReasonString));
+ if (!gWakeReasonSysctlRegistered) {
+ gWakeReasonSysctlRegistered = true;
+ }
+ WAKEEVENT_UNLOCK();
+ }
+
+ if (wakeType && wakeType->isEqualTo(kIOPMrootDomainWakeTypeLowBattery)) {
+ lowBatteryCondition = true;
+ darkWakeMaintenance = true;
+ } else {
+#if HIBERNATION
+ OSSharedPtr<OSObject> hibOptionsProp = copyProperty(kIOHibernateOptionsKey);
+ OSNumber * hibOptions = OSDynamicCast( OSNumber, hibOptionsProp.get());
+ if (hibernateAborted || ((hibOptions &&
+ !(hibOptions->unsigned32BitValue() & kIOHibernateOptionDarkWake)))) {
+ // Hibernate aborted, or EFI brought up graphics
+ darkWakeExit = true;
+ if (hibernateAborted) {
+ DLOG("Hibernation aborted\n");
+ } else {
+ DLOG("EFI brought up graphics. Going to full wake. HibOptions: 0x%x\n", hibOptions->unsigned32BitValue());
+ }
+ } else
+#endif
+ if (wakeType && (
+ wakeType->isEqualTo(kIOPMRootDomainWakeTypeUser) ||
+ wakeType->isEqualTo(kIOPMRootDomainWakeTypeAlarm))) {
+ // User wake or RTC alarm
+ darkWakeExit = true;
+ if (wakeType->isEqualTo(kIOPMRootDomainWakeTypeAlarm)) {
+ isRTCAlarmWake = true;
+ }
+ } else if (wakeType &&
+ wakeType->isEqualTo(kIOPMRootDomainWakeTypeSleepTimer)) {
+ // SMC standby timer trumps SleepX
+ darkWakeMaintenance = true;
+ sleepTimerMaintenance = true;
+ } else if ((lastDebugWakeSeconds != 0) &&
+ ((gDarkWakeFlags & kDarkWakeFlagAlarmIsDark) == 0)) {
+ // SleepX before maintenance
+ darkWakeExit = true;
+ } else if (wakeType &&
+ wakeType->isEqualTo(kIOPMRootDomainWakeTypeMaintenance)) {
+ darkWakeMaintenance = true;
+ } else if (wakeType &&
+ wakeType->isEqualTo(kIOPMRootDomainWakeTypeSleepService)) {
+ darkWakeMaintenance = true;
+ darkWakeSleepService = true;
+#if HIBERNATION
+ if (kIOHibernateStateWakingFromHibernate == gIOHibernateState) {
+ sleepToStandby = true;
+ }
+#endif
+ } else if (wakeType &&
+ wakeType->isEqualTo(kIOPMRootDomainWakeTypeHibernateError)) {
+ darkWakeMaintenance = true;
+ darkWakeHibernateError = true;
+ } else {
+ // Unidentified wake source, resume to full wake if debug
+ // alarm is pending.
+
+ if (lastDebugWakeSeconds &&
+ (!wakeReason || wakeReason->isEqualTo(""))) {
+ darkWakeExit = true;
+ }
+ }
+ }
+
+ if (darkWakeExit) {
+ darkWakeToSleepASAP = false;
+ fullWakeReason = kFullWakeReasonLocalUser;
+ reportUserInput();
+ } else if (displayPowerOnRequested && checkSystemCanSustainFullWake()) {
+ handleSetDisplayPowerOn(true);
+ } else if (!darkWakeMaintenance) {
+ // Early/late tickle for non-maintenance wake.
+ if ((gDarkWakeFlags & kDarkWakeFlagPromotionMask) != kDarkWakeFlagPromotionNone) {
+ darkWakePostTickle = true;
+ }
+ }
+#else /* !__i386__ && !__x86_64__ */
+ timeSinceReset = ml_get_time_since_reset();
+ kdebugTrace(kPMLogSystemWake, 0, (uintptr_t)(timeSinceReset >> 32), (uintptr_t) timeSinceReset);
+
+ if ((gDarkWakeFlags & kDarkWakeFlagPromotionMask) == kDarkWakeFlagPromotionEarly) {
+ wranglerTickled = true;
+ fullWakeReason = kFullWakeReasonLocalUser;
+ requestUserActive(this, "Full wake on dark wake promotion boot-arg");
+ } else if ((lastDebugWakeSeconds != 0) && !(gDarkWakeFlags & kDarkWakeFlagAlarmIsDark)) {
+ isRTCAlarmWake = true;
+ fullWakeReason = kFullWakeReasonLocalUser;
+ requestUserActive(this, "RTC debug alarm");
+ } else {
+#if HIBERNATION
+ OSSharedPtr<OSObject> hibOptionsProp = copyProperty(kIOHibernateOptionsKey);
+ OSNumber * hibOptions = OSDynamicCast(OSNumber, hibOptionsProp.get());
+ if (hibOptions && !(hibOptions->unsigned32BitValue() & kIOHibernateOptionDarkWake)) {
+ fullWakeReason = kFullWakeReasonLocalUser;
+ requestUserActive(this, "hibernate user wake");
+ }
+#endif
+ }
+
+ // stay awake for at least 30 seconds
+ startIdleSleepTimer(30);
+#endif
+ sleepCnt++;
+
+ thread_call_enter(updateConsoleUsersEntry);
+
+ changePowerStateWithTagToPriv(getRUN_STATE(), kCPSReasonWake);
+ break;
+ }
+#if !__i386__ && !__x86_64__
+ case ON_STATE:
+ case AOT_STATE:
+ {
+ DLOG("Force re-evaluating aggressiveness\n");
+ /* Force re-evaluate the aggressiveness values to set appropriate idle sleep timer */
+ pmPowerStateQueue->submitPowerEvent(
+ kPowerEventPolicyStimulus,
+ (void *) kStimulusNoIdleSleepPreventers );
+
+ // After changing to ON_STATE, invalidate any previously queued
+ // request to change to a state less than ON_STATE. This isn't
+ // necessary for AOT_STATE or if the device has only one running
+ // state since the changePowerStateToPriv() issued at the tail
+ // end of SLEEP_STATE case should take care of that.
+ if (getPowerState() == ON_STATE) {
+ changePowerStateWithTagToPriv(ON_STATE, kCPSReasonWake);
+ }
+ break;
+ }
+#endif /* !__i386__ && !__x86_64__ */
+ }
+ notifierThread = NULL;
+}
+
+//******************************************************************************
+// requestPowerDomainState
+//
+// Extend implementation in IOService. Running on PM work loop thread.
+//******************************************************************************
+
+IOReturn
+IOPMrootDomain::requestPowerDomainState(
+ IOPMPowerFlags childDesire,
+ IOPowerConnection * childConnection,
+ unsigned long specification )
+{
+ // Idle and system sleep prevention flags affects driver desire.
+ // Children desire are irrelevant so they are cleared.
+
+ return super::requestPowerDomainState(0, childConnection, specification);
+}
+
+
+static void
+makeSleepPreventersListLog(const OSSharedPtr<OSSet> &preventers, char *buf, size_t buf_size)
+{
+ if (!preventers->getCount()) {
+ return;
+ }
+
+ char *buf_iter = buf + strlen(buf);
+ char *buf_end = buf + buf_size;
+
+ OSSharedPtr<OSCollectionIterator> iterator = OSCollectionIterator::withCollection(preventers.get());
+ OSObject *obj = NULL;
+
+ while ((obj = iterator->getNextObject())) {
+ IOService *srv = OSDynamicCast(IOService, obj);
+ if (buf_iter < buf_end) {
+ buf_iter += snprintf(buf_iter, buf_end - buf_iter, " %s", srv->getName());
+ } else {
+ DLOG("Print buffer exhausted for sleep preventers list\n");
+ break;
+ }
+ }
+}
+
+//******************************************************************************
+// updatePreventIdleSleepList
+//
+// Called by IOService on PM work loop.
+// Returns true if PM policy recognized the driver's desire to prevent idle
+// sleep and updated the list of idle sleep preventers. Returns false otherwise
+//******************************************************************************
+
+bool
+IOPMrootDomain::updatePreventIdleSleepList(
+ IOService * service, bool addNotRemove)
+{
+ unsigned int oldCount;
+
+ oldCount = idleSleepPreventersCount();
+ return updatePreventIdleSleepListInternal(service, addNotRemove, oldCount);
+}
+
+bool
+IOPMrootDomain::updatePreventIdleSleepListInternal(
+ IOService * service, bool addNotRemove, unsigned int oldCount)
+{
+ unsigned int newCount;
+
+ ASSERT_GATED();
+
+#if defined(XNU_TARGET_OS_OSX)
+ // Only the display wrangler and no-idle-sleep kernel assertions
+ // can prevent idle sleep. The kIOPMPreventIdleSleep capability flag
+ // reported by drivers in their power state table is ignored.
+ if (service && (service != wrangler) && (service != this)) {
+ return false;
+ }
+#endif
+
+ if (service) {
+ if (addNotRemove) {
+ preventIdleSleepList->setObject(service);
+ DLOG("Added %s to idle sleep preventers list (Total %u)\n",
+ service->getName(), preventIdleSleepList->getCount());
+ } else if (preventIdleSleepList->member(service)) {
+ preventIdleSleepList->removeObject(service);
+ DLOG("Removed %s from idle sleep preventers list (Total %u)\n",
+ service->getName(), preventIdleSleepList->getCount());
+ }
+
+ if (preventIdleSleepList->getCount()) {
+ char buf[256] = "Idle Sleep Preventers:";
+ makeSleepPreventersListLog(preventIdleSleepList, buf, sizeof(buf));
+ DLOG("%s\n", buf);
+ }
+ }
+
+ newCount = idleSleepPreventersCount();
+
+ if ((oldCount == 0) && (newCount != 0)) {
+ // Driver added to empty prevent list.
+ // Update the driver desire to prevent idle sleep.
+ // Driver desire does not prevent demand sleep.
+
+ changePowerStateWithTagTo(getRUN_STATE(), kCPSReasonIdleSleepPrevent);
+ } else if ((oldCount != 0) && (newCount == 0)) {
+ // Last driver removed from prevent list.
+ // Drop the driver clamp to allow idle sleep.
+
+ changePowerStateWithTagTo(SLEEP_STATE, kCPSReasonIdleSleepAllow);
+ evaluatePolicy( kStimulusNoIdleSleepPreventers );
+ }
+ messageClient(kIOPMMessageIdleSleepPreventers, systemCapabilityNotifier.get(),
+ &newCount, sizeof(newCount));
+
+#if defined(XNU_TARGET_OS_OSX)
+ if (addNotRemove && (service == wrangler) && !checkSystemCanSustainFullWake()) {
+ DLOG("Cannot cancel idle sleep\n");
+ return false; // do not idle-cancel
+ }
+#endif
+
+ return true;
+}
+
+//******************************************************************************
+// startSpinDump
+//******************************************************************************
+
+void
+IOPMrootDomain::startSpinDump(uint32_t spindumpKind)
+{
+ messageClients(kIOPMMessageLaunchBootSpinDump, (void *)(uintptr_t)spindumpKind);
+}
+
+//******************************************************************************
+// preventSystemSleepListUpdate
+//
+// Called by IOService on PM work loop.
+//******************************************************************************
+
+void
+IOPMrootDomain::updatePreventSystemSleepList(
+ IOService * service, bool addNotRemove )
+{
+ unsigned int oldCount, newCount;
+
+ ASSERT_GATED();
+ if (this == service) {
+ return;
+ }
+
+ oldCount = preventSystemSleepList->getCount();
+ if (addNotRemove) {
+ preventSystemSleepList->setObject(service);
+ DLOG("Added %s to system sleep preventers list (Total %u)\n",
+ service->getName(), preventSystemSleepList->getCount());
+ if (!assertOnWakeSecs && gIOLastWakeAbsTime) {
+ AbsoluteTime now;
+ clock_usec_t microsecs;
+ clock_get_uptime(&now);
+ SUB_ABSOLUTETIME(&now, &gIOLastWakeAbsTime);
+ absolutetime_to_microtime(now, &assertOnWakeSecs, µsecs);
+ if (assertOnWakeReport) {
+ HISTREPORT_TALLYVALUE(assertOnWakeReport, (int64_t)assertOnWakeSecs);
+ DLOG("Updated assertOnWake %lu\n", (unsigned long)assertOnWakeSecs);
+ }
+ }
+ } else if (preventSystemSleepList->member(service)) {
+ preventSystemSleepList->removeObject(service);
+ DLOG("Removed %s from system sleep preventers list (Total %u)\n",
+ service->getName(), preventSystemSleepList->getCount());
+
+ if ((oldCount != 0) && (preventSystemSleepList->getCount() == 0)) {
+ // Lost all system sleep preventers.
+ // Send stimulus if system sleep was blocked, and is in dark wake.
+ evaluatePolicy( kStimulusDarkWakeEvaluate );
+ }
+ }
+
+ newCount = preventSystemSleepList->getCount();
+ if (newCount) {
+ char buf[256] = "System Sleep Preventers:";
+ makeSleepPreventersListLog(preventSystemSleepList, buf, sizeof(buf));
+ DLOG("%s\n", buf);
+ }
+
+ messageClient(kIOPMMessageSystemSleepPreventers, systemCapabilityNotifier.get(),
+ &newCount, sizeof(newCount));
+}
+
+void
+IOPMrootDomain::copySleepPreventersList(OSArray **idleSleepList, OSArray **systemSleepList)
+{
+ OSSharedPtr<OSCollectionIterator> iterator;
+ OSObject *object = NULL;
+ OSSharedPtr<OSArray> array;
+
+ if (!gIOPMWorkLoop->inGate()) {
+ gIOPMWorkLoop->runAction(
+ OSMemberFunctionCast(IOWorkLoop::Action, this,
+ &IOPMrootDomain::IOPMrootDomain::copySleepPreventersList),
+ this, (void *)idleSleepList, (void *)systemSleepList);
+ return;
+ }
+
+ if (idleSleepList && preventIdleSleepList && (preventIdleSleepList->getCount() != 0)) {
+ iterator = OSCollectionIterator::withCollection(preventIdleSleepList.get());
+ array = OSArray::withCapacity(5);
+
+ if (iterator && array) {
+ while ((object = iterator->getNextObject())) {
+ IOService *service = OSDynamicCast(IOService, object);
+ if (service) {
+ OSSharedPtr<const OSSymbol> name = service->copyName();
+ if (name) {
+ array->setObject(name.get());
+ }
+ }
+ }
+ }
+ *idleSleepList = array.detach();
+ }
+
+ if (systemSleepList && preventSystemSleepList && (preventSystemSleepList->getCount() != 0)) {
+ iterator = OSCollectionIterator::withCollection(preventSystemSleepList.get());
+ array = OSArray::withCapacity(5);
+
+ if (iterator && array) {
+ while ((object = iterator->getNextObject())) {
+ IOService *service = OSDynamicCast(IOService, object);
+ if (service) {
+ OSSharedPtr<const OSSymbol> name = service->copyName();
+ if (name) {
+ array->setObject(name.get());
+ }
+ }
+ }
+ }
+ *systemSleepList = array.detach();
+ }
+}
+
+void
+IOPMrootDomain::copySleepPreventersListWithID(OSArray **idleSleepList, OSArray **systemSleepList)
+{
+ OSSharedPtr<OSCollectionIterator> iterator;
+ OSObject *object = NULL;
+ OSSharedPtr<OSArray> array;
+
+ if (!gIOPMWorkLoop->inGate()) {
+ gIOPMWorkLoop->runAction(
+ OSMemberFunctionCast(IOWorkLoop::Action, this,
+ &IOPMrootDomain::IOPMrootDomain::copySleepPreventersListWithID),
+ this, (void *)idleSleepList, (void *)systemSleepList);
+ return;
+ }
+
+ if (idleSleepList && preventIdleSleepList && (preventIdleSleepList->getCount() != 0)) {
+ iterator = OSCollectionIterator::withCollection(preventIdleSleepList.get());
+ array = OSArray::withCapacity(5);
+
+ if (iterator && array) {
+ while ((object = iterator->getNextObject())) {
+ IOService *service = OSDynamicCast(IOService, object);
+ if (service) {
+ OSSharedPtr<OSDictionary> dict = OSDictionary::withCapacity(2);
+ OSSharedPtr<const OSSymbol> name = service->copyName();
+ OSSharedPtr<OSNumber> id = OSNumber::withNumber(service->getRegistryEntryID(), 64);
+ if (dict && name && id) {
+ dict->setObject(kIOPMDriverAssertionRegistryEntryIDKey, id.get());
+ dict->setObject(kIOPMDriverAssertionOwnerStringKey, name.get());
+ array->setObject(dict.get());
+ }
+ }
+ }
+ }
+ *idleSleepList = array.detach();
+ }
+
+ if (systemSleepList && preventSystemSleepList && (preventSystemSleepList->getCount() != 0)) {
+ iterator = OSCollectionIterator::withCollection(preventSystemSleepList.get());
+ array = OSArray::withCapacity(5);
+
+ if (iterator && array) {
+ while ((object = iterator->getNextObject())) {
+ IOService *service = OSDynamicCast(IOService, object);
+ if (service) {
+ OSSharedPtr<OSDictionary> dict = OSDictionary::withCapacity(2);
+ OSSharedPtr<const OSSymbol> name = service->copyName();
+ OSSharedPtr<OSNumber> id = OSNumber::withNumber(service->getRegistryEntryID(), 64);
+ if (dict && name && id) {
+ dict->setObject(kIOPMDriverAssertionRegistryEntryIDKey, id.get());
+ dict->setObject(kIOPMDriverAssertionOwnerStringKey, name.get());
+ array->setObject(dict.get());
+ }
+ }
+ }
+ }
+ *systemSleepList = array.detach();
+ }
+}
+
+//******************************************************************************
+// tellChangeDown
+//
+// Override the superclass implementation to send a different message type.
+//******************************************************************************
+
+bool
+IOPMrootDomain::tellChangeDown( unsigned long stateNum )
+{
+ DLOG("tellChangeDown %s->%s\n",
+ getPowerStateString((uint32_t) getPowerState()), getPowerStateString((uint32_t) stateNum));
+
+ if (SLEEP_STATE == stateNum) {
+ // Legacy apps were already told in the full->dark transition
+ if (!ignoreTellChangeDown) {
+ tracePoint( kIOPMTracePointSleepApplications );
+ } else {
+ tracePoint( kIOPMTracePointSleepPriorityClients );
+ }
+ }
+
+ if (!ignoreTellChangeDown) {
+ userActivityAtSleep = userActivityCount;
+ DLOG("tellChangeDown::userActivityAtSleep %d\n", userActivityAtSleep);
+
+ if (SLEEP_STATE == stateNum) {
+ hibernateAborted = false;
+
+ // Direct callout into OSKext so it can disable kext unloads
+ // during sleep/wake to prevent deadlocks.
+ OSKextSystemSleepOrWake( kIOMessageSystemWillSleep );
+
+ IOService::updateConsoleUsers(NULL, kIOMessageSystemWillSleep);
+
+ // Two change downs are sent by IOServicePM. Ignore the 2nd.
+ // But tellClientsWithResponse() must be called for both.
+ ignoreTellChangeDown = true;
+ }
+ }
+
+ return super::tellClientsWithResponse( kIOMessageSystemWillSleep );
+}
+
+//******************************************************************************
+// askChangeDown
+//
+// Override the superclass implementation to send a different message type.
+// This must be idle sleep since we don't ask during any other power change.
+//******************************************************************************
+
+bool
+IOPMrootDomain::askChangeDown( unsigned long stateNum )
+{
+ DLOG("askChangeDown %s->%s\n",
+ getPowerStateString((uint32_t) getPowerState()), getPowerStateString((uint32_t) stateNum));
+
+ // Don't log for dark wake entry
+ if (kSystemTransitionSleep == _systemTransitionType) {
+ tracePoint( kIOPMTracePointSleepApplications );
+ }
+
+ return super::tellClientsWithResponse( kIOMessageCanSystemSleep );
+}
+
+//******************************************************************************
+// askChangeDownDone
+//
+// An opportunity for root domain to cancel the power transition,
+// possibily due to an assertion created by powerd in response to
+// kIOMessageCanSystemSleep.
+//
+// Idle sleep:
+// full -> dark wake transition
+// 1. Notify apps and powerd with kIOMessageCanSystemSleep
+// 2. askChangeDownDone()
+// dark -> sleep transition
+// 1. Notify powerd with kIOMessageCanSystemSleep
+// 2. askChangeDownDone()
+//
+// Demand sleep:
+// full -> dark wake transition
+// 1. Notify powerd with kIOMessageCanSystemSleep
+// 2. askChangeDownDone()
+// dark -> sleep transition
+// 1. Notify powerd with kIOMessageCanSystemSleep
+// 2. askChangeDownDone()
+//******************************************************************************
+
+void
+IOPMrootDomain::askChangeDownDone(
+ IOPMPowerChangeFlags * inOutChangeFlags, bool * cancel )
+{
+ DLOG("askChangeDownDone(0x%x, %u) type %x, cap %x->%x\n",
+ *inOutChangeFlags, *cancel,
+ _systemTransitionType,
+ _currentCapability, _pendingCapability);
+
+ if ((false == *cancel) && (kSystemTransitionSleep == _systemTransitionType)) {
+ // Dark->Sleep transition.
+ // Check if there are any deny sleep assertions.
+ // lastSleepReason already set by handleOurPowerChangeStart()
+
+ if (!checkSystemCanSleep(lastSleepReason)) {
+ // Cancel dark wake to sleep transition.
+ // Must re-scan assertions upon entering dark wake.
+
+ *cancel = true;
+ DLOG("cancel dark->sleep\n");
+ }
+ if (_aotMode && (kPMCalendarTypeInvalid != _aotWakeTimeCalendar.selector)) {
+ uint64_t now = mach_continuous_time();
+ if (((now + _aotWakePreWindow) >= _aotWakeTimeContinuous)
+ && (now < (_aotWakeTimeContinuous + _aotWakePostWindow))) {
+ *cancel = true;
+ IOLog("AOT wake window cancel: %qd, %qd\n", now, _aotWakeTimeContinuous);
+ }
+ }
+ }
+}
+
+//******************************************************************************
+// systemDidNotSleep
+//
+// Work common to both canceled or aborted sleep.
+//******************************************************************************
+
+void
+IOPMrootDomain::systemDidNotSleep( void )
+{
+ // reset console lock state
+ thread_call_enter(updateConsoleUsersEntry);
+
+ if (idleSleepEnabled) {
+ if (!wrangler) {
+#if defined(XNU_TARGET_OS_OSX) && !DISPLAY_WRANGLER_PRESENT
+ startIdleSleepTimer(kIdleSleepRetryInterval);
+#else
+ startIdleSleepTimer(idleSeconds);
+#endif
+ } else if (!userIsActive) {
+ // Manually start the idle sleep timer besides waiting for
+ // the user to become inactive.
+ startIdleSleepTimer(kIdleSleepRetryInterval);
+ }
+ }
+
+ preventTransitionToUserActive(false);
+ IOService::setAdvisoryTickleEnable( true );
+
+ // After idle revert and cancel, send a did-change message to powerd
+ // to balance the previous will-change message. Kernel clients do not
+ // need this since sleep cannot be canceled once they are notified.
+
+ if (toldPowerdCapWillChange && systemCapabilityNotifier &&
+ (_pendingCapability != _currentCapability) &&
+ ((_systemMessageClientMask & kSystemMessageClientPowerd) != 0)) {
+ // Differs from a real capability gain change where notifyRef != 0,
+ // but it is zero here since no response is expected.
+
+ IOPMSystemCapabilityChangeParameters params;
+
+ bzero(¶ms, sizeof(params));
+ params.fromCapabilities = _pendingCapability;
+ params.toCapabilities = _currentCapability;
+ params.changeFlags = kIOPMSystemCapabilityDidChange;
+
+ DLOG("MESG cap %x->%x did change\n",
+ params.fromCapabilities, params.toCapabilities);
+ messageClient(kIOMessageSystemCapabilityChange, systemCapabilityNotifier.get(),
+ ¶ms, sizeof(params));
+ }
+}
+
+//******************************************************************************
+// tellNoChangeDown
+//
+// Notify registered applications and kernel clients that we are not dropping
+// power.
+//
+// We override the superclass implementation so we can send a different message
+// type to the client or application being notified.
+//
+// This must be a vetoed idle sleep, since no other power change can be vetoed.
+//******************************************************************************
+
+void
+IOPMrootDomain::tellNoChangeDown( unsigned long stateNum )
+{
+ DLOG("tellNoChangeDown %s->%s\n",
+ getPowerStateString((uint32_t) getPowerState()), getPowerStateString((uint32_t) stateNum));
+
+ // Sleep canceled, clear the sleep trace point.
+ tracePoint(kIOPMTracePointSystemUp);
+
+ systemDidNotSleep();
+ return tellClients( kIOMessageSystemWillNotSleep );
+}
+
+//******************************************************************************
+// tellChangeUp
+//
+// Notify registered applications and kernel clients that we are raising power.
+//
+// We override the superclass implementation so we can send a different message
+// type to the client or application being notified.
+//******************************************************************************
+
+void
+IOPMrootDomain::tellChangeUp( unsigned long stateNum )
+{
+ DLOG("tellChangeUp %s->%s\n",
+ getPowerStateString((uint32_t) getPowerState()), getPowerStateString((uint32_t) stateNum));
+
+ ignoreTellChangeDown = false;
+
+ if (stateNum == ON_STATE) {
+ // Direct callout into OSKext so it can disable kext unloads
+ // during sleep/wake to prevent deadlocks.
+ OSKextSystemSleepOrWake( kIOMessageSystemHasPoweredOn );
+
+ // Notify platform that sleep was cancelled or resumed.
+ getPlatform()->callPlatformFunction(
+ sleepMessagePEFunction.get(), false,
+ (void *)(uintptr_t) kIOMessageSystemHasPoweredOn,
+ NULL, NULL, NULL);
+
+ if (getPowerState() == ON_STATE) {
+ // Sleep was cancelled by idle cancel or revert
+ if (!CAP_CURRENT(kIOPMSystemCapabilityGraphics)) {
+ // rdar://problem/50363791
+ // If system is in dark wake and sleep is cancelled, do not
+ // send SystemWillPowerOn/HasPoweredOn messages to kernel
+ // priority clients. They haven't yet seen a SystemWillSleep
+ // message before the cancellation. So make sure the kernel
+ // client bit is cleared in _systemMessageClientMask before
+ // invoking the tellClients() below. This bit may have been
+ // set by handleOurPowerChangeStart() anticipating a successful
+ // sleep and setting the filter mask ahead of time allows the
+ // SystemWillSleep message to go through.
+ _systemMessageClientMask &= ~kSystemMessageClientKernel;
+ }
+
+ systemDidNotSleep();
+ tellClients( kIOMessageSystemWillPowerOn );
+ }
+
+ tracePoint( kIOPMTracePointWakeApplications );
+ tellClients( kIOMessageSystemHasPoweredOn );
+ }
+}
+
+#define CAP_WILL_CHANGE_TO_OFF(params, flag) \
+ (((params)->changeFlags & kIOPMSystemCapabilityWillChange) && \
+ ((params)->fromCapabilities & (flag)) && \
+ (((params)->toCapabilities & (flag)) == 0))
+
+#define CAP_DID_CHANGE_TO_ON(params, flag) \
+ (((params)->changeFlags & kIOPMSystemCapabilityDidChange) && \
+ ((params)->toCapabilities & (flag)) && \
+ (((params)->fromCapabilities & (flag)) == 0))
+
+#define CAP_DID_CHANGE_TO_OFF(params, flag) \
+ (((params)->changeFlags & kIOPMSystemCapabilityDidChange) && \
+ ((params)->fromCapabilities & (flag)) && \
+ (((params)->toCapabilities & (flag)) == 0))
+
+#define CAP_WILL_CHANGE_TO_ON(params, flag) \
+ (((params)->changeFlags & kIOPMSystemCapabilityWillChange) && \
+ ((params)->toCapabilities & (flag)) && \
+ (((params)->fromCapabilities & (flag)) == 0))
+
+//******************************************************************************
+// sysPowerDownHandler
+//
+// Perform a vfs sync before system sleep.
+//******************************************************************************
+
+IOReturn
+IOPMrootDomain::sysPowerDownHandler(
+ void * target, void * refCon,
+ UInt32 messageType, IOService * service,
+ void * messageArgs, vm_size_t argSize )
+{
+ static UInt32 lastSystemMessageType = 0;
+ IOReturn ret = 0;
+
+ DLOG("sysPowerDownHandler message %s\n", getIOMessageString(messageType));
+
+ // rdar://problem/50363791
+ // Sanity check to make sure the SystemWill/Has message types are
+ // received in the expected order for all kernel priority clients.
+ if (messageType == kIOMessageSystemWillSleep ||
+ messageType == kIOMessageSystemWillPowerOn ||
+ messageType == kIOMessageSystemHasPoweredOn) {
+ switch (messageType) {
+ case kIOMessageSystemWillPowerOn:
+ assert(lastSystemMessageType == kIOMessageSystemWillSleep);
+ break;
+ case kIOMessageSystemHasPoweredOn:
+ assert(lastSystemMessageType == kIOMessageSystemWillPowerOn);
+ break;
+ }
+
+ lastSystemMessageType = messageType;
+ }
+
+ if (!gRootDomain) {
+ return kIOReturnUnsupported;
+ }
+
+ if (messageType == kIOMessageSystemCapabilityChange) {
+ IOPMSystemCapabilityChangeParameters * params =
+ (IOPMSystemCapabilityChangeParameters *) messageArgs;
+
+ // Interested applications have been notified of an impending power
+ // change and have acked (when applicable).
+ // This is our chance to save whatever state we can before powering
+ // down.
+ // We call sync_internal defined in xnu/bsd/vfs/vfs_syscalls.c,
+ // via callout
+
+ DLOG("sysPowerDownHandler cap %x -> %x (flags %x)\n",
+ params->fromCapabilities, params->toCapabilities,
+ params->changeFlags);
+
+ if (CAP_WILL_CHANGE_TO_OFF(params, kIOPMSystemCapabilityCPU)) {
+ // We will ack within 20 seconds
+ params->maxWaitForReply = 20 * 1000 * 1000;
+
+#if HIBERNATION
+ gRootDomain->evaluateSystemSleepPolicyEarly();
+
+ // add in time we could spend freeing pages
+ if (gRootDomain->hibernateMode && !gRootDomain->hibernateDisabled) {
+ params->maxWaitForReply = kCapabilityClientMaxWait;
+ }
+ DLOG("sysPowerDownHandler max wait %d s\n",
+ (int) (params->maxWaitForReply / 1000 / 1000));
+#endif
+
+ // Notify platform that sleep has begun, after the early
+ // sleep policy evaluation.
+ getPlatform()->callPlatformFunction(
+ sleepMessagePEFunction.get(), false,
+ (void *)(uintptr_t) kIOMessageSystemWillSleep,
+ NULL, NULL, NULL);
+
+ if (!OSCompareAndSwap( 0, 1, &gSleepOrShutdownPending )) {
+ // Purposely delay the ack and hope that shutdown occurs quickly.
+ // Another option is not to schedule the thread and wait for
+ // ack timeout...
+ AbsoluteTime deadline;
+ clock_interval_to_deadline( 30, kSecondScale, &deadline );
+ thread_call_enter1_delayed(
+ gRootDomain->diskSyncCalloutEntry,
+ (thread_call_param_t)(uintptr_t) params->notifyRef,
+ deadline );
+ } else {
+ thread_call_enter1(
+ gRootDomain->diskSyncCalloutEntry,
+ (thread_call_param_t)(uintptr_t) params->notifyRef);
+ }
+ }
+#if HIBERNATION
+ else if (CAP_DID_CHANGE_TO_ON(params, kIOPMSystemCapabilityCPU)) {
+ // We will ack within 110 seconds
+ params->maxWaitForReply = 110 * 1000 * 1000;
+
+ thread_call_enter1(
+ gRootDomain->diskSyncCalloutEntry,
+ (thread_call_param_t)(uintptr_t) params->notifyRef);
+ }
+#endif
+ ret = kIOReturnSuccess;
+ }
+
+ return ret;
+}
+
+//******************************************************************************
+// handleQueueSleepWakeUUID
+//
+// Called from IOPMrootDomain when we're initiating a sleep,
+// or indirectly from PM configd when PM decides to clear the UUID.
+// PM clears the UUID several minutes after successful wake from sleep,
+// so that we might associate App spindumps with the immediately previous
+// sleep/wake.
+//
+// @param obj has a retain on it. We're responsible for releasing that retain.
+//******************************************************************************
+
+void
+IOPMrootDomain::handleQueueSleepWakeUUID(OSObject *obj)
+{
+ OSSharedPtr<OSString> str;
+
+ if (kOSBooleanFalse == obj) {
+ handlePublishSleepWakeUUID(false);
+ } else {
+ str.reset(OSDynamicCast(OSString, obj), OSNoRetain);
+ if (str) {
+ // This branch caches the UUID for an upcoming sleep/wake
+ queuedSleepWakeUUIDString = str;
+ DLOG("SleepWake UUID queued: %s\n", queuedSleepWakeUUIDString->getCStringNoCopy());
+ }
+ }
+}
+//******************************************************************************
+// handlePublishSleepWakeUUID
+//
+// Called from IOPMrootDomain when we're initiating a sleep,
+// or indirectly from PM configd when PM decides to clear the UUID.
+// PM clears the UUID several minutes after successful wake from sleep,
+// so that we might associate App spindumps with the immediately previous
+// sleep/wake.
+//******************************************************************************
+
+void
+IOPMrootDomain::handlePublishSleepWakeUUID( bool shouldPublish )
+{
+ ASSERT_GATED();
+
+ /*
+ * Clear the current UUID
+ */
+ if (gSleepWakeUUIDIsSet) {
+ DLOG("SleepWake UUID cleared\n");
+
+ gSleepWakeUUIDIsSet = false;
+
+ removeProperty(kIOPMSleepWakeUUIDKey);
+ messageClients(kIOPMMessageSleepWakeUUIDChange, kIOPMMessageSleepWakeUUIDCleared);
+ }
+
+ /*
+ * Optionally, publish a new UUID
+ */
+ if (queuedSleepWakeUUIDString && shouldPublish) {
+ OSSharedPtr<OSString> publishThisUUID;
+
+ publishThisUUID = queuedSleepWakeUUIDString;
+
+ if (publishThisUUID) {
+ setProperty(kIOPMSleepWakeUUIDKey, publishThisUUID.get());
+ }
+
+ gSleepWakeUUIDIsSet = true;
+ messageClients(kIOPMMessageSleepWakeUUIDChange, kIOPMMessageSleepWakeUUIDSet);
+
+ queuedSleepWakeUUIDString.reset();
+ }
+}
+
+//******************************************************************************
+// IOPMGetSleepWakeUUIDKey
+//
+// Return the truth value of gSleepWakeUUIDIsSet and optionally copy the key.
+// To get the full key -- a C string -- the buffer must large enough for
+// the end-of-string character.
+// The key is expected to be an UUID string
+//******************************************************************************
+
+extern "C" bool
+IOPMCopySleepWakeUUIDKey(char *buffer, size_t buf_len)
+{
+ if (!gSleepWakeUUIDIsSet) {
+ return false;
+ }
+
+ if (buffer != NULL) {
+ OSSharedPtr<OSString> string =
+ OSDynamicPtrCast<OSString>(gRootDomain->copyProperty(kIOPMSleepWakeUUIDKey));
+
+ if (!string) {
+ *buffer = '\0';
+ } else {
+ strlcpy(buffer, string->getCStringNoCopy(), buf_len);
+ }
+ }
+
+ return true;
+}
+
+//******************************************************************************
+// lowLatencyAudioNotify
+//
+// Used to send an update about low latency audio activity to interested
+// clients. To keep the overhead minimal the OSDictionary used here
+// is initialized at boot.
+//******************************************************************************
+
+void
+IOPMrootDomain::lowLatencyAudioNotify(uint64_t time, boolean_t state)
+{
+ if (lowLatencyAudioNotifierDict && lowLatencyAudioNotifyStateSym && lowLatencyAudioNotifyTimestampSym &&
+ lowLatencyAudioNotifyStateVal && lowLatencyAudioNotifyTimestampVal) {
+ lowLatencyAudioNotifyTimestampVal->setValue(time);
+ lowLatencyAudioNotifyStateVal->setValue(state);
+ setPMSetting(gIOPMSettingLowLatencyAudioModeKey.get(), lowLatencyAudioNotifierDict.get());
+ } else {
+ DLOG("LowLatencyAudioNotify error\n");
+ }
+ return;
+}
+
+//******************************************************************************
+// IOPMrootDomainRTNotifier
+//
+// Used by performance controller to update the timestamp and state associated
+// with low latency audio activity in the system.
+//******************************************************************************
+
+extern "C" void
+IOPMrootDomainRTNotifier(uint64_t time, boolean_t state)
+{
+ gRootDomain->lowLatencyAudioNotify(time, state);
+ return;
+}
+
+//******************************************************************************
+// initializeBootSessionUUID
+//
+// Initialize the boot session uuid at boot up and sets it into registry.
+//******************************************************************************
+
+void
+IOPMrootDomain::initializeBootSessionUUID(void)
+{
+ uuid_t new_uuid;
+ uuid_string_t new_uuid_string;
+
+ uuid_generate(new_uuid);
+ uuid_unparse_upper(new_uuid, new_uuid_string);
+ memcpy(bootsessionuuid_string, new_uuid_string, sizeof(uuid_string_t));
+
+ setProperty(kIOPMBootSessionUUIDKey, new_uuid_string);
+}
+
+//******************************************************************************
+// Root domain uses the private and tagged changePowerState methods for
+// tracking and logging purposes.
+//******************************************************************************
+
+#define REQUEST_TAG_TO_REASON(x) ((uint16_t)x)
+
+static uint32_t
+nextRequestTag( IOPMRequestTag tag )
+{
+ static SInt16 msb16 = 1;
+ uint16_t id = OSAddAtomic16(1, &msb16);
+ return ((uint32_t)id << 16) | REQUEST_TAG_TO_REASON(tag);
+}
+
+// TODO: remove this shim function and exported symbol
+IOReturn
+IOPMrootDomain::changePowerStateTo( unsigned long ordinal )
+{
+ return changePowerStateWithTagTo(ordinal, kCPSReasonNone);
+}
+
+// TODO: remove this shim function and exported symbol
+IOReturn
+IOPMrootDomain::changePowerStateToPriv( unsigned long ordinal )
+{
+ return changePowerStateWithTagToPriv(ordinal, kCPSReasonNone);
+}
+
+IOReturn
+IOPMrootDomain::changePowerStateWithOverrideTo(
+ IOPMPowerStateIndex ordinal, IOPMRequestTag reason )
+{
+ uint32_t tag = nextRequestTag(reason);
+ DLOG("%s(%s, %x)\n", __FUNCTION__, getPowerStateString((uint32_t) ordinal), tag);
+
+ if ((ordinal != ON_STATE) && (ordinal != AOT_STATE) && (ordinal != SLEEP_STATE)) {
+ return kIOReturnUnsupported;
+ }
+
+ return super::changePowerStateWithOverrideTo(ordinal, tag);
+}
+
+IOReturn
+IOPMrootDomain::changePowerStateWithTagTo(
+ IOPMPowerStateIndex ordinal, IOPMRequestTag reason )
+{
+ uint32_t tag = nextRequestTag(reason);
+ DLOG("%s(%s, %x)\n", __FUNCTION__, getPowerStateString((uint32_t) ordinal), tag);
+
+ if ((ordinal != ON_STATE) && (ordinal != AOT_STATE) && (ordinal != SLEEP_STATE)) {
+ return kIOReturnUnsupported;
+ }
+
+ return super::changePowerStateWithTagTo(ordinal, tag);
+}
+
+IOReturn
+IOPMrootDomain::changePowerStateWithTagToPriv(
+ IOPMPowerStateIndex ordinal, IOPMRequestTag reason )
+{
+ uint32_t tag = nextRequestTag(reason);
+ DLOG("%s(%s, %x)\n", __FUNCTION__, getPowerStateString((uint32_t) ordinal), tag);
+
+ if ((ordinal != ON_STATE) && (ordinal != AOT_STATE) && (ordinal != SLEEP_STATE)) {
+ return kIOReturnUnsupported;
+ }
+
+ return super::changePowerStateWithTagToPriv(ordinal, tag);
+}
+
+//******************************************************************************
+// activity detect
+//
+//******************************************************************************
+
+bool
+IOPMrootDomain::activitySinceSleep(void)
+{
+ return userActivityCount != userActivityAtSleep;
+}
+
+bool
+IOPMrootDomain::abortHibernation(void)
+{
+#if __arm64__
+ // don't allow hibernation to be aborted on ARM due to user activity
+ // since once ApplePMGR decides we're hibernating, we can't turn back
+ // see: <rdar://problem/63848862> Tonga ApplePMGR diff quiesce path support
+ return false;
+#else
+ bool ret = activitySinceSleep();
+
+ if (ret && !hibernateAborted && checkSystemCanSustainFullWake()) {
+ DLOG("activitySinceSleep ABORT [%d, %d]\n", userActivityCount, userActivityAtSleep);
+ hibernateAborted = true;
+ }
+ return ret;
+#endif
+}
+
+extern "C" int
+hibernate_should_abort(void)
+{
+ if (gRootDomain) {
+ return gRootDomain->abortHibernation();
+ } else {
+ return 0;
+ }
+}
+
+//******************************************************************************
+// willNotifyPowerChildren
+//
+// Called after all interested drivers have all acknowledged the power change,
+// but before any power children is informed. Dispatched though a thread call,
+// so it is safe to perform work that might block on a sleeping disk. PM state
+// machine (not thread) will block w/o timeout until this function returns.
+//******************************************************************************
+
+void
+IOPMrootDomain::willNotifyPowerChildren( IOPMPowerStateIndex newPowerState )
+{
+ OSSharedPtr<OSDictionary> dict;
+ OSSharedPtr<OSNumber> secs;
+
+ if (SLEEP_STATE == newPowerState) {
+ notifierThread = current_thread();
+ if (!tasksSuspended) {
+ AbsoluteTime deadline;
+ tasksSuspended = TRUE;
+ updateTasksSuspend();
+
+ clock_interval_to_deadline(10, kSecondScale, &deadline);
+#if defined(XNU_TARGET_OS_OSX)
+ vm_pageout_wait(AbsoluteTime_to_scalar(&deadline));
+#endif /* defined(XNU_TARGET_OS_OSX) */
+ }
+
+ _aotReadyToFullWake = false;
+#if 0
+ if (_aotLingerTime) {
+ uint64_t deadline;
+ IOLog("aot linger no return\n");
+ clock_absolutetime_interval_to_deadline(_aotLingerTime, &deadline);
+ clock_delay_until(deadline);
+ }
+#endif
+ if (!_aotMode) {
+ _aotTestTime = 0;
+ _aotWakeTimeCalendar.selector = kPMCalendarTypeInvalid;
+ if (_aotMetrics) {
+ bzero(_aotMetrics, sizeof(IOPMAOTMetrics));
+ }
+ } else if (!_aotNow && !_debugWakeSeconds) {
+ _aotNow = true;
+ _aotExit = false;
+ _aotPendingFlags = 0;
+ _aotTasksSuspended = true;
+ _aotLastWakeTime = 0;
+ bzero(_aotMetrics, sizeof(IOPMAOTMetrics));
+ if (kIOPMAOTModeCycle & _aotMode) {
+ clock_interval_to_absolutetime_interval(60, kSecondScale, &_aotTestInterval);
+ _aotTestTime = mach_continuous_time() + _aotTestInterval;
+ setWakeTime(_aotTestTime);
+ }
+ uint32_t lingerSecs;
+ if (!PE_parse_boot_argn("aotlinger", &lingerSecs, sizeof(lingerSecs))) {
+ lingerSecs = 0;
+ }
+ clock_interval_to_absolutetime_interval(lingerSecs, kSecondScale, &_aotLingerTime);
+ clock_interval_to_absolutetime_interval(2000, kMillisecondScale, &_aotWakePreWindow);
+ clock_interval_to_absolutetime_interval(1100, kMillisecondScale, &_aotWakePostWindow);
+ }
+
+#if HIBERNATION
+ IOHibernateSystemSleep();
+ IOHibernateIOKitSleep();
+#endif
+ if (gRootDomain->activitySinceSleep()) {
+ dict = OSDictionary::withCapacity(1);
+ secs = OSNumber::withNumber(1, 32);
+
+ if (dict && secs) {
+ dict->setObject(gIOPMSettingDebugWakeRelativeKey.get(), secs.get());
+ gRootDomain->setProperties(dict.get());
+ MSG("Reverting sleep with relative wake\n");
+ }
+ }
+
+ notifierThread = NULL;
+ }
+}
+
+//******************************************************************************
+// willTellSystemCapabilityDidChange
+//
+// IOServicePM calls this from OurChangeTellCapabilityDidChange() when root
+// domain is raising its power state, immediately after notifying interested
+// drivers and power children.
+//******************************************************************************
+
+void
+IOPMrootDomain::willTellSystemCapabilityDidChange( void )
+{
+ if ((_systemTransitionType == kSystemTransitionWake) &&
+ !CAP_GAIN(kIOPMSystemCapabilityGraphics)) {
+ // After powering up drivers, dark->full promotion on the current wake
+ // transition is no longer possible. That is because the next machine
+ // state will issue the system capability change messages.
+ // The darkWakePowerClamped flag may already be set if the system has
+ // at least one driver that was power clamped due to dark wake.
+ // This function sets the darkWakePowerClamped flag in case there
+ // is no power-clamped driver in the system.
+ //
+ // Last opportunity to exit dark wake using:
+ // requestFullWake( kFullWakeReasonLocalUser );
+
+ if (!darkWakePowerClamped) {
+ if (darkWakeLogClamp) {
+ AbsoluteTime now;
+ uint64_t nsec;
+
+ clock_get_uptime(&now);
+ SUB_ABSOLUTETIME(&now, &gIOLastWakeAbsTime);
+ absolutetime_to_nanoseconds(now, &nsec);
+ DLOG("dark wake promotion disabled at %u ms\n",
+ ((int)((nsec) / NSEC_PER_MSEC)));
+ }
+ darkWakePowerClamped = true;
+ }
+ }
+}
+
+//******************************************************************************
+// sleepOnClamshellClosed
+//
+// contains the logic to determine if the system should sleep when the clamshell
+// is closed.
+//******************************************************************************
+
+bool
+IOPMrootDomain::shouldSleepOnClamshellClosed( void )
+{
+ if (!clamshellExists) {
+ return false;
+ }
+
+ DLOG("clamshell closed %d, disabled %d/%x, desktopMode %d, ac %d\n",
+ clamshellClosed, clamshellDisabled, clamshellSleepDisableMask, desktopMode, acAdaptorConnected);
+
+ return !clamshellDisabled && !(desktopMode && acAdaptorConnected) && !clamshellSleepDisableMask;
+}
+
+bool
+IOPMrootDomain::shouldSleepOnRTCAlarmWake( void )
+{
+ // Called once every RTC/Alarm wake. Device should go to sleep if on clamshell
+ // closed && battery
+ if (!clamshellExists) {
+ return false;
+ }
+
+ DLOG("shouldSleepOnRTCAlarmWake: clamshell closed %d, disabled %d/%x, desktopMode %d, ac %d\n",
+ clamshellClosed, clamshellDisabled, clamshellSleepDisableMask, desktopMode, acAdaptorConnected);
+
+ return !acAdaptorConnected && !clamshellSleepDisableMask;
+}
+
+void
+IOPMrootDomain::sendClientClamshellNotification( void )
+{
+ /* Only broadcast clamshell alert if clamshell exists. */
+ if (!clamshellExists) {
+ return;
+ }
+
+ setProperty(kAppleClamshellStateKey,
+ clamshellClosed ? kOSBooleanTrue : kOSBooleanFalse);
+
+ setProperty(kAppleClamshellCausesSleepKey,
+ shouldSleepOnClamshellClosed() ? kOSBooleanTrue : kOSBooleanFalse);
+
+ /* Argument to message is a bitfiel of
+ * ( kClamshellStateBit | kClamshellSleepBit )
+ */
+ messageClients(kIOPMMessageClamshellStateChange,
+ (void *)(uintptr_t) ((clamshellClosed ? kClamshellStateBit : 0)
+ | (shouldSleepOnClamshellClosed() ? kClamshellSleepBit : 0)));
+}
+
+//******************************************************************************
+// getSleepSupported
+//
+// Deprecated
+//******************************************************************************
+
+IOOptionBits
+IOPMrootDomain::getSleepSupported( void )
+{
+ return platformSleepSupport;
+}
+
+//******************************************************************************
+// setSleepSupported
+//
+// Deprecated
+//******************************************************************************
+
+void
+IOPMrootDomain::setSleepSupported( IOOptionBits flags )
+{
+ DLOG("setSleepSupported(%x)\n", (uint32_t) flags);
+ OSBitOrAtomic(flags, &platformSleepSupport);
+}
+
+//******************************************************************************
+// setClamShellSleepDisable
+//
+//******************************************************************************
+
+void
+IOPMrootDomain::setClamShellSleepDisable( bool disable, uint32_t bitmask )
+{
+ uint32_t oldMask;
+
+ // User client calls this in non-gated context
+ if (gIOPMWorkLoop->inGate() == false) {
+ gIOPMWorkLoop->runAction(
+ OSMemberFunctionCast(IOWorkLoop::Action, this,
+ &IOPMrootDomain::setClamShellSleepDisable),
+ (OSObject *) this,
+ (void *) disable, (void *)(uintptr_t) bitmask);
+ return;
+ }
+
+ oldMask = clamshellSleepDisableMask;
+ if (disable) {
+ clamshellSleepDisableMask |= bitmask;
+ } else {
+ clamshellSleepDisableMask &= ~bitmask;
+ }
+ DLOG("setClamShellSleepDisable(%x->%x)\n", oldMask, clamshellSleepDisableMask);
+
+ if (clamshellExists && clamshellClosed &&
+ (clamshellSleepDisableMask != oldMask) &&
+ (clamshellSleepDisableMask == 0)) {
+ handlePowerNotification(kLocalEvalClamshellCommand);
+ }
+}
+
+//******************************************************************************
+// wakeFromDoze
+//
+// Deprecated.
+//******************************************************************************
+
+void
+IOPMrootDomain::wakeFromDoze( void )
+{
+ // Preserve symbol for familes (IOUSBFamily and IOGraphics)
+}
+
+//******************************************************************************
+// recordRTCAlarm
+//
+// Record the earliest scheduled RTC alarm to determine whether a RTC wake
+// should be a dark wake or a full wake. Both Maintenance and SleepService
+// alarms are dark wake, while AutoWake (WakeByCalendarDate) and DebugWake
+// (WakeRelativeToSleep) should trigger a full wake. Scheduled power-on
+// PMSettings are ignored.
+//
+// Caller serialized using settingsCtrlLock.
+//******************************************************************************
+
+void
+IOPMrootDomain::recordRTCAlarm(
+ const OSSymbol *type,
+ OSObject *object )
+{
+ uint32_t previousAlarmMask = _scheduledAlarmMask;
+
+ if (type == gIOPMSettingDebugWakeRelativeKey) {
+ OSNumber * n = OSDynamicCast(OSNumber, object);
+ if (n) {
+ // Debug wake has highest scheduling priority so it overrides any
+ // pre-existing alarm.
+ uint32_t debugSecs = n->unsigned32BitValue();
+ _nextScheduledAlarmType.reset(type, OSRetain);
+ _nextScheduledAlarmUTC = debugSecs;
+
+ _debugWakeSeconds = debugSecs;
+ OSBitOrAtomic(kIOPMAlarmBitDebugWake, &_scheduledAlarmMask);
+ DLOG("next alarm (%s) in %u secs\n",
+ type->getCStringNoCopy(), debugSecs);
+ }
+ } else if ((type == gIOPMSettingAutoWakeCalendarKey.get()) ||
+ (type == gIOPMSettingMaintenanceWakeCalendarKey.get()) ||
+ (type == gIOPMSettingSleepServiceWakeCalendarKey.get())) {
+ OSData * data = OSDynamicCast(OSData, object);
+ if (data && (data->getLength() == sizeof(IOPMCalendarStruct))) {
+ const IOPMCalendarStruct * cs;
+ bool replaceNextAlarm = false;
+ clock_sec_t secs;
+
+ cs = (const IOPMCalendarStruct *) data->getBytesNoCopy();
+ secs = IOPMConvertCalendarToSeconds(cs);
+ DLOG("%s " YMDTF "\n", type->getCStringNoCopy(), YMDT(cs));
+
+ // Update the next scheduled alarm type
+ if ((_nextScheduledAlarmType == NULL) ||
+ ((_nextScheduledAlarmType != gIOPMSettingDebugWakeRelativeKey) &&
+ (secs < _nextScheduledAlarmUTC))) {
+ replaceNextAlarm = true;
+ }
+
+ if (type == gIOPMSettingAutoWakeCalendarKey.get()) {
+ if (cs->year) {
+ _calendarWakeAlarmUTC = IOPMConvertCalendarToSeconds(cs);
+ OSBitOrAtomic(kIOPMAlarmBitCalendarWake, &_scheduledAlarmMask);
+ } else {
+ // TODO: can this else-block be removed?
+ _calendarWakeAlarmUTC = 0;
+ OSBitAndAtomic(~kIOPMAlarmBitCalendarWake, &_scheduledAlarmMask);
+ }
+ }
+ if (type == gIOPMSettingMaintenanceWakeCalendarKey.get()) {
+ OSBitOrAtomic(kIOPMAlarmBitMaintenanceWake, &_scheduledAlarmMask);
+ }
+ if (type == gIOPMSettingSleepServiceWakeCalendarKey.get()) {
+ OSBitOrAtomic(kIOPMAlarmBitSleepServiceWake, &_scheduledAlarmMask);
+ }
+
+ if (replaceNextAlarm) {
+ _nextScheduledAlarmType.reset(type, OSRetain);
+ _nextScheduledAlarmUTC = secs;
+ DLOG("next alarm (%s) " YMDTF "\n", type->getCStringNoCopy(), YMDT(cs));
+ }
+ }
+ }
+
+ if (_scheduledAlarmMask != previousAlarmMask) {
+ DLOG("scheduled alarm mask 0x%x\n", (uint32_t) _scheduledAlarmMask);
+ }
+}
+
+// MARK: -
+// MARK: Features
+
+//******************************************************************************
+// publishFeature
+//
+// Adds a new feature to the supported features dictionary
+//******************************************************************************
+
+void
+IOPMrootDomain::publishFeature( const char * feature )
+{
+ publishFeature(feature, kRD_AllPowerSources, NULL);
+}
+
+//******************************************************************************
+// publishFeature (with supported power source specified)
+//
+// Adds a new feature to the supported features dictionary
+//******************************************************************************
+
+void
+IOPMrootDomain::publishFeature(
+ const char *feature,
+ uint32_t supportedWhere,
+ uint32_t *uniqueFeatureID)
+{
+ static uint16_t next_feature_id = 500;
+
+ OSSharedPtr<OSNumber> new_feature_data;
+ OSNumber *existing_feature = NULL;
+ OSArray *existing_feature_arr_raw = NULL;
+ OSSharedPtr<OSArray> existing_feature_arr;
+ OSObject *osObj = NULL;
+ uint32_t feature_value = 0;
+
+ supportedWhere &= kRD_AllPowerSources; // mask off any craziness!
+
+ if (!supportedWhere) {
+ // Feature isn't supported anywhere!
+ return;
+ }
+
+ if (next_feature_id > 5000) {
+ // Far, far too many features!
+ return;
+ }
+
+ if (featuresDictLock) {
+ IOLockLock(featuresDictLock);
+ }
+
+ OSSharedPtr<OSObject> origFeaturesProp = copyProperty(kRootDomainSupportedFeatures);
+ OSDictionary *origFeatures = OSDynamicCast(OSDictionary, origFeaturesProp.get());
+ OSSharedPtr<OSDictionary> features;
+
+ // Create new features dict if necessary
+ if (origFeatures) {
+ features = OSDictionary::withDictionary(origFeatures);
+ } else {
+ features = OSDictionary::withCapacity(1);
+ }
+
+ // Create OSNumber to track new feature
+
+ next_feature_id += 1;
+ if (uniqueFeatureID) {
+ // We don't really mind if the calling kext didn't give us a place
+ // to stash their unique id. Many kexts don't plan to unload, and thus
+ // have no need to remove themselves later.
+ *uniqueFeatureID = next_feature_id;
+ }
+
+ feature_value = (uint32_t)next_feature_id;
+ feature_value <<= 16;
+ feature_value += supportedWhere;
+
+ new_feature_data = OSNumber::withNumber(
+ (unsigned long long)feature_value, 32);
+
+ // Does features object already exist?
+ if ((osObj = features->getObject(feature))) {
+ if ((existing_feature = OSDynamicCast(OSNumber, osObj))) {
+ // We need to create an OSArray to hold the now 2 elements.
+ existing_feature_arr = OSArray::withObjects(
+ (const OSObject **)&existing_feature, 1, 2);
+ } else if ((existing_feature_arr_raw = OSDynamicCast(OSArray, osObj))) {
+ // Add object to existing array
+ existing_feature_arr = OSArray::withArray(
+ existing_feature_arr_raw,
+ existing_feature_arr_raw->getCount() + 1);
+ }
+
+ if (existing_feature_arr) {
+ existing_feature_arr->setObject(new_feature_data.get());
+ features->setObject(feature, existing_feature_arr.get());
+ }
+ } else {
+ // The easy case: no previously existing features listed. We simply
+ // set the OSNumber at key 'feature' and we're on our way.
+ features->setObject(feature, new_feature_data.get());
+ }
+
+ setProperty(kRootDomainSupportedFeatures, features.get());
+
+ if (featuresDictLock) {
+ IOLockUnlock(featuresDictLock);
+ }
+
+ // Notify EnergySaver and all those in user space so they might
+ // re-populate their feature specific UI
+ if (pmPowerStateQueue) {
+ pmPowerStateQueue->submitPowerEvent( kPowerEventFeatureChanged );
+ }
+}
+
+//******************************************************************************
+// removePublishedFeature
+//
+// Removes previously published feature
+//******************************************************************************
+
+IOReturn
+IOPMrootDomain::removePublishedFeature( uint32_t removeFeatureID )
+{
+ IOReturn ret = kIOReturnError;
+ uint32_t feature_value = 0;
+ uint16_t feature_id = 0;
+ bool madeAChange = false;
+
+ OSSymbol *dictKey = NULL;
+ OSSharedPtr<OSCollectionIterator> dictIterator;
+ OSArray *arrayMember = NULL;
+ OSNumber *numberMember = NULL;
+ OSObject *osObj = NULL;
+ OSNumber *osNum = NULL;
+ OSSharedPtr<OSArray> arrayMemberCopy;
+
+ if (kBadPMFeatureID == removeFeatureID) {
+ return kIOReturnNotFound;
+ }
+
+ if (featuresDictLock) {
+ IOLockLock(featuresDictLock);
+ }
+
+ OSSharedPtr<OSObject> origFeaturesProp = copyProperty(kRootDomainSupportedFeatures);
+ OSDictionary *origFeatures = OSDynamicCast(OSDictionary, origFeaturesProp.get());
+ OSSharedPtr<OSDictionary> features;
+
+ if (origFeatures) {
+ // Any modifications to the dictionary are made to the copy to prevent
+ // races & crashes with userland clients. Dictionary updated
+ // automically later.
+ features = OSDictionary::withDictionary(origFeatures);
+ } else {
+ features = NULL;
+ ret = kIOReturnNotFound;
+ goto exit;
+ }
+
+ // We iterate 'features' dictionary looking for an entry tagged
+ // with 'removeFeatureID'. If found, we remove it from our tracking
+ // structures and notify the OS via a general interest message.
+
+ dictIterator = OSCollectionIterator::withCollection(features.get());
+ if (!dictIterator) {
+ goto exit;
+ }
+
+ while ((dictKey = OSDynamicCast(OSSymbol, dictIterator->getNextObject()))) {
+ osObj = features->getObject(dictKey);
+
+ // Each Feature is either tracked by an OSNumber
+ if (osObj && (numberMember = OSDynamicCast(OSNumber, osObj))) {
+ feature_value = numberMember->unsigned32BitValue();
+ feature_id = (uint16_t)(feature_value >> 16);
+
+ if (feature_id == (uint16_t)removeFeatureID) {
+ // Remove this node
+ features->removeObject(dictKey);
+ madeAChange = true;
+ break;
+ }
+
+ // Or tracked by an OSArray of OSNumbers
+ } else if (osObj && (arrayMember = OSDynamicCast(OSArray, osObj))) {
+ unsigned int arrayCount = arrayMember->getCount();
+
+ for (unsigned int i = 0; i < arrayCount; i++) {
+ osNum = OSDynamicCast(OSNumber, arrayMember->getObject(i));
+ if (!osNum) {
+ continue;
+ }
+
+ feature_value = osNum->unsigned32BitValue();
+ feature_id = (uint16_t)(feature_value >> 16);
+
+ if (feature_id == (uint16_t)removeFeatureID) {
+ // Remove this node
+ if (1 == arrayCount) {
+ // If the array only contains one element, remove
+ // the whole thing.
+ features->removeObject(dictKey);
+ } else {
+ // Otherwise remove the element from a copy of the array.
+ arrayMemberCopy = OSArray::withArray(arrayMember);
+ if (arrayMemberCopy) {
+ arrayMemberCopy->removeObject(i);
+ features->setObject(dictKey, arrayMemberCopy.get());
+ }
+ }
+
+ madeAChange = true;
+ break;
+ }
+ }
+ }
+ }
+
+ if (madeAChange) {
+ ret = kIOReturnSuccess;
+
+ setProperty(kRootDomainSupportedFeatures, features.get());
+
+ // Notify EnergySaver and all those in user space so they might
+ // re-populate their feature specific UI
+ if (pmPowerStateQueue) {
+ pmPowerStateQueue->submitPowerEvent( kPowerEventFeatureChanged );
+ }
+ } else {
+ ret = kIOReturnNotFound;
+ }
+
+exit:
+ if (featuresDictLock) {
+ IOLockUnlock(featuresDictLock);
+ }
+ return ret;
+}
+
+//******************************************************************************
+// publishPMSetting (private)
+//
+// Should only be called by PMSettingObject to publish a PM Setting as a
+// supported feature.
+//******************************************************************************
+
+void
+IOPMrootDomain::publishPMSetting(
+ const OSSymbol * feature, uint32_t where, uint32_t * featureID )
+{
+ if (noPublishPMSettings &&
+ (noPublishPMSettings->getNextIndexOfObject(feature, 0) != (unsigned int)-1)) {
+ // Setting found in noPublishPMSettings array
+ *featureID = kBadPMFeatureID;
+ return;
+ }
+
+ publishFeature(
+ feature->getCStringNoCopy(), where, featureID);
+}
+
+//******************************************************************************
+// setPMSetting (private)
+//
+// Internal helper to relay PM settings changes from user space to individual
+// drivers. Should be called only by IOPMrootDomain::setProperties.
+//******************************************************************************
+
+IOReturn
+IOPMrootDomain::setPMSetting(
+ const OSSymbol *type,
+ OSObject *object )
+{
+ PMSettingCallEntry *entries = NULL;
+ OSSharedPtr<OSArray> chosen;
+ const OSArray *array;
+ PMSettingObject *pmso;
+ thread_t thisThread;
+ int i, j, count, capacity;
+ bool ok = false;
+ IOReturn ret;
+
+ if (NULL == type) {
+ return kIOReturnBadArgument;
+ }
+
+ PMSETTING_LOCK();
+
+ // Update settings dict so changes are visible from copyPMSetting().
+ fPMSettingsDict->setObject(type, object);
+
+ // Prep all PMSetting objects with the given 'type' for callout.
+ array = OSDynamicCast(OSArray, settingsCallbacks->getObject(type));
+ if (!array || ((capacity = array->getCount()) == 0)) {
+ goto unlock_exit;
+ }
+
+ // Array to retain PMSetting objects targeted for callout.
+ chosen = OSArray::withCapacity(capacity);
+ if (!chosen) {
+ goto unlock_exit; // error
+ }
+ entries = IONew(PMSettingCallEntry, capacity);
+ if (!entries) {
+ goto unlock_exit; // error
+ }
+ memset(entries, 0, sizeof(PMSettingCallEntry) * capacity);
+
+ thisThread = current_thread();
+
+ for (i = 0, j = 0; i < capacity; i++) {
+ pmso = (PMSettingObject *) array->getObject(i);
+ if (pmso->disabled) {
+ continue;
+ }
+ entries[j].thread = thisThread;
+ queue_enter(&pmso->calloutQueue, &entries[j], PMSettingCallEntry *, link);
+ chosen->setObject(pmso);
+ j++;
+ }
+ count = j;
+ if (!count) {
+ goto unlock_exit;
+ }
+
+ PMSETTING_UNLOCK();
+
+ // Call each pmso in the chosen array.
+ for (i = 0; i < count; i++) {
+ pmso = (PMSettingObject *) chosen->getObject(i);
+ ret = pmso->dispatchPMSetting(type, object);
+ if (ret == kIOReturnSuccess) {
+ // At least one setting handler was successful
+ ok = true;
+#if DEVELOPMENT || DEBUG
+ } else {
+ // Log the handler and kext that failed
+ OSSharedPtr<const OSSymbol> kextName = copyKextIdentifierWithAddress((vm_address_t) pmso->func);
+ if (kextName) {
+ DLOG("PMSetting(%s) error 0x%x from %s\n",
+ type->getCStringNoCopy(), ret, kextName->getCStringNoCopy());
+ }
+#endif
+ }
+ }
+
+ PMSETTING_LOCK();
+ for (i = 0; i < count; i++) {
+ pmso = (PMSettingObject *) chosen->getObject(i);
+ queue_remove(&pmso->calloutQueue, &entries[i], PMSettingCallEntry *, link);
+ if (pmso->waitThread) {
+ PMSETTING_WAKEUP(pmso);
+ }
+ }
+
+ if (ok) {
+ recordRTCAlarm(type, object);
+ }
+unlock_exit:
+ PMSETTING_UNLOCK();
+
+ if (entries) {
+ IODelete(entries, PMSettingCallEntry, capacity);
+ }
+
+ return kIOReturnSuccess;
+}
+
+//******************************************************************************
+// copyPMSetting (public)
+//
+// Allows kexts to safely read setting values, without being subscribed to
+// notifications.
+//******************************************************************************
+
+OSSharedPtr<OSObject>
+IOPMrootDomain::copyPMSetting(
+ OSSymbol *whichSetting)
+{
+ OSSharedPtr<OSObject> obj;
+
+ if (!whichSetting) {
+ return NULL;
+ }
+
+ PMSETTING_LOCK();
+ obj.reset(fPMSettingsDict->getObject(whichSetting), OSRetain);
+ PMSETTING_UNLOCK();
+
+ return obj;
+}
+
+//******************************************************************************
+// registerPMSettingController (public)
+//
+// direct wrapper to registerPMSettingController with uint32_t power source arg
+//******************************************************************************
+
+IOReturn
+IOPMrootDomain::registerPMSettingController(
+ const OSSymbol * settings[],
+ IOPMSettingControllerCallback func,
+ OSObject *target,
+ uintptr_t refcon,
+ OSObject **handle)
+{
+ return registerPMSettingController(
+ settings,
+ (kIOPMSupportedOnAC | kIOPMSupportedOnBatt | kIOPMSupportedOnUPS),
+ func, target, refcon, handle);
+}
+
+//******************************************************************************
+// registerPMSettingController (public)
+//
+// Kexts may register for notifications when a particular setting is changed.
+// A list of settings is available in IOPM.h.
+// Arguments:
+// * settings - An OSArray containing OSSymbols. Caller should populate this
+// array with a list of settings caller wants notifications from.
+// * func - A C function callback of the type IOPMSettingControllerCallback
+// * target - caller may provide an OSObject *, which PM will pass as an
+// target to calls to "func"
+// * refcon - caller may provide an void *, which PM will pass as an
+// argument to calls to "func"
+// * handle - This is a return argument. We will populate this pointer upon
+// call success. Hold onto this and pass this argument to
+// IOPMrootDomain::deRegisterPMSettingCallback when unloading your kext
+// Returns:
+// kIOReturnSuccess on success
+//******************************************************************************
+
+IOReturn
+IOPMrootDomain::registerPMSettingController(
+ const OSSymbol * settings[],
+ uint32_t supportedPowerSources,
+ IOPMSettingControllerCallback func,
+ OSObject *target,
+ uintptr_t refcon,
+ OSObject **handle)
+{
+ PMSettingObject *pmso = NULL;
+ OSObject *pmsh = NULL;
+ int i;
+
+ if (NULL == settings ||
+ NULL == func ||
+ NULL == handle) {
+ return kIOReturnBadArgument;
+ }
+
+ pmso = PMSettingObject::pmSettingObject(
+ (IOPMrootDomain *) this, func, target,
+ refcon, supportedPowerSources, settings, &pmsh);
+
+ if (!pmso) {
+ *handle = NULL;
+ return kIOReturnInternalError;
+ }
+
+ PMSETTING_LOCK();
+ for (i = 0; settings[i]; i++) {
+ OSSharedPtr<OSArray> newList;
+ OSArray *list = OSDynamicCast(OSArray, settingsCallbacks->getObject(settings[i]));
+ if (!list) {
+ // New array of callbacks for this setting
+ newList = OSArray::withCapacity(1);
+ settingsCallbacks->setObject(settings[i], newList.get());
+ list = newList.get();
+ }
+
+ // Add caller to the callback list
+ list->setObject(pmso);
+ }
+ PMSETTING_UNLOCK();
+
+ // Return handle to the caller, the setting object is private.
+ *handle = pmsh;
+
+ return kIOReturnSuccess;
+}
+
+//******************************************************************************
+// deregisterPMSettingObject (private)
+//
+// Only called from PMSettingObject.
+//******************************************************************************
+
+void
+IOPMrootDomain::deregisterPMSettingObject( PMSettingObject * pmso )
+{
+ thread_t thisThread = current_thread();
+ PMSettingCallEntry *callEntry;
+ OSSharedPtr<OSCollectionIterator> iter;
+ OSSymbol *sym;
+ OSArray *array;
+ int index;
+ bool wait;
+
+ PMSETTING_LOCK();
+
+ pmso->disabled = true;
+
+ // Wait for all callout threads to finish.
+ do {
+ wait = false;
+ queue_iterate(&pmso->calloutQueue, callEntry, PMSettingCallEntry *, link)
+ {
+ if (callEntry->thread != thisThread) {
+ wait = true;
+ break;
+ }
+ }
+ if (wait) {
+ assert(NULL == pmso->waitThread);
+ pmso->waitThread = thisThread;
+ PMSETTING_WAIT(pmso);
+ pmso->waitThread = NULL;
+ }
+ } while (wait);
+
+ // Search each PM settings array in the kernel.
+ iter = OSCollectionIterator::withCollection(settingsCallbacks.get());
+ if (iter) {
+ while ((sym = OSDynamicCast(OSSymbol, iter->getNextObject()))) {
+ array = OSDynamicCast(OSArray, settingsCallbacks->getObject(sym));
+ index = array->getNextIndexOfObject(pmso, 0);
+ if (-1 != index) {
+ array->removeObject(index);
+ }
+ }
+ }
+
+ PMSETTING_UNLOCK();
+
+ pmso->release();
+}
+
+//******************************************************************************
+// informCPUStateChange
+//
+// Call into PM CPU code so that CPU power savings may dynamically adjust for
+// running on battery, with the lid closed, etc.
+//
+// informCPUStateChange is a no-op on non x86 systems
+// only x86 has explicit support in the IntelCPUPowerManagement kext
+//******************************************************************************
+
+void
+IOPMrootDomain::informCPUStateChange(
+ uint32_t type,
+ uint32_t value )
+{
+#if defined(__i386__) || defined(__x86_64__)
+
+ pmioctlVariableInfo_t varInfoStruct;
+ int pmCPUret = 0;
+ const char *varNameStr = NULL;
+ int32_t *varIndex = NULL;
+
+ if (kInformAC == type) {
+ varNameStr = kIOPMRootDomainBatPowerCString;
+ varIndex = &idxPMCPULimitedPower;
+ } else if (kInformLid == type) {
+ varNameStr = kIOPMRootDomainLidCloseCString;
+ varIndex = &idxPMCPUClamshell;
+ } else {
+ return;
+ }
+
+ // Set the new value!
+ // pmCPUControl will assign us a new ID if one doesn't exist yet
+ bzero(&varInfoStruct, sizeof(pmioctlVariableInfo_t));
+ varInfoStruct.varID = *varIndex;
+ varInfoStruct.varType = vBool;
+ varInfoStruct.varInitValue = value;
+ varInfoStruct.varCurValue = value;
+ strlcpy((char *)varInfoStruct.varName,
+ (const char *)varNameStr,
+ sizeof(varInfoStruct.varName));
+
+ // Set!
+ pmCPUret = pmCPUControl( PMIOCSETVARINFO, (void *)&varInfoStruct );
+
+ // pmCPU only assigns numerical id's when a new varName is specified
+ if ((0 == pmCPUret)
+ && (*varIndex == kCPUUnknownIndex)) {
+ // pmCPUControl has assigned us a new variable ID.
+ // Let's re-read the structure we just SET to learn that ID.
+ pmCPUret = pmCPUControl( PMIOCGETVARNAMEINFO, (void *)&varInfoStruct );
+
+ if (0 == pmCPUret) {
+ // Store it in idxPMCPUClamshell or idxPMCPULimitedPower
+ *varIndex = varInfoStruct.varID;
+ }
+ }
+
+ return;
+
+#endif /* __i386__ || __x86_64__ */
+}
+
+// MARK: -
+// MARK: Deep Sleep Policy
+
+#if HIBERNATION
+
+//******************************************************************************
+// evaluateSystemSleepPolicy
+//******************************************************************************
+
+#define kIOPlatformSystemSleepPolicyKey "IOPlatformSystemSleepPolicy"
+
+// Sleep flags
+enum {
+ kIOPMSleepFlagHibernate = 0x00000001,
+ kIOPMSleepFlagSleepTimerEnable = 0x00000002
+};
+
+struct IOPMSystemSleepPolicyEntry {
+ uint32_t factorMask;
+ uint32_t factorBits;
+ uint32_t sleepFlags;
+ uint32_t wakeEvents;
+} __attribute__((packed));
+
+struct IOPMSystemSleepPolicyTable {
+ uint32_t signature;
+ uint16_t version;
+ uint16_t entryCount;
+ IOPMSystemSleepPolicyEntry entries[];
+} __attribute__((packed));
+
+enum {
+ kIOPMSleepAttributeHibernateSetup = 0x00000001,
+ kIOPMSleepAttributeHibernateSleep = 0x00000002
+};
+
+static uint32_t
+getSleepTypeAttributes( uint32_t sleepType )
+{
+ static const uint32_t sleepTypeAttributes[kIOPMSleepTypeLast] =
+ {
+ /* invalid */ 0,
+ /* abort */ 0,
+ /* normal */ 0,
+ /* safesleep */ kIOPMSleepAttributeHibernateSetup,
+ /* hibernate */ kIOPMSleepAttributeHibernateSetup | kIOPMSleepAttributeHibernateSleep,
+ /* standby */ kIOPMSleepAttributeHibernateSetup | kIOPMSleepAttributeHibernateSleep,
+ /* poweroff */ kIOPMSleepAttributeHibernateSetup | kIOPMSleepAttributeHibernateSleep,
+ /* deepidle */ 0
+ };
+
+ if (sleepType >= kIOPMSleepTypeLast) {
+ return 0;
+ }
+
+ return sleepTypeAttributes[sleepType];
+}
+
+bool
+IOPMrootDomain::evaluateSystemSleepPolicy(
+ IOPMSystemSleepParameters * params, int sleepPhase, uint32_t * hibMode )
+{
+#define SLEEP_FACTOR(x) {(uint32_t) kIOPMSleepFactor ## x, #x}
+
+ static const IONamedValue factorValues[] = {
+ SLEEP_FACTOR( SleepTimerWake ),
+ SLEEP_FACTOR( LidOpen ),
+ SLEEP_FACTOR( ACPower ),
+ SLEEP_FACTOR( BatteryLow ),
+ SLEEP_FACTOR( StandbyNoDelay ),
+ SLEEP_FACTOR( StandbyForced ),
+ SLEEP_FACTOR( StandbyDisabled ),
+ SLEEP_FACTOR( USBExternalDevice ),
+ SLEEP_FACTOR( BluetoothHIDDevice ),
+ SLEEP_FACTOR( ExternalMediaMounted ),
+ SLEEP_FACTOR( ThunderboltDevice ),
+ SLEEP_FACTOR( RTCAlarmScheduled ),
+ SLEEP_FACTOR( MagicPacketWakeEnabled ),
+ SLEEP_FACTOR( HibernateForced ),
+ SLEEP_FACTOR( AutoPowerOffDisabled ),
+ SLEEP_FACTOR( AutoPowerOffForced ),
+ SLEEP_FACTOR( ExternalDisplay ),
+ SLEEP_FACTOR( NetworkKeepAliveActive ),
+ SLEEP_FACTOR( LocalUserActivity ),
+ SLEEP_FACTOR( HibernateFailed ),
+ SLEEP_FACTOR( ThermalWarning ),
+ SLEEP_FACTOR( DisplayCaptured ),
+ { 0, NULL }
+ };
+
+ const IOPMSystemSleepPolicyTable * pt;
+ OSSharedPtr<OSObject> prop;
+ OSData * policyData;
+ uint64_t currentFactors = 0;
+ char currentFactorsBuf[512];
+ uint32_t standbyDelay = 0;
+ uint32_t powerOffDelay = 0;
+ uint32_t powerOffTimer = 0;
+ uint32_t standbyTimer = 0;
+ uint32_t mismatch;
+ bool standbyEnabled;
+ bool powerOffEnabled;
+ bool found = false;
+
+ // Get platform's sleep policy table
+ if (!gSleepPolicyHandler) {
+ prop = getServiceRoot()->copyProperty(kIOPlatformSystemSleepPolicyKey);
+ if (!prop) {
+ goto done;
+ }
+ }
+
+ // Fetch additional settings
+ standbyEnabled = (getSleepOption(kIOPMDeepSleepDelayKey, &standbyDelay)
+ && propertyHasValue(kIOPMDeepSleepEnabledKey, kOSBooleanTrue));
+ powerOffEnabled = (getSleepOption(kIOPMAutoPowerOffDelayKey, &powerOffDelay)
+ && propertyHasValue(kIOPMAutoPowerOffEnabledKey, kOSBooleanTrue));
+ if (!getSleepOption(kIOPMAutoPowerOffTimerKey, &powerOffTimer)) {
+ powerOffTimer = powerOffDelay;
+ }
+ if (!getSleepOption(kIOPMDeepSleepTimerKey, &standbyTimer)) {
+ standbyTimer = standbyDelay;
+ }
+
+ DLOG("phase %d, standby %d delay %u timer %u, poweroff %d delay %u timer %u, hibernate 0x%x\n",
+ sleepPhase, standbyEnabled, standbyDelay, standbyTimer,
+ powerOffEnabled, powerOffDelay, powerOffTimer, *hibMode);
+
+ currentFactorsBuf[0] = 0;
+ // pmset level overrides
+ if ((*hibMode & kIOHibernateModeOn) == 0) {
+ if (!gSleepPolicyHandler) {
+ standbyEnabled = false;
+ powerOffEnabled = false;
+ }
+ } else if (!(*hibMode & kIOHibernateModeSleep)) {
+ // Force hibernate (i.e. mode 25)
+ // If standby is enabled, force standy.
+ // If poweroff is enabled, force poweroff.
+ if (standbyEnabled) {
+ currentFactors |= kIOPMSleepFactorStandbyForced;
+ } else if (powerOffEnabled) {
+ currentFactors |= kIOPMSleepFactorAutoPowerOffForced;
+ } else {
+ currentFactors |= kIOPMSleepFactorHibernateForced;
+ }
+ }
+
+ // Current factors based on environment and assertions
+ if (sleepTimerMaintenance) {
+ currentFactors |= kIOPMSleepFactorSleepTimerWake;
+ }
+ if (standbyEnabled && sleepToStandby && !gSleepPolicyHandler) {
+ currentFactors |= kIOPMSleepFactorSleepTimerWake;
+ }
+ if (!clamshellClosed) {
+ currentFactors |= kIOPMSleepFactorLidOpen;
+ }
+ if (acAdaptorConnected) {
+ currentFactors |= kIOPMSleepFactorACPower;
+ }
+ if (lowBatteryCondition) {
+ hibernateMode = 0;
+ getSleepOption(kIOHibernateModeKey, &hibernateMode);
+ if ((hibernateMode & kIOHibernateModeOn) == 0) {
+ DLOG("HibernateMode is 0. Not sending LowBattery factor to IOPPF\n");
+ } else {
+ currentFactors |= kIOPMSleepFactorBatteryLow;
+ }
+ }
+ if (!standbyDelay || !standbyTimer) {
+ currentFactors |= kIOPMSleepFactorStandbyNoDelay;
+ }
+ if (standbyNixed || !standbyEnabled) {
+ currentFactors |= kIOPMSleepFactorStandbyDisabled;
+ }
+ if (resetTimers) {
+ currentFactors |= kIOPMSleepFactorLocalUserActivity;
+ currentFactors &= ~kIOPMSleepFactorSleepTimerWake;
+ }
+ if (getPMAssertionLevel(kIOPMDriverAssertionUSBExternalDeviceBit) !=
+ kIOPMDriverAssertionLevelOff) {
+ currentFactors |= kIOPMSleepFactorUSBExternalDevice;
+ }
+ if (getPMAssertionLevel(kIOPMDriverAssertionBluetoothHIDDevicePairedBit) !=
+ kIOPMDriverAssertionLevelOff) {
+ currentFactors |= kIOPMSleepFactorBluetoothHIDDevice;
+ }
+ if (getPMAssertionLevel(kIOPMDriverAssertionExternalMediaMountedBit) !=
+ kIOPMDriverAssertionLevelOff) {
+ currentFactors |= kIOPMSleepFactorExternalMediaMounted;
+ }
+ if (getPMAssertionLevel(kIOPMDriverAssertionReservedBit5) !=
+ kIOPMDriverAssertionLevelOff) {
+ currentFactors |= kIOPMSleepFactorThunderboltDevice;
+ }
+ if (_scheduledAlarmMask != 0) {
+ currentFactors |= kIOPMSleepFactorRTCAlarmScheduled;
+ }
+ if (getPMAssertionLevel(kIOPMDriverAssertionMagicPacketWakeEnabledBit) !=
+ kIOPMDriverAssertionLevelOff) {
+ currentFactors |= kIOPMSleepFactorMagicPacketWakeEnabled;
+ }
+#define TCPKEEPALIVE 1
+#if TCPKEEPALIVE
+ if (getPMAssertionLevel(kIOPMDriverAssertionNetworkKeepAliveActiveBit) !=
+ kIOPMDriverAssertionLevelOff) {
+ currentFactors |= kIOPMSleepFactorNetworkKeepAliveActive;
+ }
+#endif
+ if (!powerOffEnabled) {
+ currentFactors |= kIOPMSleepFactorAutoPowerOffDisabled;
+ }
+ if (desktopMode) {
+ currentFactors |= kIOPMSleepFactorExternalDisplay;
+ }
+ if (userWasActive) {
+ currentFactors |= kIOPMSleepFactorLocalUserActivity;
+ }
+ if (darkWakeHibernateError && !CAP_HIGHEST(kIOPMSystemCapabilityGraphics)) {
+ currentFactors |= kIOPMSleepFactorHibernateFailed;
+ }
+ if (thermalWarningState) {
+ currentFactors |= kIOPMSleepFactorThermalWarning;
+ }
+
+ for (int factorBit = 0; factorBit < (8 * sizeof(uint32_t)); factorBit++) {
+ uint32_t factor = 1 << factorBit;
+ if (factor & currentFactors) {
+ strlcat(currentFactorsBuf, ", ", sizeof(currentFactorsBuf));
+ strlcat(currentFactorsBuf, IOFindNameForValue(factor, factorValues), sizeof(currentFactorsBuf));
+ }
+ }
+ DLOG("sleep factors 0x%llx%s\n", currentFactors, currentFactorsBuf);
+
+ if (gSleepPolicyHandler) {
+ uint32_t savedHibernateMode;
+ IOReturn result;
+
+ if (!gSleepPolicyVars) {
+ gSleepPolicyVars = IONew(IOPMSystemSleepPolicyVariables, 1);
+ if (!gSleepPolicyVars) {
+ goto done;
+ }
+ bzero(gSleepPolicyVars, sizeof(*gSleepPolicyVars));
+ }
+ gSleepPolicyVars->signature = kIOPMSystemSleepPolicySignature;
+ gSleepPolicyVars->version = kIOPMSystemSleepPolicyVersion;
+ gSleepPolicyVars->currentCapability = _currentCapability;
+ gSleepPolicyVars->highestCapability = _highestCapability;
+ gSleepPolicyVars->sleepFactors = currentFactors;
+ gSleepPolicyVars->sleepReason = lastSleepReason;
+ gSleepPolicyVars->sleepPhase = sleepPhase;
+ gSleepPolicyVars->standbyDelay = standbyDelay;
+ gSleepPolicyVars->standbyTimer = standbyTimer;
+ gSleepPolicyVars->poweroffDelay = powerOffDelay;
+ gSleepPolicyVars->scheduledAlarms = _scheduledAlarmMask | _userScheduledAlarmMask;
+ gSleepPolicyVars->poweroffTimer = powerOffTimer;
+
+ if (kIOPMSleepPhase0 == sleepPhase) {
+ // preserve hibernateMode
+ savedHibernateMode = gSleepPolicyVars->hibernateMode;
+ gSleepPolicyVars->hibernateMode = *hibMode;
+ } else if (kIOPMSleepPhase1 == sleepPhase) {
+ // use original hibernateMode for phase2
+ gSleepPolicyVars->hibernateMode = *hibMode;
+ }
+
+ result = gSleepPolicyHandler(gSleepPolicyTarget, gSleepPolicyVars, params);
+
+ if (kIOPMSleepPhase0 == sleepPhase) {
+ // restore hibernateMode
+ gSleepPolicyVars->hibernateMode = savedHibernateMode;
+ }
+
+ if ((result != kIOReturnSuccess) ||
+ (kIOPMSleepTypeInvalid == params->sleepType) ||
+ (params->sleepType >= kIOPMSleepTypeLast) ||
+ (kIOPMSystemSleepParametersVersion != params->version)) {
+ MSG("sleep policy handler error\n");
+ goto done;
+ }
+
+ if ((getSleepTypeAttributes(params->sleepType) &
+ kIOPMSleepAttributeHibernateSetup) &&
+ ((*hibMode & kIOHibernateModeOn) == 0)) {
+ *hibMode |= (kIOHibernateModeOn | kIOHibernateModeSleep);
+ }
+
+ DLOG("sleep params v%u, type %u, flags 0x%x, wake 0x%x, timer %u, poweroff %u\n",
+ params->version, params->sleepType, params->sleepFlags,
+ params->ecWakeEvents, params->ecWakeTimer, params->ecPoweroffTimer);
+ found = true;
+ goto done;
+ }
+
+ // Policy table is meaningless without standby enabled
+ if (!standbyEnabled) {
+ goto done;
+ }
+
+ // Validate the sleep policy table
+ policyData = OSDynamicCast(OSData, prop.get());
+ if (!policyData || (policyData->getLength() <= sizeof(IOPMSystemSleepPolicyTable))) {
+ goto done;
+ }
+
+ pt = (const IOPMSystemSleepPolicyTable *) policyData->getBytesNoCopy();
+ if ((pt->signature != kIOPMSystemSleepPolicySignature) ||
+ (pt->version != 1) || (0 == pt->entryCount)) {
+ goto done;
+ }
+
+ if (((policyData->getLength() - sizeof(IOPMSystemSleepPolicyTable)) !=
+ (sizeof(IOPMSystemSleepPolicyEntry) * pt->entryCount))) {
+ goto done;
+ }
+
+ for (uint32_t i = 0; i < pt->entryCount; i++) {
+ const IOPMSystemSleepPolicyEntry * entry = &pt->entries[i];
+ mismatch = (((uint32_t)currentFactors ^ entry->factorBits) & entry->factorMask);
+
+ DLOG("mask 0x%08x, bits 0x%08x, flags 0x%08x, wake 0x%08x, mismatch 0x%08x\n",
+ entry->factorMask, entry->factorBits,
+ entry->sleepFlags, entry->wakeEvents, mismatch);
+ if (mismatch) {
+ continue;
+ }
+
+ DLOG("^ found match\n");
+ found = true;
+
+ params->version = kIOPMSystemSleepParametersVersion;
+ params->reserved1 = 1;
+ if (entry->sleepFlags & kIOPMSleepFlagHibernate) {
+ params->sleepType = kIOPMSleepTypeStandby;
+ } else {
+ params->sleepType = kIOPMSleepTypeNormalSleep;
+ }
+
+ params->ecWakeEvents = entry->wakeEvents;
+ if (entry->sleepFlags & kIOPMSleepFlagSleepTimerEnable) {
+ if (kIOPMSleepPhase2 == sleepPhase) {
+ clock_sec_t now_secs = gIOLastSleepTime.tv_sec;
+
+ if (!_standbyTimerResetSeconds ||
+ (now_secs <= _standbyTimerResetSeconds)) {
+ // Reset standby timer adjustment
+ _standbyTimerResetSeconds = now_secs;
+ DLOG("standby delay %u, reset %u\n",
+ standbyDelay, (uint32_t) _standbyTimerResetSeconds);
+ } else if (standbyDelay) {
+ // Shorten the standby delay timer
+ clock_sec_t elapsed = now_secs - _standbyTimerResetSeconds;
+ if (standbyDelay > elapsed) {
+ standbyDelay -= elapsed;
+ } else {
+ standbyDelay = 1; // must be > 0
+ }
+ DLOG("standby delay %u, elapsed %u\n",
+ standbyDelay, (uint32_t) elapsed);
+ }
+ }
+ params->ecWakeTimer = standbyDelay;
+ } else if (kIOPMSleepPhase2 == sleepPhase) {
+ // A sleep that does not enable the sleep timer will reset
+ // the standby delay adjustment.
+ _standbyTimerResetSeconds = 0;
+ }
+ break;
+ }
+
+done:
+ return found;
+}
+
+static IOPMSystemSleepParameters gEarlySystemSleepParams;
+
+void
+IOPMrootDomain::evaluateSystemSleepPolicyEarly( void )
+{
+ // Evaluate early (priority interest phase), before drivers sleep.
+
+ DLOG("%s\n", __FUNCTION__);
+ removeProperty(kIOPMSystemSleepParametersKey);
+
+ // Full wake resets the standby timer delay adjustment
+ if (_highestCapability & kIOPMSystemCapabilityGraphics) {
+ _standbyTimerResetSeconds = 0;
+ }
+
+ hibernateDisabled = false;
+ hibernateMode = 0;
+ getSleepOption(kIOHibernateModeKey, &hibernateMode);
+
+ // Save for late evaluation if sleep is aborted
+ bzero(&gEarlySystemSleepParams, sizeof(gEarlySystemSleepParams));
+
+ if (evaluateSystemSleepPolicy(&gEarlySystemSleepParams, kIOPMSleepPhase1,
+ &hibernateMode)) {
+ if (!hibernateRetry &&
+ ((getSleepTypeAttributes(gEarlySystemSleepParams.sleepType) &
+ kIOPMSleepAttributeHibernateSetup) == 0)) {
+ // skip hibernate setup
+ hibernateDisabled = true;
+ }
+ }
+
+ // Publish IOPMSystemSleepType
+ uint32_t sleepType = gEarlySystemSleepParams.sleepType;
+ if (sleepType == kIOPMSleepTypeInvalid) {
+ // no sleep policy
+ sleepType = kIOPMSleepTypeNormalSleep;
+ if (hibernateMode & kIOHibernateModeOn) {
+ sleepType = (hibernateMode & kIOHibernateModeSleep) ?
+ kIOPMSleepTypeSafeSleep : kIOPMSleepTypeHibernate;
+ }
+ } else if ((sleepType == kIOPMSleepTypeStandby) &&
+ (gEarlySystemSleepParams.ecPoweroffTimer)) {
+ // report the lowest possible sleep state
+ sleepType = kIOPMSleepTypePowerOff;
+ }
+
+ setProperty(kIOPMSystemSleepTypeKey, sleepType, 32);
+}
+
+void
+IOPMrootDomain::evaluateSystemSleepPolicyFinal( void )
+{
+ IOPMSystemSleepParameters params;
+ OSSharedPtr<OSData> paramsData;
+ bool wakeNow;
+ // Evaluate sleep policy after sleeping drivers but before platform sleep.
+
+ DLOG("%s\n", __FUNCTION__);
+
+ bzero(¶ms, sizeof(params));
+ wakeNow = false;
+ if (evaluateSystemSleepPolicy(¶ms, kIOPMSleepPhase2, &hibernateMode)) {
+ if ((kIOPMSleepTypeStandby == params.sleepType)
+ && gIOHibernateStandbyDisabled && gSleepPolicyVars
+ && (!((kIOPMSleepFactorStandbyForced | kIOPMSleepFactorAutoPowerOffForced | kIOPMSleepFactorHibernateForced)
+ & gSleepPolicyVars->sleepFactors))) {
+ standbyNixed = true;
+ wakeNow = true;
+ }
+ if (wakeNow
+ || ((hibernateDisabled || hibernateAborted) &&
+ (getSleepTypeAttributes(params.sleepType) &
+ kIOPMSleepAttributeHibernateSetup))) {
+ // Final evaluation picked a state requiring hibernation,
+ // but hibernate isn't going to proceed. Arm a short sleep using
+ // the early non-hibernate sleep parameters.
+ bcopy(&gEarlySystemSleepParams, ¶ms, sizeof(params));
+ params.sleepType = kIOPMSleepTypeAbortedSleep;
+ params.ecWakeTimer = 1;
+ if (standbyNixed) {
+ resetTimers = true;
+ } else {
+ // Set hibernateRetry flag to force hibernate setup on the
+ // next sleep.
+ hibernateRetry = true;
+ }
+ DLOG("wake in %u secs for hibernateDisabled %d, hibernateAborted %d, standbyNixed %d\n",
+ params.ecWakeTimer, hibernateDisabled, hibernateAborted, standbyNixed);
+ } else {
+ hibernateRetry = false;
+ }
+
+ if (kIOPMSleepTypeAbortedSleep != params.sleepType) {
+ resetTimers = false;
+ }
+
+ paramsData = OSData::withBytes(¶ms, sizeof(params));
+ if (paramsData) {
+ setProperty(kIOPMSystemSleepParametersKey, paramsData.get());
+ }
+
+ if (getSleepTypeAttributes(params.sleepType) &
+ kIOPMSleepAttributeHibernateSleep) {
+ // Disable sleep to force hibernation
+ gIOHibernateMode &= ~kIOHibernateModeSleep;
+ }
+ }
+}
+
+bool
+IOPMrootDomain::getHibernateSettings(
+ uint32_t * hibernateModePtr,
+ uint32_t * hibernateFreeRatio,
+ uint32_t * hibernateFreeTime )
+{
+ // Called by IOHibernateSystemSleep() after evaluateSystemSleepPolicyEarly()
+ // has updated the hibernateDisabled flag.
+
+ bool ok = getSleepOption(kIOHibernateModeKey, hibernateModePtr);
+ getSleepOption(kIOHibernateFreeRatioKey, hibernateFreeRatio);
+ getSleepOption(kIOHibernateFreeTimeKey, hibernateFreeTime);
+ if (hibernateDisabled) {
+ *hibernateModePtr = 0;
+ } else if (gSleepPolicyHandler) {
+ *hibernateModePtr = hibernateMode;
+ }
+ DLOG("hibernateMode 0x%x\n", *hibernateModePtr);
+ return ok;
+}
+
+bool
+IOPMrootDomain::getSleepOption( const char * key, uint32_t * option )
+{
+ OSSharedPtr<OSObject> optionsProp;
+ OSDictionary * optionsDict;
+ OSSharedPtr<OSObject> obj;
+ OSNumber * num;
+ bool ok = false;
+
+ optionsProp = copyProperty(kRootDomainSleepOptionsKey);
+ optionsDict = OSDynamicCast(OSDictionary, optionsProp.get());
+
+ if (optionsDict) {
+ obj.reset(optionsDict->getObject(key), OSRetain);
+ }
+ if (!obj) {
+ obj = copyProperty(key);
+ }
+ if (obj) {
+ if ((num = OSDynamicCast(OSNumber, obj.get()))) {
+ *option = num->unsigned32BitValue();
+ ok = true;
+ } else if (OSDynamicCast(OSBoolean, obj.get())) {
+ *option = (obj == kOSBooleanTrue) ? 1 : 0;
+ ok = true;
+ }
+ }
+
+ return ok;
+}
+#endif /* HIBERNATION */
+
+IOReturn
+IOPMrootDomain::getSystemSleepType( uint32_t * sleepType, uint32_t * standbyTimer )
+{
+#if HIBERNATION
+ IOPMSystemSleepParameters params;
+ uint32_t hibMode = 0;
+ bool ok;
+
+ if (gIOPMWorkLoop->inGate() == false) {
+ IOReturn ret = gIOPMWorkLoop->runAction(
+ OSMemberFunctionCast(IOWorkLoop::Action, this,
+ &IOPMrootDomain::getSystemSleepType),
+ (OSObject *) this,
+ (void *) sleepType, (void *) standbyTimer);
+ return ret;
+ }
+
+ getSleepOption(kIOHibernateModeKey, &hibMode);
+ bzero(¶ms, sizeof(params));
+
+ ok = evaluateSystemSleepPolicy(¶ms, kIOPMSleepPhase0, &hibMode);
+ if (ok) {
+ *sleepType = params.sleepType;
+ if (!getSleepOption(kIOPMDeepSleepTimerKey, standbyTimer) &&
+ !getSleepOption(kIOPMDeepSleepDelayKey, standbyTimer)) {
+ DLOG("Standby delay is not set\n");
+ *standbyTimer = 0;
+ }
+ return kIOReturnSuccess;
+ }
+#endif
+
+ return kIOReturnUnsupported;
+}
+
+// MARK: -
+// MARK: Shutdown and Restart
+
+//******************************************************************************
+// handlePlatformHaltRestart
+//
+//******************************************************************************
+
+// Phases while performing shutdown/restart
+typedef enum {
+ kNotifyDone = 0x00,
+ kNotifyPriorityClients = 0x10,
+ kNotifyPowerPlaneDrivers = 0x20,
+ kNotifyHaltRestartAction = 0x30,
+ kQuiescePM = 0x40,
+} shutdownPhase_t;
+
+
+struct HaltRestartApplierContext {
+ IOPMrootDomain * RootDomain;
+ unsigned long PowerState;
+ IOPMPowerFlags PowerFlags;
+ UInt32 MessageType;
+ UInt32 Counter;
+ const char * LogString;
+ shutdownPhase_t phase;
+
+ IOServiceInterestHandler handler;
+} gHaltRestartCtx;
+
+const char *
+shutdownPhase2String(shutdownPhase_t phase)
+{
+ switch (phase) {
+ case kNotifyDone:
+ return "Notifications completed";
+ case kNotifyPriorityClients:
+ return "Notifying priority clients";
+ case kNotifyPowerPlaneDrivers:
+ return "Notifying power plane drivers";
+ case kNotifyHaltRestartAction:
+ return "Notifying HaltRestart action handlers";
+ case kQuiescePM:
+ return "Quiescing PM";
+ default:
+ return "Unknown";
+ }
+}
+
+static void
+platformHaltRestartApplier( OSObject * object, void * context )
+{
+ IOPowerStateChangeNotification notify;
+ HaltRestartApplierContext * ctx;
+ AbsoluteTime startTime, elapsedTime;
+ uint32_t deltaTime;
+
+ ctx = (HaltRestartApplierContext *) context;
+
+ _IOServiceInterestNotifier * notifier;
+ notifier = OSDynamicCast(_IOServiceInterestNotifier, object);
+ memset(¬ify, 0, sizeof(notify));
+ notify.powerRef = (void *)(uintptr_t)ctx->Counter;
+ notify.returnValue = 0;
+ notify.stateNumber = ctx->PowerState;
+ notify.stateFlags = ctx->PowerFlags;
+
+ if (notifier) {
+ ctx->handler = notifier->handler;
+ }
+
+ clock_get_uptime(&startTime);
+ ctx->RootDomain->messageClient( ctx->MessageType, object, (void *)¬ify );
+ deltaTime = computeDeltaTimeMS(&startTime, &elapsedTime);
+
+ if ((deltaTime > kPMHaltTimeoutMS) && notifier) {
+ LOG("%s handler %p took %u ms\n",
+ ctx->LogString, OBFUSCATE(notifier->handler), deltaTime);
+ halt_log_enter("PowerOff/Restart message to priority client", (const void *) notifier->handler, elapsedTime);
+ }
+
+ ctx->handler = NULL;
+ ctx->Counter++;
+}
+
+static void
+quiescePowerTreeCallback( void * target, void * param )
+{
+ IOLockLock(gPMHaltLock);
+ gPMQuiesced = true;
+ thread_wakeup(param);
+ IOLockUnlock(gPMHaltLock);
+}
+
+void
+IOPMrootDomain::handlePlatformHaltRestart( UInt32 pe_type )
+{
+ AbsoluteTime startTime, elapsedTime;
+ uint32_t deltaTime;
+
+ memset(&gHaltRestartCtx, 0, sizeof(gHaltRestartCtx));
+ gHaltRestartCtx.RootDomain = this;
+
+ clock_get_uptime(&startTime);
+ switch (pe_type) {
+ case kPEHaltCPU:
+ case kPEUPSDelayHaltCPU:
+ gHaltRestartCtx.PowerState = OFF_STATE;
+ gHaltRestartCtx.MessageType = kIOMessageSystemWillPowerOff;
+ gHaltRestartCtx.LogString = "PowerOff";
+ break;
+
+ case kPERestartCPU:
+ gHaltRestartCtx.PowerState = RESTART_STATE;
+ gHaltRestartCtx.MessageType = kIOMessageSystemWillRestart;
+ gHaltRestartCtx.LogString = "Restart";
+ break;
+
+ case kPEPagingOff:
+ gHaltRestartCtx.PowerState = ON_STATE;
+ gHaltRestartCtx.MessageType = kIOMessageSystemPagingOff;
+ gHaltRestartCtx.LogString = "PagingOff";
+ IOService::updateConsoleUsers(NULL, kIOMessageSystemPagingOff);
+#if HIBERNATION
+ IOHibernateSystemRestart();
+#endif
+ break;
+
+ default:
+ return;
+ }
+
+ gHaltRestartCtx.phase = kNotifyPriorityClients;
+ // Notify legacy clients
+ applyToInterested(gIOPriorityPowerStateInterest, platformHaltRestartApplier, &gHaltRestartCtx);
+
+ // For normal shutdown, turn off File Server Mode.
+ if (kPEHaltCPU == pe_type) {
+ OSSharedPtr<const OSSymbol> setting = OSSymbol::withCString(kIOPMSettingRestartOnPowerLossKey);
+ OSSharedPtr<OSNumber> num = OSNumber::withNumber((unsigned long long) 0, 32);
+ if (setting && num) {
+ setPMSetting(setting.get(), num.get());
+ }
+ }
+
+ if (kPEPagingOff != pe_type) {
+ gHaltRestartCtx.phase = kNotifyPowerPlaneDrivers;
+ // Notify in power tree order
+ notifySystemShutdown(this, gHaltRestartCtx.MessageType);
+ }
+
+ gHaltRestartCtx.phase = kNotifyHaltRestartAction;
+#if defined(XNU_TARGET_OS_OSX)
+ IOCPURunPlatformHaltRestartActions(pe_type);
+#else /* !defined(XNU_TARGET_OS_OSX) */
+ if (kPEPagingOff != pe_type) {
+ IOCPURunPlatformHaltRestartActions(pe_type);
+ }
+#endif /* !defined(XNU_TARGET_OS_OSX) */
+
+ // Wait for PM to quiesce
+ if ((kPEPagingOff != pe_type) && gPMHaltLock) {
+ gHaltRestartCtx.phase = kQuiescePM;
+ AbsoluteTime quiesceTime = mach_absolute_time();
+
+ IOLockLock(gPMHaltLock);
+ gPMQuiesced = false;
+ if (quiescePowerTree(this, &quiescePowerTreeCallback, &gPMQuiesced) ==
+ kIOReturnSuccess) {
+ while (!gPMQuiesced) {
+ IOLockSleep(gPMHaltLock, &gPMQuiesced, THREAD_UNINT);
+ }
+ }
+ IOLockUnlock(gPMHaltLock);
+ deltaTime = computeDeltaTimeMS(&quiesceTime, &elapsedTime);
+ DLOG("PM quiesce took %u ms\n", deltaTime);
+ halt_log_enter("Quiesce", NULL, elapsedTime);
+ }
+ gHaltRestartCtx.phase = kNotifyDone;
+
+ deltaTime = computeDeltaTimeMS(&startTime, &elapsedTime);
+ LOG("%s all drivers took %u ms\n", gHaltRestartCtx.LogString, deltaTime);
+
+ halt_log_enter(gHaltRestartCtx.LogString, NULL, elapsedTime);
+
+ deltaTime = computeDeltaTimeMS(&gHaltStartTime, &elapsedTime);
+ LOG("%s total %u ms\n", gHaltRestartCtx.LogString, deltaTime);
+
+ if (gHaltLog && gHaltTimeMaxLog && (deltaTime >= gHaltTimeMaxLog)) {
+ printf("%s total %d ms:%s\n", gHaltRestartCtx.LogString, deltaTime, gHaltLog);
+ }
+
+ checkShutdownTimeout();
+}
+
+bool
+IOPMrootDomain::checkShutdownTimeout()
+{
+ AbsoluteTime elapsedTime;
+ uint32_t deltaTime = computeDeltaTimeMS(&gHaltStartTime, &elapsedTime);
+
+ if (gHaltTimeMaxPanic && (deltaTime >= gHaltTimeMaxPanic)) {
+ return true;
+ }
+ return false;
+}
+
+void
+IOPMrootDomain::panicWithShutdownLog(uint32_t timeoutInMs)
+{
+ if (gHaltLog) {
+ if ((gHaltRestartCtx.phase == kNotifyPriorityClients) && gHaltRestartCtx.handler) {
+ halt_log_enter("Blocked on priority client", (void *)gHaltRestartCtx.handler, mach_absolute_time() - gHaltStartTime);
+ }
+ panic("%s timed out in phase '%s'. Total %d ms:%s",
+ gHaltRestartCtx.LogString, shutdownPhase2String(gHaltRestartCtx.phase), timeoutInMs, gHaltLog);
+ } else {
+ panic("%s timed out in phase \'%s\'. Total %d ms",
+ gHaltRestartCtx.LogString, shutdownPhase2String(gHaltRestartCtx.phase), timeoutInMs);
+ }
+}
+
+//******************************************************************************
+// shutdownSystem
+//
+//******************************************************************************
+
+IOReturn
+IOPMrootDomain::shutdownSystem( void )
+{
+ return kIOReturnUnsupported;
+}
+
+//******************************************************************************
+// restartSystem
+//
+//******************************************************************************
+
+IOReturn
+IOPMrootDomain::restartSystem( void )
+{
+ return kIOReturnUnsupported;
+}
+
+// MARK: -
+// MARK: System Capability
+
+//******************************************************************************
+// tagPowerPlaneService
+//
+// Running on PM work loop thread.
+//******************************************************************************
+
+void
+IOPMrootDomain::tagPowerPlaneService(
+ IOService * service,
+ IOPMActions * actions,
+ IOPMPowerStateIndex maxPowerState )
+{
+ uint32_t flags = 0;
+
+ memset(actions, 0, sizeof(*actions));
+ actions->target = this;
+
+ if (service == this) {
+ actions->actionPowerChangeStart =
+ OSMemberFunctionCast(
+ IOPMActionPowerChangeStart, this,
+ &IOPMrootDomain::handleOurPowerChangeStart);
+
+ actions->actionPowerChangeDone =
+ OSMemberFunctionCast(
+ IOPMActionPowerChangeDone, this,
+ &IOPMrootDomain::handleOurPowerChangeDone);
+
+ actions->actionPowerChangeOverride =
+ OSMemberFunctionCast(
+ IOPMActionPowerChangeOverride, this,
+ &IOPMrootDomain::overrideOurPowerChange);
+ return;
+ }
+
+#if DISPLAY_WRANGLER_PRESENT
+ if (NULL != service->metaCast("IODisplayWrangler")) {
+ // XXX should this really retain?
+ wrangler.reset(service, OSRetain);
+ wrangler->registerInterest(gIOGeneralInterest,
+ &displayWranglerNotification, this, NULL);
+
+ // found the display wrangler, check for any display assertions already created
+ if (pmAssertions->getActivatedAssertions() & kIOPMDriverAssertionPreventDisplaySleepBit) {
+ DLOG("wrangler setIgnoreIdleTimer\(1) due to pre-existing assertion\n");
+ wrangler->setIgnoreIdleTimer( true );
+ }
+ flags |= kPMActionsFlagIsDisplayWrangler;
+ }
+#endif /* DISPLAY_WRANGLER_PRESENT */
+
+ if (service->propertyExists("IOPMStrictTreeOrder")) {
+ flags |= kPMActionsFlagIsGraphicsDriver;
+ }
+ if (service->propertyExists("IOPMUnattendedWakePowerState")) {
+ flags |= kPMActionsFlagIsAudioDriver;
+ }
+
+ OSSharedPtr<OSObject> prop = service->copyProperty(kIOPMDarkWakeMaxPowerStateKey);
+ if (prop) {
+ OSNumber * num = OSDynamicCast(OSNumber, prop.get());
+ if (num) {
+ actions->darkWakePowerState = num->unsigned32BitValue();
+ if (actions->darkWakePowerState < maxPowerState) {
+ flags |= kPMActionsFlagHasDarkWakePowerState;
+ }
+ }
+ }
+
+ // Find the power connection object that is a child of the PCI host
+ // bridge, and has a graphics/audio device attached below. Mark the
+ // power branch for delayed child notifications.
+
+ if (flags) {
+ IORegistryEntry * child = service;
+ IORegistryEntry * parent = child->getParentEntry(gIOPowerPlane);
+
+ while (child != this) {
+ if (child->propertyHasValue("IOPCITunnelled", kOSBooleanTrue)) {
+ // Skip delaying notifications and clamping power on external graphics and audio devices.
+ DLOG("Avoiding delayChildNotification on object 0x%llx. flags: 0x%x\n", service->getRegistryEntryID(), flags);
+ flags = 0;
+ break;
+ }
+ if ((parent == pciHostBridgeDriver) ||
+ (parent == this)) {
+ if (OSDynamicCast(IOPowerConnection, child)) {
+ IOPowerConnection * conn = (IOPowerConnection *) child;
+ conn->delayChildNotification = true;
+ DLOG("delayChildNotification for 0x%llx\n", conn->getRegistryEntryID());
+ }
+ break;
+ }
+ child = parent;
+ parent = child->getParentEntry(gIOPowerPlane);
+ }
+ }
+
+ if (flags) {
+ DLOG("%s tag flags %x\n", service->getName(), flags);
+ actions->flags |= flags;
+ actions->actionPowerChangeOverride =
+ OSMemberFunctionCast(
+ IOPMActionPowerChangeOverride, this,
+ &IOPMrootDomain::overridePowerChangeForService);
+
+ if (flags & kPMActionsFlagIsDisplayWrangler) {
+ actions->actionActivityTickle =
+ OSMemberFunctionCast(
+ IOPMActionActivityTickle, this,
+ &IOPMrootDomain::handleActivityTickleForDisplayWrangler);
+
+ actions->actionUpdatePowerClient =
+ OSMemberFunctionCast(
+ IOPMActionUpdatePowerClient, this,
+ &IOPMrootDomain::handleUpdatePowerClientForDisplayWrangler);
+ }
+ return;
+ }
+
+ // Locate the first PCI host bridge for PMTrace.
+ if (!pciHostBridgeDevice && service->metaCast("IOPCIBridge")) {
+ IOService * provider = service->getProvider();
+ if (OSDynamicCast(IOPlatformDevice, provider) &&
+ provider->inPlane(gIODTPlane)) {
+ pciHostBridgeDevice.reset(provider, OSNoRetain);
+ pciHostBridgeDriver.reset(service, OSNoRetain);
+ DLOG("PMTrace found PCI host bridge %s->%s\n",
+ provider->getName(), service->getName());
+ }
+ }
+
+ // Tag top-level PCI devices. The order of PMinit() call does not
+ // change across boots and is used as the PCI bit number.
+ if (pciHostBridgeDevice && service->metaCast("IOPCIDevice")) {
+ // Would prefer to check built-in property, but tagPowerPlaneService()
+ // is called before pciDevice->registerService().
+ IORegistryEntry * parent = service->getParentEntry(gIODTPlane);
+ if ((parent == pciHostBridgeDevice) && service->propertyExists("acpi-device")) {
+ int bit = pmTracer->recordTopLevelPCIDevice( service );
+ if (bit >= 0) {
+ // Save the assigned bit for fast lookup.
+ actions->flags |= (bit & kPMActionsPCIBitNumberMask);
+
+ actions->actionPowerChangeStart =
+ OSMemberFunctionCast(
+ IOPMActionPowerChangeStart, this,
+ &IOPMrootDomain::handlePowerChangeStartForPCIDevice);
+
+ actions->actionPowerChangeDone =
+ OSMemberFunctionCast(
+ IOPMActionPowerChangeDone, this,
+ &IOPMrootDomain::handlePowerChangeDoneForPCIDevice);
+ }
+ }
+ }
+}
+
+//******************************************************************************
+// PM actions for root domain
+//******************************************************************************
+
+void
+IOPMrootDomain::overrideOurPowerChange(
+ IOService * service,
+ IOPMActions * actions,
+ const IOPMRequest * request,
+ IOPMPowerStateIndex * inOutPowerState,
+ IOPMPowerChangeFlags * inOutChangeFlags )
+{
+ uint32_t changeFlags = *inOutChangeFlags;
+ uint32_t desiredPowerState = (uint32_t) *inOutPowerState;
+ uint32_t currentPowerState = (uint32_t) getPowerState();
+
+ if (request->getTag() == 0) {
+ // Set a tag for any request that originates from IOServicePM
+ (const_cast<IOPMRequest *>(request))->fTag = nextRequestTag(kCPSReasonPMInternals);
+ }
+
+ DLOG("PowerChangeOverride (%s->%s, %x, 0x%x) tag 0x%x\n",
+ getPowerStateString(currentPowerState),
+ getPowerStateString(desiredPowerState),
+ _currentCapability, changeFlags,
+ request->getTag());
+
+
+#if defined(XNU_TARGET_OS_OSX) && !DISPLAY_WRANGLER_PRESENT
+ /*
+ * ASBM send lowBattery notifications every 1 second until the device
+ * enters hibernation. This queues up multiple sleep requests.
+ * After the device wakes from hibernation, none of these previously
+ * queued sleep requests are valid.
+ * lowBattteryCondition variable is set when ASBM notifies rootDomain
+ * and is cleared at the very last point in sleep.
+ * Any attempt to sleep with reason kIOPMSleepReasonLowPower without
+ * lowBatteryCondition is invalid
+ */
+ if (REQUEST_TAG_TO_REASON(request->getTag()) == kIOPMSleepReasonLowPower) {
+ if (!lowBatteryCondition) {
+ DLOG("Duplicate lowBattery sleep");
+ *inOutChangeFlags |= kIOPMNotDone;
+ return;
+ }
+ }
+#endif
+
+ if ((AOT_STATE == desiredPowerState) && (ON_STATE == currentPowerState)) {
+ // Assertion may have been taken in AOT leading to changePowerStateTo(AOT)
+ *inOutChangeFlags |= kIOPMNotDone;
+ return;
+ }
+
+ if (changeFlags & kIOPMParentInitiated) {
+ // Root parent is permanently pegged at max power,
+ // a parent initiated power change is unexpected.
+ *inOutChangeFlags |= kIOPMNotDone;
+ return;
+ }
+
+ if (desiredPowerState < currentPowerState) {
+ if (CAP_CURRENT(kIOPMSystemCapabilityGraphics)) {
+ // Root domain is dropping power state from ON->SLEEP.
+ // If system is in full wake, first enter dark wake by
+ // converting the power drop to a capability change.
+ // Once in dark wake, transition to sleep state ASAP.
+
+ darkWakeToSleepASAP = true;
+
+ // Drop graphics and audio capability
+ _desiredCapability &= ~(
+ kIOPMSystemCapabilityGraphics |
+ kIOPMSystemCapabilityAudio);
+
+ // Convert to capability change (ON->ON)
+ *inOutPowerState = getRUN_STATE();
+ *inOutChangeFlags |= kIOPMSynchronize;
+
+ // Revert device desire from SLEEP to ON
+ changePowerStateWithTagToPriv(getRUN_STATE(), kCPSReasonPowerOverride);
+ } else {
+ // System is already in dark wake, ok to drop power state.
+ // Broadcast root power down to entire tree.
+ *inOutChangeFlags |= kIOPMRootChangeDown;
+ }
+ } else if (desiredPowerState > currentPowerState) {
+ if ((_currentCapability & kIOPMSystemCapabilityCPU) == 0) {
+ // Broadcast power up when waking from sleep, but not for the
+ // initial power change at boot by checking for cpu capability.
+ *inOutChangeFlags |= kIOPMRootChangeUp;
+ }
+ }
+}
+
+void
+IOPMrootDomain::handleOurPowerChangeStart(
+ IOService * service,
+ IOPMActions * actions,
+ const IOPMRequest * request,
+ IOPMPowerStateIndex newPowerState,
+ IOPMPowerChangeFlags * inOutChangeFlags )
+{
+ IOPMRequestTag requestTag = request->getTag();
+ IOPMRequestTag sleepReason;
+
+ uint32_t changeFlags = *inOutChangeFlags;
+ uint32_t currentPowerState = (uint32_t) getPowerState();
+ bool publishSleepReason = false;
+
+ // Check if request has a valid sleep reason
+ sleepReason = REQUEST_TAG_TO_REASON(requestTag);
+ if (sleepReason < kIOPMSleepReasonClamshell) {
+ sleepReason = kIOPMSleepReasonIdle;
+ }
+
+ _systemTransitionType = kSystemTransitionNone;
+ _systemMessageClientMask = 0;
+ capabilityLoss = false;
+ toldPowerdCapWillChange = false;
+
+ // Emergency notifications may arrive after the initial sleep request
+ // has been queued. Override the sleep reason so powerd and others can
+ // treat this as an emergency sleep.
+ if (lowBatteryCondition) {
+ sleepReason = kIOPMSleepReasonLowPower;
+ } else if (thermalEmergencyState) {
+ sleepReason = kIOPMSleepReasonThermalEmergency;
+ }
+
+ // 1. Explicit capability change.
+ if (changeFlags & kIOPMSynchronize) {
+ if (newPowerState == ON_STATE) {
+ if (changeFlags & kIOPMSyncNoChildNotify) {
+ _systemTransitionType = kSystemTransitionNewCapClient;
+ } else {
+ _systemTransitionType = kSystemTransitionCapability;
+ }
+ }
+ }
+ // 2. Going to sleep (cancellation still possible).
+ else if (newPowerState < currentPowerState) {
+ _systemTransitionType = kSystemTransitionSleep;
+ }
+ // 3. Woke from (idle or demand) sleep.
+ else if (!systemBooting &&
+ (changeFlags & kIOPMSelfInitiated) &&
+ (newPowerState > currentPowerState)) {
+ _systemTransitionType = kSystemTransitionWake;
+ _desiredCapability = kIOPMSystemCapabilityCPU | kIOPMSystemCapabilityNetwork;
+
+ // Early exit from dark wake to full (e.g. LID open)
+ if (kFullWakeReasonNone != fullWakeReason) {
+ _desiredCapability |= (
+ kIOPMSystemCapabilityGraphics |
+ kIOPMSystemCapabilityAudio);
+
+#if defined(XNU_TARGET_OS_OSX) && !DISPLAY_WRANGLER_PRESENT
+ if (fullWakeReason == kFullWakeReasonLocalUser) {
+ darkWakeExit = true;
+ darkWakeToSleepASAP = false;
+ setProperty(kIOPMRootDomainWakeTypeKey, isRTCAlarmWake ?
+ kIOPMRootDomainWakeTypeAlarm : kIOPMRootDomainWakeTypeUser);
+ }
+#endif
+ }
+#if HIBERNATION
+ IOHibernateSetWakeCapabilities(_desiredCapability);
+#endif
+ }
+
+ // Update pending wake capability at the beginning of every
+ // state transition (including synchronize). This will become
+ // the current capability at the end of the transition.
+
+ if (kSystemTransitionSleep == _systemTransitionType) {
+ _pendingCapability = 0;
+ capabilityLoss = true;
+ } else if (kSystemTransitionNewCapClient != _systemTransitionType) {
+ _pendingCapability = _desiredCapability |
+ kIOPMSystemCapabilityCPU |
+ kIOPMSystemCapabilityNetwork;
+
+ if (_pendingCapability & kIOPMSystemCapabilityGraphics) {
+ _pendingCapability |= kIOPMSystemCapabilityAudio;
+ }
+
+ if ((kSystemTransitionCapability == _systemTransitionType) &&
+ (_pendingCapability == _currentCapability)) {
+ // Cancel the PM state change.
+ _systemTransitionType = kSystemTransitionNone;
+ *inOutChangeFlags |= kIOPMNotDone;
+ }
+ if (__builtin_popcount(_pendingCapability) <
+ __builtin_popcount(_currentCapability)) {
+ capabilityLoss = true;
+ }
+ }
+
+ // 1. Capability change.
+ if (kSystemTransitionCapability == _systemTransitionType) {
+ // Dark to Full transition.
+ if (CAP_GAIN(kIOPMSystemCapabilityGraphics)) {
+ tracePoint( kIOPMTracePointDarkWakeExit );
+
+#if defined(XNU_TARGET_OS_OSX)
+ // rdar://problem/65627936
+ // When a dark->full wake promotion is scheduled before an ON->SLEEP
+ // power state drop, invalidate any request to drop power state already
+ // in the queue, including the override variant, unless full wake cannot
+ // be sustained. Any power state drop queued after this SustainFullWake
+ // request will not be affected.
+ if (checkSystemCanSustainFullWake()) {
+ changePowerStateWithOverrideTo(getRUN_STATE(), kCPSReasonSustainFullWake);
+ }
+#endif
+
+ willEnterFullWake();
+ }
+
+ // Full to Dark transition.
+ if (CAP_LOSS(kIOPMSystemCapabilityGraphics)) {
+ // Clear previous stats
+ IOLockLock(pmStatsLock);
+ if (pmStatsAppResponses) {
+ pmStatsAppResponses = OSArray::withCapacity(5);
+ }
+ IOLockUnlock(pmStatsLock);
+
+ tracePoint( kIOPMTracePointDarkWakeEntry );
+ *inOutChangeFlags |= kIOPMSyncTellPowerDown;
+ _systemMessageClientMask = kSystemMessageClientPowerd |
+ kSystemMessageClientLegacyApp;
+
+ // rdar://15971327
+ // Prevent user active transitions before notifying clients
+ // that system will sleep.
+ preventTransitionToUserActive(true);
+
+ IOService::setAdvisoryTickleEnable( false );
+
+ // Publish the sleep reason for full to dark wake
+ publishSleepReason = true;
+ lastSleepReason = fullToDarkReason = sleepReason;
+
+ // Publish a UUID for the Sleep --> Wake cycle
+ handlePublishSleepWakeUUID(true);
+ if (sleepDelaysReport) {
+ clock_get_uptime(&ts_sleepStart);
+ DLOG("sleepDelaysReport f->9 start at 0x%llx\n", ts_sleepStart);
+ }
+
+ darkWakeExit = false;
+ }
+ }
+ // 2. System sleep.
+ else if (kSystemTransitionSleep == _systemTransitionType) {
+ // Beginning of a system sleep transition.
+ // Cancellation is still possible.
+ tracePoint( kIOPMTracePointSleepStarted );
+
+ _systemMessageClientMask = kSystemMessageClientAll;
+ if ((_currentCapability & kIOPMSystemCapabilityGraphics) == 0) {
+ _systemMessageClientMask &= ~kSystemMessageClientLegacyApp;
+ }
+ if ((_highestCapability & kIOPMSystemCapabilityGraphics) == 0) {
+ // Kernel priority clients are only notified on the initial
+ // transition to full wake, so don't notify them unless system
+ // has gained graphics capability since the last system wake.
+ _systemMessageClientMask &= ~kSystemMessageClientKernel;
+ } else {
+ // System was in full wake, but the downwards power transition is driven
+ // by a request that originates from IOServicePM, so it isn't tagged with
+ // a valid system sleep reason.
+ if (REQUEST_TAG_TO_REASON(requestTag) == kCPSReasonPMInternals) {
+ // Publish the same reason for full to dark
+ sleepReason = fullToDarkReason;
+ }
+ }
+#if HIBERNATION
+ gIOHibernateState = 0;
+#endif
+
+ // Record the reason for dark wake back to sleep
+ // System may not have ever achieved full wake
+
+ publishSleepReason = true;
+ lastSleepReason = sleepReason;
+ if (sleepDelaysReport) {
+ clock_get_uptime(&ts_sleepStart);
+ DLOG("sleepDelaysReport 9->0 start at 0x%llx\n", ts_sleepStart);
+ }
+ }
+ // 3. System wake.
+ else if (kSystemTransitionWake == _systemTransitionType) {
+ tracePoint( kIOPMTracePointWakeWillPowerOnClients );
+ // Clear stats about sleep
+
+ if (AOT_STATE == newPowerState) {
+ _pendingCapability = 0;
+ }
+
+ if (AOT_STATE == currentPowerState) {
+ // Wake events are no longer accepted after waking to AOT_STATE.
+ // Re-enable wake event acceptance to append wake events claimed
+ // during the AOT to ON_STATE transition.
+ acceptSystemWakeEvents(kAcceptSystemWakeEvents_Reenable);
+ }
+
+ if (_pendingCapability & kIOPMSystemCapabilityGraphics) {
+ willEnterFullWake();
+ }
+ }
+
+ // The only location where the sleep reason is published. At this point
+ // sleep can still be cancelled, but sleep reason should be published
+ // early for logging purposes.
+
+ if (publishSleepReason) {
+ static const char * IOPMSleepReasons[] =
+ {
+ kIOPMClamshellSleepKey,
+ kIOPMPowerButtonSleepKey,
+ kIOPMSoftwareSleepKey,
+ kIOPMOSSwitchHibernationKey,
+ kIOPMIdleSleepKey,
+ kIOPMLowPowerSleepKey,
+ kIOPMThermalEmergencySleepKey,
+ kIOPMMaintenanceSleepKey,
+ kIOPMSleepServiceExitKey,
+ kIOPMDarkWakeThermalEmergencyKey,
+ kIOPMNotificationWakeExitKey
+ };
+
+ // Record sleep cause in IORegistry
+ uint32_t reasonIndex = sleepReason - kIOPMSleepReasonClamshell;
+ if (reasonIndex < sizeof(IOPMSleepReasons) / sizeof(IOPMSleepReasons[0])) {
+ DLOG("sleep reason %s\n", IOPMSleepReasons[reasonIndex]);
+ setProperty(kRootDomainSleepReasonKey, IOPMSleepReasons[reasonIndex]);
+ }
+ }
+
+ if ((kSystemTransitionNone != _systemTransitionType) &&
+ (kSystemTransitionNewCapClient != _systemTransitionType)) {
+ _systemStateGeneration++;
+ systemDarkWake = false;
+
+ DLOG("=== START (%s->%s, %x->%x, 0x%x) gen %u, msg %x, tag %x\n",
+ getPowerStateString(currentPowerState),
+ getPowerStateString((uint32_t) newPowerState),
+ _currentCapability, _pendingCapability,
+ *inOutChangeFlags, _systemStateGeneration, _systemMessageClientMask,
+ requestTag);
+ }
+
+ if ((AOT_STATE == newPowerState) && (SLEEP_STATE != currentPowerState)) {
+ panic("illegal AOT entry from %s", getPowerStateString(currentPowerState));
+ }
+ if (_aotNow && (ON_STATE == newPowerState)) {
+ WAKEEVENT_LOCK();
+ aotShouldExit(false, true);
+ WAKEEVENT_UNLOCK();
+ aotExit(false);
+ }
+}
+
+void
+IOPMrootDomain::handleOurPowerChangeDone(
+ IOService * service,
+ IOPMActions * actions,
+ const IOPMRequest * request,
+ IOPMPowerStateIndex oldPowerState,
+ IOPMPowerChangeFlags changeFlags )
+{
+ if (kSystemTransitionNewCapClient == _systemTransitionType) {
+ _systemTransitionType = kSystemTransitionNone;
+ return;
+ }
+
+ if (_systemTransitionType != kSystemTransitionNone) {
+ uint32_t currentPowerState = (uint32_t) getPowerState();
+
+ if (changeFlags & kIOPMNotDone) {
+ // Power down was cancelled or vetoed.
+ _pendingCapability = _currentCapability;
+ lastSleepReason = 0;
+
+ // When sleep is cancelled or reverted, don't report
+ // the target (lower) power state as the previous state.
+ oldPowerState = currentPowerState;
+
+ if (!CAP_CURRENT(kIOPMSystemCapabilityGraphics) &&
+ CAP_CURRENT(kIOPMSystemCapabilityCPU)) {
+#if defined(XNU_TARGET_OS_OSX)
+ pmPowerStateQueue->submitPowerEvent(
+ kPowerEventPolicyStimulus,
+ (void *) kStimulusDarkWakeReentry,
+ _systemStateGeneration );
+#else /* !defined(XNU_TARGET_OS_OSX) */
+ // On embedded, there are no factors that can prolong a
+ // "darkWake" when a power down is vetoed. We need to
+ // promote to "fullWake" at least once so that factors
+ // that prevent idle sleep can assert themselves if required
+ pmPowerStateQueue->submitPowerEvent(
+ kPowerEventPolicyStimulus,
+ (void *) kStimulusDarkWakeActivityTickle);
+#endif /* !defined(XNU_TARGET_OS_OSX) */
+ }
+
+ // Revert device desire to max.
+ changePowerStateWithTagToPriv(getRUN_STATE(), kCPSReasonPowerDownCancel);
+ } else {
+ // Send message on dark wake to full wake promotion.
+ // tellChangeUp() handles the normal SLEEP->ON case.
+
+ if (kSystemTransitionCapability == _systemTransitionType) {
+ if (CAP_GAIN(kIOPMSystemCapabilityGraphics)) {
+ lastSleepReason = 0; // stop logging wrangler tickles
+ tellClients(kIOMessageSystemHasPoweredOn);
+ }
+ if (CAP_LOSS(kIOPMSystemCapabilityGraphics)) {
+ // Going dark, reset full wake state
+ // userIsActive will be cleared by wrangler powering down
+ fullWakeReason = kFullWakeReasonNone;
+
+ if (ts_sleepStart) {
+ clock_get_uptime(&wake2DarkwakeDelay);
+ SUB_ABSOLUTETIME(&wake2DarkwakeDelay, &ts_sleepStart);
+ DLOG("sleepDelaysReport f->9 end 0x%llx\n", wake2DarkwakeDelay);
+ ts_sleepStart = 0;
+ }
+ }
+ }
+
+ // Reset state after exiting from dark wake.
+
+ if (CAP_GAIN(kIOPMSystemCapabilityGraphics) ||
+ CAP_LOSS(kIOPMSystemCapabilityCPU)) {
+ darkWakeMaintenance = false;
+ darkWakeToSleepASAP = false;
+ pciCantSleepValid = false;
+ darkWakeSleepService = false;
+
+ if (CAP_LOSS(kIOPMSystemCapabilityCPU)) {
+ // Remove the influence of display power assertion
+ // before next system wake.
+ if (wrangler) {
+ wrangler->changePowerStateForRootDomain(
+ kWranglerPowerStateMin );
+ }
+ removeProperty(gIOPMUserTriggeredFullWakeKey.get());
+ }
+ }
+
+ // Entered dark mode.
+
+ if (((_pendingCapability & kIOPMSystemCapabilityGraphics) == 0) &&
+ (_pendingCapability & kIOPMSystemCapabilityCPU)) {
+ // Queue an evaluation of whether to remain in dark wake,
+ // and for how long. This serves the purpose of draining
+ // any assertions from the queue.
+
+ pmPowerStateQueue->submitPowerEvent(
+ kPowerEventPolicyStimulus,
+ (void *) kStimulusDarkWakeEntry,
+ _systemStateGeneration );
+ }
+ }
+
+ DLOG("=== FINISH (%s->%s, %x->%x, 0x%x) gen %u, msg %x, tag %x\n",
+ getPowerStateString((uint32_t) oldPowerState), getPowerStateString(currentPowerState),
+ _currentCapability, _pendingCapability,
+ changeFlags, _systemStateGeneration, _systemMessageClientMask,
+ request->getTag());
+
+ if ((currentPowerState == ON_STATE) && pmAssertions) {
+ pmAssertions->reportCPUBitAccounting();
+ }
+
+ if (_pendingCapability & kIOPMSystemCapabilityGraphics) {
+ displayWakeCnt++;
+#if DARK_TO_FULL_EVALUATE_CLAMSHELL_DELAY
+ if (clamshellExists && fullWakeThreadCall) {
+ AbsoluteTime deadline;
+ clock_interval_to_deadline(DARK_TO_FULL_EVALUATE_CLAMSHELL_DELAY, kSecondScale, &deadline);
+ thread_call_enter_delayed(fullWakeThreadCall, deadline);
+ }
+#endif
+ } else if (CAP_GAIN(kIOPMSystemCapabilityCPU)) {
+ darkWakeCnt++;
+ }
+
+ // Update current system capability.
+ if (_currentCapability != _pendingCapability) {
+ _currentCapability = _pendingCapability;
+ }
+
+ // Update highest system capability.
+
+ _highestCapability |= _currentCapability;
+
+ if (darkWakePostTickle &&
+ (kSystemTransitionWake == _systemTransitionType) &&
+ (gDarkWakeFlags & kDarkWakeFlagPromotionMask) ==
+ kDarkWakeFlagPromotionLate) {
+ darkWakePostTickle = false;
+ reportUserInput();
+ } else if (darkWakeExit) {
+ requestFullWake( kFullWakeReasonLocalUser );
+ }
+
+ // Reset tracepoint at completion of capability change,
+ // completion of wake transition, and aborted sleep transition.
+
+ if ((_systemTransitionType == kSystemTransitionCapability) ||
+ (_systemTransitionType == kSystemTransitionWake) ||
+ ((_systemTransitionType == kSystemTransitionSleep) &&
+ (changeFlags & kIOPMNotDone))) {
+ setProperty(kIOPMSystemCapabilitiesKey, _currentCapability, 64);
+ tracePoint( kIOPMTracePointSystemUp );
+ }
+
+ _systemTransitionType = kSystemTransitionNone;
+ _systemMessageClientMask = 0;
+ toldPowerdCapWillChange = false;
+
+ darkWakeLogClamp = false;
+
+ if (lowBatteryCondition) {
+ privateSleepSystem(kIOPMSleepReasonLowPower);
+ } else if (thermalEmergencyState) {
+ privateSleepSystem(kIOPMSleepReasonThermalEmergency);
+ } else if ((fullWakeReason == kFullWakeReasonDisplayOn) && !displayPowerOnRequested) {
+ // Request for full wake is removed while system is waking up to full wake
+ DLOG("DisplayOn fullwake request is removed\n");
+ handleSetDisplayPowerOn(false);
+ }
+
+ if ((gClamshellFlags & kClamshell_WAR_47715679) && isRTCAlarmWake) {
+ pmPowerStateQueue->submitPowerEvent(
+ kPowerEventReceivedPowerNotification, (void *)(uintptr_t) kLocalEvalClamshellCommand );
+ }
+ }
+}
+
+//******************************************************************************
+// PM actions for graphics and audio.
+//******************************************************************************
+
+void
+IOPMrootDomain::overridePowerChangeForService(
+ IOService * service,
+ IOPMActions * actions,
+ const IOPMRequest * request,
+ IOPMPowerStateIndex * inOutPowerState,
+ IOPMPowerChangeFlags * inOutChangeFlags )
+{
+ uint32_t powerState = (uint32_t) *inOutPowerState;
+ uint32_t changeFlags = (uint32_t) *inOutChangeFlags;
+ const uint32_t actionFlags = actions->flags;
+
+ if (kSystemTransitionNone == _systemTransitionType) {
+ // Not in midst of a system transition.
+ // Do not set kPMActionsStatePowerClamped.
+ } else if ((actions->state & kPMActionsStatePowerClamped) == 0) {
+ bool enableClamp = false;
+
+ // For most drivers, enable the clamp during ON->Dark transition
+ // which has the kIOPMSynchronize flag set in changeFlags.
+ if ((actionFlags & kPMActionsFlagIsDisplayWrangler) &&
+ ((_pendingCapability & kIOPMSystemCapabilityGraphics) == 0) &&
+ (changeFlags & kIOPMSynchronize)) {
+ enableClamp = true;
+ } else if ((actionFlags & kPMActionsFlagIsAudioDriver) &&
+ ((gDarkWakeFlags & kDarkWakeFlagAudioNotSuppressed) == 0) &&
+ ((_pendingCapability & kIOPMSystemCapabilityAudio) == 0) &&
+ (changeFlags & kIOPMSynchronize)) {
+ enableClamp = true;
+ } else if ((actionFlags & kPMActionsFlagHasDarkWakePowerState) &&
+ ((_pendingCapability & kIOPMSystemCapabilityGraphics) == 0) &&
+ (changeFlags & kIOPMSynchronize)) {
+ enableClamp = true;
+ } else if ((actionFlags & kPMActionsFlagIsGraphicsDriver) &&
+ (_systemTransitionType == kSystemTransitionSleep)) {
+ // For graphics drivers, clamp power when entering
+ // system sleep. Not when dropping to dark wake.
+ enableClamp = true;
+ }
+
+ if (enableClamp) {
+ actions->state |= kPMActionsStatePowerClamped;
+ DLOG("power clamp enabled %s %qx, pendingCap 0x%x, ps %d, cflags 0x%x\n",
+ service->getName(), service->getRegistryEntryID(),
+ _pendingCapability, powerState, changeFlags);
+ }
+ } else if ((actions->state & kPMActionsStatePowerClamped) != 0) {
+ bool disableClamp = false;
+
+ if ((actionFlags & (
+ kPMActionsFlagIsDisplayWrangler |
+ kPMActionsFlagIsGraphicsDriver)) &&
+ (_pendingCapability & kIOPMSystemCapabilityGraphics)) {
+ disableClamp = true;
+ } else if ((actionFlags & kPMActionsFlagIsAudioDriver) &&
+ (_pendingCapability & kIOPMSystemCapabilityAudio)) {
+ disableClamp = true;
+ } else if ((actionFlags & kPMActionsFlagHasDarkWakePowerState) &&
+ (_pendingCapability & kIOPMSystemCapabilityGraphics)) {
+ disableClamp = true;
+ }
+
+ if (disableClamp) {
+ actions->state &= ~kPMActionsStatePowerClamped;
+ DLOG("power clamp removed %s %qx, pendingCap 0x%x, ps %d, cflags 0x%x\n",
+ service->getName(), service->getRegistryEntryID(),
+ _pendingCapability, powerState, changeFlags);
+ }
+ }
+
+ if (actions->state & kPMActionsStatePowerClamped) {
+ uint32_t maxPowerState = 0;
+
+ // Determine the max power state allowed when clamp is enabled
+ if (changeFlags & (kIOPMDomainDidChange | kIOPMDomainWillChange)) {
+ // Parent intiated power state changes
+ if ((service->getPowerState() > maxPowerState) &&
+ (actionFlags & kPMActionsFlagIsDisplayWrangler)) {
+ maxPowerState++;
+
+ // Remove lingering effects of any tickle before entering
+ // dark wake. It will take a new tickle to return to full
+ // wake, so the existing tickle state is useless.
+
+ if (changeFlags & kIOPMDomainDidChange) {
+ *inOutChangeFlags |= kIOPMExpireIdleTimer;
+ }
+ } else if (actionFlags & kPMActionsFlagIsGraphicsDriver) {
+ maxPowerState++;
+ } else if (actionFlags & kPMActionsFlagHasDarkWakePowerState) {
+ maxPowerState = actions->darkWakePowerState;
+ }
+ } else {
+ // Deny all self-initiated changes when power is limited.
+ // Wrangler tickle should never defeat the limiter.
+ maxPowerState = service->getPowerState();
+ }
+
+ if (powerState > maxPowerState) {
+ DLOG("power clamped %s %qx, ps %u->%u, cflags 0x%x)\n",
+ service->getName(), service->getRegistryEntryID(),
+ powerState, maxPowerState, changeFlags);
+ *inOutPowerState = maxPowerState;
+
+ if (darkWakePostTickle &&
+ (actionFlags & kPMActionsFlagIsDisplayWrangler) &&
+ (changeFlags & kIOPMDomainWillChange) &&
+ ((gDarkWakeFlags & kDarkWakeFlagPromotionMask) ==
+ kDarkWakeFlagPromotionEarly)) {
+ darkWakePostTickle = false;
+ reportUserInput();
+ }
+ }
+
+ if (!darkWakePowerClamped && (changeFlags & kIOPMDomainDidChange)) {
+ if (darkWakeLogClamp) {
+ AbsoluteTime now;
+ uint64_t nsec;
+
+ clock_get_uptime(&now);
+ SUB_ABSOLUTETIME(&now, &gIOLastWakeAbsTime);
+ absolutetime_to_nanoseconds(now, &nsec);
+ DLOG("dark wake power clamped after %u ms\n",
+ ((int)((nsec) / NSEC_PER_MSEC)));
+ }
+ darkWakePowerClamped = true;
+ }
+ }
+}
+
+void
+IOPMrootDomain::handleActivityTickleForDisplayWrangler(
+ IOService * service,
+ IOPMActions * actions )
+{
+#if DISPLAY_WRANGLER_PRESENT
+ // Warning: Not running in PM work loop context - don't modify state !!!
+ // Trap tickle directed to IODisplayWrangler while running with graphics
+ // capability suppressed.
+
+ assert(service == wrangler);
+
+ clock_get_uptime(&userActivityTime);
+ bool aborting = ((lastSleepReason == kIOPMSleepReasonIdle)
+ || (lastSleepReason == kIOPMSleepReasonMaintenance)
+ || (lastSleepReason == kIOPMSleepReasonSoftware));
+ if (aborting) {
+ userActivityCount++;
+ DLOG("display wrangler tickled1 %d lastSleepReason %d\n",
+ userActivityCount, lastSleepReason);
+ }
+
+ if (!darkWakeExit && ((_pendingCapability & kIOPMSystemCapabilityGraphics) == 0)) {
+ DLOG("display wrangler tickled\n");
+ if (kIOLogPMRootDomain & gIOKitDebug) {
+ OSReportWithBacktrace("Dark wake display tickle");
+ }
+ if (pmPowerStateQueue) {
+ pmPowerStateQueue->submitPowerEvent(
+ kPowerEventPolicyStimulus,
+ (void *) kStimulusDarkWakeActivityTickle,
+ true /* set wake type */ );
+ }
+ }
+#endif /* DISPLAY_WRANGLER_PRESENT */
+}
+
+void
+IOPMrootDomain::handleUpdatePowerClientForDisplayWrangler(
+ IOService * service,
+ IOPMActions * actions,
+ const OSSymbol * powerClient,
+ IOPMPowerStateIndex oldPowerState,
+ IOPMPowerStateIndex newPowerState )
+{
+#if DISPLAY_WRANGLER_PRESENT
+ assert(service == wrangler);
+
+ // This function implements half of the user active detection
+ // by monitoring changes to the display wrangler's device desire.
+ //
+ // User becomes active when either:
+ // 1. Wrangler's DeviceDesire increases to max, but wrangler is already
+ // in max power state. This desire change in absence of a power state
+ // change is detected within. This handles the case when user becomes
+ // active while the display is already lit by setDisplayPowerOn().
+ //
+ // 2. Power state change to max, and DeviceDesire is also at max.
+ // Handled by displayWranglerNotification().
+ //
+ // User becomes inactive when DeviceDesire drops to sleep state or below.
+
+ DLOG("wrangler %s (ps %u, %u->%u)\n",
+ powerClient->getCStringNoCopy(),
+ (uint32_t) service->getPowerState(),
+ (uint32_t) oldPowerState, (uint32_t) newPowerState);
+
+ if (powerClient == gIOPMPowerClientDevice) {
+ if ((newPowerState > oldPowerState) &&
+ (newPowerState == kWranglerPowerStateMax) &&
+ (service->getPowerState() == kWranglerPowerStateMax)) {
+ evaluatePolicy( kStimulusEnterUserActiveState );
+ } else if ((newPowerState < oldPowerState) &&
+ (newPowerState <= kWranglerPowerStateSleep)) {
+ evaluatePolicy( kStimulusLeaveUserActiveState );
+ }
+ }
+
+ if (newPowerState <= kWranglerPowerStateSleep) {
+ evaluatePolicy( kStimulusDisplayWranglerSleep );
+ } else if (newPowerState == kWranglerPowerStateMax) {
+ evaluatePolicy( kStimulusDisplayWranglerWake );
+ }
+#endif /* DISPLAY_WRANGLER_PRESENT */
+}
+
+//******************************************************************************
+// User active state management
+//******************************************************************************
+
+void
+IOPMrootDomain::preventTransitionToUserActive( bool prevent )
+{
+#if DISPLAY_WRANGLER_PRESENT
+ _preventUserActive = prevent;
+ if (wrangler && !_preventUserActive) {
+ // Allowing transition to user active, but the wrangler may have
+ // already powered ON in case of sleep cancel/revert. Poll the
+ // same conditions checked for in displayWranglerNotification()
+ // to bring the user active state up to date.
+
+ if ((wrangler->getPowerState() == kWranglerPowerStateMax) &&
+ (wrangler->getPowerStateForClient(gIOPMPowerClientDevice) ==
+ kWranglerPowerStateMax)) {
+ evaluatePolicy( kStimulusEnterUserActiveState );
+ }
+ }
+#endif /* DISPLAY_WRANGLER_PRESENT */
+}
+
+//******************************************************************************
+// Approve usage of delayed child notification by PM.
+//******************************************************************************
+
+bool
+IOPMrootDomain::shouldDelayChildNotification(
+ IOService * service )
+{
+ if ((kFullWakeReasonNone == fullWakeReason) &&
+ (kSystemTransitionWake == _systemTransitionType)) {
+ DLOG("%s: delay child notify\n", service->getName());
+ return true;
+ }
+ return false;
+}
+
+//******************************************************************************
+// PM actions for PCI device.
+//******************************************************************************
+
+void
+IOPMrootDomain::handlePowerChangeStartForPCIDevice(
+ IOService * service,
+ IOPMActions * actions,
+ const IOPMRequest * request,
+ IOPMPowerStateIndex powerState,
+ IOPMPowerChangeFlags * inOutChangeFlags )
+{
+ pmTracer->tracePCIPowerChange(
+ PMTraceWorker::kPowerChangeStart,
+ service, *inOutChangeFlags,
+ (actions->flags & kPMActionsPCIBitNumberMask));
+}
+
+void
+IOPMrootDomain::handlePowerChangeDoneForPCIDevice(
+ IOService * service,
+ IOPMActions * actions,
+ const IOPMRequest * request,
+ IOPMPowerStateIndex powerState,
+ IOPMPowerChangeFlags changeFlags )
+{
+ pmTracer->tracePCIPowerChange(
+ PMTraceWorker::kPowerChangeCompleted,
+ service, changeFlags,
+ (actions->flags & kPMActionsPCIBitNumberMask));
+}
+
+//******************************************************************************
+// registerInterest
+//
+// Override IOService::registerInterest() for root domain clients.
+//******************************************************************************
+
+class IOPMServiceInterestNotifier : public _IOServiceInterestNotifier
+{
+ friend class IOPMrootDomain;
+ OSDeclareDefaultStructors(IOPMServiceInterestNotifier);
+
+protected:
+ uint32_t ackTimeoutCnt;
+ uint32_t msgType; // Message pending ack
+ uint32_t msgIndex;
+ uint32_t maxMsgDelayMS;
+ uint32_t maxAckDelayMS;
+ uint64_t msgAbsTime;
+ uint64_t uuid0;
+ uint64_t uuid1;
+ OSSharedPtr<const OSSymbol> identifier;
+ OSSharedPtr<const OSSymbol> clientName;
+};
+
+OSDefineMetaClassAndStructors(IOPMServiceInterestNotifier, _IOServiceInterestNotifier)
+
+OSSharedPtr<IONotifier>
+IOPMrootDomain::registerInterest(
+ const OSSymbol * typeOfInterest,
+ IOServiceInterestHandler handler,
+ void * target, void * ref )
+{
+ IOPMServiceInterestNotifier* notifier;
+ bool isSystemCapabilityClient;
+ bool isKernelCapabilityClient;
+ IOReturn rc = kIOReturnError;
+
+ isSystemCapabilityClient = typeOfInterest &&
+ typeOfInterest->isEqualTo(kIOPMSystemCapabilityInterest);
+
+ isKernelCapabilityClient = typeOfInterest &&
+ typeOfInterest->isEqualTo(gIOPriorityPowerStateInterest);
+
+ if (isSystemCapabilityClient) {
+ typeOfInterest = gIOAppPowerStateInterest;
+ }
+
+ notifier = new IOPMServiceInterestNotifier;
+ if (!notifier) {
+ return NULL;
+ }
+
+ if (notifier->init()) {
+ rc = super::registerInterestForNotifier(notifier, typeOfInterest, handler, target, ref);
+ }
+ if (rc != kIOReturnSuccess) {
+ return NULL;
+ }
+
+ notifier->ackTimeoutCnt = 0;
+
+ if (pmPowerStateQueue) {
+ if (isSystemCapabilityClient) {
+ notifier->retain();
+ if (pmPowerStateQueue->submitPowerEvent(
+ kPowerEventRegisterSystemCapabilityClient, notifier) == false) {
+ notifier->release();
+ }
+ }
+
+ if (isKernelCapabilityClient) {
+ notifier->retain();
+ if (pmPowerStateQueue->submitPowerEvent(
+ kPowerEventRegisterKernelCapabilityClient, notifier) == false) {
+ notifier->release();
+ }
+ }
+ }
+
+ OSSharedPtr<OSData> data;
+ uint8_t *uuid = NULL;
+ OSSharedPtr<OSKext> kext = OSKext::lookupKextWithAddress((vm_address_t)handler);
+ if (kext) {
+ data = kext->copyUUID();
+ }
+ if (data && (data->getLength() == sizeof(uuid_t))) {
+ uuid = (uint8_t *)(data->getBytesNoCopy());
+
+ notifier->uuid0 = ((uint64_t)(uuid[0]) << 56) | ((uint64_t)(uuid[1]) << 48) | ((uint64_t)(uuid[2]) << 40) |
+ ((uint64_t)(uuid[3]) << 32) | ((uint64_t)(uuid[4]) << 24) | ((uint64_t)(uuid[5]) << 16) |
+ ((uint64_t)(uuid[6]) << 8) | (uuid[7]);
+ notifier->uuid1 = ((uint64_t)(uuid[8]) << 56) | ((uint64_t)(uuid[9]) << 48) | ((uint64_t)(uuid[10]) << 40) |
+ ((uint64_t)(uuid[11]) << 32) | ((uint64_t)(uuid[12]) << 24) | ((uint64_t)(uuid[13]) << 16) |
+ ((uint64_t)(uuid[14]) << 8) | (uuid[15]);
+
+ notifier->identifier = copyKextIdentifierWithAddress((vm_address_t) handler);
+ }
+ return OSSharedPtr<IOPMServiceInterestNotifier>(notifier, OSNoRetain);
+}
+
+//******************************************************************************
+// systemMessageFilter
+//
+//******************************************************************************
+
+bool
+IOPMrootDomain::systemMessageFilter(
+ void * object, void * arg1, void * arg2, void * arg3 )
+{
+ const IOPMInterestContext * context = (const IOPMInterestContext *) arg1;
+ bool isCapMsg = (context->messageType == kIOMessageSystemCapabilityChange);
+ bool isCapClient = false;
+ bool allow = false;
+ IOPMServiceInterestNotifier *notifier;
+
+ notifier = OSDynamicCast(IOPMServiceInterestNotifier, (OSObject *)object);
+
+ do {
+ if ((kSystemTransitionNewCapClient == _systemTransitionType) &&
+ (!isCapMsg || !_joinedCapabilityClients ||
+ !_joinedCapabilityClients->containsObject((OSObject *) object))) {
+ break;
+ }
+
+ // Capability change message for app and kernel clients.
+
+ if (isCapMsg) {
+ // Kernel clients
+ if ((context->notifyType == kNotifyPriority) ||
+ (context->notifyType == kNotifyCapabilityChangePriority)) {
+ isCapClient = true;
+ }
+
+ // powerd's systemCapabilityNotifier
+ if ((context->notifyType == kNotifyCapabilityChangeApps) &&
+ (object == (void *) systemCapabilityNotifier.get())) {
+ isCapClient = true;
+ }
+ }
+
+ if (isCapClient) {
+ IOPMSystemCapabilityChangeParameters * capArgs =
+ (IOPMSystemCapabilityChangeParameters *) arg2;
+
+ if (kSystemTransitionNewCapClient == _systemTransitionType) {
+ capArgs->fromCapabilities = 0;
+ capArgs->toCapabilities = _currentCapability;
+ capArgs->changeFlags = 0;
+ } else {
+ capArgs->fromCapabilities = _currentCapability;
+ capArgs->toCapabilities = _pendingCapability;
+
+ if (context->isPreChange) {
+ capArgs->changeFlags = kIOPMSystemCapabilityWillChange;
+ } else {
+ capArgs->changeFlags = kIOPMSystemCapabilityDidChange;
+ }
+
+ if ((object == (void *) systemCapabilityNotifier.get()) &&
+ context->isPreChange) {
+ toldPowerdCapWillChange = true;
+ }
+ }
+
+ // Capability change messages only go to the PM configd plugin.
+ // Wait for response post-change if capabilitiy is increasing.
+ // Wait for response pre-change if capability is decreasing.
+
+ if ((context->notifyType == kNotifyCapabilityChangeApps) && arg3 &&
+ ((capabilityLoss && context->isPreChange) ||
+ (!capabilityLoss && !context->isPreChange))) {
+ // app has not replied yet, wait for it
+ *((OSObject **) arg3) = kOSBooleanFalse;
+ }
+
+ allow = true;
+ break;
+ }
+
+ // Capability client will always see kIOMessageCanSystemSleep,
+ // even for demand sleep. It will also have a chance to veto
+ // sleep one last time after all clients have responded to
+ // kIOMessageSystemWillSleep
+
+ if ((kIOMessageCanSystemSleep == context->messageType) ||
+ (kIOMessageSystemWillNotSleep == context->messageType)) {
+ if (object == (OSObject *) systemCapabilityNotifier.get()) {
+ allow = true;
+ break;
+ }
+
+ // Not idle sleep, don't ask apps.
+ if (context->changeFlags & kIOPMSkipAskPowerDown) {
+ break;
+ }
+ }
+
+ if (kIOPMMessageLastCallBeforeSleep == context->messageType) {
+ if ((object == (OSObject *) systemCapabilityNotifier.get()) &&
+ CAP_HIGHEST(kIOPMSystemCapabilityGraphics) &&
+ (fullToDarkReason == kIOPMSleepReasonIdle)) {
+ allow = true;
+ }
+ break;
+ }
+
+ // Reject capability change messages for legacy clients.
+ // Reject legacy system sleep messages for capability client.
+
+ if (isCapMsg || (object == (OSObject *) systemCapabilityNotifier.get())) {
+ break;
+ }
+
+ // Filter system sleep messages.
+
+ if ((context->notifyType == kNotifyApps) &&
+ (_systemMessageClientMask & kSystemMessageClientLegacyApp)) {
+ allow = true;
+
+ if (notifier) {
+ if (arg3) {
+ if (notifier->ackTimeoutCnt >= 3) {
+ *((OSObject **) arg3) = kOSBooleanFalse;
+ } else {
+ *((OSObject **) arg3) = kOSBooleanTrue;
+ }
+ }
+ }
+ } else if ((context->notifyType == kNotifyPriority) &&
+ (_systemMessageClientMask & kSystemMessageClientKernel)) {
+ allow = true;
+ }
+ }while (false);
+
+ if (allow && isCapMsg && _joinedCapabilityClients) {
+ _joinedCapabilityClients->removeObject((OSObject *) object);
+ if (_joinedCapabilityClients->getCount() == 0) {
+ DLOG("destroyed capability client set %p\n",
+ OBFUSCATE(_joinedCapabilityClients.get()));
+ _joinedCapabilityClients.reset();
+ }
+ }
+ if (notifier) {
+ notifier->msgType = context->messageType;
+ }
+
+ return allow;
+}
+
+//******************************************************************************
+// setMaintenanceWakeCalendar
+//
+//******************************************************************************
+
+IOReturn
+IOPMrootDomain::setMaintenanceWakeCalendar(
+ const IOPMCalendarStruct * calendar )
+{
+ OSSharedPtr<OSData> data;
+ IOReturn ret = 0;
+
+ if (!calendar) {
+ return kIOReturnBadArgument;
+ }
+
+ data = OSData::withBytes((void *) calendar, sizeof(*calendar));
+ if (!data) {
+ return kIOReturnNoMemory;
+ }
+
+ if (kPMCalendarTypeMaintenance == calendar->selector) {
+ ret = setPMSetting(gIOPMSettingMaintenanceWakeCalendarKey.get(), data.get());
+ } else if (kPMCalendarTypeSleepService == calendar->selector) {
+ ret = setPMSetting(gIOPMSettingSleepServiceWakeCalendarKey.get(), data.get());
+ }
+
+ return ret;
+}
+
+// MARK: -
+// MARK: Display Wrangler
+
+//******************************************************************************
+// displayWranglerNotification
+//
+// Handle the notification when the IODisplayWrangler changes power state.
+//******************************************************************************
+
+IOReturn
+IOPMrootDomain::displayWranglerNotification(
+ void * target, void * refCon,
+ UInt32 messageType, IOService * service,
+ void * messageArgument, vm_size_t argSize )
+{
+#if DISPLAY_WRANGLER_PRESENT
+ IOPMPowerStateIndex displayPowerState;
+ IOPowerStateChangeNotification * params =
+ (IOPowerStateChangeNotification *) messageArgument;
+
+ if ((messageType != kIOMessageDeviceWillPowerOff) &&
+ (messageType != kIOMessageDeviceHasPoweredOn)) {
+ return kIOReturnUnsupported;
+ }
+
+ ASSERT_GATED();
+ if (!gRootDomain) {
+ return kIOReturnUnsupported;
+ }
+
+ displayPowerState = params->stateNumber;
+ DLOG("wrangler %s ps %d\n",
+ getIOMessageString(messageType), (uint32_t) displayPowerState);
+
+ switch (messageType) {
+ case kIOMessageDeviceWillPowerOff:
+ // Display wrangler has dropped power due to display idle
+ // or force system sleep.
+ //
+ // 4 Display ON kWranglerPowerStateMax
+ // 3 Display Dim kWranglerPowerStateDim
+ // 2 Display Sleep kWranglerPowerStateSleep
+ // 1 Not visible to user
+ // 0 Not visible to user kWranglerPowerStateMin
+
+ if (displayPowerState <= kWranglerPowerStateSleep) {
+ gRootDomain->evaluatePolicy( kStimulusDisplayWranglerSleep );
+ }
+ break;
+
+ case kIOMessageDeviceHasPoweredOn:
+ // Display wrangler has powered on due to user activity
+ // or wake from sleep.
+
+ if (kWranglerPowerStateMax == displayPowerState) {
+ gRootDomain->evaluatePolicy( kStimulusDisplayWranglerWake );
+
+ // See comment in handleUpdatePowerClientForDisplayWrangler
+ if (service->getPowerStateForClient(gIOPMPowerClientDevice) ==
+ kWranglerPowerStateMax) {
+ gRootDomain->evaluatePolicy( kStimulusEnterUserActiveState );
+ }
+ }
+ break;
+ }
+#endif /* DISPLAY_WRANGLER_PRESENT */
+ return kIOReturnUnsupported;
+}
+
+//******************************************************************************
+// reportUserInput
+//
+//******************************************************************************
+
+void
+IOPMrootDomain::updateUserActivity( void )
+{
+#if defined(XNU_TARGET_OS_OSX) && !DISPLAY_WRANGLER_PRESENT
+ clock_get_uptime(&userActivityTime);
+ bool aborting = ((lastSleepReason == kIOPMSleepReasonSoftware)
+ || (lastSleepReason == kIOPMSleepReasonIdle)
+ || (lastSleepReason == kIOPMSleepReasonMaintenance));
+ if (aborting) {
+ userActivityCount++;
+ DLOG("user activity reported %d lastSleepReason %d\n", userActivityCount, lastSleepReason);
+ }
+#endif
+}
+void
+IOPMrootDomain::reportUserInput( void )
+{
+ if (wrangler) {
+ wrangler->activityTickle(0, 0);
+ }
+#if defined(XNU_TARGET_OS_OSX) && !DISPLAY_WRANGLER_PRESENT
+ // Update user activity
+ updateUserActivity();
+
+ if (!darkWakeExit && ((_pendingCapability & kIOPMSystemCapabilityGraphics) == 0)) {
+ // update user active abs time
+ clock_get_uptime(&gUserActiveAbsTime);
+ pmPowerStateQueue->submitPowerEvent(
+ kPowerEventPolicyStimulus,
+ (void *) kStimulusDarkWakeActivityTickle,
+ true /* set wake type */ );
+ }
+#endif
+}
+
+void
+IOPMrootDomain::requestUserActive(IOService *device, const char *reason)
+{
+#if DISPLAY_WRANGLER_PRESENT
+ if (wrangler) {
+ wrangler->activityTickle(0, 0);
+ }
+#else
+ if (!device) {
+ DLOG("requestUserActive: device is null\n");
+ return;
+ }
+ OSSharedPtr<const OSSymbol> deviceName = device->copyName();
+ uint64_t registryID = device->getRegistryEntryID();
+
+ if (!deviceName || !registryID) {
+ DLOG("requestUserActive: no device name or registry entry\n");
+ return;
+ }
+ const char *name = deviceName->getCStringNoCopy();
+ char payload[128];
+ snprintf(payload, sizeof(payload), "%s:%s", name, reason);
+ DLOG("requestUserActive from %s (0x%llx) for %s\n", name, registryID, reason);
+ messageClient(kIOPMMessageRequestUserActive, systemCapabilityNotifier.get(), (void *)payload, sizeof(payload));
+#endif
projects / apple / xnu.git / blobdiff