1/*
2 * Copyright (c) 2002-2020 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_IOPMPRIVATE_H
29#define _IOKIT_IOPMPRIVATE_H
30
31#include <IOKit/pwr_mgt/IOPM.h>
32
33/* @constant kIOPMEventTypeIntermediateFlag
34 * @abstract This bit indicates the event is an intermediate event
35 * which must occur within a major system power event.
36 */
37#define kIOPMEventTypeIntermediateFlag 0x10000000
38
39/* @enum SystemEventTypes
40 * @abstract Potential system events logged in the system event record.
41 */
42enum {
43 kIOPMEventTypeUndefined = 0,
44
45 /* Event types mark driver events
46 */
47 kIOPMEventTypeSetPowerStateImmediate = 1001,
48 kIOPMEventTypeSetPowerStateDelayed = 1002,
49 kIOPMEventTypePSWillChangeTo = 1003,
50 kIOPMEventTypePSDidChangeTo = 1004,
51 kIOPMEventTypeAppResponse = 1005,
52
53
54 /* Start and stop event types bracket major
55 * system power management events.
56 */
57 kIOPMEventTypeSleep = 2001,
58 kIOPMEventTypeSleepDone = 2002,
59 kIOPMEventTypeWake = 3001,
60 kIOPMEventTypeWakeDone = 3002,
61 kIOPMEventTypeDoze = 4001,
62 kIOPMEventTypeDozeDone = 4002,
63 kIOPMEventTypeUUIDSet = 6001,
64 kIOPMEventTypeUUIDClear = 6002,
65
66 /* Intermediate events that may only occur within the bounds
67 * of a major system event (between the event's initiation and its "done event".)
68 * e.g. chronologically kIOPMEventTypeSleep may be followed by one or more
69 * intermediate events, which then must be followed by kIOPMEventTypeSleepDone.
70 *
71 * The intermediate events below will always occur in a Sleep or Wake event, and may
72 * or may not occur for any of the other events.
73 */
74 kIOPMEventTypeAppNotificationsFinished = 501 | kIOPMEventTypeIntermediateFlag,
75 kIOPMEventTypeDriverNotificationsFinished = 502 | kIOPMEventTypeIntermediateFlag,
76 kIOPMEventTypeCalTimeChange = 503 | kIOPMEventTypeIntermediateFlag
77};
78
79/*****************************************************************************
80 *
81 * Private Root Domain general interest messages
82 *
83 * Check IOPM.h when adding new messages to avoid conflict.
84 *
85 *****************************************************************************/
86
87/* kIOPMMessageUserIsActiveChanged
88 * User became active or inactive. Message sent after the kIOPMUserIsActiveKey
89 * property was updated with a new value.
90 */
91#define kIOPMMessageUserIsActiveChanged \
92 iokit_family_msg(sub_iokit_powermanagement, 0x400)
93
94/*
95 * Private IOMessage notifications shared between kernel and userspace PM policy
96 */
97#define kIOPMMessageLastCallBeforeSleep \
98 iokit_family_msg(sub_iokit_powermanagement, 0x410)
99
100#define kIOPMMessageIdleSleepPreventers \
101 iokit_family_msg(sub_iokit_powermanagement, 0x420)
102
103#define kIOPMMessageSystemSleepPreventers \
104 iokit_family_msg(sub_iokit_powermanagement, 0x430)
105
106#define kIOPMMessageLaunchBootSpinDump \
107 iokit_family_msg(sub_iokit_powermanagement, 0x440)
108
109#define kIOPMMessageProModeStateChange \
110 iokit_family_msg(sub_iokit_powermanagement, 0x450)
111
112#define kIOPMMessageRequestUserActive \
113 iokit_family_msg(sub_iokit_powermanagement, 0x460)
114
115/* @enum SystemSleepReasons
116 * @abstract The potential causes for system sleep as logged in the system event record.
117 */
118enum {
119 kIOPMSleepReasonClamshell = 101,
120 kIOPMSleepReasonPowerButton = 102,
121 kIOPMSleepReasonSoftware = 103,
122 kIOPMSleepReasonOSSwitchHibernate = 104,
123 kIOPMSleepReasonIdle = 105,
124 kIOPMSleepReasonLowPower = 106,
125 kIOPMSleepReasonThermalEmergency = 107,
126 kIOPMSleepReasonMaintenance = 108,
127 kIOPMSleepReasonSleepServiceExit = 109,
128 kIOPMSleepReasonDarkWakeThermalEmergency = 110,
129 kIOPMSleepReasonNotificationWakeExit = 111
130};
131
132/*
133 * Possible C-string sleep reasons found under kRootDomainSleepReasonsKey
134 */
135#define kIOPMClamshellSleepKey "Clamshell Sleep"
136#define kIOPMPowerButtonSleepKey "Power Button Sleep"
137#define kIOPMSoftwareSleepKey "Software Sleep"
138#define kIOPMOSSwitchHibernationKey "OS Switch Sleep"
139#define kIOPMIdleSleepKey "Idle Sleep"
140#define kIOPMLowPowerSleepKey "Low Power Sleep"
141#define kIOPMThermalEmergencySleepKey "Thermal Emergency Sleep"
142#define kIOPMSleepServiceExitKey "Sleep Service Back to Sleep"
143#define kIOPMDarkWakeThermalEmergencyKey "Dark Wake Thermal Emergency"
144#define kIOPMNotificationWakeExitKey "Notification Wake Back to Sleep"
145
146#define kIOPMPSRestrictedModeKey "RestrictedMode"
147
148// Private keys for kIOPMPSAdapterDetailsKey dictionary
149#define kIOPMPSAdapterDetailsIsWirelessKey "IsWireless"
150
151#pragma mark Stray Bitfields
152// Private power commands issued to root domain
153// bits 0-7 in IOPM.h
154
155enum {
156 kIOPMSetValue = (1<<16),
157 // don't sleep on clamshell closure on a portable with AC connected
158 kIOPMSetDesktopMode = (1<<17),
159 // set state of AC adaptor connected
160 kIOPMSetACAdaptorConnected = (1<<18)
161};
162
163/*****************************************************************************/
164/*****************************************************************************/
165
166/*
167 * PM notification types
168 */
169
170/*! @constant kIOPMSleepServiceScheduleImmediate
171 *
172 * Setting type used in calls to IOPMrootDomain::registerPMSettingController
173 * Use this type between powerd and IOKit.framework
174 *
175 */
176#define kIOPMSleepServiceScheduleImmediate "SleepServiceImmediate"
177
178/*! @constant kIOPMSettingSleepServiceScheduleImmediate
179 *
180 * Setting type used in calls to IOPMrootDomain::registerPMSettingController
181 * Use this type between xnu and AppleRTC
182 */
183#define kIOPMSettingSleepServiceWakeCalendarKey "SleepServiceWakeCalendarKey"
184
185/*! @constant kIOPMCalendarWakeTypes
186 *
187 * These are valid values for IOPM.h:IOPMCalendarStruct->selector
188 */
189enum {
190 kPMCalendarTypeInvalid = 0,
191 kPMCalendarTypeMaintenance = 1,
192 kPMCalendarTypeSleepService = 2
193};
194
195
196/* @constant kIOPMStateConsoleShutdown
197 * @abstract Notification of GUI shutdown state available to kexts.
198 * @discussion This type can be passed as arguments to registerPMSettingController()
199 * to receive callbacks.
200 */
201#define kIOPMStateConsoleShutdown "ConsoleShutdown"
202
203/* @enum ShutdownValues
204 * @abstract Potential values shared with key kIOPMStateConsoleShutdown
205 */
206enum {
207/* @constant kIOPMStateConsoleShutdownNone
208 * @abstract System shutdown (or restart) hasn't started; system is ON.
209 * @discussion Next state: 2
210 */
211 kIOPMStateConsoleShutdownNone = 1,
212/* @constant kIOPMStateConsoleShutdownPossible
213 * @abstract User has been presented with the option to shutdown or restart. Shutdown may be cancelled.
214 * @discussion Next state may be: 1, 4
215 */
216 kIOPMStateConsoleShutdownPossible = 2,
217/* @constant kIOPMStateConsoleShutdownUnderway
218 * @abstract Shutdown or restart is proceeding. It may still be cancelled.
219 * @discussion Next state may be: 1, 4. This state is currently unused.
220 */
221 kIOPMStateConsoleShutdownUnderway = 3,
222/* @constant kIOPMStateConsoleShutdownCertain
223 * @abstract Shutdown is in progress and irrevocable.
224 * @discussion State remains 4 until power is removed from CPU.
225 */
226 kIOPMStateConsoleShutdownCertain = 4,
227/* @constant kIOPMStateConsoleSULogoutInitiated
228 Indicates that LoginWindow has initiated a software update restart.
229 The next logout will not immediately lead to a shutdown.
230 */
231 kIOPMStateConsoleSULogoutInitiated = 5
232};
233
234/* @constant kIOPMSettingSilentRunningKey
235 * @abstract Notification of silent running mode changes to kexts.
236 * @discussion This key can be passed as an argument to registerPMSettingController()
237 * and also identifies the type of PMSetting notification callback.
238 */
239#define kIOPMSettingSilentRunningKey "SilentRunning"
240#define kIOPMFeatureSilentRunningKey kIOPMSettingSilentRunningKey
241
242/* @enum SilentRunningFlags
243 * @abstract The kIOPMSettingSilentRunningKey notification provides an OSNumber
244 * object with a value described by the following flags.
245 */
246enum {
247 kIOPMSilentRunningModeOn = 0x00000001
248};
249
250/* @constant kIOPMSettingLowLatencyAudioModeKey
251 * @abstract Notification about low latency activity in the system available to kexts.
252 * @discussion This type can be passed as arguments to registerPMSettingController()
253 * to receive callbacks.
254 */
255#define kIOPMSettingLowLatencyAudioModeKey "LowLatencyAudioMode"
256
257/*****************************************************************************/
258/*****************************************************************************/
259
260/* PM Statistics - event indices
261 * These are arguments to IOPMrootDomain::pmStatsRecordEvent().
262 */
263enum {
264 kIOPMStatsHibernateImageWrite = 1,
265 kIOPMStatsHibernateImageRead,
266 kIOPMStatsDriversNotify,
267 kIOPMStatsApplicationNotify,
268 kIOPMStatsLateDriverAcknowledge,
269 kIOPMStatsLateAppAcknowledge,
270
271 // To designate if you're specifying the start or stop end of
272 // each of the above events, do a bitwise OR of the appropriate
273 // Start/Stop flag and pass the result to IOPMrootDomain to record
274 // the event.
275 kIOPMStatsEventStartFlag = (1 << 24),
276 kIOPMStatsEventStopFlag = (1 << 25)
277};
278
279// Keys for IOPMrootDomain registry properties
280#define kIOPMSleepStatisticsKey "SleepStatistics"
281#define kIOPMSleepStatisticsAppsKey "AppStatistics"
282#define kIOPMIdleSleepPreventersKey "IdleSleepPreventers"
283#define kIOPMSystemSleepPreventersKey "SystemSleepPreventers"
284#define kIOPMIdleSleepPreventersWithIDKey "IdleSleepPreventersWithID"
285#define kIOPMSystemSleepPreventersWithIDKey "SystemSleepPreventersWithID"
286
287// Application response statistics
288#define kIOPMStatsNameKey "Name"
289#define kIOPMStatsPIDKey "Pid"
290#define kIOPMStatsTimeMSKey "TimeMS"
291#define kIOPMStatsApplicationResponseTypeKey "ResponseType"
292#define kIOPMStatsMessageTypeKey "MessageType"
293#define kIOPMStatsPowerCapabilityKey "PowerCaps"
294#define kIOPMStatsSystemTransitionKey "TransitionType"
295
296// PM Statistics: potential values for the key kIOPMStatsApplicationResponseTypeKey
297// entry in the application results array.
298#define kIOPMStatsResponseTimedOut "ResponseTimedOut"
299#define kIOPMStatsResponseCancel "ResponseCancel"
300#define kIOPMStatsResponseSlow "ResponseSlow"
301#define kIOPMStatsResponsePrompt "ResponsePrompt"
302#define kIOPMStatsDriverPSChangeSlow "DriverPSChangeSlow"
303
304struct PMStatsBounds{
305 uint64_t start;
306 uint64_t stop;
307};
308typedef struct {
309
310 struct PMStatsBounds hibWrite;
311 struct PMStatsBounds hibRead;
312// bounds driverNotifySleep;
313// bounds driverNotifyWake;
314// bounds appNotifySleep;
315// bounds appNotifyWake;
316// OSDictionary *tardyApps;
317// OSDictionary *tardyDrivers;
318} PMStatsStruct;
319
320/*****************************************************************************/
321
322/* PM RootDomain tracePoints
323 *
324 * In the sleep/wake process, we expect the sleep trace points to proceed
325 * in increasing order. Once sleep begins with code kIOPMTracePointSleepStarted,
326 * we expect sleep to continue in a monotonically increasing order of tracepoints
327 * to kIOPMTracePointSystemLoginwindowPhase. After trace point SystemLoginWindowPhase,
328 * the system will return to kIOPMTracePointSystemUp.
329 *
330 * If the trace point decreases (instead of increasing) before reaching kIOPMTracePointSystemUp,
331 * that indicates that the sleep process was cancelled. The cancel reason shall be indicated
332 * in the cancel tracepoint. (TBD)
333 */
334
335enum {
336/* When kTracePointSystemUp is the latest tracePoint,
337 * the system is awake. It is not asleep, sleeping, or waking.
338 *
339 * Phase begins: At boot, at completion of wake from sleep,
340 * immediately following kIOPMTracePointSystemLoginwindowPhase.
341 * Phase ends: When a sleep attempt is initiated.
342 */
343 kIOPMTracePointSystemUp = 0,
344
345/* When kIOPMTracePointSleepStarted is the latest tracePoint,
346 * sleep has been initiated.
347 *
348 * Phase begins: At initiation of system sleep (idle or forced).
349 * Phase ends: PM starts to notify applications of system sleep.
350 */
351 kIOPMTracePointSleepStarted = 0x10,
352
353/* When kIOPMTracePointSleepApplications is the latest tracePoint,
354 * a system sleep has been initiated and PM waits for responses
355 * from notified applications.
356 *
357 * Phase begins: Begin to asynchronously fire kIOMessageSystemWillSleep
358 * notifications, and also kIOMessageCanSystemSleep for the idle sleep case.
359 * Phase ends: When PM has received all application responses.
360 */
361 kIOPMTracePointSleepApplications = 0x11,
362
363/* When kIOPMTracePointSleepPriorityClients is the latest tracePoint,
364 * PM is notifying priority clients and in-kernel system capability
365 * clients, and waiting for any asynchronous completions.
366 *
367 * Phase begins: Synchronous delivery of kIOMessageSystemWillSleep notifications.
368 * Phase ends: All notified clients have acknowledged.
369 */
370 kIOPMTracePointSleepPriorityClients = 0x12,
371
372/* When kIOPMTracePointSleepWillChangeInterests is the latest tracePoint,
373 * PM is calling powerStateWillChangeTo() on interested drivers of root domain.
374 *
375 * Phase begins: Dispatch a callout thread to call interested drivers.
376 * Phase ends: Callout thread work done, and acknowledgePowerChange() called
377 * by drivers that indicated asynchronous completion.
378 */
379 kIOPMTracePointSleepWillChangeInterests = 0x13,
380
381/* When kIOPMTracePointSleepPowerPlaneDrivers is the latest tracePoint,
382 * PM is directing power plane drivers to power off in leaf-to-root order.
383 *
384 * Phase begins: Root domain informs its power children that it will drop to
385 * sleep state. This has a cascade effect and triggers all drivers in
386 * the power plane to transition to a lower power state if necessary.
387 * Phase ends: All power transitions in response to the root domain power
388 * change have completed.
389 */
390 kIOPMTracePointSleepPowerPlaneDrivers = 0x14,
391
392/* When kIOPMTracePointSleepDidChangeInterests is the latest tracePoint,
393 * PM is calling powerStateDidChangeTo() on interested drivers of root domain.
394 *
395 * Phase begins: Dispatch a callout thread to call interested drivers.
396 * Phase ends: Callout thread work done, and acknowledgePowerChange() called
397 * by drivers that indicated asynchronous completion.
398 */
399 kIOPMTracePointSleepDidChangeInterests = 0x15,
400
401/* When kIOPMTracePointSleepCapabilityClients is the latest tracePoint,
402 * PM is notifying system capability clients about system sleep.
403 *
404 * Phase begins: Send kIOMessageSystemCapabilityChange notifications to inform
405 * capability clients that system has lost all capabilities.
406 * Phase ends: Finished sending notifications.
407 */
408 kIOPMTracePointSleepCapabilityClients = 0x16,
409
410/* When kIOPMTracePointSleepPlatformActions is the latest tracePoint,
411 * PM is calling drivers that have registered a platform sleep action.
412 */
413 kIOPMTracePointSleepPlatformActions = 0x17,
414
415/* When kIOPMTracePointSleepCPUs is the latest tracePoint,
416 * PM is shutting down all non-boot processors.
417 *
418 * Phase begins: Shutdown all non-boot processors.
419 * Phase ends: Reduced to only the boot processor running.
420 */
421 kIOPMTracePointSleepCPUs = 0x18,
422
423/* When kIOPMTracePointSleepPlatformDriver is the latest tracePoint,
424 * PM is executing platform dependent code to prepare for system sleep.
425 */
426 kIOPMTracePointSleepPlatformDriver = 0x19,
427
428/* When kIOPMTracePointHibernate is the latest tracePoint,
429 * PM is writing the hibernate image to disk.
430 */
431 kIOPMTracePointHibernate = 0x1a,
432
433/* When kIOPMTracePointSystemSleep is the latest tracePoint,
434 * PM has recorded the final trace point before the hardware platform
435 * enters sleep state, or low level wakeup is underway - such as restoring
436 * the hibernate image from disk.
437 *
438 * Note: If a system is asleep and then loses power, and it does not have a
439 * hibernate image to restore from (e.g. hibernatemode = 0), then OS X will
440 * interpret this power loss as a failure in kIOPMTracePointSystemSleep.
441 *
442 * Phase begins: Before the OS directs the hardware to enter sleep state.
443 * Phase ends: Control returns to the OS on wake, but before recording the first
444 * wake trace point.
445 */
446 kIOPMTracePointSystemSleep = 0x1f,
447
448/* When kIOPMTracePointWakePlatformDriver is the latest tracePoint,
449 * PM is executing platform dependent code to prepare for system wake.
450 */
451 kIOPMTracePointWakePlatformDriver = 0x21,
452
453/* When kIOPMTracePointWakePlatformActions is the latest tracePoint,
454 * PM is calling drivers that have registered a platform wake action.
455 */
456 kIOPMTracePointWakePlatformActions = 0x22,
457
458/* When kIOPMTracePointWakeCPUs is the latest tracePoint,
459 * PM is bringing all non-boot processors online.
460 */
461 kIOPMTracePointWakeCPUs = 0x23,
462
463/* When kIOPMTracePointWakeWillPowerOnClients is the latest tracePoint,
464 * PM is sending kIOMessageSystemWillPowerOn to both kernel clients and
465 * applications. PM also notifies system capability clients about the
466 * proposed capability change.
467 *
468 * Phase begins: Send kIOMessageSystemWillPowerOn and
469 * kIOMessageSystemCapabilityChange notifications.
470 * Phase ends: Finished sending notifications.
471 */
472 kIOPMTracePointWakeWillPowerOnClients = 0x24,
473
474/* When kIOPMTracePointWakeWillChangeInterests is the latest tracePoint,
475 * PM is calling powerStateWillChangeTo() on interested drivers of root domain.
476 *
477 * Phase begins: Dispatch a callout thread to call interested drivers.
478 * Phase ends: Callout thread work done, and acknowledgePowerChange() called
479 * by drivers that indicated asynchronous completion.
480 */
481 kIOPMTracePointWakeWillChangeInterests = 0x25,
482
483/* When kIOPMTracePointWakeDidChangeInterests is the latest tracePoint,
484 * PM is calling powerStateDidChangeTo() on interested drivers of root domain.
485 *
486 * Phase begins: Dispatch a callout thread to call interested drivers.
487 * Phase ends: Callout thread work done, and acknowledgePowerChange() called
488 * by drivers that indicated asynchronous completion.
489 */
490 kIOPMTracePointWakeDidChangeInterests = 0x26,
491
492/* When kIOPMTracePointWakePowerPlaneDrivers is the latest tracePoint,
493 * PM is directing power plane drivers to power up in root-to-leaf order.
494 *
495 * Phase begins: Root domain informs its power children that it transitioned
496 * to ON state. This has a cascade effect and triggers all drivers in
497 * the power plane to re-evaluate and potentially change power state.
498 * Phase ends: All power transitions in response to the root domain power
499 * change have completed.
500 */
501 kIOPMTracePointWakePowerPlaneDrivers = 0x27,
502
503/* When kIOPMTracePointWakeCapabilityClients is the latest tracePoint,
504 * PM is notifying system capability clients about system wake, and waiting
505 * for any asynchronous completions.
506 *
507 * Phase begins: Inform capability clients that system has gained capabilities.
508 * Phase ends: All notified clients have acknowledged.
509 */
510 kIOPMTracePointWakeCapabilityClients = 0x28,
511
512/* When kIOPMTracePointWakeApplications is the latest tracePoint,
513 * System CPU is powered, PM has powered on each driver.
514 *
515 * Phase begins: Send asynchronous kIOMessageSystemHasPoweredOn notifications.
516 * Phase ends: Finished sending asynchronous notifications.
517 */
518 kIOPMTracePointWakeApplications = 0x29,
519
520/* kIOPMTracePointSystemLoginwindowPhase
521 * This phase represents a several minute window after the system has powered on.
522 * Higher levels of system diagnostics are in a heightened state of alert in this phase,
523 * in case any user errors occurred that we could not detect in software.
524 *
525 * Phase begins: After IOPMrootDomain sends kIOMessageSystemHasPoweredOn message.
526 * Phase ends: When loginwindow calls IOPMSleepWakeSetUUID(NULL) the system shall
527 * be considered awake and usable. The next phase shall be kIOPMTracePointSystemUp.
528 */
529 kIOPMTracePointSystemLoginwindowPhase = 0x30,
530
531/* When kIOPMTracePointDarkWakeEntry is the latest tracePoint,
532 * PM has started a transition from full wake to dark wake.
533 *
534 * Phase begins: Start transition to dark wake.
535 * Phase ends: System in dark wake. Before recording kIOPMTracePointSystemUp.
536 */
537 kIOPMTracePointDarkWakeEntry = 0x31,
538
539/* When kIOPMTracePointDarkWakeExit is the latest tracePoint,
540 * PM has started a transition from dark wake to full wake.
541 *
542 * Phase begins: Start transition to full wake.
543 * Phase ends: System in full wake. Before recording kIOPMTracePointSystemUp.
544 */
545 kIOPMTracePointDarkWakeExit = 0x32
546};
547
548/*****************************************************************************/
549
550/*
551 * Component wake progress keys
552 *
553 * Certain components have the ability to log their wake progress with
554 * root domain using the keys provided below.
555 *
556 * LoginWindow - 4 bits
557 * CoreDisplay - 8 bits
558 * CoreGraphics - 8 bits
559 *
560 * These bits are stored with the trace phase that gets logged to
561 * the RTC register.
562 */
563
564// Values that should be passed in to IOPMLogWakeProgress
565enum {
566 kIOPMLoginWindowProgress = 1,
567 kIOPMCoreDisplayProgress = 2,
568 kIOPMCoreGraphicsProgress = 3
569};
570
571enum {
572 kIOPMLoginWindowProgressMask = 0x0f,
573 kIOPMCoreDisplayProgressMask = 0xff,
574 kIOPMCoreGraphicsProgressMask = 0xff
575};
576
577/*
578 * kIOPMLoginWindowProgressKey - identifies PM debug data specific to LoginWindow
579 * for use with IOPMrootDomain. Only 4 bits of data are allotted.
580 */
581#define kIOPMLoginWindowProgressKey "LoginWindowProgress"
582
583/*
584 * kIOPMCoreDisplayProgressKey - identifies PM debug data specific to CoreDisplay
585 * for use with IOPMrootDomain. Only 8 bits of data are allotted.
586 */
587#define kIOPMCoreDisplayProgressKey "CoreDisplayProgress"
588
589/*
590 * kIOPMCoreGraphicsProgressKey - identifies PM debug data specific to CoreGraphics
591 * for use with IOPMrootDomain. Only 8 bits of data are allotted.
592 */
593#define kIOPMCoreGraphicsProgressKey "CoreGraphicsProgress"
594
595// For PM internal use only - key to locate sleep failure results within SCDynamicStore.
596#define kIOPMDynamicStoreSleepFailureKey "SleepFailure"
597
598/*****************************************************************************/
599
600// For IOPMLibPrivate.h
601#define kIOPMSleepWakeFailureKey "PMFailurePhase"
602#define kIOPMSleepWakeFailureCodeKey "PMStatusCode"
603#define kIOPMSleepWakeFailureLoginKey "LWFailurePhase"
604#define kIOPMSleepWakeFailureUUIDKey "UUID"
605#define kIOPMSleepWakeFailureDateKey "Date"
606#define kIOPMSleepWakeWdogRebootKey "SWWdogTriggeredRestart"
607#define kIOPMSleepWakeWdogLogsValidKey "SWWdogLogsValid"
608
609/*****************************************************************************
610 *
611 * Root Domain private property keys
612 *
613 *****************************************************************************/
614
615/* kIOPMFeatureAutoPowerOffKey
616 * Feature published if Auto Power Off is supported
617 */
618#define kIOPMFeatureAutoPowerOffKey "AutoPowerOff"
619
620/* kIOPMAutoPowerOffEnabledKey
621 * Indicates if Auto Power Off is enabled.
622 * It has a boolean value.
623 * true == Auto Power Off is enabled
624 * false == Auto Power Off is disabled
625 * not present == Auto Power Off is not supported on this hardware
626 */
627#define kIOPMAutoPowerOffEnabledKey "AutoPowerOff Enabled"
628
629/* kIOPMAutoPowerOffDelayKey
630 * Key refers to a CFNumberRef that represents the delay in seconds before
631 * entering the Auto Power Off state. The property is not present if Auto
632 * Power Off is unsupported.
633 */
634#define kIOPMAutoPowerOffDelayKey "AutoPowerOff Delay"
635
636/* kIOPMAutoPowerOffTimerKey
637 * Key refers to a CFNumberRef that indicates the time in seconds until the
638 * expiration of the Auto Power Off delay period. This value should be used
639 * to program a wake alarm before system sleep.
640 */
641#define kIOPMAutoPowerOffTimerKey "AutoPowerOff Timer"
642
643/* kIOPMDeepSleepTimerKey
644 * Key refers to a CFNumberRef that indicates the time in seconds until the
645 * expiration of the Standby delay period. This value should be used
646 * to program a wake alarm before system sleep.
647 */
648#define kIOPMDeepSleepTimerKey "Standby Timer"
649
650/* kIOPMUserWakeAlarmScheduledKey
651 * Key refers to a boolean value that indicates if an user alarm was scheduled
652 * or pending.
653 */
654#define kIOPMUserWakeAlarmScheduledKey "UserWakeAlarmScheduled"
655
656/* kIOPMDeepIdleSupportedKey
657 * Presence of this key indicates Deep Idle is supported on this platform.
658 * Key will always refer to a value of kOSBooleanTrue.
659 */
660#define kIOPMDeepIdleSupportedKey "IOPMDeepIdleSupported"
661
662/* kIOPMUserTriggeredFullWakeKey
663 * Key refers to a boolean value that indicates if the first full wake since
664 * last system sleep was triggered by the local user. This property is set
665 * before the initial full wake transition, and removed after powering down
666 * drivers for system sleep.
667 */
668#define kIOPMUserTriggeredFullWakeKey "IOPMUserTriggeredFullWake"
669
670/* kIOPMUserIsActiveKey
671 * Key refers to a boolean value that indicates if the user is active.
672 */
673#define kIOPMUserIsActiveKey "IOPMUserIsActive"
674
675/* kIOPMDriverWakeEventsKey
676 * Key refers to a property that should only be examined by powerd.
677 */
678#define kIOPMDriverWakeEventsKey "IOPMDriverWakeEvents"
679
680/*****************************************************************************
681 *
682 * IOPMDriverWakeEvents dictionary keys
683 *
684 *****************************************************************************/
685
686#define kIOPMWakeEventTimeKey "Time"
687#define kIOPMWakeEventFlagsKey "Flags"
688#define kIOPMWakeEventReasonKey "Reason"
689#define kIOPMWakeEventDetailsKey "Details"
690
691/* kIOPMFeatureProModeKey
692 * Feature published if ProMode is supported
693 */
694#define kIOPMFeatureProModeKey "ProMode"
695
696/*****************************************************************************
697 *
698 * Wake event flags reported to IOPMrootDomain::claimSystemWakeEvent()
699 *
700 *****************************************************************************/
701
702#define kIOPMWakeEventSource 0x00000001
703
704/*****************************************************************************
705 *
706 * AOT defs
707 *
708 *****************************************************************************/
709
710// signals the device should wake up to user space running
711#define kIOPMWakeEventAOTExit 0x00000002
712
713// will start a 400 ms timer before sleeping
714#define kIOPMWakeEventAOTPossibleExit 0x00000004
715
716// signals the device should wake up to user space running
717#define kIOPMWakeEventAOTConfirmedPossibleExit 0x00000008
718
719// signals the device should go back to AOT
720#define kIOPMWakeEventAOTRejectedPossibleExit 0x00000010
721
722// signals the device should go back to AOT
723#define kIOPMWakeEventAOTExpiredPossibleExit 0x00000020
724
725#define kIOPMWakeEventAOTFlags \
726 (kIOPMWakeEventAOTExit \
727 | kIOPMWakeEventAOTPossibleExit \
728 | kIOPMWakeEventAOTConfirmedPossibleExit \
729 | kIOPMWakeEventAOTRejectedPossibleExit \
730 | kIOPMWakeEventAOTExpiredPossibleExit)
731
732#define kIOPMWakeEventAOTPossibleFlags \
733 (kIOPMWakeEventAOTPossibleExit \
734 | kIOPMWakeEventAOTConfirmedPossibleExit \
735 | kIOPMWakeEventAOTRejectedPossibleExit \
736 | kIOPMWakeEventAOTExpiredPossibleExit)
737
738#define kIOPMWakeEventAOTPerCycleFlags \
739 (kIOPMWakeEventAOTPossibleExit \
740 | kIOPMWakeEventAOTRejectedPossibleExit \
741 | kIOPMWakeEventAOTExpiredPossibleExit)
742
743#define kIOPMWakeEventAOTExitFlags \
744 (kIOPMWakeEventAOTExit \
745 | kIOPMWakeEventAOTConfirmedPossibleExit)
746
747enum {
748 kIOPMAOTModeMask = 0x000000ff,
749 kIOPMAOTModeEnable = 0x00000001,
750 kIOPMAOTModeCycle = 0x00000002,
751 kIOPMAOTModeAddEventFlags = 0x00000004,
752 kIOPMAOTModeRespectTimers = 0x00000008,
753 kIOPMAOTModeDefault = (kIOPMAOTModeEnable | kIOPMAOTModeAddEventFlags | kIOPMAOTModeRespectTimers)
754};
755
756enum {
757 kIOPMAOTMetricsKernelWakeCountMax = 24
758};
759
760struct IOPMAOTMetrics
761{
762 uint32_t sleepCount;
763 uint32_t possibleCount;
764 uint32_t confirmedPossibleCount;
765 uint32_t rejectedPossibleCount;
766 uint32_t expiredPossibleCount;
767 uint32_t noTimeSetCount;
768 uint32_t rtcAlarmsCount;
769 uint32_t softwareRequestCount;
770 uint64_t totalTime;
771
772 char kernelWakeReason[kIOPMAOTMetricsKernelWakeCountMax][64];
773 // 54:10 secs:ms calendar time
774 uint64_t kernelSleepTime[kIOPMAOTMetricsKernelWakeCountMax];
775 uint64_t kernelWakeTime[kIOPMAOTMetricsKernelWakeCountMax];
776};
777
778#define kIOPMAOTPowerKey "aot-power"
779
780/*****************************************************************************
781 *
782 * Dark Wake
783 *
784 *****************************************************************************/
785
786/* An OSNumber property set on a power managed driver that the root domain
787 * will use as the driver's max power state while system is in dark wake.
788 * This property should be set prior to the driver joining the PM tree.
789 */
790#define kIOPMDarkWakeMaxPowerStateKey "IOPMDarkWakeMaxPowerState"
791
792/*****************************************************************************
793 *
794 * System Sleep Policy
795 *
796 *****************************************************************************/
797
798#define kIOPMSystemSleepPolicySignature 0x54504c53
799#define kIOPMSystemSleepPolicyVersion 2
800
801/*!
802 * @defined kIOPMSystemSleepTypeKey
803 * @abstract Indicates the type of system sleep.
804 * @discussion An OSNumber property of root domain that describes the type
805 * of system sleep. This property is set after notifying priority sleep/wake
806 * clients, but before informing interested drivers and shutting down power
807 * plane drivers. On a hibernate abort or failure, this property will not be
808 * updated and will indicate the failed sleep type.
809 */
810#define kIOPMSystemSleepTypeKey "IOPMSystemSleepType"
811
812struct IOPMSystemSleepPolicyVariables
813{
814 uint32_t signature; // kIOPMSystemSleepPolicySignature
815 uint32_t version; // kIOPMSystemSleepPolicyVersion
816
817 uint64_t currentCapability; // current system capability bits
818 uint64_t highestCapability; // highest system capability bits
819
820 uint64_t sleepFactors; // sleep factor bits
821 uint32_t sleepReason; // kIOPMSleepReason*
822 uint32_t sleepPhase; // identify the sleep phase
823 uint32_t hibernateMode; // current hibernate mode
824
825 uint32_t standbyDelay; // standby delay in seconds
826 uint32_t standbyTimer; // standby timer in seconds
827 uint32_t poweroffDelay; // auto-poweroff delay in seconds
828 uint32_t scheduledAlarms; // bitmask of scheduled alarm types
829 uint32_t poweroffTimer; // auto-poweroff timer in seconds
830
831 uint32_t reserved[49]; // pad sizeof 256 bytes
832};
833
834enum {
835 kIOPMAlarmBitDebugWake = 0x01,
836 kIOPMAlarmBitCalendarWake = 0x02,
837 kIOPMAlarmBitMaintenanceWake = 0x04,
838 kIOPMAlarmBitSleepServiceWake = 0x08
839};
840
841enum {
842 kIOPMSleepPhase0 = 0,
843 kIOPMSleepPhase1,
844 kIOPMSleepPhase2
845};
846
847// Sleep Factor Mask / Bits
848enum {
849 kIOPMSleepFactorSleepTimerWake = 0x00000001ULL,
850 kIOPMSleepFactorLidOpen = 0x00000002ULL,
851 kIOPMSleepFactorACPower = 0x00000004ULL,
852 kIOPMSleepFactorBatteryLow = 0x00000008ULL,
853 kIOPMSleepFactorStandbyNoDelay = 0x00000010ULL,
854 kIOPMSleepFactorStandbyForced = 0x00000020ULL,
855 kIOPMSleepFactorStandbyDisabled = 0x00000040ULL,
856 kIOPMSleepFactorUSBExternalDevice = 0x00000080ULL,
857 kIOPMSleepFactorBluetoothHIDDevice = 0x00000100ULL,
858 kIOPMSleepFactorExternalMediaMounted = 0x00000200ULL,
859 kIOPMSleepFactorThunderboltDevice = 0x00000400ULL,
860 kIOPMSleepFactorRTCAlarmScheduled = 0x00000800ULL,
861 kIOPMSleepFactorMagicPacketWakeEnabled = 0x00001000ULL,
862 kIOPMSleepFactorHibernateForced = 0x00010000ULL,
863 kIOPMSleepFactorAutoPowerOffDisabled = 0x00020000ULL,
864 kIOPMSleepFactorAutoPowerOffForced = 0x00040000ULL,
865 kIOPMSleepFactorExternalDisplay = 0x00080000ULL,
866 kIOPMSleepFactorNetworkKeepAliveActive = 0x00100000ULL,
867 kIOPMSleepFactorLocalUserActivity = 0x00200000ULL,
868 kIOPMSleepFactorHibernateFailed = 0x00400000ULL,
869 kIOPMSleepFactorThermalWarning = 0x00800000ULL,
870 kIOPMSleepFactorDisplayCaptured = 0x01000000ULL
871};
872
873// System Sleep Types
874enum {
875 kIOPMSleepTypeInvalid = 0,
876 kIOPMSleepTypeAbortedSleep = 1,
877 kIOPMSleepTypeNormalSleep = 2,
878 kIOPMSleepTypeSafeSleep = 3,
879 kIOPMSleepTypeHibernate = 4,
880 kIOPMSleepTypeStandby = 5,
881 kIOPMSleepTypePowerOff = 6,
882 kIOPMSleepTypeDeepIdle = 7,
883 kIOPMSleepTypeLast = 8
884};
885
886// System Sleep Flags
887enum {
888 kIOPMSleepFlagDisableHibernateAbort = 0x00000001,
889 kIOPMSleepFlagDisableUSBWakeEvents = 0x00000002,
890 kIOPMSleepFlagDisableBatlowAssertion = 0x00000004,
891 kIOPMSleepFlagDisableS4WakeSources = 0x00000008
892};
893
894// System Wake Events
895enum {
896 kIOPMWakeEventLidOpen = 0x00000001,
897 kIOPMWakeEventLidClose = 0x00000002,
898 kIOPMWakeEventACAttach = 0x00000004,
899 kIOPMWakeEventACDetach = 0x00000008,
900 kIOPMWakeEventCDInsert = 0x00000010,
901 kIOPMWakeEventCDEject = 0x00000020,
902 kIOPMWakeEventHPDAttach = 0x00000040,
903 kIOPMWakeEventHPDDetach = 0x00000080,
904 kIOPMWakeEventPowerButton = 0x00000100,
905 kIOPMWakeEventG3PowerOn = 0x00000200,
906 kIOPMWakeEventUserPME = 0x00000400,
907 kIOPMWakeEventSleepTimer = 0x00000800,
908 kIOPMWakeEventBatteryLow = 0x00001000,
909 kIOPMWakeEventDarkPME = 0x00002000,
910 kIOPMWakeEventWifi = 0x00004000,
911 kIOPMWakeEventRTCSystem = 0x00008000, // Maintenance RTC wake
912 kIOPMWakeEventUSBCPlugin = 0x00010000, // USB-C Plugin
913 kIOPMWakeEventHID = 0x00020000,
914 kIOPMWakeEventBluetooth = 0x00040000,
915 kIOPMWakeEventDFR = 0x00080000,
916 kIOPMWakeEventSD = 0x00100000, // SD card
917 kIOPMWakeEventLANWake = 0x00200000, // Wake on Lan
918 kIOPMWakeEventLANPlugin = 0x00400000, // Ethernet media sense
919 kIOPMWakeEventThunderbolt = 0x00800000,
920 kIOPMWakeEventRTCUser = 0x01000000, // User requested RTC wake
921};
922
923/*!
924 * @defined kIOPMSystemSleepParametersKey
925 * @abstract Sleep parameters describing the upcoming sleep
926 * @discussion Root domain updates this OSData property before system sleep
927 * to pass sleep parameters to the platform driver. Some of the parameters
928 * are based on the chosen entry in the system sleep policy table.
929 */
930#define kIOPMSystemSleepParametersKey "IOPMSystemSleepParameters"
931#define kIOPMSystemSleepParametersVersion 2
932
933struct IOPMSystemSleepParameters
934{
935 uint16_t version;
936 uint16_t reserved1;
937 uint32_t sleepType;
938 uint32_t sleepFlags;
939 uint32_t ecWakeEvents;
940 uint32_t ecWakeTimer;
941 uint32_t ecPoweroffTimer;
942 uint32_t reserved2[10];
943} __attribute__((packed));
944
945
946/*
947 * Sleep Wake debug buffer header
948 */
949typedef struct {
950 uint32_t signature;
951 uint32_t alloc_size;
952 uint32_t crc; /* CRC for spindump & following data.*/
953 uint32_t spindump_offset; /* Offset at which spindump offset is stored */
954 uint32_t spindump_size;
955 uint8_t is_osx_watchdog;
956
957 /* All members from UUID onwards are saved into log file */
958 char UUID[44];
959 char spindump_status[24]; /* stackshot status*/
960 char PMStatusCode[32];
961 char reason[32];
962} swd_hdr;
963
964
965#define SWD_HDR_SIGNATURE 0xdeb8da2a
966
967#define SWD_STACKSHOT_SIZE (40*PAGE_SIZE)
968#define SWD_COMPRESSED_BUFSIZE (5*PAGE_SIZE)
969#define SWD_ZLIB_BUFSIZE (10*PAGE_SIZE)
970#define SWD_STACKSHOT_VAR_PREFIX "sleepwake_diags"
971
972#define SWD_SPINDUMP_SIZE (256*1024)
973#define SWD_INITIAL_SPINDUMP_SIZE ((SWD_SPINDUMP_SIZE/2)-sizeof(swd_hdr))
974#define SWD_MAX_STACKSHOTS (10)
975
976/* Bits in swd_flags */
977#define SWD_WDOG_ENABLED 0x01
978#define SWD_BOOT_BY_SW_WDOG 0x02
979#define SWD_BOOT_BY_OSX_WDOG 0x04
980#define SWD_VALID_LOGS 0x08
981#define SWD_LOGS_IN_FILE 0x10
982#define SWD_LOGS_IN_MEM 0x20
983#define SWD_PWR_BTN_STACKSHOT 0x30
984
985#define SWD_DATA_CRC_ERROR 0x010000
986#define SWD_BUF_SIZE_ERROR 0x020000
987#define SWD_HDR_SIZE_ERROR 0x040000
988#define SWD_FILEOP_ERROR 0x080000
989#define SWD_HDR_SIGNATURE_ERROR 0x100000
990#define SWD_INTERNAL_FAILURE 0x200000
991
992
993/* Filenames associated with the stackshots/logs generated by the SWD */
994#define kOSWatchdogStacksFilename "/var/log/OSXWatchdogStacks.gz"
995#define kOSWatchdogFailureStringFile "/var/log/OSWatchdogFailureString.txt"
996#define kSleepWakeStacksFilename "/var/log/SleepWakeStacks.gz"
997#define kSleepWakeFailureStringFile "/var/log/SleepWakeFailureString.txt"
998
999
1000/* RootDomain IOReporting channels */
1001#define kSleepCntChID IOREPORT_MAKEID('S','l','e','e','p','C','n','t')
1002#define kDarkWkCntChID IOREPORT_MAKEID('G','U','I','W','k','C','n','t')
1003#define kUserWkCntChID IOREPORT_MAKEID('D','r','k','W','k','C','n','t')
1004
1005/*
1006 * kAssertDelayChID - Histogram of time elapsed before assertion after wake.
1007 */
1008#define kAssertDelayBcktCnt 11
1009#define kAssertDelayBcktSize 3
1010#define kAssertDelayChID IOREPORT_MAKEID('r','d','A','s','r','t','D','l')
1011
1012/*
1013 * kSleepDelaysChID - Histogram of time taken to put system to sleep
1014 */
1015#define kSleepDelaysBcktCnt 13
1016#define kSleepDelaysBcktSize 10
1017#define kSleepDelaysChID IOREPORT_MAKEID('r','d','S','l','p','D','l','y')
1018
1019/* Sleep Options/settings */
1020#define kSleepOptionDisplayCapturedModeKey "DisplayCapturedMode"
1021
1022
1023#if defined(KERNEL) && defined(__cplusplus)
1024
1025/*!
1026 * @defined kIOPMInstallSystemSleepPolicyHandlerKey
1027 * @abstract Name of the platform function to install a sleep policy handler.
1028 * @discussion Pass to IOPMrootDomain::callPlatformFunction(), with a pointer
1029 * to the C-function handler at param1, and an optional target at param2, to
1030 * register a sleep policy handler. Only a single sleep policy handler can
1031 * be installed.
1032 */
1033#define kIOPMInstallSystemSleepPolicyHandlerKey \
1034 "IOPMInstallSystemSleepPolicyHandler"
1035
1036typedef IOReturn (*IOPMSystemSleepPolicyHandler)(
1037 void * target,
1038 const IOPMSystemSleepPolicyVariables * vars,
1039 IOPMSystemSleepParameters * params );
1040
1041#endif /* KERNEL */
1042
1043/*****************************************************************************
1044 *
1045 * Performance Warning
1046 *
1047 *****************************************************************************/
1048
1049/* Performance Warning Key
1050 * Key for performance warning event published using IOPMrootDomain::
1051 * systemPowerEventOccurred()
1052 */
1053#define kIOPMPerformanceWarningKey "Performance_Warning"
1054
1055/* Performance warning values */
1056enum {
1057 kIOPMPerformanceNormal = 0,
1058 kIOPMPerformanceWarning = 100
1059};
1060
1061
1062#endif /* _IOKIT_IOPMPRIVATE_H */
1063