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