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#include <sys/vnode.h> 35 36#ifdef XNU_KERNEL_PRIVATE 37struct AggressivesRecord; 38struct IOPMMessageFilterContext; 39struct IOPMActions; 40struct IOPMSystemSleepParameters; 41class PMSettingObject; 42class PMTraceWorker; 43class IOPMPowerStateQueue; 44class RootDomainUserClient; 45class PMAssertionsTracker; 46 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)) 50 51#endif 52 53/*! 54 * Types for PM Assertions 55 * For creating, releasing, and getting PM assertion levels. 56 */ 57 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>. 62 */ 63typedef uint64_t IOPMDriverAssertionType; 64 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. 70 */ 71typedef uint64_t IOPMDriverAssertionID; 72#define kIOPMUndefinedDriverAssertionID 0 73 74/* IOPMDriverAssertionLevel 75 * Possible values for IOPMDriverAssertionLevel are <link>kIOPMDriverAssertionLevelOff</link> 76 * and <link>kIOPMDriverAssertionLevelOn</link> 77 */ 78typedef uint32_t IOPMDriverAssertionLevel; 79#define kIOPMDriverAssertionLevelOff 0 80#define kIOPMDriverAssertionLevelOn 255 81 82/* 83 * Flags for get/setSleepSupported() 84 */ 85enum { 86 kRootDomainSleepNotSupported = 0x00000000, 87 kRootDomainSleepSupported = 0x00000001, 88 kFrameBufferDeepSleepSupported = 0x00000002, 89 kPCICantSleep = 0x00000004 90}; 91 92/* 93 *IOPMrootDomain registry property keys 94 */ 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" 101 102/* 103 * Possible sleep reasons found under kRootDomainSleepReasonsKey 104 */ 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" 113 114/* 115 * String constants for communication with PM CPU 116 */ 117#define kIOPMRootDomainLidCloseCString "LidClose" 118#define kIOPMRootDomainBatPowerCString "BatPower" 119 120/* 121 * Supported Feature bitfields for IOPMrootDomain::publishFeature() 122 */ 123enum { 124 kIOPMSupportedOnAC = (1<<0), 125 kIOPMSupportedOnBatt = (1<<1), 126 kIOPMSupportedOnUPS = (1<<2) 127}; 128 129typedef IOReturn (*IOPMSettingControllerCallback) 130 (OSObject *target, const OSSymbol *type, 131 OSObject *val, uintptr_t refcon); 132 133__BEGIN_DECLS 134IONotifier * registerSleepWakeInterest( 135 IOServiceInterestHandler, void *, void * = 0); 136 137IONotifier * registerPrioritySleepWakeInterest( 138 IOServiceInterestHandler handler, 139 void * self, void * ref = 0); 140 141IOReturn acknowledgeSleepWakeNotification(void * ); 142 143IOReturn vetoSleepWakeNotification(void * PMrefcon); 144__END_DECLS 145 146#define IOPM_ROOTDOMAIN_REV 2 147 148class IOPMrootDomain: public IOService 149{ 150 OSDeclareFinalStructors(IOPMrootDomain) 151 152public: 153 static IOPMrootDomain * construct( void ); 154 155 virtual bool start( IOService * provider ); 156 virtual IOReturn setAggressiveness( unsigned long, unsigned long ); 157 virtual IOReturn getAggressiveness( unsigned long, unsigned long * ); 158 159 virtual IOReturn sleepSystem( void ); 160 IOReturn sleepSystemOptions( OSDictionary *options ); 161 162 virtual IOReturn setProperties( OSObject * ); 163 virtual bool serializeProperties( OSSerialize * s ) const; 164 virtual OSObject * copyProperty( const char * aKey ) const; 165 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 */ 176 177 IOReturn systemPowerEventOccurred( 178 const OSSymbol *event, 179 uint32_t intValue ); 180 181 IOReturn systemPowerEventOccurred( 182 const OSSymbol *event, 183 OSObject *value ); 184 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. 191 192 - Drivers should call claimSystemWakeEvent before completing 193 their setPowerState() acknowledgement. IOPMrootDomain stops 194 collecting wake events when driver wake is complete. 195 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. 199 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). 202 203 Examples: 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") 210 211 @param device The device/nub that is associated with the wake event. 212 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. 217 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: 221 [Hardware].[Event] 222 WiFi.MagicPacket 223 WiFi.ScanOffload 224 WiFi.mDNSConflict 225 WiFi.mDNSService 226 WiFi.TCPData 227 WiFi.TCPTimeout 228 WiFi.FirmwareCrash 229 Enet.MagicPacket 230 Enet.mDNSConflict 231 Enet.mDNSService 232 Enet.TCPData 233 Enet.TCPTimeout 234 Enet.Service 235 Enet.LinkToggle 236 Enet.ConflictResolution 237 Enet.PatternMatch 238 Enet.Timer 239 Enet.LinkUpTimeout 240 Enet.LinkDown 241 USB.DeviceAttach 242 USB.DeviceDetach 243 244 @param details Optional details further describing the wake event. 245 Please pass an OSString defining the event. 246 */ 247#endif 248 void claimSystemWakeEvent( IOService *device, 249 IOOptionBits flags, 250 const char *reason, 251 OSObject *details = 0 ); 252 253 virtual IOReturn receivePowerNotification( UInt32 msg ); 254 255 virtual void setSleepSupported( IOOptionBits flags ); 256 257 virtual IOOptionBits getSleepSupported( void ); 258 259 void wakeFromDoze( void ); 260 261 // KEXT driver announces support of power management feature 262 263 void publishFeature( const char *feature ); 264 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 268 // feature. 269 // NULL is acceptable for uniqueFeatureID for kexts without plans to unload. 270 271 void publishFeature( const char *feature, 272 uint32_t supportedWhere, 273 uint32_t *uniqueFeatureID); 274 275 // KEXT driver announces removal of a previously published power management 276 // feature. Pass 'uniqueFeatureID' returned from publishFeature() 277 278 IOReturn removePublishedFeature( uint32_t removeFeatureID ); 279 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. */ 285 286 OSObject * copyPMSetting( OSSymbol *whichSetting ); 287 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. */ 299 300 IOReturn registerPMSettingController( 301 const OSSymbol *settings[], 302 IOPMSettingControllerCallback callout, 303 OSObject *target, 304 uintptr_t refcon, 305 OSObject **handle); // out param 306 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. */ 320 321 IOReturn registerPMSettingController( 322 const OSSymbol *settings[], 323 uint32_t supportedPowerSources, 324 IOPMSettingControllerCallback callout, 325 OSObject *target, 326 uintptr_t refcon, 327 OSObject **handle); // out param 328 329 virtual IONotifier * registerInterest( 330 const OSSymbol * typeOfInterest, 331 IOServiceInterestHandler handler, 332 void * target, void * ref = 0 ); 333 334 virtual IOReturn callPlatformFunction( 335 const OSSymbol *functionName, 336 bool waitForFunction, 337 void *param1, void *param2, 338 void *param3, void *param4 ); 339 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 348*/ 349 IOPMDriverAssertionID createPMAssertion( 350 IOPMDriverAssertionType whichAssertionsBits, 351 IOPMDriverAssertionLevel assertionLevel, 352 IOService *ownerService, 353 const char *ownerDescription); 354 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 360 their lifespan. 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. 364*/ 365 IOReturn setPMAssertionLevel(IOPMDriverAssertionID assertionID, IOPMDriverAssertionLevel assertionLevel); 366 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 378 result is undefined. 379*/ 380 IOPMDriverAssertionLevel getPMAssertionLevel(IOPMDriverAssertionType whichAssertionBits); 381 382/*! @function releasePMAssertion 383 @abstract Removes an assertion to influence system power behavior. 384 @result On success, returns a new assertion of type IOPMDriverAssertionID * 385*/ 386 IOReturn releasePMAssertion(IOPMDriverAssertionID releaseAssertion); 387 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. 391*/ 392 IOReturn restartWithStackshot(); 393 394private: 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, 405 void *result, 406 void *destination); 407 virtual IOReturn updateReport(IOReportChannelList *channels, 408 IOReportUpdateAction action, 409 void *result, 410 void *destination); 411 412#ifdef XNU_KERNEL_PRIVATE 413 /* Root Domain internals */ 414public: 415 void tagPowerPlaneService( 416 IOService * service, 417 IOPMActions * actions ); 418 419 void overrideOurPowerChange( 420 IOService * service, 421 IOPMActions * actions, 422 IOPMPowerStateIndex * inOutPowerState, 423 IOPMPowerChangeFlags * inOutChangeFlags, 424 IOPMRequestTag requestTag ); 425 426 void handleOurPowerChangeStart( 427 IOService * service, 428 IOPMActions * actions, 429 IOPMPowerStateIndex powerState, 430 IOPMPowerChangeFlags * inOutChangeFlags, 431 IOPMRequestTag requestTag ); 432 433 void handleOurPowerChangeDone( 434 IOService * service, 435 IOPMActions * actions, 436 IOPMPowerStateIndex powerState, 437 IOPMPowerChangeFlags changeFlags, 438 IOPMRequestTag requestTag ); 439 440 void overridePowerChangeForUIService( 441 IOService * service, 442 IOPMActions * actions, 443 IOPMPowerStateIndex * inOutPowerState, 444 IOPMPowerChangeFlags * inOutChangeFlags ); 445 446 void handleActivityTickleForDisplayWrangler( 447 IOService * service, 448 IOPMActions * actions ); 449 450 void handleUpdatePowerClientForDisplayWrangler( 451 IOService * service, 452 IOPMActions * actions, 453 const OSSymbol * powerClient, 454 IOPMPowerStateIndex oldPowerState, 455 IOPMPowerStateIndex newPowerState ); 456 457 bool shouldDelayChildNotification( 458 IOService * service ); 459 460 void handlePowerChangeStartForPCIDevice( 461 IOService * service, 462 IOPMActions * actions, 463 IOPMPowerStateIndex powerState, 464 IOPMPowerChangeFlags * inOutChangeFlags ); 465 466 void handlePowerChangeDoneForPCIDevice( 467 IOService * service, 468 IOPMActions * actions, 469 IOPMPowerStateIndex powerState, 470 IOPMPowerChangeFlags changeFlags ); 471 472 void askChangeDownDone( 473 IOPMPowerChangeFlags * inOutChangeFlags, 474 bool * cancel ); 475 476 void handlePublishSleepWakeUUID( 477 bool shouldPublish); 478 479 void handleQueueSleepWakeUUID( 480 OSObject *obj); 481 482 void willNotifyPowerChildren( IOPMPowerStateIndex newPowerState ); 483 484 IOReturn setMaintenanceWakeCalendar( 485 const IOPMCalendarStruct * calendar ); 486 487 IOReturn getSystemSleepType( uint32_t * sleepType ); 488 489 // Handle callbacks from IOService::systemWillShutdown() 490 void acknowledgeSystemWillShutdown( IOService * from ); 491 492 // Handle platform halt and restart notifications 493 void handlePlatformHaltRestart( UInt32 pe_type ); 494 495 IOReturn shutdownSystem( void ); 496 IOReturn restartSystem( void ); 497 void handleSleepTimerExpiration( void ); 498 499 bool activitySinceSleep(void); 500 bool abortHibernation(void); 501 502 IOReturn joinAggressiveness( IOService * service ); 503 void handleAggressivesRequests( void ); 504 505 void tracePoint( uint8_t point ); 506 void tracePoint( uint8_t point, uint8_t data ); 507 void traceDetail( uint32_t data32 ); 508 509 bool systemMessageFilter( 510 void * object, void * arg1, void * arg2, void * arg3 ); 511 512 bool updatePreventIdleSleepList( 513 IOService * service, bool addNotRemove ); 514 void updatePreventSystemSleepList( 515 IOService * service, bool addNotRemove ); 516 517 void publishPMSetting( 518 const OSSymbol * feature, uint32_t where, uint32_t * featureID ); 519 520 void pmStatsRecordEvent( 521 int eventIndex, 522 AbsoluteTime timestamp); 523 524 void pmStatsRecordApplicationResponse( 525 const OSSymbol *response, 526 const char *name, 527 int messageType, 528 uint32_t delay_ms, 529 int app_pid, 530 OSObject *object, 531 IOPMPowerStateIndex ps=0); 532 533 void copyWakeReasonString( char * outBuf, size_t bufSize ); 534 535#if HIBERNATION 536 bool getHibernateSettings( 537 uint32_t * hibernateMode, 538 uint32_t * hibernateFreeRatio, 539 uint32_t * hibernateFreeTime ); 540#endif 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); 546 547private: 548 friend class PMSettingObject; 549 friend class RootDomainUserClient; 550 friend class PMAssertionsTracker; 551 552 static IOReturn sysPowerDownHandler( void * target, void * refCon, 553 UInt32 messageType, IOService * service, 554 void * messageArgument, vm_size_t argSize ); 555 556 static IOReturn displayWranglerNotification( void * target, void * refCon, 557 UInt32 messageType, IOService * service, 558 void * messageArgument, vm_size_t argSize ); 559 560 static IOReturn rootBusyStateChangeHandler( void * target, void * refCon, 561 UInt32 messageType, IOService * service, 562 void * messageArgument, vm_size_t argSize ); 563 564 static bool displayWranglerMatchPublished( void * target, void * refCon, 565 IOService * newService, 566 IONotifier * notifier); 567 568 static bool IONVRAMMatchPublished( void * target, void * refCon, 569 IOService * newService, 570 IONotifier * notifier); 571 572 static bool batteryPublished( void * target, void * refCon, 573 IOService * resourceService, 574 IONotifier * notifier); 575 576 void initializeBootSessionUUID( void ); 577 578 void fullWakeDelayedWork( void ); 579 580 IOService * wrangler; 581 OSDictionary * wranglerIdleSettings; 582 583 IOLock *featuresDictLock; // guards supportedFeatures 584 IOLock *wakeEventLock; 585 IOPMPowerStateQueue *pmPowerStateQueue; 586 587 OSArray *allowedPMSettings; 588 OSArray *noPublishPMSettings; 589 PMTraceWorker *pmTracer; 590 PMAssertionsTracker *pmAssertions; 591 592 // Settings controller info 593 IOLock *settingsCtrlLock; 594 OSDictionary *settingsCallbacks; 595 OSDictionary *fPMSettingsDict; 596 597 IONotifier *_batteryPublishNotifier; 598 IONotifier *_displayWranglerNotifier; 599 600 // Statistics 601 const OSSymbol *_statsNameKey; 602 const OSSymbol *_statsPIDKey; 603 const OSSymbol *_statsTimeMSKey; 604 const OSSymbol *_statsResponseTypeKey; 605 const OSSymbol *_statsMessageTypeKey; 606 const OSSymbol *_statsPowerCapsKey; 607 uint32_t sleepCnt; 608 uint32_t darkWakeCnt; 609 uint32_t displayWakeCnt; 610 611 OSString *queuedSleepWakeUUIDString; 612 OSArray *pmStatsAppResponses; 613 IOLock *pmStatsLock; // guards pmStatsAppResponses 614 615 bool uuidPublished; 616 617 // Pref: idle time before idle sleep 618 unsigned long sleepSlider; 619 unsigned long idleSeconds; 620 uint64_t autoWakeStart; 621 uint64_t autoWakeEnd; 622 623 // Difference between sleepSlider and longestNonSleepSlider 624 unsigned long extraSleepDelay; 625 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; 631 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; 639 640 // Type of clients that can receive system messages. 641 enum { 642 kSystemMessageClientPowerd = 0x01, 643 kSystemMessageClientLegacyApp = 0x02, 644 kSystemMessageClientKernel = 0x04, 645 kSystemMessageClientAll = 0x07 646 }; 647 uint32_t _systemMessageClientMask; 648 649 // Power state and capability change transitions. 650 enum { 651 kSystemTransitionNone = 0, 652 kSystemTransitionSleep = 1, 653 kSystemTransitionWake = 2, 654 kSystemTransitionCapability = 3, 655 kSystemTransitionNewCapClient = 4 656 } _systemTransitionType; 657 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; 666 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; 675 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; 684 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; 693 694 unsigned int displayIdleForDemandSleep :1; 695 unsigned int darkWakeHibernateError :1; 696 697 uint32_t hibernateMode; 698 AbsoluteTime userActivityTime; 699 AbsoluteTime userActivityTime_prev; 700 uint32_t userActivityCount; 701 uint32_t userActivityAtSleep; 702 uint32_t lastSleepReason; 703 uint32_t fullToDarkReason; 704 uint32_t hibernateAborted; 705 706 enum FullWakeReason { 707 kFullWakeReasonNone = 0, 708 kFullWakeReasonLocalUser = 1, 709 kFullWakeReasonDisplayOn = 2, 710 fFullWakeReasonDisplayOnAndLocalUser = 3 711 }; 712 uint32_t fullWakeReason; 713 714 // Info for communicating system state changes to PMCPU 715 int32_t idxPMCPUClamshell; 716 int32_t idxPMCPULimitedPower; 717 718 IOOptionBits platformSleepSupport; 719 uint32_t _debugWakeSeconds; 720 uint32_t _lastDebugWakeSeconds; 721 722 queue_head_t aggressivesQueue; 723 thread_call_t aggressivesThreadCall; 724 OSData * aggressivesData; 725 726 AbsoluteTime userBecameInactiveTime; 727 AbsoluteTime systemWakeTime; 728 729 // PCI top-level PM trace 730 IOService * pciHostBridgeDevice; 731 IOService * pciHostBridgeDriver; 732 733 IONotifier * systemCapabilityNotifier; 734 735 typedef struct { 736 uint32_t pid; 737 uint32_t refcount; 738 } PMNotifySuspendedStruct; 739 740 uint32_t pmSuspendedCapacity; 741 uint32_t pmSuspendedSize; 742 PMNotifySuspendedStruct *pmSuspendedPIDS; 743 744 OSSet * preventIdleSleepList; 745 OSSet * preventSystemSleepList; 746 747 UInt32 _scheduledAlarms; 748 UInt32 _userScheduledAlarm; 749 750#if HIBERNATION 751 clock_sec_t _standbyTimerResetSeconds; 752#endif 753 volatile uint32_t swd_lock; /* Lock to access swd_buffer & and its header */ 754 void * swd_buffer; /* Memory allocated for dumping sleep/wake logs */ 755 uint8_t swd_flags; /* Flags defined in IOPMPrivate.h */ 756 757 IOMemoryMap * swd_logBufMap; /* Memory with sleep/wake logs from previous boot */ 758 759 // Wake Event Reporting 760 OSArray * _systemWakeEventsArray; 761 bool _acceptSystemWakeEvents; 762 763 int findSuspendedPID(uint32_t pid, uint32_t *outRefCount); 764 765 // IOPMrootDomain internal sleep call 766 IOReturn privateSleepSystem( uint32_t sleepReason ); 767 void reportUserInput( void ); 768 void setDisableClamShellSleep( bool ); 769 bool checkSystemSleepAllowed( IOOptionBits options, 770 uint32_t sleepReason ); 771 bool checkSystemSleepEnabled( void ); 772 bool checkSystemCanSleep( uint32_t sleepReason ); 773 bool checkSystemCanSustainFullWake( void ); 774 775 void adjustPowerState( bool sleepASAP = false ); 776 void setQuickSpinDownTimeout( void ); 777 void restoreUserSpinDownTimeout( void ); 778 779 bool shouldSleepOnClamshellClosed(void ); 780 void sendClientClamshellNotification( void ); 781 782 // Inform PMCPU of changes to state like lid, AC vs. battery 783 void informCPUStateChange( uint32_t type, uint32_t value ); 784 785 void dispatchPowerEvent( uint32_t event, void * arg0, uint64_t arg1 ); 786 void handlePowerNotification( UInt32 msg ); 787 788 IOReturn setPMSetting(const OSSymbol *, OSObject *); 789 790 void startIdleSleepTimer( uint32_t inSeconds ); 791 void cancelIdleSleepTimer( void ); 792 uint32_t getTimeToIdleSleep( void ); 793 794 IOReturn setAggressiveness( 795 unsigned long type, 796 unsigned long value, 797 IOOptionBits options ); 798 799 void synchronizeAggressives( 800 queue_head_t * services, 801 const AggressivesRecord * array, 802 int count ); 803 804 void broadcastAggressives( 805 const AggressivesRecord * array, 806 int count ); 807 808 IOReturn setPMAssertionUserLevels(IOPMDriverAssertionType); 809 810 void publishSleepWakeUUID( bool shouldPublish ); 811 812 void evaluatePolicy( int stimulus, uint32_t arg = 0 ); 813 void requestFullWake( FullWakeReason reason ); 814 void willEnterFullWake( void ); 815 816 void evaluateAssertions(IOPMDriverAssertionType newAssertions, 817 IOPMDriverAssertionType oldAssertions); 818 819 void deregisterPMSettingObject( PMSettingObject * pmso ); 820 821 void sleepWakeDebugMemAlloc( ); 822 void sleepWakeDebugDumpFromMem(IOMemoryMap *logBufMap); 823 void sleepWakeDebugDumpFromFile( ); 824 IOMemoryMap *sleepWakeDebugRetrieve(); 825 errno_t sleepWakeDebugSaveFile(const char *name, char *buf, int len); 826 errno_t sleepWakeDebugCopyFile( struct vnode *srcVp, 827 vfs_context_t srcCtx, 828 char *tmpBuf, uint64_t tmpBufSize, 829 uint64_t srcOffset, 830 const char *dstFname, 831 uint64_t numBytes, 832 uint32_t crc); 833 834 835#if HIBERNATION 836 bool getSleepOption( const char * key, uint32_t * option ); 837 bool evaluateSystemSleepPolicy( IOPMSystemSleepParameters * p, 838 int phase, uint32_t * hibMode ); 839 void evaluateSystemSleepPolicyEarly( void ); 840 void evaluateSystemSleepPolicyFinal( void ); 841#endif /* HIBERNATION */ 842 843 bool latchDisplayWranglerTickle( bool latch ); 844 void setDisplayPowerOn( uint32_t options ); 845 846 void acceptSystemWakeEvents( bool accept ); 847 void systemDidNotSleep( void ); 848 void preventTransitionToUserActive( bool prevent ); 849#endif /* XNU_KERNEL_PRIVATE */ 850}; 851 852#ifdef XNU_KERNEL_PRIVATE 853class IORootParent: public IOService 854{ 855 OSDeclareFinalStructors(IORootParent) 856 857public: 858 static void initialize( void ); 859 virtual OSObject * copyProperty( const char * aKey ) const; 860 bool start( IOService * nub ); 861 void shutDownSystem( void ); 862 void restartSystem( void ); 863 void sleepSystem( void ); 864 void dozeSystem( void ); 865 void sleepToDoze( void ); 866 void wakeSystem( void ); 867}; 868#endif /* XNU_KERNEL_PRIVATE */ 869 870#endif /* _IOKIT_ROOTDOMAIN_H */ 871