1/* 2 * Copyright (c) 1998-2000 Apple Computer, Inc. All rights reserved. 3 * 4 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@ 5 * 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. 14 * 15 * Please obtain a copy of the License at 16 * http://www.opensource.apple.com/apsl/ and read it before using this file. 17 * 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. 25 * 26 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@ 27 */ 28#ifndef _IOKIT_ROOTDOMAIN_H 29#define _IOKIT_ROOTDOMAIN_H 30 31#include <IOKit/IOService.h> 32#include <IOKit/pwr_mgt/IOPM.h> 33#include <IOKit/IOBufferMemoryDescriptor.h> 34 35#ifdef XNU_KERNEL_PRIVATE 36struct AggressivesRecord; 37struct IOPMMessageFilterContext; 38struct IOPMActions; 39struct IOPMSystemSleepParameters; 40class PMSettingObject; 41class IOPMTimeline; 42class PMEventDetails; 43class PMTraceWorker; 44class IOPMPowerStateQueue; 45class RootDomainUserClient; 46class PMAssertionsTracker; 47#endif 48 49/*! 50 * Types for PM Assertions 51 * For creating, releasing, and getting PM assertion levels. 52 */ 53 54/*! IOPMDriverAssertionType 55 * A bitfield describing a set of assertions. May be used to specify which assertions 56 * to set with <link>IOPMrootDomain::createPMAssertion</link>; or to query which 57 * assertions are set with <link>IOPMrootDomain::releasePMAssertion</link>. 58 */ 59typedef uint64_t IOPMDriverAssertionType; 60 61/* IOPMDriverAssertionID 62 * Drivers may create PM assertions to request system behavior (keep the system awake, 63 * or keep the display awake). When a driver creates an assertion via 64 * <link>IOPMrootDomain::createPMAssertion</link>, PM returns a handle to 65 * the assertion of type IOPMDriverAssertionID. 66 */ 67typedef uint64_t IOPMDriverAssertionID; 68#define kIOPMUndefinedDriverAssertionID 0 69 70/* IOPMDriverAssertionLevel 71 * Possible values for IOPMDriverAssertionLevel are <link>kIOPMDriverAssertionLevelOff</link> 72 * and <link>kIOPMDriverAssertionLevelOn</link> 73 */ 74typedef uint32_t IOPMDriverAssertionLevel; 75#define kIOPMDriverAssertionLevelOff 0 76#define kIOPMDriverAssertionLevelOn 255 77 78/* 79 * Flags for get/setSleepSupported() 80 */ 81enum { 82 kRootDomainSleepNotSupported = 0x00000000, 83 kRootDomainSleepSupported = 0x00000001, 84 kFrameBufferDeepSleepSupported = 0x00000002, 85 kPCICantSleep = 0x00000004 86}; 87 88/* 89 *IOPMrootDomain registry property keys 90 */ 91#define kRootDomainSupportedFeatures "Supported Features" 92#define kRootDomainSleepReasonKey "Last Sleep Reason" 93#define kRootDomainSleepOptionsKey "Last Sleep Options" 94#define kIOPMRootDomainWakeReasonKey "Wake Reason" 95#define kIOPMRootDomainWakeTypeKey "Wake Type" 96#define kIOPMRootDomainPowerStatusKey "Power Status" 97 98/* 99 * Possible sleep reasons found under kRootDomainSleepReasonsKey 100 */ 101#define kIOPMClamshellSleepKey "Clamshell Sleep" 102#define kIOPMPowerButtonSleepKey "Power Button Sleep" 103#define kIOPMSoftwareSleepKey "Software Sleep" 104#define kIOPMOSSwitchHibernationKey "OS Switch Sleep" 105#define kIOPMIdleSleepKey "Idle Sleep" 106#define kIOPMLowPowerSleepKey "Low Power Sleep" 107#define kIOPMThermalEmergencySleepKey "Thermal Emergency Sleep" 108#define kIOPMMaintenanceSleepKey "Maintenance Sleep" 109 110/* 111 * String constants for communication with PM CPU 112 */ 113#define kIOPMRootDomainLidCloseCString "LidClose" 114#define kIOPMRootDomainBatPowerCString "BatPower" 115 116/* 117 * Supported Feature bitfields for IOPMrootDomain::publishFeature() 118 */ 119enum { 120 kIOPMSupportedOnAC = (1<<0), 121 kIOPMSupportedOnBatt = (1<<1), 122 kIOPMSupportedOnUPS = (1<<2) 123}; 124 125typedef IOReturn (*IOPMSettingControllerCallback) 126 (OSObject *target, const OSSymbol *type, 127 OSObject *val, uintptr_t refcon); 128 129__BEGIN_DECLS 130IONotifier * registerSleepWakeInterest( 131 IOServiceInterestHandler, void *, void * = 0); 132 133IONotifier * registerPrioritySleepWakeInterest( 134 IOServiceInterestHandler handler, 135 void * self, void * ref = 0); 136 137IOReturn acknowledgeSleepWakeNotification(void * ); 138 139IOReturn vetoSleepWakeNotification(void * PMrefcon); 140__END_DECLS 141 142#define IOPM_ROOTDOMAIN_REV 2 143 144class IOPMrootDomain: public IOService 145{ 146 OSDeclareFinalStructors(IOPMrootDomain) 147 148public: 149 static IOPMrootDomain * construct( void ); 150 151 virtual bool start( IOService * provider ); 152 virtual IOReturn setAggressiveness( unsigned long, unsigned long ); 153 virtual IOReturn getAggressiveness( unsigned long, unsigned long * ); 154 155 virtual IOReturn sleepSystem( void ); 156 IOReturn sleepSystemOptions( OSDictionary *options ); 157 158 virtual IOReturn setProperties( OSObject * ); 159 virtual bool serializeProperties( OSSerialize * s ) const; 160 161/*! @function systemPowerEventOccurred 162 @abstract Other drivers may inform IOPMrootDomain of system PM events 163 @discussion systemPowerEventOccurred is a richer alternative to receivePowerNotification() 164 Only Apple-owned kexts should have reason to call systemPowerEventOccurred. 165 @param event An OSSymbol describing the type of power event. 166 @param value A 32-bit integer value associated with the event. 167 @param shouldUpdate indicates whether the root domain should send a notification 168 to interested parties. Pass false if you're calling systemPowerEventOccurred 169 several times in succession; and pass true only on the last invocatino. 170 @result kIOReturnSuccess on success */ 171 172 IOReturn systemPowerEventOccurred( 173 const OSSymbol *event, 174 uint32_t intValue ); 175 176 IOReturn systemPowerEventOccurred( 177 const OSSymbol *event, 178 OSObject *value ); 179 180 virtual IOReturn receivePowerNotification( UInt32 msg ); 181 182 virtual void setSleepSupported( IOOptionBits flags ); 183 184 virtual IOOptionBits getSleepSupported( void ); 185 186 void wakeFromDoze( void ); 187 188 // KEXT driver announces support of power management feature 189 190 void publishFeature( const char *feature ); 191 192 // KEXT driver announces support of power management feature 193 // And specifies power sources with kIOPMSupportedOn{AC/Batt/UPS} bitfield. 194 // Returns a unique uint32_t identifier for later removing support for this 195 // feature. 196 // NULL is acceptable for uniqueFeatureID for kexts without plans to unload. 197 198 void publishFeature( const char *feature, 199 uint32_t supportedWhere, 200 uint32_t *uniqueFeatureID); 201 202 // KEXT driver announces removal of a previously published power management 203 // feature. Pass 'uniqueFeatureID' returned from publishFeature() 204 205 IOReturn removePublishedFeature( uint32_t removeFeatureID ); 206 207/*! @function copyPMSetting 208 @abstract Copy the current value for a PM setting. Returns an OSNumber or 209 OSData depending on the setting. 210 @param whichSetting Name of the desired setting. 211 @result OSObject value if valid, NULL otherwise. */ 212 213 OSObject * copyPMSetting( OSSymbol *whichSetting ); 214 215/*! @function registerPMSettingController 216 @abstract Register for callbacks on changes to certain PM settings. 217 @param settings NULL terminated array of C strings, each string for a PM 218 setting that the caller is interested in and wants to get callbacks for. 219 @param callout C function ptr or member function cast as such. 220 @param target The target of the callback, usually 'this' 221 @param refcon Will be passed to caller in callback; for caller's use. 222 @param handle Caller should keep the OSObject * returned here. If non-NULL, 223 handle will have a retain count of 1 on return. To deregister, pass to 224 unregisterPMSettingController() 225 @result kIOReturnSuccess on success. */ 226 227 IOReturn registerPMSettingController( 228 const OSSymbol *settings[], 229 IOPMSettingControllerCallback callout, 230 OSObject *target, 231 uintptr_t refcon, 232 OSObject **handle); // out param 233 234/*! @function registerPMSettingController 235 @abstract Register for callbacks on changes to certain PM settings. 236 @param settings NULL terminated array of C strings, each string for a PM 237 setting that the caller is interested in and wants to get callbacks for. 238 @param supportedPowerSources bitfield indicating which power sources these 239 settings are supported for (kIOPMSupportedOnAC, etc.) 240 @param callout C function ptr or member function cast as such. 241 @param target The target of the callback, usually 'this' 242 @param refcon Will be passed to caller in callback; for caller's use. 243 @param handle Caller should keep the OSObject * returned here. If non-NULL, 244 handle will have a retain count of 1 on return. To deregister, pass to 245 unregisterPMSettingController() 246 @result kIOReturnSuccess on success. */ 247 248 IOReturn registerPMSettingController( 249 const OSSymbol *settings[], 250 uint32_t supportedPowerSources, 251 IOPMSettingControllerCallback callout, 252 OSObject *target, 253 uintptr_t refcon, 254 OSObject **handle); // out param 255 256 virtual IONotifier * registerInterest( 257 const OSSymbol * typeOfInterest, 258 IOServiceInterestHandler handler, 259 void * target, void * ref = 0 ); 260 261 virtual IOReturn callPlatformFunction( 262 const OSSymbol *functionName, 263 bool waitForFunction, 264 void *param1, void *param2, 265 void *param3, void *param4 ); 266 267/*! @function createPMAssertion 268 @abstract Creates an assertion to influence system power behavior. 269 @param whichAssertionBits A bitfield specify the assertion that the caller requests. 270 @param assertionLevel An integer detailing the initial assertion level, kIOPMDriverAssertionLevelOn 271 or kIOPMDriverAssertionLevelOff. 272 @param ownerService A pointer to the caller's IOService class, for tracking. 273 @param ownerDescription A reverse-DNS string describing the caller's identity and reason. 274 @result On success, returns a new assertion of type IOPMDriverAssertionID 275*/ 276 IOPMDriverAssertionID createPMAssertion( 277 IOPMDriverAssertionType whichAssertionsBits, 278 IOPMDriverAssertionLevel assertionLevel, 279 IOService *ownerService, 280 const char *ownerDescription); 281 282/* @function setPMAssertionLevel 283 @abstract Modify the level of a pre-existing assertion. 284 @discussion Change the value of a PM assertion to influence system behavior, 285 without undergoing the work required to create or destroy an assertion. Suggested 286 for clients who will assert and de-assert needs for PM behavior several times over 287 their lifespan. 288 @param assertionID An assertion ID previously returned by <link>createPMAssertion</link> 289 @param assertionLevel The new assertion level. 290 @result kIOReturnSuccess if it worked; kIOReturnNotFound or other IOReturn error on failure. 291*/ 292 IOReturn setPMAssertionLevel(IOPMDriverAssertionID assertionID, IOPMDriverAssertionLevel assertionLevel); 293 294/*! @function getPMAssertionLevel 295 @absract Returns the active level of the specified assertion(s). 296 @discussion Returns <link>kIOPMDriverAssertionLevelOff</link> or 297 <link>kIOPMDriverAssertionLevelOn</link>. If multiple assertions are specified 298 in the bitfield, only returns <link>kIOPMDriverAssertionLevelOn</link> 299 if all assertions are active. 300 @param whichAssertionBits Bits defining the assertion or assertions the caller is interested in 301 the level of. If in doubt, pass <link>kIOPMDriverAssertionCPUBit</link> as the argument. 302 @result Returns <link>kIOPMDriverAssertionLevelOff</link> or 303 <link>kIOPMDriverAssertionLevelOn</link> indicating the specified assertion's levels, if available. 304 If the assertions aren't supported on this machine, or aren't recognized by the OS, the 305 result is undefined. 306*/ 307 IOPMDriverAssertionLevel getPMAssertionLevel(IOPMDriverAssertionType whichAssertionBits); 308 309/*! @function releasePMAssertion 310 @abstract Removes an assertion to influence system power behavior. 311 @result On success, returns a new assertion of type IOPMDriverAssertionID * 312*/ 313 IOReturn releasePMAssertion(IOPMDriverAssertionID releaseAssertion); 314 315private: 316 virtual IOReturn changePowerStateTo( unsigned long ordinal ); 317 virtual IOReturn changePowerStateToPriv( unsigned long ordinal ); 318 virtual IOReturn requestPowerDomainState( IOPMPowerFlags, IOPowerConnection *, unsigned long ); 319 virtual void powerChangeDone( unsigned long ); 320 virtual bool tellChangeDown( unsigned long ); 321 virtual bool askChangeDown( unsigned long ); 322 virtual void tellChangeUp( unsigned long ); 323 virtual void tellNoChangeDown( unsigned long ); 324#ifdef XNU_KERNEL_PRIVATE 325 /* Root Domain internals */ 326public: 327 void tagPowerPlaneService( 328 IOService * service, 329 IOPMActions * actions ); 330 331 void overrideOurPowerChange( 332 IOService * service, 333 IOPMActions * actions, 334 unsigned long * inOutPowerState, 335 uint32_t * inOutChangeFlags ); 336 337 void handleOurPowerChangeStart( 338 IOService * service, 339 IOPMActions * actions, 340 uint32_t powerState, 341 uint32_t * inOutChangeFlags ); 342 343 void handleOurPowerChangeDone( 344 IOService * service, 345 IOPMActions * actions, 346 uint32_t powerState, 347 uint32_t changeFlags ); 348 349 void overridePowerChangeForUIService( 350 IOService * service, 351 IOPMActions * actions, 352 unsigned long * inOutPowerState, 353 uint32_t * inOutChangeFlags ); 354 355 void handleActivityTickleForDisplayWrangler( 356 IOService * service, 357 IOPMActions * actions ); 358 359 bool shouldDelayChildNotification( 360 IOService * service ); 361 362 void handlePowerChangeStartForPCIDevice( 363 IOService * service, 364 IOPMActions * actions, 365 uint32_t powerState, 366 uint32_t * inOutChangeFlags ); 367 368 void handlePowerChangeDoneForPCIDevice( 369 IOService * service, 370 IOPMActions * actions, 371 uint32_t powerState, 372 uint32_t changeFlags ); 373 374 void askChangeDownDone( 375 IOPMPowerChangeFlags * inOutChangeFlags, 376 bool * cancel ); 377 378 void handlePublishSleepWakeUUID( 379 bool shouldPublish); 380 381 void handleQueueSleepWakeUUID( 382 OSObject *obj); 383 384 void handleSuspendPMNotificationClient( 385 uint32_t pid, bool doSuspend); 386 387 IOReturn setMaintenanceWakeCalendar( 388 const IOPMCalendarStruct * calendar ); 389 390 IOReturn getSystemSleepType( uint32_t * sleepType ); 391 392 // Handle callbacks from IOService::systemWillShutdown() 393 void acknowledgeSystemWillShutdown( IOService * from ); 394 395 // Handle platform halt and restart notifications 396 void handlePlatformHaltRestart( UInt32 pe_type ); 397 398 IOReturn shutdownSystem( void ); 399 IOReturn restartSystem( void ); 400 void handleSleepTimerExpiration( void ); 401 402 bool activitySinceSleep(void); 403 bool abortHibernation(void); 404 405 IOReturn joinAggressiveness( IOService * service ); 406 void handleAggressivesRequests( void ); 407 408 void tracePoint( uint8_t point ); 409 void tracePoint( uint8_t point, uint8_t data ); 410 void traceDetail( uint32_t data32 ); 411 412 bool systemMessageFilter( 413 void * object, void * arg1, void * arg2, void * arg3 ); 414 415 void updatePreventIdleSleepList( 416 IOService * service, bool addNotRemove ); 417 void updatePreventSystemSleepList( 418 IOService * service, bool addNotRemove ); 419 420 void publishPMSetting( 421 const OSSymbol * feature, uint32_t where, uint32_t * featureID ); 422 423/*! @function recordPMEvent 424 @abstract Logs IOService PM event timing. 425 @discussion Should only be called from IOServicePM. Should not be exported. 426 @result kIOReturn on success. 427*/ 428 IOReturn recordPMEvent( PMEventDetails *details ); 429 IOReturn recordAndReleasePMEvent( PMEventDetails *details ); 430 IOReturn recordPMEventGated( PMEventDetails *details ); 431 IOReturn recordAndReleasePMEventGated( PMEventDetails *details ); 432 433 void pmStatsRecordEvent( 434 int eventIndex, 435 AbsoluteTime timestamp); 436 437 void pmStatsRecordApplicationResponse( 438 const OSSymbol *response, 439 const char *name, 440 int messageType, 441 uint32_t delay_ms, 442 int app_pid); 443 444 445/*! @function suspendPMNotificationsForPID 446 @abstract kernel process management calls this to disable sleep/wake notifications 447 when a process is suspended. 448 @param pid the process ID 449 @param doSuspend true suspends the notifications; false enables them 450*/ 451 void suspendPMNotificationsForPID( uint32_t pid, bool doSuspend); 452 453/*! @function pmNotificationIsSuspended 454 @abstract returns true if PM notifications have been suspended 455 @param pid the process ID 456 @result true if the process has been suspended 457*/ 458 bool pmNotificationIsSuspended( uint32_t pid ); 459 460#if HIBERNATION 461 bool getHibernateSettings( 462 uint32_t * hibernateMode, 463 uint32_t * hibernateFreeRatio, 464 uint32_t * hibernateFreeTime ); 465#endif 466 467private: 468 friend class PMSettingObject; 469 friend class RootDomainUserClient; 470 friend class PMAssertionsTracker; 471 472 static IOReturn sysPowerDownHandler( void * target, void * refCon, 473 UInt32 messageType, IOService * service, 474 void * messageArgument, vm_size_t argSize ); 475 476 static IOReturn displayWranglerNotification( void * target, void * refCon, 477 UInt32 messageType, IOService * service, 478 void * messageArgument, vm_size_t argSize ); 479 480 static IOReturn rootBusyStateChangeHandler( void * target, void * refCon, 481 UInt32 messageType, IOService * service, 482 void * messageArgument, vm_size_t argSize ); 483 484 static bool displayWranglerMatchPublished( void * target, void * refCon, 485 IOService * newService, 486 IONotifier * notifier); 487 488 static bool batteryPublished( void * target, void * refCon, 489 IOService * resourceService, 490 IONotifier * notifier); 491 492 IOService * wrangler; 493 494 IOLock *featuresDictLock; // guards supportedFeatures 495 IOPMPowerStateQueue *pmPowerStateQueue; 496 497 OSArray *allowedPMSettings; 498 OSArray *noPublishPMSettings; 499 PMTraceWorker *pmTracer; 500 PMAssertionsTracker *pmAssertions; 501 502 // Settings controller info 503 IOLock *settingsCtrlLock; 504 OSDictionary *settingsCallbacks; 505 OSDictionary *fPMSettingsDict; 506 507 IONotifier *_batteryPublishNotifier; 508 IONotifier *_displayWranglerNotifier; 509 510 // Statistics 511 const OSSymbol *_statsNameKey; 512 const OSSymbol *_statsPIDKey; 513 const OSSymbol *_statsTimeMSKey; 514 const OSSymbol *_statsResponseTypeKey; 515 const OSSymbol *_statsMessageTypeKey; 516 517 OSString *queuedSleepWakeUUIDString; 518 OSArray *pmStatsAppResponses; 519 520 bool uuidPublished; 521 522 // Pref: idle time before idle sleep 523 unsigned long sleepSlider; 524 unsigned long idleSeconds; 525 uint64_t autoWakeStart; 526 uint64_t autoWakeEnd; 527 528 // Difference between sleepSlider and longestNonSleepSlider 529 unsigned long extraSleepDelay; 530 531 // Used to wait between say display idle and system idle 532 thread_call_t extraSleepTimer; 533 thread_call_t diskSyncCalloutEntry; 534 535 // IOPMActions parameter encoding 536 enum { 537 kPMActionsFlagIsDisplayWrangler = 0x00000001, 538 kPMActionsFlagIsGraphicsDevice = 0x00000002, 539 kPMActionsFlagIsAudioDevice = 0x00000004, 540 kPMActionsFlagLimitPower = 0x00000008, 541 kPMActionsPCIBitNumberMask = 0x000000ff 542 }; 543 544 // Track system capabilities. 545 uint32_t _desiredCapability; 546 uint32_t _currentCapability; 547 uint32_t _pendingCapability; 548 uint32_t _highestCapability; 549 OSSet * _joinedCapabilityClients; 550 uint32_t _systemStateGeneration; 551 552 // Type of clients that can receive system messages. 553 enum { 554 kSystemMessageClientConfigd = 0x01, 555 kSystemMessageClientApp = 0x02, 556 kSystemMessageClientUser = 0x03, 557 kSystemMessageClientKernel = 0x04, 558 kSystemMessageClientAll = 0x07 559 }; 560 uint32_t _systemMessageClientMask; 561 562 // Power state and capability change transitions. 563 enum { 564 kSystemTransitionNone = 0, 565 kSystemTransitionSleep = 1, 566 kSystemTransitionWake = 2, 567 kSystemTransitionCapability = 3, 568 kSystemTransitionNewCapClient = 4 569 } _systemTransitionType; 570 571 unsigned int systemBooting :1; 572 unsigned int systemShutdown :1; 573 unsigned int systemDarkWake :1; 574 unsigned int clamshellExists :1; 575 unsigned int clamshellClosed :1; 576 unsigned int clamshellDisabled :1; 577 unsigned int desktopMode :1; 578 unsigned int acAdaptorConnected :1; 579 unsigned int clamshellSleepDisabled :1; 580 581 unsigned int idleSleepTimerPending :1; 582 unsigned int userDisabledAllSleep :1; 583 unsigned int ignoreTellChangeDown :1; 584 unsigned int wranglerAsleep :1; 585 unsigned int wranglerTickled :1; 586 unsigned int wranglerSleepIgnored :1; 587 unsigned int graphicsSuppressed :1; 588 unsigned int darkWakeThermalAlarm :1; 589 590 unsigned int capabilityLoss :1; 591 unsigned int pciCantSleepFlag :1; 592 unsigned int pciCantSleepValid :1; 593 unsigned int logWranglerTickle :1; 594 unsigned int logGraphicsClamp :1; 595 unsigned int darkWakeToSleepASAP :1; 596 unsigned int darkWakeMaintenance :1; 597 unsigned int darkWakeSleepService :1; 598 599 unsigned int darkWakePostTickle :1; 600 unsigned int sleepTimerMaintenance :1; 601 unsigned int lowBatteryCondition :1; 602 unsigned int darkWakeThermalEmergency:1; 603 unsigned int hibernateDisabled :1; 604 unsigned int hibernateNoDefeat :1; 605 unsigned int rejectWranglerTickle :1; 606 unsigned int wranglerTickleLatched :1; 607 608 uint32_t hibernateMode; 609 uint32_t userActivityCount; 610 uint32_t userActivityAtSleep; 611 uint32_t lastSleepReason; 612 uint32_t hibernateAborted; 613 614 // Info for communicating system state changes to PMCPU 615 int32_t idxPMCPUClamshell; 616 int32_t idxPMCPULimitedPower; 617 618 IOOptionBits platformSleepSupport; 619 uint32_t _debugWakeSeconds; 620 uint32_t _lastDebugWakeSeconds; 621 622 queue_head_t aggressivesQueue; 623 thread_call_t aggressivesThreadCall; 624 OSData * aggressivesData; 625 626 AbsoluteTime wranglerSleepTime; 627 AbsoluteTime systemWakeTime; 628 629 // PCI top-level PM trace 630 IOService * pciHostBridgeDevice; 631 IOService * pciHostBridgeDriver; 632 633 IONotifier * systemCapabilityNotifier; 634 635 IOPMTimeline *timeline; 636 637 typedef struct { 638 uint32_t pid; 639 uint32_t refcount; 640 } PMNotifySuspendedStruct; 641 642 uint32_t pmSuspendedCapacity; 643 uint32_t pmSuspendedSize; 644 PMNotifySuspendedStruct *pmSuspendedPIDS; 645 646 OSSet * preventIdleSleepList; 647 OSSet * preventSystemSleepList; 648 649 UInt32 _scheduledAlarms; 650 UInt32 _userScheduledAlarm; 651 652#if HIBERNATION 653 clock_sec_t _standbyTimerResetSeconds; 654#endif 655 656 int findSuspendedPID(uint32_t pid, uint32_t *outRefCount); 657 658 // IOPMrootDomain internal sleep call 659 IOReturn privateSleepSystem( uint32_t sleepReason ); 660 void reportUserInput( void ); 661 void setDisableClamShellSleep( bool ); 662 bool checkSystemCanSleep( IOOptionBits options = 0 ); 663 bool checkSystemCanSustainFullWake( void ); 664 665 void adjustPowerState( bool sleepASAP = false ); 666 void setQuickSpinDownTimeout( void ); 667 void restoreUserSpinDownTimeout( void ); 668 669 bool shouldSleepOnClamshellClosed(void ); 670 void sendClientClamshellNotification( void ); 671 672 // Inform PMCPU of changes to state like lid, AC vs. battery 673 void informCPUStateChange( uint32_t type, uint32_t value ); 674 675 void dispatchPowerEvent( uint32_t event, void * arg0, uint64_t arg1 ); 676 void handlePowerNotification( UInt32 msg ); 677 678 IOReturn setPMSetting(const OSSymbol *, OSObject *); 679 680 void startIdleSleepTimer( uint32_t inSeconds ); 681 void cancelIdleSleepTimer( void ); 682 683 IOReturn setAggressiveness( 684 unsigned long type, 685 unsigned long value, 686 IOOptionBits options ); 687 688 void synchronizeAggressives( 689 queue_head_t * services, 690 const AggressivesRecord * array, 691 int count ); 692 693 void broadcastAggressives( 694 const AggressivesRecord * array, 695 int count ); 696 697 // getPMTraceMemoryDescriptor should only be called by our friend RootDomainUserClient 698 IOMemoryDescriptor *getPMTraceMemoryDescriptor(void); 699 700 IOReturn setPMAssertionUserLevels(IOPMDriverAssertionType); 701 702 void publishSleepWakeUUID( bool shouldPublish ); 703 704 void evaluatePolicy( int stimulus, uint32_t arg = 0 ); 705 706 void evaluateAssertions(IOPMDriverAssertionType newAssertions, 707 IOPMDriverAssertionType oldAssertions); 708 709 void deregisterPMSettingObject( PMSettingObject * pmso ); 710 711#if HIBERNATION 712 bool getSleepOption( const char * key, uint32_t * option ); 713 bool evaluateSystemSleepPolicy( IOPMSystemSleepParameters * p, 714 int phase, uint32_t * hibMode ); 715 void evaluateSystemSleepPolicyEarly( void ); 716 void evaluateSystemSleepPolicyFinal( void ); 717#endif /* HIBERNATION */ 718 719 bool latchDisplayWranglerTickle( bool latch ); 720#endif /* XNU_KERNEL_PRIVATE */ 721}; 722 723#ifdef XNU_KERNEL_PRIVATE 724class IORootParent: public IOService 725{ 726 OSDeclareFinalStructors(IORootParent) 727 728public: 729 static void initialize( void ); 730 virtual OSObject * copyProperty( const char * aKey ) const; 731 bool start( IOService * nub ); 732 void shutDownSystem( void ); 733 void restartSystem( void ); 734 void sleepSystem( void ); 735 void dozeSystem( void ); 736 void sleepToDoze( void ); 737 void wakeSystem( void ); 738}; 739#endif /* XNU_KERNEL_PRIVATE */ 740 741#endif /* _IOKIT_ROOTDOMAIN_H */ 742