2 * Copyright (c) 1998-2000 Apple Computer, Inc. All rights reserved.
4 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
6 * This file contains Original Code and/or Modifications of Original Code
7 * as defined in and that are subject to the Apple Public Source License
8 * Version 2.0 (the 'License'). You may not use this file except in
9 * compliance with the License. The rights granted to you under the License
10 * may not be used to create, or enable the creation or redistribution of,
11 * unlawful or unlicensed copies of an Apple operating system, or to
12 * circumvent, violate, or enable the circumvention or violation of, any
13 * terms of an Apple operating system software license agreement.
15 * Please obtain a copy of the License at
16 * http://www.opensource.apple.com/apsl/ and read it before using this file.
18 * The Original Code and all software distributed under the License are
19 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
20 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
21 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
22 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
23 * Please see the License for the specific language governing rights and
24 * limitations under the License.
26 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
28 #ifndef _IOKIT_ROOTDOMAIN_H
29 #define _IOKIT_ROOTDOMAIN_H
31 #include <IOKit/IOService.h>
32 #include <IOKit/pwr_mgt/IOPM.h>
33 #include <IOKit/IOBufferMemoryDescriptor.h>
34 #include <sys/vnode.h>
36 #ifdef XNU_KERNEL_PRIVATE
37 struct AggressivesRecord
;
38 struct IOPMMessageFilterContext
;
40 struct IOPMSystemSleepParameters
;
41 class PMSettingObject
;
43 class IOPMPowerStateQueue
;
44 class RootDomainUserClient
;
45 class PMAssertionsTracker
;
47 #define OBFUSCATE(x) \
48 (((((uintptr_t)(x)) >= VM_MIN_KERNEL_AND_KEXT_ADDRESS) && (((uintptr_t)(x)) < VM_MAX_KERNEL_ADDRESS)) ? \
49 ((void *)(VM_KERNEL_ADDRPERM(x))) : (void *)(x))
54 * Types for PM Assertions
55 * For creating, releasing, and getting PM assertion levels.
58 /*! IOPMDriverAssertionType
59 * A bitfield describing a set of assertions. May be used to specify which assertions
60 * to set with <link>IOPMrootDomain::createPMAssertion</link>; or to query which
61 * assertions are set with <link>IOPMrootDomain::releasePMAssertion</link>.
63 typedef uint64_t IOPMDriverAssertionType
;
65 /* IOPMDriverAssertionID
66 * Drivers may create PM assertions to request system behavior (keep the system awake,
67 * or keep the display awake). When a driver creates an assertion via
68 * <link>IOPMrootDomain::createPMAssertion</link>, PM returns a handle to
69 * the assertion of type IOPMDriverAssertionID.
71 typedef uint64_t IOPMDriverAssertionID
;
72 #define kIOPMUndefinedDriverAssertionID 0
74 /* IOPMDriverAssertionLevel
75 * Possible values for IOPMDriverAssertionLevel are <link>kIOPMDriverAssertionLevelOff</link>
76 * and <link>kIOPMDriverAssertionLevelOn</link>
78 typedef uint32_t IOPMDriverAssertionLevel
;
79 #define kIOPMDriverAssertionLevelOff 0
80 #define kIOPMDriverAssertionLevelOn 255
83 * Flags for get/setSleepSupported()
86 kRootDomainSleepNotSupported
= 0x00000000,
87 kRootDomainSleepSupported
= 0x00000001,
88 kFrameBufferDeepSleepSupported
= 0x00000002,
89 kPCICantSleep
= 0x00000004
93 *IOPMrootDomain registry property keys
95 #define kRootDomainSupportedFeatures "Supported Features"
96 #define kRootDomainSleepReasonKey "Last Sleep Reason"
97 #define kRootDomainSleepOptionsKey "Last Sleep Options"
98 #define kIOPMRootDomainWakeReasonKey "Wake Reason"
99 #define kIOPMRootDomainWakeTypeKey "Wake Type"
100 #define kIOPMRootDomainPowerStatusKey "Power Status"
103 * Possible sleep reasons found under kRootDomainSleepReasonsKey
105 #define kIOPMClamshellSleepKey "Clamshell Sleep"
106 #define kIOPMPowerButtonSleepKey "Power Button Sleep"
107 #define kIOPMSoftwareSleepKey "Software Sleep"
108 #define kIOPMOSSwitchHibernationKey "OS Switch Sleep"
109 #define kIOPMIdleSleepKey "Idle Sleep"
110 #define kIOPMLowPowerSleepKey "Low Power Sleep"
111 #define kIOPMThermalEmergencySleepKey "Thermal Emergency Sleep"
112 #define kIOPMMaintenanceSleepKey "Maintenance Sleep"
115 * String constants for communication with PM CPU
117 #define kIOPMRootDomainLidCloseCString "LidClose"
118 #define kIOPMRootDomainBatPowerCString "BatPower"
121 * Supported Feature bitfields for IOPMrootDomain::publishFeature()
124 kIOPMSupportedOnAC
= (1<<0),
125 kIOPMSupportedOnBatt
= (1<<1),
126 kIOPMSupportedOnUPS
= (1<<2)
129 typedef IOReturn (*IOPMSettingControllerCallback
)
130 (OSObject
*target
, const OSSymbol
*type
,
131 OSObject
*val
, uintptr_t refcon
);
134 IONotifier
* registerSleepWakeInterest(
135 IOServiceInterestHandler
, void *, void * = 0);
137 IONotifier
* registerPrioritySleepWakeInterest(
138 IOServiceInterestHandler handler
,
139 void * self
, void * ref
= 0);
141 IOReturn
acknowledgeSleepWakeNotification(void * );
143 IOReturn
vetoSleepWakeNotification(void * PMrefcon
);
146 #define IOPM_ROOTDOMAIN_REV 2
148 class IOPMrootDomain
: public IOService
150 OSDeclareFinalStructors(IOPMrootDomain
)
153 static IOPMrootDomain
* construct( void );
155 virtual bool start( IOService
* provider
);
156 virtual IOReturn
setAggressiveness( unsigned long, unsigned long );
157 virtual IOReturn
getAggressiveness( unsigned long, unsigned long * );
159 virtual IOReturn
sleepSystem( void );
160 IOReturn
sleepSystemOptions( OSDictionary
*options
);
162 virtual IOReturn
setProperties( OSObject
* );
163 virtual bool serializeProperties( OSSerialize
* s
) const;
164 virtual OSObject
* copyProperty( const char * aKey
) const;
166 /*! @function systemPowerEventOccurred
167 @abstract Other drivers may inform IOPMrootDomain of system PM events
168 @discussion systemPowerEventOccurred is a richer alternative to receivePowerNotification()
169 Only Apple-owned kexts should have reason to call systemPowerEventOccurred.
170 @param event An OSSymbol describing the type of power event.
171 @param value A 32-bit integer value associated with the event.
172 @param shouldUpdate indicates whether the root domain should send a notification
173 to interested parties. Pass false if you're calling systemPowerEventOccurred
174 several times in succession; and pass true only on the last invocatino.
175 @result kIOReturnSuccess on success */
177 IOReturn
systemPowerEventOccurred(
178 const OSSymbol
*event
,
181 IOReturn
systemPowerEventOccurred(
182 const OSSymbol
*event
,
185 #ifdef XNU_KERNEL_PRIVATE // Hide doc from public headers
186 /*! @function claimSystemWakeEvent
187 @abstract Apple-internal SPI to describe system wake events.
188 @discussion IOKit drivers may call claimSystemWakeEvent() during system wakeup to
189 provide human readable debug information describing the event(s) that
190 caused the system to wake.
192 - Drivers should call claimSystemWakeEvent before completing
193 their setPowerState() acknowledgement. IOPMrootDomain stops
194 collecting wake events when driver wake is complete.
196 - It is only appropriate to claim a wake event when the driver
197 can positively identify its hardware has generated an event
198 that can wake the system.
200 - This call tracks wake events from a non-S0 state (S0i, S3, S4) into S0.
201 - This call does not track wake events from DarkWake(S0) to FullWake(S0).
204 (reason = "WiFi.TCPData",
205 details = "TCPKeepAlive packet arrived from IP 16.2.1.1")
206 (reason = "WiFi.ScanOffload",
207 details = "WiFi station 'AppleWiFi' signal dropped below threshold")
208 (reason = "Enet.LinkToggle",
209 details = "Ethernet attached")
211 @param device The device/nub that is associated with the wake event.
213 @param flags Pass kIOPMWakeEventSource if the device is the source
214 of the wake event. Pass zero if the device is forwarding or
215 aggregating wake events from multiple sources, e.g. an USB or
216 Thunderbolt host controller.
218 @param reason Caller should pass a human readable C string describing the
219 wake reason. Please use a string from the list below, or create
220 your own string matching this format:
236 Enet.ConflictResolution
244 @param details Optional details further describing the wake event.
245 Please pass an OSString defining the event.
248 void claimSystemWakeEvent( IOService
*device
,
251 OSObject
*details
= 0 );
253 virtual IOReturn
receivePowerNotification( UInt32 msg
);
255 virtual void setSleepSupported( IOOptionBits flags
);
257 virtual IOOptionBits
getSleepSupported( void );
259 void wakeFromDoze( void );
261 // KEXT driver announces support of power management feature
263 void publishFeature( const char *feature
);
265 // KEXT driver announces support of power management feature
266 // And specifies power sources with kIOPMSupportedOn{AC/Batt/UPS} bitfield.
267 // Returns a unique uint32_t identifier for later removing support for this
269 // NULL is acceptable for uniqueFeatureID for kexts without plans to unload.
271 void publishFeature( const char *feature
,
272 uint32_t supportedWhere
,
273 uint32_t *uniqueFeatureID
);
275 // KEXT driver announces removal of a previously published power management
276 // feature. Pass 'uniqueFeatureID' returned from publishFeature()
278 IOReturn
removePublishedFeature( uint32_t removeFeatureID
);
280 /*! @function copyPMSetting
281 @abstract Copy the current value for a PM setting. Returns an OSNumber or
282 OSData depending on the setting.
283 @param whichSetting Name of the desired setting.
284 @result OSObject value if valid, NULL otherwise. */
286 OSObject
* copyPMSetting( OSSymbol
*whichSetting
);
288 /*! @function registerPMSettingController
289 @abstract Register for callbacks on changes to certain PM settings.
290 @param settings NULL terminated array of C strings, each string for a PM
291 setting that the caller is interested in and wants to get callbacks for.
292 @param callout C function ptr or member function cast as such.
293 @param target The target of the callback, usually 'this'
294 @param refcon Will be passed to caller in callback; for caller's use.
295 @param handle Caller should keep the OSObject * returned here. If non-NULL,
296 handle will have a retain count of 1 on return. To deregister, pass to
297 unregisterPMSettingController()
298 @result kIOReturnSuccess on success. */
300 IOReturn
registerPMSettingController(
301 const OSSymbol
*settings
[],
302 IOPMSettingControllerCallback callout
,
305 OSObject
**handle
); // out param
307 /*! @function registerPMSettingController
308 @abstract Register for callbacks on changes to certain PM settings.
309 @param settings NULL terminated array of C strings, each string for a PM
310 setting that the caller is interested in and wants to get callbacks for.
311 @param supportedPowerSources bitfield indicating which power sources these
312 settings are supported for (kIOPMSupportedOnAC, etc.)
313 @param callout C function ptr or member function cast as such.
314 @param target The target of the callback, usually 'this'
315 @param refcon Will be passed to caller in callback; for caller's use.
316 @param handle Caller should keep the OSObject * returned here. If non-NULL,
317 handle will have a retain count of 1 on return. To deregister, pass to
318 unregisterPMSettingController()
319 @result kIOReturnSuccess on success. */
321 IOReturn
registerPMSettingController(
322 const OSSymbol
*settings
[],
323 uint32_t supportedPowerSources
,
324 IOPMSettingControllerCallback callout
,
327 OSObject
**handle
); // out param
329 virtual IONotifier
* registerInterest(
330 const OSSymbol
* typeOfInterest
,
331 IOServiceInterestHandler handler
,
332 void * target
, void * ref
= 0 );
334 virtual IOReturn
callPlatformFunction(
335 const OSSymbol
*functionName
,
336 bool waitForFunction
,
337 void *param1
, void *param2
,
338 void *param3
, void *param4
);
340 /*! @function createPMAssertion
341 @abstract Creates an assertion to influence system power behavior.
342 @param whichAssertionBits A bitfield specify the assertion that the caller requests.
343 @param assertionLevel An integer detailing the initial assertion level, kIOPMDriverAssertionLevelOn
344 or kIOPMDriverAssertionLevelOff.
345 @param ownerService A pointer to the caller's IOService class, for tracking.
346 @param ownerDescription A reverse-DNS string describing the caller's identity and reason.
347 @result On success, returns a new assertion of type IOPMDriverAssertionID
349 IOPMDriverAssertionID
createPMAssertion(
350 IOPMDriverAssertionType whichAssertionsBits
,
351 IOPMDriverAssertionLevel assertionLevel
,
352 IOService
*ownerService
,
353 const char *ownerDescription
);
355 /* @function setPMAssertionLevel
356 @abstract Modify the level of a pre-existing assertion.
357 @discussion Change the value of a PM assertion to influence system behavior,
358 without undergoing the work required to create or destroy an assertion. Suggested
359 for clients who will assert and de-assert needs for PM behavior several times over
361 @param assertionID An assertion ID previously returned by <link>createPMAssertion</link>
362 @param assertionLevel The new assertion level.
363 @result kIOReturnSuccess if it worked; kIOReturnNotFound or other IOReturn error on failure.
365 IOReturn
setPMAssertionLevel(IOPMDriverAssertionID assertionID
, IOPMDriverAssertionLevel assertionLevel
);
367 /*! @function getPMAssertionLevel
368 @absract Returns the active level of the specified assertion(s).
369 @discussion Returns <link>kIOPMDriverAssertionLevelOff</link> or
370 <link>kIOPMDriverAssertionLevelOn</link>. If multiple assertions are specified
371 in the bitfield, only returns <link>kIOPMDriverAssertionLevelOn</link>
372 if all assertions are active.
373 @param whichAssertionBits Bits defining the assertion or assertions the caller is interested in
374 the level of. If in doubt, pass <link>kIOPMDriverAssertionCPUBit</link> as the argument.
375 @result Returns <link>kIOPMDriverAssertionLevelOff</link> or
376 <link>kIOPMDriverAssertionLevelOn</link> indicating the specified assertion's levels, if available.
377 If the assertions aren't supported on this machine, or aren't recognized by the OS, the
380 IOPMDriverAssertionLevel
getPMAssertionLevel(IOPMDriverAssertionType whichAssertionBits
);
382 /*! @function releasePMAssertion
383 @abstract Removes an assertion to influence system power behavior.
384 @result On success, returns a new assertion of type IOPMDriverAssertionID *
386 IOReturn
releasePMAssertion(IOPMDriverAssertionID releaseAssertion
);
388 /*! @function restartWithStackshot
389 @abstract Take a stackshot of the system and restart the system.
390 @result Return kIOReturnSuccess if it work, kIOReturnError if the service is not available.
392 IOReturn
restartWithStackshot();
395 virtual IOReturn
changePowerStateTo( unsigned long ordinal
);
396 virtual IOReturn
changePowerStateToPriv( unsigned long ordinal
);
397 virtual IOReturn
requestPowerDomainState( IOPMPowerFlags
, IOPowerConnection
*, unsigned long );
398 virtual void powerChangeDone( unsigned long );
399 virtual bool tellChangeDown( unsigned long );
400 virtual bool askChangeDown( unsigned long );
401 virtual void tellChangeUp( unsigned long );
402 virtual void tellNoChangeDown( unsigned long );
403 virtual IOReturn
configureReport(IOReportChannelList
*channels
,
404 IOReportConfigureAction action
,
407 virtual IOReturn
updateReport(IOReportChannelList
*channels
,
408 IOReportUpdateAction action
,
412 #ifdef XNU_KERNEL_PRIVATE
413 /* Root Domain internals */
415 void tagPowerPlaneService(
417 IOPMActions
* actions
);
419 void overrideOurPowerChange(
421 IOPMActions
* actions
,
422 IOPMPowerStateIndex
* inOutPowerState
,
423 IOPMPowerChangeFlags
* inOutChangeFlags
,
424 IOPMRequestTag requestTag
);
426 void handleOurPowerChangeStart(
428 IOPMActions
* actions
,
429 IOPMPowerStateIndex powerState
,
430 IOPMPowerChangeFlags
* inOutChangeFlags
,
431 IOPMRequestTag requestTag
);
433 void handleOurPowerChangeDone(
435 IOPMActions
* actions
,
436 IOPMPowerStateIndex powerState
,
437 IOPMPowerChangeFlags changeFlags
,
438 IOPMRequestTag requestTag
);
440 void overridePowerChangeForUIService(
442 IOPMActions
* actions
,
443 IOPMPowerStateIndex
* inOutPowerState
,
444 IOPMPowerChangeFlags
* inOutChangeFlags
);
446 void handleActivityTickleForDisplayWrangler(
448 IOPMActions
* actions
);
450 void handleUpdatePowerClientForDisplayWrangler(
452 IOPMActions
* actions
,
453 const OSSymbol
* powerClient
,
454 IOPMPowerStateIndex oldPowerState
,
455 IOPMPowerStateIndex newPowerState
);
457 bool shouldDelayChildNotification(
458 IOService
* service
);
460 void handlePowerChangeStartForPCIDevice(
462 IOPMActions
* actions
,
463 IOPMPowerStateIndex powerState
,
464 IOPMPowerChangeFlags
* inOutChangeFlags
);
466 void handlePowerChangeDoneForPCIDevice(
468 IOPMActions
* actions
,
469 IOPMPowerStateIndex powerState
,
470 IOPMPowerChangeFlags changeFlags
);
472 void askChangeDownDone(
473 IOPMPowerChangeFlags
* inOutChangeFlags
,
476 void handlePublishSleepWakeUUID(
479 void handleQueueSleepWakeUUID(
482 void willNotifyPowerChildren( IOPMPowerStateIndex newPowerState
);
484 IOReturn
setMaintenanceWakeCalendar(
485 const IOPMCalendarStruct
* calendar
);
487 IOReturn
getSystemSleepType( uint32_t * sleepType
);
489 // Handle callbacks from IOService::systemWillShutdown()
490 void acknowledgeSystemWillShutdown( IOService
* from
);
492 // Handle platform halt and restart notifications
493 void handlePlatformHaltRestart( UInt32 pe_type
);
495 IOReturn
shutdownSystem( void );
496 IOReturn
restartSystem( void );
497 void handleSleepTimerExpiration( void );
499 bool activitySinceSleep(void);
500 bool abortHibernation(void);
502 IOReturn
joinAggressiveness( IOService
* service
);
503 void handleAggressivesRequests( void );
505 void tracePoint( uint8_t point
);
506 void tracePoint( uint8_t point
, uint8_t data
);
507 void traceDetail( uint32_t data32
);
509 bool systemMessageFilter(
510 void * object
, void * arg1
, void * arg2
, void * arg3
);
512 bool updatePreventIdleSleepList(
513 IOService
* service
, bool addNotRemove
);
514 void updatePreventSystemSleepList(
515 IOService
* service
, bool addNotRemove
);
517 void publishPMSetting(
518 const OSSymbol
* feature
, uint32_t where
, uint32_t * featureID
);
520 void pmStatsRecordEvent(
522 AbsoluteTime timestamp
);
524 void pmStatsRecordApplicationResponse(
525 const OSSymbol
*response
,
531 IOPMPowerStateIndex ps
=0);
533 void copyWakeReasonString( char * outBuf
, size_t bufSize
);
536 bool getHibernateSettings(
537 uint32_t * hibernateMode
,
538 uint32_t * hibernateFreeRatio
,
539 uint32_t * hibernateFreeTime
);
541 void takeStackshot(bool restart
, bool isOSXWatchdog
);
542 void sleepWakeDebugTrig(bool restart
);
543 void sleepWakeDebugEnableWdog();
544 bool sleepWakeDebugIsWdogEnabled();
545 static void saveTimeoutAppStackShot(void *p0
, void *p1
);
548 friend class PMSettingObject
;
549 friend class RootDomainUserClient
;
550 friend class PMAssertionsTracker
;
552 static IOReturn
sysPowerDownHandler( void * target
, void * refCon
,
553 UInt32 messageType
, IOService
* service
,
554 void * messageArgument
, vm_size_t argSize
);
556 static IOReturn
displayWranglerNotification( void * target
, void * refCon
,
557 UInt32 messageType
, IOService
* service
,
558 void * messageArgument
, vm_size_t argSize
);
560 static IOReturn
rootBusyStateChangeHandler( void * target
, void * refCon
,
561 UInt32 messageType
, IOService
* service
,
562 void * messageArgument
, vm_size_t argSize
);
564 static bool displayWranglerMatchPublished( void * target
, void * refCon
,
565 IOService
* newService
,
566 IONotifier
* notifier
);
568 static bool IONVRAMMatchPublished( void * target
, void * refCon
,
569 IOService
* newService
,
570 IONotifier
* notifier
);
572 static bool batteryPublished( void * target
, void * refCon
,
573 IOService
* resourceService
,
574 IONotifier
* notifier
);
576 void initializeBootSessionUUID( void );
578 void fullWakeDelayedWork( void );
580 IOService
* wrangler
;
581 OSDictionary
* wranglerIdleSettings
;
583 IOLock
*featuresDictLock
; // guards supportedFeatures
584 IOLock
*wakeEventLock
;
585 IOPMPowerStateQueue
*pmPowerStateQueue
;
587 OSArray
*allowedPMSettings
;
588 OSArray
*noPublishPMSettings
;
589 PMTraceWorker
*pmTracer
;
590 PMAssertionsTracker
*pmAssertions
;
592 // Settings controller info
593 IOLock
*settingsCtrlLock
;
594 OSDictionary
*settingsCallbacks
;
595 OSDictionary
*fPMSettingsDict
;
597 IONotifier
*_batteryPublishNotifier
;
598 IONotifier
*_displayWranglerNotifier
;
601 const OSSymbol
*_statsNameKey
;
602 const OSSymbol
*_statsPIDKey
;
603 const OSSymbol
*_statsTimeMSKey
;
604 const OSSymbol
*_statsResponseTypeKey
;
605 const OSSymbol
*_statsMessageTypeKey
;
606 const OSSymbol
*_statsPowerCapsKey
;
608 uint32_t darkWakeCnt
;
609 uint32_t displayWakeCnt
;
611 OSString
*queuedSleepWakeUUIDString
;
612 OSArray
*pmStatsAppResponses
;
613 IOLock
*pmStatsLock
; // guards pmStatsAppResponses
617 // Pref: idle time before idle sleep
618 unsigned long sleepSlider
;
619 unsigned long idleSeconds
;
620 uint64_t autoWakeStart
;
621 uint64_t autoWakeEnd
;
623 // Difference between sleepSlider and longestNonSleepSlider
624 unsigned long extraSleepDelay
;
626 // Used to wait between say display idle and system idle
627 thread_call_t extraSleepTimer
;
628 thread_call_t diskSyncCalloutEntry
;
629 thread_call_t fullWakeThreadCall
;
630 thread_call_t hibDebugSetupEntry
;
632 // Track system capabilities.
633 uint32_t _desiredCapability
;
634 uint32_t _currentCapability
;
635 uint32_t _pendingCapability
;
636 uint32_t _highestCapability
;
637 OSSet
* _joinedCapabilityClients
;
638 uint32_t _systemStateGeneration
;
640 // Type of clients that can receive system messages.
642 kSystemMessageClientPowerd
= 0x01,
643 kSystemMessageClientLegacyApp
= 0x02,
644 kSystemMessageClientKernel
= 0x04,
645 kSystemMessageClientAll
= 0x07
647 uint32_t _systemMessageClientMask
;
649 // Power state and capability change transitions.
651 kSystemTransitionNone
= 0,
652 kSystemTransitionSleep
= 1,
653 kSystemTransitionWake
= 2,
654 kSystemTransitionCapability
= 3,
655 kSystemTransitionNewCapClient
= 4
656 } _systemTransitionType
;
658 unsigned int systemBooting
:1;
659 unsigned int systemShutdown
:1;
660 unsigned int systemDarkWake
:1;
661 unsigned int clamshellExists
:1;
662 unsigned int clamshellClosed
:1;
663 unsigned int clamshellDisabled
:1;
664 unsigned int desktopMode
:1;
665 unsigned int acAdaptorConnected
:1;
667 unsigned int clamshellSleepDisabled
:1;
668 unsigned int idleSleepTimerPending
:1;
669 unsigned int userDisabledAllSleep
:1;
670 unsigned int ignoreTellChangeDown
:1;
671 unsigned int wranglerAsleep
:1;
672 unsigned int wranglerTickled
:1;
673 unsigned int _preventUserActive
:1;
674 unsigned int graphicsSuppressed
:1;
676 unsigned int capabilityLoss
:1;
677 unsigned int pciCantSleepFlag
:1;
678 unsigned int pciCantSleepValid
:1;
679 unsigned int logGraphicsClamp
:1;
680 unsigned int darkWakeToSleepASAP
:1;
681 unsigned int darkWakeMaintenance
:1;
682 unsigned int darkWakeSleepService
:1;
683 unsigned int darkWakePostTickle
:1;
685 unsigned int sleepTimerMaintenance
:1;
686 unsigned int sleepToStandby
:1;
687 unsigned int lowBatteryCondition
:1;
688 unsigned int hibernateDisabled
:1;
689 unsigned int hibernateRetry
:1;
690 unsigned int wranglerTickleLatched
:1;
691 unsigned int userIsActive
:1;
692 unsigned int userWasActive
:1;
694 unsigned int displayIdleForDemandSleep
:1;
695 unsigned int darkWakeHibernateError
:1;
696 unsigned int thermalWarningState
:1;
698 uint32_t hibernateMode
;
699 AbsoluteTime userActivityTime
;
700 AbsoluteTime userActivityTime_prev
;
701 uint32_t userActivityCount
;
702 uint32_t userActivityAtSleep
;
703 uint32_t lastSleepReason
;
704 uint32_t fullToDarkReason
;
705 uint32_t hibernateAborted
;
707 enum FullWakeReason
{
708 kFullWakeReasonNone
= 0,
709 kFullWakeReasonLocalUser
= 1,
710 kFullWakeReasonDisplayOn
= 2,
711 fFullWakeReasonDisplayOnAndLocalUser
= 3
713 uint32_t fullWakeReason
;
715 // Info for communicating system state changes to PMCPU
716 int32_t idxPMCPUClamshell
;
717 int32_t idxPMCPULimitedPower
;
719 IOOptionBits platformSleepSupport
;
720 uint32_t _debugWakeSeconds
;
721 uint32_t _lastDebugWakeSeconds
;
723 queue_head_t aggressivesQueue
;
724 thread_call_t aggressivesThreadCall
;
725 OSData
* aggressivesData
;
727 AbsoluteTime userBecameInactiveTime
;
728 AbsoluteTime systemWakeTime
;
730 // PCI top-level PM trace
731 IOService
* pciHostBridgeDevice
;
732 IOService
* pciHostBridgeDriver
;
734 IONotifier
* systemCapabilityNotifier
;
739 } PMNotifySuspendedStruct
;
741 uint32_t pmSuspendedCapacity
;
742 uint32_t pmSuspendedSize
;
743 PMNotifySuspendedStruct
*pmSuspendedPIDS
;
745 OSSet
* preventIdleSleepList
;
746 OSSet
* preventSystemSleepList
;
748 UInt32 _scheduledAlarms
;
749 UInt32 _userScheduledAlarm
;
752 clock_sec_t _standbyTimerResetSeconds
;
754 volatile uint32_t swd_lock
; /* Lock to access swd_buffer & and its header */
755 void * swd_buffer
; /* Memory allocated for dumping sleep/wake logs */
756 uint8_t swd_flags
; /* Flags defined in IOPMPrivate.h */
758 IOMemoryMap
* swd_logBufMap
; /* Memory with sleep/wake logs from previous boot */
760 // Wake Event Reporting
761 OSArray
* _systemWakeEventsArray
;
762 bool _acceptSystemWakeEvents
;
764 int findSuspendedPID(uint32_t pid
, uint32_t *outRefCount
);
766 // IOPMrootDomain internal sleep call
767 IOReturn
privateSleepSystem( uint32_t sleepReason
);
768 void reportUserInput( void );
769 void setDisableClamShellSleep( bool );
770 bool checkSystemSleepAllowed( IOOptionBits options
,
771 uint32_t sleepReason
);
772 bool checkSystemSleepEnabled( void );
773 bool checkSystemCanSleep( uint32_t sleepReason
);
774 bool checkSystemCanSustainFullWake( void );
776 void adjustPowerState( bool sleepASAP
= false );
777 void setQuickSpinDownTimeout( void );
778 void restoreUserSpinDownTimeout( void );
780 bool shouldSleepOnClamshellClosed(void );
781 void sendClientClamshellNotification( void );
783 // Inform PMCPU of changes to state like lid, AC vs. battery
784 void informCPUStateChange( uint32_t type
, uint32_t value
);
786 void dispatchPowerEvent( uint32_t event
, void * arg0
, uint64_t arg1
);
787 void handlePowerNotification( UInt32 msg
);
789 IOReturn
setPMSetting(const OSSymbol
*, OSObject
*);
791 void startIdleSleepTimer( uint32_t inSeconds
);
792 void cancelIdleSleepTimer( void );
793 uint32_t getTimeToIdleSleep( void );
795 IOReturn
setAggressiveness(
798 IOOptionBits options
);
800 void synchronizeAggressives(
801 queue_head_t
* services
,
802 const AggressivesRecord
* array
,
805 void broadcastAggressives(
806 const AggressivesRecord
* array
,
809 IOReturn
setPMAssertionUserLevels(IOPMDriverAssertionType
);
811 void publishSleepWakeUUID( bool shouldPublish
);
813 void evaluatePolicy( int stimulus
, uint32_t arg
= 0 );
814 void requestFullWake( FullWakeReason reason
);
815 void willEnterFullWake( void );
817 void evaluateAssertions(IOPMDriverAssertionType newAssertions
,
818 IOPMDriverAssertionType oldAssertions
);
820 void deregisterPMSettingObject( PMSettingObject
* pmso
);
822 void sleepWakeDebugMemAlloc( );
823 void sleepWakeDebugDumpFromMem(IOMemoryMap
*logBufMap
);
824 void sleepWakeDebugDumpFromFile( );
825 IOMemoryMap
*sleepWakeDebugRetrieve();
826 errno_t
sleepWakeDebugSaveFile(const char *name
, char *buf
, int len
);
827 errno_t
sleepWakeDebugCopyFile( struct vnode
*srcVp
,
828 vfs_context_t srcCtx
,
829 char *tmpBuf
, uint64_t tmpBufSize
,
831 const char *dstFname
,
837 bool getSleepOption( const char * key
, uint32_t * option
);
838 bool evaluateSystemSleepPolicy( IOPMSystemSleepParameters
* p
,
839 int phase
, uint32_t * hibMode
);
840 void evaluateSystemSleepPolicyEarly( void );
841 void evaluateSystemSleepPolicyFinal( void );
842 #endif /* HIBERNATION */
844 bool latchDisplayWranglerTickle( bool latch
);
845 void setDisplayPowerOn( uint32_t options
);
847 void acceptSystemWakeEvents( bool accept
);
848 void systemDidNotSleep( void );
849 void preventTransitionToUserActive( bool prevent
);
850 void setThermalState(OSObject
*value
);
851 #endif /* XNU_KERNEL_PRIVATE */
854 #ifdef XNU_KERNEL_PRIVATE
855 class IORootParent
: public IOService
857 OSDeclareFinalStructors(IORootParent
)
860 static void initialize( void );
861 virtual OSObject
* copyProperty( const char * aKey
) const;
862 bool start( IOService
* nub
);
863 void shutDownSystem( void );
864 void restartSystem( void );
865 void sleepSystem( void );
866 void dozeSystem( void );
867 void sleepToDoze( void );
868 void wakeSystem( void );
870 #endif /* XNU_KERNEL_PRIVATE */
872 #endif /* _IOKIT_ROOTDOMAIN_H */