iokit/IOKit/pwr_mgt/RootDomain.h

   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
  37 struct AggressivesRecord;
  38 struct IOPMMessageFilterContext;
  39 struct IOPMActions;
  40 struct IOPMSystemSleepParameters;
  41 class PMSettingObject;
  42 class PMTraceWorker;
  43 class IOPMPowerStateQueue;
  44 class RootDomainUserClient;
  45 class 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  */
  63 typedef 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  */
  71 typedef 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  */
  78 typedef uint32_t IOPMDriverAssertionLevel;
  79 #define kIOPMDriverAssertionLevelOff          0
  80 #define kIOPMDriverAssertionLevelOn           255
  81
  82 /*
  83  * Flags for get/setSleepSupported()
  84  */
  85 enum {
  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  */
 123 enum {
 124     kIOPMSupportedOnAC      = (1<<0),
 125     kIOPMSupportedOnBatt    = (1<<1),
 126     kIOPMSupportedOnUPS     = (1<<2)
 127 };
 128
 129 typedef IOReturn (*IOPMSettingControllerCallback)
 130                     (OSObject *target, const OSSymbol *type,
 131                      OSObject *val, uintptr_t refcon);
 132
 133 __BEGIN_DECLS
 134 IONotifier *    registerSleepWakeInterest(
 135                     IOServiceInterestHandler, void *, void * = 0);
 136
 137 IONotifier *    registerPrioritySleepWakeInterest(
 138                     IOServiceInterestHandler handler,
 139                     void * self, void * ref = 0);
 140
 141 IOReturn        acknowledgeSleepWakeNotification(void * );
 142
 143 IOReturn        vetoSleepWakeNotification(void * PMrefcon);
 144 __END_DECLS
 145
 146 #define IOPM_ROOTDOMAIN_REV        2
 147
 148 class IOPMrootDomain: public IOService
 149 {
 150     OSDeclareFinalStructors(IOPMrootDomain)
 151
 152 public:
 153     static IOPMrootDomain * construct( void );
 154
 155     virtual bool        start( IOService * provider ) APPLE_KEXT_OVERRIDE;
 156     virtual IOReturn    setAggressiveness( unsigned long, unsigned long ) APPLE_KEXT_OVERRIDE;
 157     virtual IOReturn    getAggressiveness( unsigned long, unsigned long * ) APPLE_KEXT_OVERRIDE;
 158
 159     virtual IOReturn    sleepSystem( void );
 160     IOReturn            sleepSystemOptions( OSDictionary *options );
 161
 162     virtual IOReturn    setProperties( OSObject * ) APPLE_KEXT_OVERRIDE;
 163     virtual bool        serializeProperties( OSSerialize * s ) const APPLE_KEXT_OVERRIDE;
 164     virtual OSObject *  copyProperty( const char * aKey ) const APPLE_KEXT_OVERRIDE;
 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 ) APPLE_KEXT_OVERRIDE;
 333
 334     virtual IOReturn    callPlatformFunction(
 335                                 const OSSymbol *functionName,
 336                                 bool waitForFunction,
 337                                 void *param1, void *param2,
 338                                 void *param3, void *param4 ) APPLE_KEXT_OVERRIDE;
 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
 394 private:
 395     virtual IOReturn    changePowerStateTo( unsigned long ordinal ) APPLE_KEXT_COMPATIBILITY_OVERRIDE;
 396     virtual IOReturn    changePowerStateToPriv( unsigned long ordinal );
 397     virtual IOReturn    requestPowerDomainState( IOPMPowerFlags, IOPowerConnection *, unsigned long ) APPLE_KEXT_OVERRIDE;
 398     virtual void        powerChangeDone( unsigned long ) APPLE_KEXT_OVERRIDE;
 399     virtual bool        tellChangeDown( unsigned long ) APPLE_KEXT_OVERRIDE;
 400     virtual bool        askChangeDown( unsigned long ) APPLE_KEXT_OVERRIDE;
 401     virtual void        tellChangeUp( unsigned long ) APPLE_KEXT_OVERRIDE;
 402     virtual void        tellNoChangeDown( unsigned long ) APPLE_KEXT_OVERRIDE;
 403     virtual IOReturn configureReport(IOReportChannelList   *channels,
 404                                     IOReportConfigureAction action,
 405                                     void                    *result,
 406                                     void                    *destination) APPLE_KEXT_OVERRIDE;
 407     virtual IOReturn updateReport(IOReportChannelList      *channels,
 408                                   IOReportUpdateAction     action,
 409                                   void                     *result,
 410                                   void                     *destination) APPLE_KEXT_OVERRIDE;
 411
 412     void             configureReportGated(uint64_t channel_id,
 413                                           uint64_t action,
 414                                           void     *result);
 415     IOReturn         updateReportGated(uint64_t ch_id,
 416                                        void *result,
 417                                        IOBufferMemoryDescriptor *dest);
 418
 419 #ifdef XNU_KERNEL_PRIVATE
 420     /* Root Domain internals */
 421 public:
 422     void        tagPowerPlaneService(
 423                     IOService *     service,
 424                     IOPMActions *   actions );
 425
 426     void        overrideOurPowerChange(
 427                     IOService *             service,
 428                     IOPMActions *           actions,
 429                     IOPMPowerStateIndex *   inOutPowerState,
 430                     IOPMPowerChangeFlags *  inOutChangeFlags,
 431                     IOPMRequestTag          requestTag );
 432
 433     void        handleOurPowerChangeStart(
 434                     IOService *             service,
 435                     IOPMActions *           actions,
 436                     IOPMPowerStateIndex     powerState,
 437                     IOPMPowerChangeFlags *  inOutChangeFlags,
 438                     IOPMRequestTag          requestTag );
 439
 440     void        handleOurPowerChangeDone(
 441                     IOService *             service,
 442                     IOPMActions *           actions,
 443                     IOPMPowerStateIndex     powerState,
 444                     IOPMPowerChangeFlags    changeFlags,
 445                     IOPMRequestTag          requestTag );
 446
 447     void        overridePowerChangeForUIService(
 448                     IOService *             service,
 449                     IOPMActions *           actions,
 450                     IOPMPowerStateIndex *   inOutPowerState,
 451                     IOPMPowerChangeFlags *  inOutChangeFlags );
 452
 453     void        handleActivityTickleForDisplayWrangler(
 454                     IOService *             service,
 455                     IOPMActions *           actions );
 456
 457     void        handleUpdatePowerClientForDisplayWrangler(
 458                     IOService *             service,
 459                     IOPMActions *           actions,
 460                     const OSSymbol *        powerClient,
 461                     IOPMPowerStateIndex     oldPowerState,
 462                     IOPMPowerStateIndex     newPowerState );
 463
 464     bool        shouldDelayChildNotification(
 465                     IOService *     service );
 466
 467     void        handlePowerChangeStartForPCIDevice(
 468                     IOService *             service,
 469                     IOPMActions *           actions,
 470                     IOPMPowerStateIndex     powerState,
 471                     IOPMPowerChangeFlags *  inOutChangeFlags );
 472
 473     void        handlePowerChangeDoneForPCIDevice(
 474                     IOService *             service,
 475                     IOPMActions *           actions,
 476                     IOPMPowerStateIndex     powerState,
 477                     IOPMPowerChangeFlags    changeFlags );
 478
 479     void        askChangeDownDone(
 480                     IOPMPowerChangeFlags * inOutChangeFlags,
 481                     bool * cancel );
 482
 483     void        handlePublishSleepWakeUUID(
 484                     bool shouldPublish);
 485
 486     void        handleQueueSleepWakeUUID(
 487                     OSObject *obj);
 488
 489     void        handleDisplayPowerOn( );
 490
 491     void        willNotifyPowerChildren( IOPMPowerStateIndex newPowerState );
 492
 493     IOReturn    setMaintenanceWakeCalendar(
 494                     const IOPMCalendarStruct * calendar );
 495
 496     IOReturn    getSystemSleepType( uint32_t * sleepType );
 497
 498     // Handle callbacks from IOService::systemWillShutdown()
 499     void        acknowledgeSystemWillShutdown( IOService * from );
 500
 501     // Handle platform halt and restart notifications
 502     void        handlePlatformHaltRestart( UInt32 pe_type );
 503
 504     IOReturn    shutdownSystem( void );
 505     IOReturn    restartSystem( void );
 506     void        handleSleepTimerExpiration( void );
 507
 508     bool        activitySinceSleep(void);
 509     bool        abortHibernation(void);
 510     void        updateConsoleUsers(void);
 511
 512     IOReturn    joinAggressiveness( IOService * service );
 513     void        handleAggressivesRequests( void );
 514
 515     void        tracePoint( uint8_t point );
 516     void        tracePoint( uint8_t point, uint8_t data );
 517     void        traceDetail( uint32_t data32 );
 518
 519     bool        systemMessageFilter(
 520                     void * object, void * arg1, void * arg2, void * arg3 );
 521
 522     bool        updatePreventIdleSleepList(
 523                     IOService * service, bool addNotRemove );
 524     void        updatePreventSystemSleepList(
 525                     IOService * service, bool addNotRemove );
 526
 527     void        publishPMSetting(
 528                     const OSSymbol * feature, uint32_t where, uint32_t * featureID );
 529
 530     void        pmStatsRecordEvent(
 531                                 int             eventIndex,
 532                                 AbsoluteTime    timestamp);
 533
 534     void        pmStatsRecordApplicationResponse(
 535                                 const OSSymbol      *response,
 536                                 const char          *name,
 537                                 int                 messageType,
 538                                 uint32_t            delay_ms,
 539                                 int                 app_pid,
 540                                 OSObject            *object,
 541                                 IOPMPowerStateIndex ps=0);
 542
 543     void        copyWakeReasonString( char * outBuf, size_t bufSize );
 544
 545 #if HIBERNATION
 546     bool        getHibernateSettings(
 547                     uint32_t *  hibernateMode,
 548                     uint32_t *  hibernateFreeRatio,
 549                     uint32_t *  hibernateFreeTime );
 550 #endif
 551     void        takeStackshot(bool restart, bool isOSXWatchdog, bool isSpinDump);
 552     void        sleepWakeDebugTrig(bool restart);
 553     void        sleepWakeDebugEnableWdog();
 554     bool        sleepWakeDebugIsWdogEnabled();
 555     static void saveTimeoutAppStackShot(void *p0, void *p1);
 556     void        sleepWakeDebugSaveSpinDumpFile();
 557
 558 private:
 559     friend class PMSettingObject;
 560     friend class RootDomainUserClient;
 561     friend class PMAssertionsTracker;
 562
 563     static IOReturn sysPowerDownHandler( void * target, void * refCon,
 564                                     UInt32 messageType, IOService * service,
 565                                     void * messageArgument, vm_size_t argSize );
 566
 567     static IOReturn displayWranglerNotification( void * target, void * refCon,
 568                                     UInt32 messageType, IOService * service,
 569                                     void * messageArgument, vm_size_t argSize );
 570
 571     static IOReturn rootBusyStateChangeHandler( void * target, void * refCon,
 572                                     UInt32 messageType, IOService * service,
 573                                     void * messageArgument, vm_size_t argSize );
 574
 575     static bool displayWranglerMatchPublished( void * target, void * refCon,
 576                                     IOService * newService,
 577                                     IONotifier * notifier);
 578
 579     static bool IONVRAMMatchPublished( void * target, void * refCon,
 580                                     IOService * newService,
 581                                     IONotifier * notifier);
 582
 583     static bool batteryPublished( void * target, void * refCon,
 584                                     IOService * resourceService,
 585                                     IONotifier * notifier);
 586
 587     void initializeBootSessionUUID( void );
 588
 589     void fullWakeDelayedWork( void );
 590
 591     IOService *             wrangler;
 592     OSDictionary *          wranglerIdleSettings;
 593
 594     IOLock                  *featuresDictLock;  // guards supportedFeatures
 595     IOLock                  *wakeEventLock;
 596     IOPMPowerStateQueue     *pmPowerStateQueue;
 597
 598     OSArray                 *allowedPMSettings;
 599     OSArray                 *noPublishPMSettings;
 600     PMTraceWorker           *pmTracer;
 601     PMAssertionsTracker     *pmAssertions;
 602
 603     // Settings controller info
 604     IOLock                  *settingsCtrlLock;
 605     OSDictionary            *settingsCallbacks;
 606     OSDictionary            *fPMSettingsDict;
 607
 608     IONotifier              *_batteryPublishNotifier;
 609     IONotifier              *_displayWranglerNotifier;
 610
 611     // Statistics
 612     const OSSymbol          *_statsNameKey;
 613     const OSSymbol          *_statsPIDKey;
 614     const OSSymbol          *_statsTimeMSKey;
 615     const OSSymbol          *_statsResponseTypeKey;
 616     const OSSymbol          *_statsMessageTypeKey;
 617     const OSSymbol          *_statsPowerCapsKey;
 618     uint32_t                sleepCnt;
 619     uint32_t                darkWakeCnt;
 620     uint32_t                displayWakeCnt;
 621
 622     OSString                *queuedSleepWakeUUIDString;
 623     OSArray                 *pmStatsAppResponses;
 624     IOLock                  *pmStatsLock;   // guards pmStatsAppResponses
 625
 626     void                    *sleepDelaysReport;     // report to track time taken to go to sleep
 627     uint32_t                sleepDelaysClientCnt;   // Number of interested clients in sleepDelaysReport
 628     uint64_t                ts_sleepStart;
 629     uint64_t                wake2DarkwakeDelay;      // Time taken to change from full wake -> Dark wake
 630
 631
 632     void                    *assertOnWakeReport;    // report to track time spent without any assertions held after wake
 633     uint32_t                assertOnWakeClientCnt;  // Number of clients interested in assertOnWakeReport
 634     clock_sec_t             assertOnWakeSecs;       // Num of secs after wake for first assertion
 635
 636     bool                    uuidPublished;
 637
 638     // Pref: idle time before idle sleep
 639     unsigned long           sleepSlider;
 640     unsigned long           idleSeconds;
 641     uint64_t                autoWakeStart;
 642     uint64_t                autoWakeEnd;
 643
 644     // Difference between sleepSlider and longestNonSleepSlider
 645     unsigned long           extraSleepDelay;
 646
 647     // Used to wait between say display idle and system idle
 648     thread_call_t           extraSleepTimer;
 649     thread_call_t           diskSyncCalloutEntry;
 650     thread_call_t           fullWakeThreadCall;
 651     thread_call_t           hibDebugSetupEntry;
 652     thread_call_t           updateConsoleUsersEntry;
 653
 654     // Track system capabilities.
 655     uint32_t                _desiredCapability;
 656     uint32_t                _currentCapability;
 657     uint32_t                _pendingCapability;
 658     uint32_t                _highestCapability;
 659     OSSet *                 _joinedCapabilityClients;
 660     uint32_t                _systemStateGeneration;
 661
 662     // Type of clients that can receive system messages.
 663     enum {
 664         kSystemMessageClientPowerd    = 0x01,
 665         kSystemMessageClientLegacyApp = 0x02,
 666         kSystemMessageClientKernel    = 0x04,
 667         kSystemMessageClientAll       = 0x07
 668     };
 669     uint32_t                _systemMessageClientMask;
 670
 671     // Power state and capability change transitions.
 672     enum {
 673         kSystemTransitionNone         = 0,
 674         kSystemTransitionSleep        = 1,
 675         kSystemTransitionWake         = 2,
 676         kSystemTransitionCapability   = 3,
 677         kSystemTransitionNewCapClient = 4
 678     }                       _systemTransitionType;
 679
 680     unsigned int            systemBooting           :1;
 681     unsigned int            systemShutdown          :1;
 682     unsigned int            systemDarkWake          :1;
 683     unsigned int            clamshellExists         :1;
 684     unsigned int            clamshellClosed         :1;
 685     unsigned int            clamshellDisabled       :1;
 686     unsigned int            desktopMode             :1;
 687     unsigned int            acAdaptorConnected      :1;
 688
 689     unsigned int            clamshellSleepDisabled  :1;
 690     unsigned int            idleSleepTimerPending   :1;
 691     unsigned int            userDisabledAllSleep    :1;
 692     unsigned int            ignoreTellChangeDown    :1;
 693     unsigned int            wranglerAsleep          :1;
 694     unsigned int            wranglerTickled         :1;
 695     unsigned int            _preventUserActive      :1;
 696     unsigned int            graphicsSuppressed      :1;
 697
 698     unsigned int            capabilityLoss          :1;
 699     unsigned int            pciCantSleepFlag        :1;
 700     unsigned int            pciCantSleepValid       :1;
 701     unsigned int            logGraphicsClamp        :1;
 702     unsigned int            darkWakeToSleepASAP     :1;
 703     unsigned int            darkWakeMaintenance     :1;
 704     unsigned int            darkWakeSleepService    :1;
 705     unsigned int            darkWakePostTickle      :1;
 706
 707     unsigned int            sleepTimerMaintenance   :1;
 708     unsigned int            sleepToStandby          :1;
 709     unsigned int            lowBatteryCondition     :1;
 710     unsigned int            hibernateDisabled       :1;
 711     unsigned int            hibernateRetry          :1;
 712     unsigned int            wranglerTickleLatched   :1;
 713     unsigned int            userIsActive            :1;
 714     unsigned int            userWasActive           :1;
 715
 716     unsigned int            displayIdleForDemandSleep :1;
 717     unsigned int            darkWakeHibernateError  :1;
 718     unsigned int            thermalWarningState:1;
 719     unsigned int            toldPowerdCapWillChange :1;
 720     unsigned int            displayPowerOnRequested:1;
 721
 722     uint8_t                 tasksSuspended;
 723     uint32_t                hibernateMode;
 724     AbsoluteTime            userActivityTime;
 725     AbsoluteTime            userActivityTime_prev;
 726     uint32_t                userActivityCount;
 727     uint32_t                userActivityAtSleep;
 728     uint32_t                lastSleepReason;
 729     uint32_t                fullToDarkReason;
 730     uint32_t                hibernateAborted;
 731
 732     enum FullWakeReason {
 733         kFullWakeReasonNone = 0,
 734         kFullWakeReasonLocalUser = 1,
 735         kFullWakeReasonDisplayOn = 2,
 736         fFullWakeReasonDisplayOnAndLocalUser = 3
 737     };
 738     uint32_t                fullWakeReason;
 739
 740     // Info for communicating system state changes to PMCPU
 741     int32_t                 idxPMCPUClamshell;
 742     int32_t                 idxPMCPULimitedPower;
 743
 744     IOOptionBits            platformSleepSupport;
 745     uint32_t                _debugWakeSeconds;
 746     uint32_t                _lastDebugWakeSeconds;
 747
 748     queue_head_t            aggressivesQueue;
 749     thread_call_t           aggressivesThreadCall;
 750     OSData *                aggressivesData;
 751
 752     AbsoluteTime            userBecameInactiveTime;
 753     AbsoluteTime            systemWakeTime;
 754
 755     // PCI top-level PM trace
 756     IOService *             pciHostBridgeDevice;
 757     IOService *             pciHostBridgeDriver;
 758
 759     IONotifier *            systemCapabilityNotifier;
 760
 761     typedef struct {
 762         uint32_t            pid;
 763         uint32_t            refcount;
 764     } PMNotifySuspendedStruct;
 765
 766     uint32_t                pmSuspendedCapacity;
 767     uint32_t                pmSuspendedSize;
 768     PMNotifySuspendedStruct *pmSuspendedPIDS;
 769
 770     OSSet *                 preventIdleSleepList;
 771     OSSet *                 preventSystemSleepList;
 772
 773     UInt32                  _scheduledAlarms;
 774     UInt32                  _userScheduledAlarm;
 775
 776 #if HIBERNATION
 777     clock_sec_t             _standbyTimerResetSeconds;
 778 #endif
 779     volatile uint32_t   swd_lock;    /* Lock to access swd_buffer & and its header */
 780     void  *             swd_buffer;  /* Memory allocated for dumping sleep/wake logs */
 781     uint8_t             swd_flags;   /* Flags defined in IOPMPrivate.h */
 782     void  *             swd_spindump_buffer;
 783
 784     IOMemoryMap  *      swd_logBufMap; /* Memory with sleep/wake logs from previous boot */
 785
 786     // Wake Event Reporting
 787     OSArray *               _systemWakeEventsArray;
 788     bool                    _acceptSystemWakeEvents;
 789
 790     int         findSuspendedPID(uint32_t pid, uint32_t *outRefCount);
 791
 792     // IOPMrootDomain internal sleep call
 793     IOReturn    privateSleepSystem( uint32_t sleepReason );
 794     void        reportUserInput( void );
 795     void        setDisableClamShellSleep( bool );
 796     bool        checkSystemSleepAllowed( IOOptionBits options,
 797                                          uint32_t sleepReason );
 798     bool        checkSystemSleepEnabled( void );
 799     bool        checkSystemCanSleep( uint32_t sleepReason );
 800     bool        checkSystemCanSustainFullWake( void );
 801
 802     void        adjustPowerState( bool sleepASAP = false );
 803     void        setQuickSpinDownTimeout( void );
 804     void        restoreUserSpinDownTimeout( void );
 805
 806     bool        shouldSleepOnClamshellClosed(void );
 807     void        sendClientClamshellNotification( void );
 808
 809     // Inform PMCPU of changes to state like lid, AC vs. battery
 810     void        informCPUStateChange( uint32_t type, uint32_t value );
 811
 812     void        dispatchPowerEvent( uint32_t event, void * arg0, uint64_t arg1 );
 813     void        handlePowerNotification( UInt32 msg );
 814
 815     IOReturn    setPMSetting(const OSSymbol *, OSObject *);
 816
 817     void        startIdleSleepTimer( uint32_t inSeconds );
 818     void        cancelIdleSleepTimer( void );
 819     uint32_t    getTimeToIdleSleep( void );
 820
 821     IOReturn    setAggressiveness(
 822                         unsigned long type,
 823                         unsigned long value,
 824                         IOOptionBits  options );
 825
 826     void        synchronizeAggressives(
 827                         queue_head_t * services,
 828                         const AggressivesRecord * array,
 829                         int count );
 830
 831     void        broadcastAggressives(
 832                         const AggressivesRecord * array,
 833                         int count );
 834
 835     IOReturn    setPMAssertionUserLevels(IOPMDriverAssertionType);
 836
 837     void        publishSleepWakeUUID( bool shouldPublish );
 838
 839     void        evaluatePolicy( int stimulus, uint32_t arg = 0 );
 840     void        requestFullWake( FullWakeReason reason );
 841     void        willEnterFullWake( void );
 842
 843     void        evaluateAssertions(IOPMDriverAssertionType newAssertions,
 844                                    IOPMDriverAssertionType oldAssertions);
 845
 846     void        deregisterPMSettingObject( PMSettingObject * pmso );
 847
 848     void        checkForValidDebugData(const char *fname, vfs_context_t *ctx,
 849                                             void *tmpBuf, struct vnode **vp);
 850     void        sleepWakeDebugMemAlloc( );
 851     void        sleepWakeDebugSpinDumpMemAlloc( );
 852     void        sleepWakeDebugDumpFromMem(IOMemoryMap *logBufMap);
 853     void        sleepWakeDebugDumpFromFile( );
 854     IOMemoryMap *sleepWakeDebugRetrieve();
 855     errno_t     sleepWakeDebugSaveFile(const char *name, char *buf, int len);
 856     errno_t     sleepWakeDebugCopyFile( struct vnode *srcVp,
 857                                vfs_context_t srcCtx,
 858                                char *tmpBuf, uint64_t tmpBufSize,
 859                                uint64_t srcOffset,
 860                                const char *dstFname,
 861                                uint64_t numBytes,
 862                                uint32_t crc);
 863
 864
 865 #if HIBERNATION
 866     bool        getSleepOption( const char * key, uint32_t * option );
 867     bool        evaluateSystemSleepPolicy( IOPMSystemSleepParameters * p,
 868                                            int phase, uint32_t * hibMode );
 869     void        evaluateSystemSleepPolicyEarly( void );
 870     void        evaluateSystemSleepPolicyFinal( void );
 871 #endif /* HIBERNATION */
 872
 873     bool        latchDisplayWranglerTickle( bool latch );
 874     void        setDisplayPowerOn( uint32_t options );
 875
 876     void        acceptSystemWakeEvents( bool accept );
 877     void        systemDidNotSleep( void );
 878     void        preventTransitionToUserActive( bool prevent );
 879     void        setThermalState(OSObject *value);
 880     void        copySleepPreventersList(OSArray  **idleSleepList, OSArray  **systemSleepList);
 881 #endif /* XNU_KERNEL_PRIVATE */
 882 };
 883
 884 #ifdef XNU_KERNEL_PRIVATE
 885 class IORootParent: public IOService
 886 {
 887     OSDeclareFinalStructors(IORootParent)
 888
 889 public:
 890     static void initialize( void );
 891     virtual OSObject * copyProperty( const char * aKey ) const APPLE_KEXT_OVERRIDE;
 892     bool start( IOService * nub ) APPLE_KEXT_OVERRIDE;
 893     void shutDownSystem( void );
 894     void restartSystem( void );
 895     void sleepSystem( void );
 896     void dozeSystem( void );
 897     void sleepToDoze( void );
 898     void wakeSystem( void );
 899 };
 900 #endif /* XNU_KERNEL_PRIVATE */
 901
 902 #endif /* _IOKIT_ROOTDOMAIN_H */