#ifndef _IOKIT_ROOTDOMAIN_H
#define _IOKIT_ROOTDOMAIN_H
#include <IOKit/IOService.h>
#include <IOKit/pwr_mgt/IOPM.h>
#include "IOKit/pwr_mgt/IOPMPrivate.h"
#ifdef XNU_KERNEL_PRIVATE
#if defined(__i386__) || defined(__x86_64__)
#define ROOT_DOMAIN_RUN_STATES 1
#endif
struct AggressivesRecord;
class PMAssertionsTracker;
#endif
class IOPMPowerStateQueue;
class RootDomainUserClient;
class PMTraceWorker;
typedef uint64_t IOPMDriverAssertionType;
typedef uint64_t IOPMDriverAssertionID;
#define kIOPMUndefinedDriverAssertionID 0
typedef uint32_t IOPMDriverAssertionLevel;
#define kIOPMDriverAssertionLevelOff 0
#define kIOPMDriverAssertionLevelOn 255
enum {
kRootDomainSleepNotSupported = 0x00000000,
kRootDomainSleepSupported = 0x00000001,
kFrameBufferDeepSleepSupported = 0x00000002,
kPCICantSleep = 0x00000004
};
#define kRootDomainSupportedFeatures "Supported Features"
#define kRootDomainSleepReasonKey "Last Sleep Reason"
#define kRootDomainSleepOptionsKey "Last Sleep Options"
#define kIOPMRootDomainWakeReasonKey "Wake Reason"
#define kIOPMRootDomainWakeTypeKey "Wake Type"
#define kIOPMRootDomainPowerStatusKey "Power Status"
#define kIOPMClamshellSleepKey "Clamshell Sleep"
#define kIOPMPowerButtonSleepKey "Power Button Sleep"
#define kIOPMSoftwareSleepKey "Software Sleep"
#define kIOPMOSSwitchHibernationKey "OS Switch Sleep"
#define kIOPMIdleSleepKey "Idle Sleep"
#define kIOPMLowPowerSleepKey "Low Power Sleep"
#define kIOPMThermalEmergencySleepKey "Thermal Emergency Sleep"
#define kIOPMMaintenanceSleepKey "Maintenance Sleep"
enum
{
kIOPMSleepReasonClamshell = 1,
kIOPMSleepReasonPowerButton = 2,
kIOPMSleepReasonSoftware = 3,
kIOPMSleepReasonOSSwitchHibernation = 4,
kIOPMSleepReasonIdle = 5,
kIOPMSleepReasonLowPower = 6,
kIOPMSleepReasonThermalEmergency = 7,
kIOPMSleepReasonMaintenance = 8,
kIOPMSleepReasonMax
};
#define kIOPMRootDomainLidCloseCString "LidClose"
#define kIOPMRootDomainBatPowerCString "BatPower"
enum {
kIOPMSupportedOnAC = (1<<0),
kIOPMSupportedOnBatt = (1<<1),
kIOPMSupportedOnUPS = (1<<2)
};
typedef IOReturn (*IOPMSettingControllerCallback)
(OSObject *target, const OSSymbol *type,
OSObject *val, uintptr_t refcon);
__BEGIN_DECLS
IONotifier * registerSleepWakeInterest(
IOServiceInterestHandler, void *, void * = 0);
IONotifier * registerPrioritySleepWakeInterest(
IOServiceInterestHandler handler,
void * self, void * ref = 0);
IOReturn acknowledgeSleepWakeNotification(void * );
IOReturn vetoSleepWakeNotification(void * PMrefcon);
__END_DECLS
#define IOPM_ROOTDOMAIN_REV 2
class IOPMrootDomain: public IOService
{
OSDeclareFinalStructors(IOPMrootDomain)
public:
static IOPMrootDomain * construct( void );
virtual bool start( IOService * provider );
virtual IOReturn setAggressiveness( unsigned long, unsigned long );
virtual IOReturn getAggressiveness( unsigned long, unsigned long * );
virtual IOReturn sleepSystem( void );
IOReturn sleepSystemOptions( OSDictionary *options );
virtual IOReturn setProperties( OSObject * );
virtual bool serializeProperties( OSSerialize * s ) const;
IOReturn systemPowerEventOccurred(
const OSSymbol *event,
uint32_t intValue );
IOReturn systemPowerEventOccurred(
const OSSymbol *event,
OSObject *value );
virtual IOReturn receivePowerNotification( UInt32 msg );
virtual void setSleepSupported( IOOptionBits flags );
virtual IOOptionBits getSleepSupported( void );
void wakeFromDoze( void );
void publishFeature( const char *feature );
void publishFeature( const char *feature,
uint32_t supportedWhere,
uint32_t *uniqueFeatureID);
IOReturn removePublishedFeature( uint32_t removeFeatureID );
OSObject * copyPMSetting( OSSymbol *whichSetting );
IOReturn registerPMSettingController(
const OSSymbol *settings[],
IOPMSettingControllerCallback callout,
OSObject *target,
uintptr_t refcon,
OSObject **handle);
IOReturn registerPMSettingController(
const OSSymbol *settings[],
uint32_t supportedPowerSources,
IOPMSettingControllerCallback callout,
OSObject *target,
uintptr_t refcon,
OSObject **handle);
virtual IONotifier * registerInterest(
const OSSymbol * typeOfInterest,
IOServiceInterestHandler handler,
void * target, void * ref = 0 );
void pmStatsRecordEvent(
int eventIndex,
AbsoluteTime timestamp);
void pmStatsRecordApplicationResponse(
const OSSymbol *response,
const char *name,
int messageType,
uint32_t delay_ms,
int app_pid);
virtual IOReturn callPlatformFunction(
const OSSymbol *functionName,
bool waitForFunction,
void *param1, void *param2,
void *param3, void *param4 );
IOPMDriverAssertionID createPMAssertion(
IOPMDriverAssertionType whichAssertionsBits,
IOPMDriverAssertionLevel assertionLevel,
IOService *ownerService,
const char *ownerDescription);
IOReturn setPMAssertionLevel(IOPMDriverAssertionID assertionID, IOPMDriverAssertionLevel assertionLevel);
IOPMDriverAssertionLevel getPMAssertionLevel(IOPMDriverAssertionType whichAssertionBits);
IOReturn releasePMAssertion(IOPMDriverAssertionID releaseAssertion);
private:
virtual IOReturn changePowerStateTo( unsigned long ordinal );
virtual IOReturn changePowerStateToPriv( unsigned long ordinal );
virtual IOReturn requestPowerDomainState( IOPMPowerFlags, IOPowerConnection *, unsigned long );
virtual void powerChangeDone( unsigned long );
virtual bool tellChangeDown( unsigned long );
virtual bool askChangeDown( unsigned long );
virtual void tellChangeUp( unsigned long );
virtual void tellNoChangeDown( unsigned long );
#ifdef XNU_KERNEL_PRIVATE
public:
#if HIBERNATION
bool getHibernateSettings(
uint32_t * hibernateMode,
uint32_t * hibernateFreeRatio,
uint32_t * hibernateFreeTime );
#endif
#if ROOT_DOMAIN_RUN_STATES
void tagPowerPlaneService(
IOService * service,
uint32_t * rdFlags );
void handleActivityTickleForService( IOService * service,
unsigned long type,
unsigned long currentPowerState,
uint32_t activityTickleCount );
void handlePowerChangeStartForService(
IOService * service,
uint32_t * rootDomainFlags,
uint32_t newPowerState,
uint32_t changeFlags );
void handlePowerChangeDoneForService(
IOService * service,
uint32_t * rootDomainFlags,
uint32_t newPowerState,
uint32_t changeFlags );
void overridePowerStateForService(
IOService * service,
uint32_t * rdFlags,
unsigned long * powerState,
uint32_t changeFlags );
IOReturn setMaintenanceWakeCalendar(
const IOPMCalendarStruct * calendar );
#endif
void acknowledgeSystemWillShutdown( IOService * from );
void handlePlatformHaltRestart( UInt32 pe_type );
IOReturn shutdownSystem( void );
IOReturn restartSystem( void );
void handleSleepTimerExpiration( void );
void handleForcedSleepTimerExpiration( void );
void stopIgnoringClamshellEventsDuringWakeup( void );
bool activitySinceSleep(void);
bool abortHibernation(void);
IOReturn joinAggressiveness( IOService * service );
void handleAggressivesRequests( void );
void tracePoint( uint8_t point );
private:
friend class PMSettingObject;
friend class PMAssertionsTracker;
friend class RootDomainUserClient;
IOService * wrangler;
class IORootParent * patriarch;
IOLock *featuresDictLock; IOPMPowerStateQueue *pmPowerStateQueue;
OSArray *allowedPMSettings;
PMTraceWorker *pmTracer;
PMAssertionsTracker *pmAssertions;
IORecursiveLock *settingsCtrlLock;
OSDictionary *settingsCallbacks;
OSDictionary *fPMSettingsDict;
IONotifier *_batteryPublishNotifier;
IONotifier *_displayWranglerNotifier;
const OSSymbol *_statsNameKey;
const OSSymbol *_statsPIDKey;
const OSSymbol *_statsTimeMSKey;
const OSSymbol *_statsResponseTypeKey;
const OSSymbol *_statsMessageTypeKey;
OSString *queuedSleepWakeUUIDString;
OSArray *pmStatsAppResponses;
PMStatsStruct pmStats;
unsigned long sleepSlider;
unsigned long idleSeconds;
uint64_t autoWakeStart;
uint64_t autoWakeEnd;
unsigned long extraSleepDelay;
thread_call_t extraSleepTimer;
thread_call_t clamshellWakeupIgnore;
thread_call_t diskSyncCalloutEntry;
uint32_t runStateIndex;
uint32_t runStateFlags;
uint32_t nextRunStateIndex;
uint32_t wranglerTickled;
unsigned int systemBooting :1;
unsigned int systemShutdown :1;
unsigned int clamshellExists :1;
unsigned int clamshellIsClosed :1;
unsigned int ignoringClamshell :1;
unsigned int ignoringClamshellOnWake :1;
unsigned int desktopMode :1;
unsigned int acAdaptorConnected :1;
unsigned int allowSleep :1;
unsigned int sleepIsSupported :1;
unsigned int canSleep :1;
unsigned int sleepASAP :1;
unsigned int idleSleepTimerPending :1;
unsigned int userDisabledAllSleep :1;
unsigned int ignoreChangeDown :1;
unsigned int wranglerAsleep :1;
unsigned int sleepTimerMaintenance :1;
unsigned int lowBatteryCondition :1;
unsigned int hibernateDisabled :1;
unsigned int hibernateNoDefeat :1;
unsigned int hibernateAborted :1;
uint32_t hibernateMode;
uint32_t userActivityCount;
uint32_t userActivityAtSleep;
uint32_t lastSleepReason;
int32_t idxPMCPUClamshell;
int32_t idxPMCPULimitedPower;
IOOptionBits platformSleepSupport;
queue_head_t aggressivesQueue;
thread_call_t aggressivesThreadCall;
OSData * aggressivesData;
AbsoluteTime wranglerSleepTime;
IOService * pciHostBridgeDevice;
IOReturn privateSleepSystem( uint32_t sleepReason );
void announcePowerSourceChange( void );
void reportUserInput( void );
static IOReturn sysPowerDownHandler( void * target, void * refCon,
UInt32 messageType, IOService * service,
void * messageArgument, vm_size_t argSize );
static IOReturn displayWranglerNotification( void * target, void * refCon,
UInt32 messageType, IOService * service,
void * messageArgument, vm_size_t argSize );
static bool displayWranglerPublished( void * target, void * refCon,
IOService * newService);
static bool batteryPublished( void * target, void * refCon,
IOService * resourceService );
void adjustPowerState( void );
void setQuickSpinDownTimeout( void );
void restoreUserSpinDownTimeout( void );
bool shouldSleepOnClamshellClosed(void );
void sendClientClamshellNotification( void );
void informCPUStateChange( uint32_t type, uint32_t value );
void dispatchPowerEvent( uint32_t event, void * arg0, uint64_t arg1 );
void handlePowerNotification( UInt32 msg );
IOReturn setPMSetting(const OSSymbol *, OSObject *);
void startIdleSleepTimer( uint32_t inSeconds );
void cancelIdleSleepTimer( void );
void updateRunState( uint32_t inRunState );
IOReturn setAggressiveness(
unsigned long type,
unsigned long value,
IOOptionBits options );
void synchronizeAggressives(
queue_head_t * services,
const AggressivesRecord * array,
int count );
void broadcastAggressives(
const AggressivesRecord * array,
int count );
void aggressivenessChanged( void );
IOReturn setPMAssertionUserLevels(IOPMDriverAssertionType);
void publishSleepWakeUUID( bool shouldPublish );
#if HIBERNATION
bool getSleepOption( const char * key, uint32_t * option );
bool evaluateSystemSleepPolicy( IOPMSystemSleepParameters * p );
void evaluateSystemSleepPolicyEarly( void );
void evaluateSystemSleepPolicyFinal( void );
#endif
#endif
};
#ifdef XNU_KERNEL_PRIVATE
class IORootParent: public IOService
{
OSDeclareFinalStructors(IORootParent)
private:
unsigned long mostRecentChange;
public:
bool start( IOService * nub );
void shutDownSystem( void );
void restartSystem( void );
void sleepSystem( void );
void dozeSystem( void );
void sleepToDoze( void );
void wakeSystem( void );
};
#endif
#endif