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
 511     IOReturn    joinAggressiveness( IOService * service );
 512     void        handleAggressivesRequests( void );
 513
 514     void        tracePoint( uint8_t point );
 515     void        tracePoint( uint8_t point, uint8_t data );
 516     void        traceDetail( uint32_t data32 );
 517
 518     bool        systemMessageFilter(
 519                     void * object, void * arg1, void * arg2, void * arg3 );
 520
 521     bool        updatePreventIdleSleepList(
 522                     IOService * service, bool addNotRemove );
 523     void        updatePreventSystemSleepList(
 524                     IOService * service, bool addNotRemove );
 525
 526     void        publishPMSetting(
 527                     const OSSymbol * feature, uint32_t where, uint32_t * featureID );
 528
 529     void        pmStatsRecordEvent(
 530                                 int             eventIndex,
 531                                 AbsoluteTime    timestamp);
 532
 533     void        pmStatsRecordApplicationResponse(
 534                                 const OSSymbol      *response,
 535                                 const char          *name,
 536                                 int                 messageType,
 537                                 uint32_t            delay_ms,
 538                                 int                 app_pid,
 539                                 OSObject            *object,
 540                                 IOPMPowerStateIndex ps=0);
 541
 542     void        copyWakeReasonString( char * outBuf, size_t bufSize );
 543
 544 #if HIBERNATION
 545     bool        getHibernateSettings(
 546                     uint32_t *  hibernateMode,
 547                     uint32_t *  hibernateFreeRatio,
 548                     uint32_t *  hibernateFreeTime );
 549 #endif
 550     void        takeStackshot(bool restart, bool isOSXWatchdog, bool isSpinDump);
 551     void        sleepWakeDebugTrig(bool restart);
 552     void        sleepWakeDebugEnableWdog();
 553     bool        sleepWakeDebugIsWdogEnabled();
 554     static void saveTimeoutAppStackShot(void *p0, void *p1);
 555     void        sleepWakeDebugSaveSpinDumpFile();
 556
 557 private:
 558     friend class PMSettingObject;
 559     friend class RootDomainUserClient;
 560     friend class PMAssertionsTracker;
 561
 562     static IOReturn sysPowerDownHandler( void * target, void * refCon,
 563                                     UInt32 messageType, IOService * service,
 564                                     void * messageArgument, vm_size_t argSize );
 565
 566     static IOReturn displayWranglerNotification( void * target, void * refCon,
 567                                     UInt32 messageType, IOService * service,
 568                                     void * messageArgument, vm_size_t argSize );
 569
 570     static IOReturn rootBusyStateChangeHandler( void * target, void * refCon,
 571                                     UInt32 messageType, IOService * service,
 572                                     void * messageArgument, vm_size_t argSize );
 573
 574     static bool displayWranglerMatchPublished( void * target, void * refCon,
 575                                     IOService * newService,
 576                                     IONotifier * notifier);
 577
 578     static bool IONVRAMMatchPublished( void * target, void * refCon,
 579                                     IOService * newService,
 580                                     IONotifier * notifier);
 581
 582     static bool batteryPublished( void * target, void * refCon,
 583                                     IOService * resourceService,
 584                                     IONotifier * notifier);
 585
 586     void initializeBootSessionUUID( void );
 587
 588     void fullWakeDelayedWork( void );
 589
 590     IOService *             wrangler;
 591     OSDictionary *          wranglerIdleSettings;
 592
 593     IOLock                  *featuresDictLock;  // guards supportedFeatures
 594     IOLock                  *wakeEventLock;
 595     IOPMPowerStateQueue     *pmPowerStateQueue;
 596
 597     OSArray                 *allowedPMSettings;
 598     OSArray                 *noPublishPMSettings;
 599     PMTraceWorker           *pmTracer;
 600     PMAssertionsTracker     *pmAssertions;
 601
 602     // Settings controller info
 603     IOLock                  *settingsCtrlLock;
 604     OSDictionary            *settingsCallbacks;
 605     OSDictionary            *fPMSettingsDict;
 606
 607     IONotifier              *_batteryPublishNotifier;
 608     IONotifier              *_displayWranglerNotifier;
 609
 610     // Statistics
 611     const OSSymbol          *_statsNameKey;
 612     const OSSymbol          *_statsPIDKey;
 613     const OSSymbol          *_statsTimeMSKey;
 614     const OSSymbol          *_statsResponseTypeKey;
 615     const OSSymbol          *_statsMessageTypeKey;
 616     const OSSymbol          *_statsPowerCapsKey;
 617     uint32_t                sleepCnt;
 618     uint32_t                darkWakeCnt;
 619     uint32_t                displayWakeCnt;
 620
 621     OSString                *queuedSleepWakeUUIDString;
 622     OSArray                 *pmStatsAppResponses;
 623     IOLock                  *pmStatsLock;   // guards pmStatsAppResponses
 624
 625     void                    *sleepDelaysReport;     // report to track time taken to go to sleep
 626     uint32_t                sleepDelaysClientCnt;   // Number of interested clients in sleepDelaysReport
 627     uint64_t                ts_sleepStart;
 628     uint64_t                wake2DarkwakeDelay;      // Time taken to change from full wake -> Dark wake
 629
 630
 631     void                    *assertOnWakeReport;    // report to track time spent without any assertions held after wake
 632     uint32_t                assertOnWakeClientCnt;  // Number of clients interested in assertOnWakeReport
 633     clock_sec_t             assertOnWakeSecs;       // Num of secs after wake for first assertion
 634
 635     bool                    uuidPublished;
 636
 637     // Pref: idle time before idle sleep
 638     unsigned long           sleepSlider;
 639     unsigned long           idleSeconds;
 640     uint64_t                autoWakeStart;
 641     uint64_t                autoWakeEnd;
 642
 643     // Difference between sleepSlider and longestNonSleepSlider
 644     unsigned long           extraSleepDelay;
 645
 646     // Used to wait between say display idle and system idle
 647     thread_call_t           extraSleepTimer;
 648     thread_call_t           diskSyncCalloutEntry;
 649     thread_call_t           fullWakeThreadCall;
 650     thread_call_t           hibDebugSetupEntry;
 651     thread_call_t           updateConsoleUsersEntry;
 652
 653     // Track system capabilities.
 654     uint32_t                _desiredCapability;
 655     uint32_t                _currentCapability;
 656     uint32_t                _pendingCapability;
 657     uint32_t                _highestCapability;
 658     OSSet *                 _joinedCapabilityClients;
 659     uint32_t                _systemStateGeneration;
 660
 661     // Type of clients that can receive system messages.
 662     enum {
 663         kSystemMessageClientPowerd    = 0x01,
 664         kSystemMessageClientLegacyApp = 0x02,
 665         kSystemMessageClientKernel    = 0x04,
 666         kSystemMessageClientAll       = 0x07
 667     };
 668     uint32_t                _systemMessageClientMask;
 669
 670     // Power state and capability change transitions.
 671     enum {
 672         kSystemTransitionNone         = 0,
 673         kSystemTransitionSleep        = 1,
 674         kSystemTransitionWake         = 2,
 675         kSystemTransitionCapability   = 3,
 676         kSystemTransitionNewCapClient = 4
 677     }                       _systemTransitionType;
 678
 679     unsigned int            systemBooting           :1;
 680     unsigned int            systemShutdown          :1;
 681     unsigned int            systemDarkWake          :1;
 682     unsigned int            clamshellExists         :1;
 683     unsigned int            clamshellClosed         :1;
 684     unsigned int            clamshellDisabled       :1;
 685     unsigned int            desktopMode             :1;
 686     unsigned int            acAdaptorConnected      :1;
 687
 688     unsigned int            clamshellSleepDisabled  :1;
 689     unsigned int            idleSleepTimerPending   :1;
 690     unsigned int            userDisabledAllSleep    :1;
 691     unsigned int            ignoreTellChangeDown    :1;
 692     unsigned int            wranglerAsleep          :1;
 693     unsigned int            wranglerTickled         :1;
 694     unsigned int            _preventUserActive      :1;
 695     unsigned int            graphicsSuppressed      :1;
 696
 697     unsigned int            capabilityLoss          :1;
 698     unsigned int            pciCantSleepFlag        :1;
 699     unsigned int            pciCantSleepValid       :1;
 700     unsigned int            logGraphicsClamp        :1;
 701     unsigned int            darkWakeToSleepASAP     :1;
 702     unsigned int            darkWakeMaintenance     :1;
 703     unsigned int            darkWakeSleepService    :1;
 704     unsigned int            darkWakePostTickle      :1;
 705
 706     unsigned int            sleepTimerMaintenance   :1;
 707     unsigned int            sleepToStandby          :1;
 708     unsigned int            lowBatteryCondition     :1;
 709     unsigned int            hibernateDisabled       :1;
 710     unsigned int            hibernateRetry          :1;
 711     unsigned int            wranglerTickleLatched   :1;
 712     unsigned int            userIsActive            :1;
 713     unsigned int            userWasActive           :1;
 714
 715     unsigned int            displayIdleForDemandSleep :1;
 716     unsigned int            darkWakeHibernateError  :1;
 717     unsigned int            thermalWarningState:1;
 718     unsigned int            toldPowerdCapWillChange :1;
 719     unsigned int            displayPowerOnRequested:1;
 720
 721     uint32_t                hibernateMode;
 722     AbsoluteTime            userActivityTime;
 723     AbsoluteTime            userActivityTime_prev;
 724     uint32_t                userActivityCount;
 725     uint32_t                userActivityAtSleep;
 726     uint32_t                lastSleepReason;
 727     uint32_t                fullToDarkReason;
 728     uint32_t                hibernateAborted;
 729
 730     enum FullWakeReason {
 731         kFullWakeReasonNone = 0,
 732         kFullWakeReasonLocalUser = 1,
 733         kFullWakeReasonDisplayOn = 2,
 734         fFullWakeReasonDisplayOnAndLocalUser = 3
 735     };
 736     uint32_t                fullWakeReason;
 737
 738     // Info for communicating system state changes to PMCPU
 739     int32_t                 idxPMCPUClamshell;
 740     int32_t                 idxPMCPULimitedPower;
 741
 742     IOOptionBits            platformSleepSupport;
 743     uint32_t                _debugWakeSeconds;
 744     uint32_t                _lastDebugWakeSeconds;
 745
 746     queue_head_t            aggressivesQueue;
 747     thread_call_t           aggressivesThreadCall;
 748     OSData *                aggressivesData;
 749
 750     AbsoluteTime            userBecameInactiveTime;
 751     AbsoluteTime            systemWakeTime;
 752
 753     // PCI top-level PM trace
 754     IOService *             pciHostBridgeDevice;
 755     IOService *             pciHostBridgeDriver;
 756
 757     IONotifier *            systemCapabilityNotifier;
 758
 759     typedef struct {
 760         uint32_t            pid;
 761         uint32_t            refcount;
 762     } PMNotifySuspendedStruct;
 763
 764     uint32_t                pmSuspendedCapacity;
 765     uint32_t                pmSuspendedSize;
 766     PMNotifySuspendedStruct *pmSuspendedPIDS;
 767
 768     OSSet *                 preventIdleSleepList;
 769     OSSet *                 preventSystemSleepList;
 770
 771     UInt32                  _scheduledAlarms;
 772     UInt32                  _userScheduledAlarm;
 773
 774 #if HIBERNATION
 775     clock_sec_t             _standbyTimerResetSeconds;
 776 #endif
 777     volatile uint32_t   swd_lock;    /* Lock to access swd_buffer & and its header */
 778     void  *             swd_buffer;  /* Memory allocated for dumping sleep/wake logs */
 779     uint8_t             swd_flags;   /* Flags defined in IOPMPrivate.h */
 780     void  *             swd_spindump_buffer;
 781
 782     IOMemoryMap  *      swd_logBufMap; /* Memory with sleep/wake logs from previous boot */
 783
 784     // Wake Event Reporting
 785     OSArray *               _systemWakeEventsArray;
 786     bool                    _acceptSystemWakeEvents;
 787
 788     int         findSuspendedPID(uint32_t pid, uint32_t *outRefCount);
 789
 790     // IOPMrootDomain internal sleep call
 791     IOReturn    privateSleepSystem( uint32_t sleepReason );
 792     void        reportUserInput( void );
 793     void        setDisableClamShellSleep( bool );
 794     bool        checkSystemSleepAllowed( IOOptionBits options,
 795                                          uint32_t sleepReason );
 796     bool        checkSystemSleepEnabled( void );
 797     bool        checkSystemCanSleep( uint32_t sleepReason );
 798     bool        checkSystemCanSustainFullWake( void );
 799
 800     void        adjustPowerState( bool sleepASAP = false );
 801     void        setQuickSpinDownTimeout( void );
 802     void        restoreUserSpinDownTimeout( void );
 803
 804     bool        shouldSleepOnClamshellClosed(void );
 805     void        sendClientClamshellNotification( void );
 806
 807     // Inform PMCPU of changes to state like lid, AC vs. battery
 808     void        informCPUStateChange( uint32_t type, uint32_t value );
 809
 810     void        dispatchPowerEvent( uint32_t event, void * arg0, uint64_t arg1 );
 811     void        handlePowerNotification( UInt32 msg );
 812
 813     IOReturn    setPMSetting(const OSSymbol *, OSObject *);
 814
 815     void        startIdleSleepTimer( uint32_t inSeconds );
 816     void        cancelIdleSleepTimer( void );
 817     uint32_t    getTimeToIdleSleep( void );
 818
 819     IOReturn    setAggressiveness(
 820                         unsigned long type,
 821                         unsigned long value,
 822                         IOOptionBits  options );
 823
 824     void        synchronizeAggressives(
 825                         queue_head_t * services,
 826                         const AggressivesRecord * array,
 827                         int count );
 828
 829     void        broadcastAggressives(
 830                         const AggressivesRecord * array,
 831                         int count );
 832
 833     IOReturn    setPMAssertionUserLevels(IOPMDriverAssertionType);
 834
 835     void        publishSleepWakeUUID( bool shouldPublish );
 836
 837     void        evaluatePolicy( int stimulus, uint32_t arg = 0 );
 838     void        requestFullWake( FullWakeReason reason );
 839     void        willEnterFullWake( void );
 840
 841     void        evaluateAssertions(IOPMDriverAssertionType newAssertions,
 842                                    IOPMDriverAssertionType oldAssertions);
 843
 844     void        deregisterPMSettingObject( PMSettingObject * pmso );
 845
 846     void        checkForValidDebugData(const char *fname, vfs_context_t *ctx,
 847                                             void *tmpBuf, struct vnode **vp);
 848     void        sleepWakeDebugMemAlloc( );
 849     void        sleepWakeDebugSpinDumpMemAlloc( );
 850     void        sleepWakeDebugDumpFromMem(IOMemoryMap *logBufMap);
 851     void        sleepWakeDebugDumpFromFile( );
 852     IOMemoryMap *sleepWakeDebugRetrieve();
 853     errno_t     sleepWakeDebugSaveFile(const char *name, char *buf, int len);
 854     errno_t     sleepWakeDebugCopyFile( struct vnode *srcVp,
 855                                vfs_context_t srcCtx,
 856                                char *tmpBuf, uint64_t tmpBufSize,
 857                                uint64_t srcOffset,
 858                                const char *dstFname,
 859                                uint64_t numBytes,
 860                                uint32_t crc);
 861
 862
 863 #if HIBERNATION
 864     bool        getSleepOption( const char * key, uint32_t * option );
 865     bool        evaluateSystemSleepPolicy( IOPMSystemSleepParameters * p,
 866                                            int phase, uint32_t * hibMode );
 867     void        evaluateSystemSleepPolicyEarly( void );
 868     void        evaluateSystemSleepPolicyFinal( void );
 869 #endif /* HIBERNATION */
 870
 871     bool        latchDisplayWranglerTickle( bool latch );
 872     void        setDisplayPowerOn( uint32_t options );
 873
 874     void        acceptSystemWakeEvents( bool accept );
 875     void        systemDidNotSleep( void );
 876     void        preventTransitionToUserActive( bool prevent );
 877     void        setThermalState(OSObject *value);
 878     void        copySleepPreventersList(OSArray  **idleSleepList, OSArray  **systemSleepList);
 879 #endif /* XNU_KERNEL_PRIVATE */
 880 };
 881
 882 #ifdef XNU_KERNEL_PRIVATE
 883 class IORootParent: public IOService
 884 {
 885     OSDeclareFinalStructors(IORootParent)
 886
 887 public:
 888     static void initialize( void );
 889     virtual OSObject * copyProperty( const char * aKey ) const APPLE_KEXT_OVERRIDE;
 890     bool start( IOService * nub ) APPLE_KEXT_OVERRIDE;
 891     void shutDownSystem( void );
 892     void restartSystem( void );
 893     void sleepSystem( void );
 894     void dozeSystem( void );
 895     void sleepToDoze( void );
 896     void wakeSystem( void );
 897 };
 898 #endif /* XNU_KERNEL_PRIVATE */
 899
 900 #endif /* _IOKIT_ROOTDOMAIN_H */