IOPMrootDomain.cpp [plain text]
#include <libkern/c++/OSKext.h>
#include <libkern/c++/OSMetaClass.h>
#include <libkern/OSDebug.h>
#include <IOKit/IOWorkLoop.h>
#include <IOKit/IOCommandGate.h>
#include <IOKit/IOPlatformExpert.h>
#include <IOKit/IOKitDebug.h>
#include <IOKit/IOTimeStamp.h>
#include <IOKit/pwr_mgt/IOPMlog.h>
#include <IOKit/pwr_mgt/RootDomain.h>
#include <IOKit/pwr_mgt/IOPMPrivate.h>
#include <IOKit/IODeviceTreeSupport.h>
#include <IOKit/IOMessage.h>
#include <IOKit/IOReturn.h>
#include "RootDomainUserClient.h"
#include "IOKit/pwr_mgt/IOPowerConnection.h"
#include "IOPMPowerStateQueue.h"
#include <IOKit/IOCatalogue.h>
#include <IOKit/IOCommand.h> // IOServicePMPrivate
#if HIBERNATION
#include <IOKit/IOHibernatePrivate.h>
#endif
#include <sys/syslog.h>
#include <sys/sysctl.h>
#include <sys/time.h>
#include "IOServicePrivate.h" // _IOServiceInterestNotifier
#include "IOServicePMPrivate.h"
__BEGIN_DECLS
#include <mach/shared_region.h>
__END_DECLS
#if defined(__i386__) || defined(__x86_64__)
__BEGIN_DECLS
#include "IOPMrootDomainInternal.h"
__END_DECLS
#endif
#define kIOPMrootDomainClass "IOPMrootDomain"
#define LOG_PREFIX "PMRD: "
#define LOG(x...) do { \
kprintf(LOG_PREFIX x); IOLog(x); } while (false)
#define KLOG(x...) do { \
kprintf(LOG_PREFIX x); } while (false)
#define DLOG(x...) do { \
if (kIOLogPMRootDomain & gIOKitDebug) \
kprintf(LOG_PREFIX x); } while (false)
#define CHECK_THREAD_CONTEXT
#ifdef CHECK_THREAD_CONTEXT
static IOWorkLoop * gIOPMWorkLoop = 0;
#define ASSERT_GATED(x) \
do { \
if (gIOPMWorkLoop && gIOPMWorkLoop->inGate() != true) { \
panic("RootDomain: not inside PM gate"); \
} \
} while(false)
#else
#define ASSERT_GATED(x)
#endif
enum {
kPowerEventFeatureChanged = 1,
kPowerEventReceivedPowerNotification,
kPowerEventSystemBootCompleted,
kPowerEventSystemShutdown,
kPowerEventUserDisabledSleep,
kPowerEventConfigdRegisteredInterest,
kPowerEventAggressivenessChanged,
kPowerEventAssertionCreate, kPowerEventAssertionRelease, kPowerEventAssertionSetLevel };
extern "C" {
IOReturn OSKextSystemSleepOrWake( UInt32 );
}
extern const IORegistryPlane * gIOPowerPlane;
static void idleSleepTimerExpired( thread_call_param_t, thread_call_param_t );
static void wakeupClamshellTimerExpired( thread_call_param_t us, thread_call_param_t );
static void notifySystemShutdown( IOService * root, unsigned long event );
static bool clientMessageFilter( OSObject * object, void * context );
static void handleAggressivesFunction( thread_call_param_t param1, thread_call_param_t param2 );
static void pmEventTimeStamp(uint64_t *recordTS);
static const OSSymbol *sleepSupportedPEFunction = NULL;
static const OSSymbol *sleepMessagePEFunction = NULL;
#define kIOSleepSupportedKey "IOSleepSupported"
#define kRD_AllPowerSources (kIOPMSupportedOnAC \
| kIOPMSupportedOnBatt \
| kIOPMSupportedOnUPS)
enum
{
kAutoWakePreWindow = 45,
kAutoWakePostWindow = 15
};
#define kLocalEvalClamshellCommand (1 << 15)
enum {
OFF_STATE = 0,
RESTART_STATE = 1,
SLEEP_STATE = 2,
DOZE_STATE = 3,
ON_STATE = 4,
NUM_POWER_STATES
};
#define ON_POWER kIOPMPowerOn
#define RESTART_POWER kIOPMRestart
#define SLEEP_POWER kIOPMAuxPowerOn
#define DOZE_POWER kIOPMDoze
static IOPMPowerState ourPowerStates[NUM_POWER_STATES] =
{
{1, 0, 0, 0, 0,0,0,0,0,0,0,0},
{1, kIOPMRestartCapability, kIOPMRestart, RESTART_POWER, 0,0,0,0,0,0,0,0},
{1, kIOPMSleepCapability, kIOPMSleep, SLEEP_POWER, 0,0,0,0,0,0,0,0},
{1, kIOPMDoze, kIOPMDoze, DOZE_POWER, 0,0,0,0,0,0,0,0},
{1, kIOPMPowerOn, kIOPMPowerOn, ON_POWER, 0,0,0,0,0,0,0,0}
};
enum {
kMessageClientNone = 0,
kMessageClientAll,
kMessageClientConfigd
};
enum {
kRStateNormal = 0,
kRStateDark,
kRStateMaintenance,
kRStateCount
};
enum {
kServiceFlagGraphics = 0x01,
kServiceFlagNoPowerUp = 0x02,
kServiceFlagTopLevelPCI = 0x04
};
enum {
kRStateFlagNone = 0x00000000,
kRStateFlagSuppressGraphics = 0x00000001,
kRStateFlagSuppressMessages = 0x00000002,
kRStateFlagSuppressPCICheck = 0x00000004,
kRStateFlagDisableIdleSleep = 0x00000008
};
#if ROOT_DOMAIN_RUN_STATES
static uint32_t gRStateFlags[ kRStateCount ] =
{
kRStateFlagNone,
kRStateFlagSuppressGraphics,
kRStateFlagSuppressGraphics |
kRStateFlagSuppressMessages |
kRStateFlagSuppressPCICheck |
kRStateFlagDisableIdleSleep
};
static IONotifier * gConfigdNotifier = 0;
#define kIOPMRootDomainRunStateKey "Run State"
#define kIOPMRootDomainWakeTypeMaintenance "Maintenance"
#define kIOPMRootDomainWakeTypeSleepTimer "SleepTimer"
#define kIOPMrootDomainWakeTypeLowBattery "LowBattery"
#endif
#define kIOPMPrivilegedPowerInterest "IOPMPrivilegedPowerInterest"
static IONotifier * gSysPowerDownNotifier = 0;
#define AGGRESSIVES_LOCK() IOLockLock(featuresDictLock)
#define AGGRESSIVES_UNLOCK() IOLockUnlock(featuresDictLock)
#define kAggressivesMinValue 1
static uint32_t gAggressivesState = 0;
enum {
kAggressivesStateBusy = 0x01,
kAggressivesStateQuickSpindown = 0x02
};
struct AggressivesRecord {
uint32_t flags;
uint32_t type;
uint32_t value;
};
struct AggressivesRequest {
queue_chain_t chain;
uint32_t options;
uint32_t dataType;
union {
IOService * service;
AggressivesRecord record;
} data;
};
enum {
kAggressivesRequestTypeService = 1,
kAggressivesRequestTypeRecord
};
enum {
kAggressivesOptionSynchronous = 0x00000001,
kAggressivesOptionQuickSpindownEnable = 0x00000100,
kAggressivesOptionQuickSpindownDisable = 0x00000200,
kAggressivesOptionQuickSpindownMask = 0x00000300
};
enum {
kAggressivesRecordFlagModified = 0x00000001,
kAggressivesRecordFlagMinValue = 0x00000002
};
static IOPMrootDomain * gRootDomain;
static UInt32 gSleepOrShutdownPending = 0;
static UInt32 gWillShutdown = 0;
static uint32_t gMessageClientType = kMessageClientNone;
static UInt32 gSleepWakeUUIDIsSet = false;
struct timeval gIOLastSleepTime;
struct timeval gIOLastWakeTime;
#define kCPUUnknownIndex 9999999
enum {
kInformAC = 0,
kInformLid = 1,
kInformableCount = 2
};
const OSSymbol *gIOPMStatsApplicationResponseTimedOut;
const OSSymbol *gIOPMStatsApplicationResponseCancel;
const OSSymbol *gIOPMStatsApplicationResponseSlow;
class PMSettingObject : public OSObject
{
OSDeclareFinalStructors(PMSettingObject)
private:
IOPMrootDomain *parent;
IOPMSettingControllerCallback func;
OSObject *target;
uintptr_t refcon;
uint32_t *publishedFeatureID;
int releaseAtCount;
public:
static PMSettingObject *pmSettingObject(
IOPMrootDomain *parent_arg,
IOPMSettingControllerCallback handler_arg,
OSObject *target_arg,
uintptr_t refcon_arg,
uint32_t supportedPowerSources,
const OSSymbol *settings[]);
void setPMSetting(const OSSymbol *type, OSObject *obj);
void taggedRelease(const void *tag, const int when) const;
void free(void);
};
class PMAssertionsTracker : public OSObject
{
OSDeclareFinalStructors(PMAssertionsTracker)
public:
static PMAssertionsTracker *pmAssertionsTracker( IOPMrootDomain * );
IOReturn createAssertion(IOPMDriverAssertionType, IOPMDriverAssertionLevel, IOService *, const char *, IOPMDriverAssertionID *);
IOReturn releaseAssertion(IOPMDriverAssertionID);
IOReturn setAssertionLevel(IOPMDriverAssertionID, IOPMDriverAssertionLevel);
IOReturn setUserAssertionLevels(IOPMDriverAssertionType);
OSArray *copyAssertionsArray(void);
IOPMDriverAssertionType getActivatedAssertions(void);
IOPMDriverAssertionLevel getAssertionLevel(IOPMDriverAssertionType);
IOReturn handleCreateAssertion(OSData *);
IOReturn handleReleaseAssertion(IOPMDriverAssertionID);
IOReturn handleSetAssertionLevel(IOPMDriverAssertionID, IOPMDriverAssertionLevel);
IOReturn handleSetUserAssertionLevels(void * arg0);
void publishProperties(void);
private:
typedef struct {
IOPMDriverAssertionID id;
IOPMDriverAssertionType assertionBits;
uint64_t createdTime;
uint64_t modifiedTime;
const OSSymbol *ownerString;
IOService *ownerService;
IOPMDriverAssertionLevel level;
} PMAssertStruct;
uint32_t tabulateProducerCount;
uint32_t tabulateConsumerCount;
PMAssertStruct *detailsForID(IOPMDriverAssertionID, int *);
void tabulate(void);
IOPMrootDomain *owner;
OSArray *assertionsArray;
IOLock *assertionsArrayLock;
IOPMDriverAssertionID issuingUniqueID;
IOPMDriverAssertionType assertionsKernel;
IOPMDriverAssertionType assertionsUser;
IOPMDriverAssertionType assertionsCombined;
};
OSDefineMetaClassAndFinalStructors(PMAssertionsTracker, OSObject);
typedef void (*IOPMTracePointHandler)(
void * target, uint32_t code, uint32_t data );
class PMTraceWorker : public OSObject
{
OSDeclareDefaultStructors(PMTraceWorker)
public:
typedef enum { kPowerChangeStart, kPowerChangeCompleted } change_t;
static PMTraceWorker *tracer( IOPMrootDomain * );
void tracePCIPowerChange(change_t, IOService *, uint32_t, uint32_t);
void tracePoint(uint8_t phase);
void traceLoginWindowPhase(uint8_t phase);
int recordTopLevelPCIDevice(IOService *);
void RTC_TRACE(void);
virtual bool serialize(OSSerialize *s) const;
IOPMTracePointHandler tracePointHandler;
void * tracePointTarget;
private:
IOPMrootDomain *owner;
IOLock *pciMappingLock;
OSArray *pciDeviceBitMappings;
uint8_t tracePhase;
uint8_t loginWindowPhase;
uint8_t addedToRegistry;
uint8_t unused0;
uint32_t pciBusyBitMask;
};
#define kPMHaltMaxWorkers 8
#define kPMHaltTimeoutMS 100
class PMHaltWorker : public OSObject
{
OSDeclareFinalStructors( PMHaltWorker )
public:
IOService * service; AbsoluteTime startTime; int depth; int visits; IOLock * lock;
bool timeout;
static PMHaltWorker * worker( void );
static void main( void * arg, wait_result_t waitResult );
static void work( PMHaltWorker * me );
static void checkTimeout( PMHaltWorker * me, AbsoluteTime * now );
virtual void free( void );
};
OSDefineMetaClassAndFinalStructors( PMHaltWorker, OSObject )
#define super IOService
OSDefineMetaClassAndFinalStructors(IOPMrootDomain, IOService)
extern "C"
{
IONotifier * registerSleepWakeInterest(IOServiceInterestHandler handler, void * self, void * ref)
{
return gRootDomain->registerInterest( gIOGeneralInterest, handler, self, ref );
}
IONotifier * registerPrioritySleepWakeInterest(IOServiceInterestHandler handler, void * self, void * ref)
{
return gRootDomain->registerInterest( gIOPriorityPowerStateInterest, handler, self, ref );
}
IOReturn acknowledgeSleepWakeNotification(void * PMrefcon)
{
return gRootDomain->allowPowerChange ( (unsigned long)PMrefcon );
}
IOReturn vetoSleepWakeNotification(void * PMrefcon)
{
return gRootDomain->cancelPowerChange ( (unsigned long)PMrefcon );
}
IOReturn rootDomainRestart ( void )
{
return gRootDomain->restartSystem();
}
IOReturn rootDomainShutdown ( void )
{
return gRootDomain->shutdownSystem();
}
void IOSystemShutdownNotification ( void )
{
if (OSCompareAndSwap(0, 1, &gWillShutdown))
{
OSKext::willShutdown();
for (int i = 0; i < 100; i++)
{
if (OSCompareAndSwap(0, 1, &gSleepOrShutdownPending)) break;
IOSleep( 100 );
}
}
}
int sync_internal(void);
}
IOPMrootDomain * IOPMrootDomain::construct( void )
{
IOPMrootDomain *root;
root = new IOPMrootDomain;
if( root)
root->init();
return( root );
}
static void disk_sync_callout( thread_call_param_t p0, thread_call_param_t p1 )
{
IOService *rootDomain = (IOService *) p0;
unsigned long pmRef = (unsigned long) p1;
DLOG("disk_sync_callout start\n");
#if HIBERNATION
IOHibernateSystemSleep();
#endif
sync_internal();
rootDomain->allowPowerChange(pmRef);
DLOG("disk_sync_callout finish\n");
}
static UInt32 computeDeltaTimeMS( const AbsoluteTime * startTime )
{
AbsoluteTime endTime;
UInt64 nano = 0;
clock_get_uptime(&endTime);
if (CMP_ABSOLUTETIME(&endTime, startTime) > 0)
{
SUB_ABSOLUTETIME(&endTime, startTime);
absolutetime_to_nanoseconds(endTime, &nano);
}
return (UInt32)(nano / 1000000ULL);
}
static int
sysctl_sleepwaketime SYSCTL_HANDLER_ARGS
{
struct timeval *swt = (struct timeval *)arg1;
struct proc *p = req->p;
if (p == kernproc) {
return sysctl_io_opaque(req, swt, sizeof(*swt), NULL);
} else if(proc_is64bit(p)) {
struct user64_timeval t;
t.tv_sec = swt->tv_sec;
t.tv_usec = swt->tv_usec;
return sysctl_io_opaque(req, &t, sizeof(t), NULL);
} else {
struct user32_timeval t;
t.tv_sec = swt->tv_sec;
t.tv_usec = swt->tv_usec;
return sysctl_io_opaque(req, &t, sizeof(t), NULL);
}
}
static SYSCTL_PROC(_kern, OID_AUTO, sleeptime,
CTLTYPE_STRUCT | CTLFLAG_RD | CTLFLAG_NOAUTO | CTLFLAG_KERN,
&gIOLastSleepTime, 0, sysctl_sleepwaketime, "S,timeval", "");
static SYSCTL_PROC(_kern, OID_AUTO, waketime,
CTLTYPE_STRUCT | CTLFLAG_RD | CTLFLAG_NOAUTO | CTLFLAG_KERN,
&gIOLastWakeTime, 0, sysctl_sleepwaketime, "S,timeval", "");
static int
sysctl_willshutdown
(__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
{
int new_value, changed;
int error = sysctl_io_number(req, gWillShutdown, sizeof(int), &new_value, &changed);
if (changed) {
if (!gWillShutdown && (new_value == 1)) {
IOSystemShutdownNotification();
} else
error = EINVAL;
}
return(error);
}
static SYSCTL_PROC(_kern, OID_AUTO, willshutdown,
CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NOAUTO | CTLFLAG_KERN,
0, 0, sysctl_willshutdown, "I", "");
#if !CONFIG_EMBEDDED
static int
sysctl_progressmeterenable
(__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
{
int error;
int new_value, changed;
error = sysctl_io_number(req, vc_progress_meter_enable, sizeof(int), &new_value, &changed);
if (changed)
vc_enable_progressmeter(new_value);
return (error);
}
static int
sysctl_progressmeter
(__unused struct sysctl_oid *oidp, __unused void *arg1, __unused int arg2, struct sysctl_req *req)
{
int error;
int new_value, changed;
error = sysctl_io_number(req, vc_progress_meter_value, sizeof(int), &new_value, &changed);
if (changed)
vc_set_progressmeter(new_value);
return (error);
}
static SYSCTL_PROC(_kern, OID_AUTO, progressmeterenable,
CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NOAUTO | CTLFLAG_KERN,
0, 0, sysctl_progressmeterenable, "I", "");
static SYSCTL_PROC(_kern, OID_AUTO, progressmeter,
CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NOAUTO | CTLFLAG_KERN,
0, 0, sysctl_progressmeter, "I", "");
#endif
static const OSSymbol * gIOPMSettingAutoWakeSecondsKey;
static const OSSymbol * gIOPMSettingMaintenanceWakeCalendarKey;
#define kRootDomainSettingsCount 16
bool IOPMrootDomain::start( IOService * nub )
{
OSIterator *psIterator;
OSDictionary *tmpDict;
super::start(nub);
gRootDomain = this;
gIOPMSettingAutoWakeSecondsKey = OSSymbol::withCString(kIOPMSettingAutoWakeSecondsKey);
gIOPMSettingMaintenanceWakeCalendarKey =
OSSymbol::withCString(kIOPMSettingMaintenanceWakeCalendarKey);
gIOPMStatsApplicationResponseTimedOut = OSSymbol::withCString(kIOPMStatsResponseTimedOut);
gIOPMStatsApplicationResponseCancel = OSSymbol::withCString(kIOPMStatsResponseCancel);
gIOPMStatsApplicationResponseSlow = OSSymbol::withCString(kIOPMStatsResponseSlow);
sleepSupportedPEFunction = OSSymbol::withCString("IOPMSetSleepSupported");
sleepMessagePEFunction = OSSymbol::withCString("IOPMSystemSleepMessage");
const OSSymbol *settingsArr[kRootDomainSettingsCount] =
{
OSSymbol::withCString(kIOPMSettingSleepOnPowerButtonKey),
gIOPMSettingAutoWakeSecondsKey,
OSSymbol::withCString(kIOPMSettingAutoPowerSecondsKey),
OSSymbol::withCString(kIOPMSettingAutoWakeCalendarKey),
OSSymbol::withCString(kIOPMSettingAutoPowerCalendarKey),
OSSymbol::withCString(kIOPMSettingDebugWakeRelativeKey),
OSSymbol::withCString(kIOPMSettingDebugPowerRelativeKey),
OSSymbol::withCString(kIOPMSettingWakeOnRingKey),
OSSymbol::withCString(kIOPMSettingRestartOnPowerLossKey),
OSSymbol::withCString(kIOPMSettingWakeOnClamshellKey),
OSSymbol::withCString(kIOPMSettingWakeOnACChangeKey),
OSSymbol::withCString(kIOPMSettingTimeZoneOffsetKey),
OSSymbol::withCString(kIOPMSettingDisplaySleepUsesDimKey),
OSSymbol::withCString(kIOPMSettingMobileMotionModuleKey),
OSSymbol::withCString(kIOPMSettingGraphicsSwitchKey),
OSSymbol::withCString(kIOPMStateConsoleShutdown)
};
queue_init(&aggressivesQueue);
aggressivesThreadCall = thread_call_allocate(handleAggressivesFunction, this);
aggressivesData = OSData::withCapacity(
sizeof(AggressivesRecord) * (kPMLastAggressivenessType + 4));
featuresDictLock = IOLockAlloc();
settingsCtrlLock = IORecursiveLockAlloc();
setPMRootDomain(this);
extraSleepTimer = thread_call_allocate(
idleSleepTimerExpired,
(thread_call_param_t) this);
clamshellWakeupIgnore = thread_call_allocate(
wakeupClamshellTimerExpired,
(thread_call_param_t) this);
diskSyncCalloutEntry = thread_call_allocate(
&disk_sync_callout,
(thread_call_param_t) this);
canSleep = true;
setProperty(kIOSleepSupportedKey, true);
bzero(&pmStats, sizeof(pmStats));
pmTracer = PMTraceWorker::tracer(this);
pmAssertions = PMAssertionsTracker::pmAssertionsTracker(this);
updateRunState(kRStateNormal);
userDisabledAllSleep = false;
allowSleep = true;
sleepIsSupported = true;
systemBooting = true;
sleepSlider = 0;
idleSleepTimerPending = false;
wrangler = NULL;
sleepASAP = false;
clamshellIsClosed = false;
clamshellExists = false;
ignoringClamshell = true;
ignoringClamshellOnWake = false;
acAdaptorConnected = true;
queuedSleepWakeUUIDString = NULL;
pmStatsAppResponses = OSArray::withCapacity(5);
_statsNameKey = OSSymbol::withCString(kIOPMStatsNameKey);
_statsPIDKey = OSSymbol::withCString(kIOPMStatsPIDKey);
_statsTimeMSKey = OSSymbol::withCString(kIOPMStatsTimeMSKey);
_statsResponseTypeKey = OSSymbol::withCString(kIOPMStatsApplicationResponseTypeKey);
_statsMessageTypeKey = OSSymbol::withCString(kIOPMStatsMessageTypeKey);
idxPMCPUClamshell = kCPUUnknownIndex;
idxPMCPULimitedPower = kCPUUnknownIndex;
tmpDict = OSDictionary::withCapacity(1);
setProperty(kRootDomainSupportedFeatures, tmpDict);
tmpDict->release();
settingsCallbacks = OSDictionary::withCapacity(1);
allowedPMSettings = OSArray::withObjects(
(const OSObject **)settingsArr,
kRootDomainSettingsCount,
0);
fPMSettingsDict = OSDictionary::withCapacity(5);
PMinit();
pmPowerStateQueue = IOPMPowerStateQueue::PMPowerStateQueue(
this, OSMemberFunctionCast(IOEventSource::Action, this,
&IOPMrootDomain::dispatchPowerEvent));
getPMworkloop()->addEventSource(pmPowerStateQueue);
#ifdef CHECK_THREAD_CONTEXT
gIOPMWorkLoop = getPMworkloop();
#endif
patriarch = new IORootParent;
patriarch->init();
patriarch->attach(this);
patriarch->start(this);
patriarch->addPowerChild(this);
registerPowerDriver(this, ourPowerStates, NUM_POWER_STATES);
changePowerStateToPriv(ON_STATE);
gSysPowerDownNotifier = registerPrioritySleepWakeInterest( &sysPowerDownHandler, this, 0);
#if !NO_KERNEL_HID
if ((tmpDict = serviceMatching("IODisplayWrangler")))
{
_displayWranglerNotifier = addMatchingNotification(
gIOPublishNotification, tmpDict,
(IOServiceMatchingNotificationHandler) &displayWranglerPublished,
this, 0);
tmpDict->release();
}
#endif
if ((tmpDict = serviceMatching("IOPMPowerSource")))
{
_batteryPublishNotifier = addMatchingNotification(
gIOPublishNotification, tmpDict,
(IOServiceMatchingNotificationHandler) &batteryPublished,
this, this);
tmpDict->release();
}
const OSSymbol *ucClassName = OSSymbol::withCStringNoCopy("RootDomainUserClient");
setProperty(gIOUserClientClassKey, (OSObject *) ucClassName);
ucClassName->release();
psIterator = getMatchingServices( serviceMatching("IOPMPowerSource") );
if( psIterator && psIterator->getNextObject() )
{
publishFeature("DisplayDims");
}
if(psIterator) {
psIterator->release();
}
sysctl_register_oid(&sysctl__kern_sleeptime);
sysctl_register_oid(&sysctl__kern_waketime);
sysctl_register_oid(&sysctl__kern_willshutdown);
#if !CONFIG_EMBEDDED
sysctl_register_oid(&sysctl__kern_progressmeterenable);
sysctl_register_oid(&sysctl__kern_progressmeter);
#endif
#if HIBERNATION
IOHibernateSystemInit(this);
#endif
registerService();
return true;
}
IOReturn IOPMrootDomain::setProperties( OSObject * props_obj )
{
IOReturn return_value = kIOReturnSuccess;
OSDictionary *dict = OSDynamicCast(OSDictionary, props_obj);
OSBoolean *b;
OSNumber *n;
OSString *str;
OSSymbol *type;
OSObject *obj;
unsigned int i;
const OSSymbol *boot_complete_string =
OSSymbol::withCString("System Boot Complete");
const OSSymbol *sys_shutdown_string =
OSSymbol::withCString("System Shutdown");
const OSSymbol *stall_halt_string =
OSSymbol::withCString("StallSystemAtHalt");
const OSSymbol *battery_warning_disabled_string =
OSSymbol::withCString("BatteryWarningsDisabled");
const OSSymbol *idle_seconds_string =
OSSymbol::withCString("System Idle Seconds");
#if HIBERNATION
const OSSymbol *hibernatemode_string =
OSSymbol::withCString(kIOHibernateModeKey);
const OSSymbol *hibernatefile_string =
OSSymbol::withCString(kIOHibernateFileKey);
const OSSymbol *hibernatefreeratio_string =
OSSymbol::withCString(kIOHibernateFreeRatioKey);
const OSSymbol *hibernatefreetime_string =
OSSymbol::withCString(kIOHibernateFreeTimeKey);
#endif
const OSSymbol *sleepdisabled_string =
OSSymbol::withCString("SleepDisabled");
const OSSymbol *ondeck_sleepwake_uuid_string =
OSSymbol::withCString(kIOPMSleepWakeUUIDKey);
const OSSymbol *loginwindow_tracepoint_string =
OSSymbol::withCString(kIOPMLoginWindowSecurityDebugKey);
if(!dict)
{
return_value = kIOReturnBadArgument;
goto exit;
}
if ((n = OSDynamicCast(OSNumber, dict->getObject(idle_seconds_string))))
{
setProperty(idle_seconds_string, n);
idleSeconds = n->unsigned32BitValue();
}
if (boot_complete_string && dict->getObject(boot_complete_string))
{
pmPowerStateQueue->submitPowerEvent( kPowerEventSystemBootCompleted );
}
if( battery_warning_disabled_string
&& dict->getObject(battery_warning_disabled_string))
{
setProperty( battery_warning_disabled_string,
dict->getObject(battery_warning_disabled_string));
}
if( sys_shutdown_string
&& (b = OSDynamicCast(OSBoolean, dict->getObject(sys_shutdown_string))))
{
pmPowerStateQueue->submitPowerEvent(kPowerEventSystemShutdown, (void *) b);
}
if( stall_halt_string
&& (b = OSDynamicCast(OSBoolean, dict->getObject(stall_halt_string))) )
{
setProperty(stall_halt_string, b);
}
#if HIBERNATION
if ( hibernatemode_string
&& (n = OSDynamicCast(OSNumber, dict->getObject(hibernatemode_string))))
{
setProperty(hibernatemode_string, n);
}
if ( hibernatefreeratio_string
&& (n = OSDynamicCast(OSNumber, dict->getObject(hibernatefreeratio_string))))
{
setProperty(hibernatefreeratio_string, n);
}
if ( hibernatefreetime_string
&& (n = OSDynamicCast(OSNumber, dict->getObject(hibernatefreetime_string))))
{
setProperty(hibernatefreetime_string, n);
}
if ( hibernatefile_string
&& (str = OSDynamicCast(OSString, dict->getObject(hibernatefile_string))))
{
setProperty(hibernatefile_string, str);
}
#endif
if( sleepdisabled_string
&& (b = OSDynamicCast(OSBoolean, dict->getObject(sleepdisabled_string))) )
{
setProperty(sleepdisabled_string, b);
pmPowerStateQueue->submitPowerEvent(kPowerEventUserDisabledSleep, (void *) b);
}
if (ondeck_sleepwake_uuid_string
&& (obj = dict->getObject(ondeck_sleepwake_uuid_string)))
{
if (kOSBooleanFalse == obj)
{
publishSleepWakeUUID(NULL);
}
if ((str = OSDynamicCast(OSString, obj)))
{
if (queuedSleepWakeUUIDString) {
queuedSleepWakeUUIDString->release();
queuedSleepWakeUUIDString = NULL;
}
queuedSleepWakeUUIDString = str;
queuedSleepWakeUUIDString->retain();
DLOG("SleepWake UUID queued: %s\n",
queuedSleepWakeUUIDString->getCStringNoCopy());
}
}
if (loginwindow_tracepoint_string
&& (n = OSDynamicCast(OSNumber, dict->getObject(loginwindow_tracepoint_string)))
&& pmTracer)
{
pmTracer->traceLoginWindowPhase( n->unsigned8BitValue() );
}
if ((b = OSDynamicCast(OSBoolean, dict->getObject(kIOPMDeepSleepEnabledKey))))
{
setProperty(kIOPMDeepSleepEnabledKey, b);
}
if ((n = OSDynamicCast(OSNumber, dict->getObject(kIOPMDeepSleepDelayKey))))
{
setProperty(kIOPMDeepSleepDelayKey, n);
}
for(i = 0; i < allowedPMSettings->getCount(); i++) {
type = (OSSymbol *)allowedPMSettings->getObject(i);
if(!type) continue;
obj = dict->getObject(type);
if(!obj) continue;
if ((gIOPMSettingAutoWakeSecondsKey == type) && ((n = OSDynamicCast(OSNumber, obj))))
{
UInt32 rsecs = n->unsigned32BitValue();
if (!rsecs)
autoWakeStart = autoWakeEnd = 0;
else
{
AbsoluteTime deadline;
clock_interval_to_deadline(rsecs + kAutoWakePostWindow, kSecondScale, &deadline);
autoWakeEnd = AbsoluteTime_to_scalar(&deadline);
if (rsecs > kAutoWakePreWindow)
rsecs -= kAutoWakePreWindow;
else
rsecs = 0;
clock_interval_to_deadline(rsecs, kSecondScale, &deadline);
autoWakeStart = AbsoluteTime_to_scalar(&deadline);
}
}
return_value = setPMSetting(type, obj);
if(kIOReturnSuccess != return_value) goto exit;
}
exit:
if(boot_complete_string) boot_complete_string->release();
if(sys_shutdown_string) sys_shutdown_string->release();
if(stall_halt_string) stall_halt_string->release();
if (battery_warning_disabled_string) battery_warning_disabled_string->release();
if(idle_seconds_string) idle_seconds_string->release();
if(sleepdisabled_string) sleepdisabled_string->release();
if(ondeck_sleepwake_uuid_string) ondeck_sleepwake_uuid_string->release();
if(loginwindow_tracepoint_string) loginwindow_tracepoint_string->release();
#if HIBERNATION
if(hibernatemode_string) hibernatemode_string->release();
if(hibernatefile_string) hibernatefile_string->release();
if(hibernatefreeratio_string) hibernatefreeratio_string->release();
if(hibernatefreetime_string) hibernatefreetime_string->release();
#endif
return return_value;
}
void IOPMrootDomain::aggressivenessChanged( void )
{
unsigned long minutesToSleep = 0;
unsigned long minutesToDisplayDim = 0;
ASSERT_GATED();
getAggressiveness(kPMMinutesToSleep, &minutesToSleep);
getAggressiveness(kPMMinutesToDim, &minutesToDisplayDim);
DLOG("aggressiveness changed system %u, display %u\n",
(uint32_t) minutesToSleep, (uint32_t) minutesToDisplayDim);
DLOG("idle time -> %ld secs (ena %d)\n",
idleSeconds, (minutesToSleep != 0));
if (0x7fffffff == minutesToSleep)
minutesToSleep = idleSeconds;
if ( minutesToSleep > minutesToDisplayDim ) {
extraSleepDelay = minutesToSleep - minutesToDisplayDim;
}
else {
extraSleepDelay = 0;
}
if ( (sleepSlider == 0) && (minutesToSleep != 0) ) {
if (!wrangler)
{
sleepASAP = false;
changePowerStateToPriv(ON_STATE);
if (idleSeconds)
{
startIdleSleepTimer( idleSeconds );
}
}
else
{
sleepASAP = false;
if (wranglerAsleep)
{
AbsoluteTime now;
uint64_t nanos;
uint32_t minutesSinceDisplaySleep = 0;
uint32_t sleepDelay;
clock_get_uptime(&now);
if (CMP_ABSOLUTETIME(&now, &wranglerSleepTime) > 0)
{
SUB_ABSOLUTETIME(&now, &wranglerSleepTime);
absolutetime_to_nanoseconds(now, &nanos);
minutesSinceDisplaySleep = nanos / (60000000000ULL);
}
if (extraSleepDelay > minutesSinceDisplaySleep)
{
sleepDelay = extraSleepDelay - minutesSinceDisplaySleep;
}
else
{
sleepDelay = 1;
}
startIdleSleepTimer(sleepDelay * 60);
DLOG("display slept %u min, set idle timer to %u min\n",
minutesSinceDisplaySleep, sleepDelay);
}
}
}
sleepSlider = minutesToSleep;
if ( sleepSlider == 0 ) {
cancelIdleSleepTimer();
adjustPowerState();
patriarch->wakeSystem();
}
}
IOReturn IOPMrootDomain::setAggressiveness(
unsigned long type,
unsigned long value )
{
return setAggressiveness( type, value, 0 );
}
IOReturn IOPMrootDomain::setAggressiveness(
unsigned long type,
unsigned long value,
IOOptionBits options )
{
AggressivesRequest * entry;
AggressivesRequest * request;
bool found = false;
DLOG("setAggressiveness 0x%x = %u, options 0x%x\n",
(uint32_t) type, (uint32_t) value, (uint32_t) options);
request = IONew(AggressivesRequest, 1);
if (!request)
return kIOReturnNoMemory;
memset(request, 0, sizeof(*request));
request->options = options;
request->dataType = kAggressivesRequestTypeRecord;
request->data.record.type = (uint32_t) type;
request->data.record.value = (uint32_t) value;
AGGRESSIVES_LOCK();
if (options & kAggressivesOptionQuickSpindownEnable)
gAggressivesState |= kAggressivesStateQuickSpindown;
else if (options & kAggressivesOptionQuickSpindownDisable)
gAggressivesState &= ~kAggressivesStateQuickSpindown;
else
{
queue_iterate(&aggressivesQueue, entry, AggressivesRequest *, chain)
{
if ((entry->dataType == kAggressivesRequestTypeRecord) &&
(entry->data.record.type == type) &&
((entry->options & kAggressivesOptionQuickSpindownMask) == 0))
{
entry->data.record.value = value;
found = true;
break;
}
}
}
if (!found)
{
queue_enter(&aggressivesQueue, request, AggressivesRequest *, chain);
}
AGGRESSIVES_UNLOCK();
if (found)
IODelete(request, AggressivesRequest, 1);
if (options & kAggressivesOptionSynchronous)
handleAggressivesRequests(); else
thread_call_enter(aggressivesThreadCall);
return kIOReturnSuccess;
}
IOReturn IOPMrootDomain::getAggressiveness (
unsigned long type,
unsigned long * outLevel )
{
uint32_t value = 0;
int source = 0;
if (!outLevel)
return kIOReturnBadArgument;
AGGRESSIVES_LOCK();
if ((gAggressivesState & kAggressivesStateQuickSpindown) &&
(type == kPMMinutesToSpinDown))
{
value = kAggressivesMinValue;
source = 1;
}
if (!source)
{
AggressivesRequest * entry;
queue_iterate(&aggressivesQueue, entry, AggressivesRequest *, chain)
{
if ((entry->dataType == kAggressivesRequestTypeRecord) &&
(entry->data.record.type == type) &&
((entry->options & kAggressivesOptionQuickSpindownMask) == 0))
{
value = entry->data.record.value;
source = 2;
break;
}
}
}
if (!source && aggressivesData)
{
AggressivesRecord * record;
int i, count;
count = aggressivesData->getLength() / sizeof(AggressivesRecord);
record = (AggressivesRecord *) aggressivesData->getBytesNoCopy();
for (i = 0; i < count; i++, record++)
{
if (record->type == type)
{
value = record->value;
source = 3;
break;
}
}
}
AGGRESSIVES_UNLOCK();
if (source)
{
DLOG("getAggressiveness 0x%x = %u, source %d\n",
(uint32_t) type, value, source);
*outLevel = (unsigned long) value;
return kIOReturnSuccess;
}
else
{
DLOG("getAggressiveness type 0x%x not found\n", (uint32_t) type);
*outLevel = 0; return kIOReturnInvalid;
}
}
IOReturn IOPMrootDomain::joinAggressiveness(
IOService * service )
{
AggressivesRequest * request;
if (!service || (service == this))
return kIOReturnBadArgument;
DLOG("joinAggressiveness %s (%p)\n", service->getName(), service);
request = IONew(AggressivesRequest, 1);
if (!request)
return kIOReturnNoMemory;
service->retain();
memset(request, 0, sizeof(*request));
request->dataType = kAggressivesRequestTypeService;
request->data.service = service;
AGGRESSIVES_LOCK();
queue_enter(&aggressivesQueue, request, AggressivesRequest *, chain);
AGGRESSIVES_UNLOCK();
thread_call_enter(aggressivesThreadCall);
return kIOReturnSuccess;
}
static void
handleAggressivesFunction(
thread_call_param_t param1,
thread_call_param_t param2 )
{
if (param1)
{
((IOPMrootDomain *) param1)->handleAggressivesRequests();
}
}
void IOPMrootDomain::handleAggressivesRequests( void )
{
AggressivesRecord * start;
AggressivesRecord * record;
AggressivesRequest * request;
queue_head_t joinedQueue;
int i, count;
bool broadcast;
bool found;
bool pingSelf = false;
AGGRESSIVES_LOCK();
if ((gAggressivesState & kAggressivesStateBusy) || !aggressivesData ||
queue_empty(&aggressivesQueue))
goto unlock_done;
gAggressivesState |= kAggressivesStateBusy;
count = aggressivesData->getLength() / sizeof(AggressivesRecord);
start = (AggressivesRecord *) aggressivesData->getBytesNoCopy();
do
{
broadcast = false;
queue_init(&joinedQueue);
do
{
queue_remove_first(&aggressivesQueue, request, AggressivesRequest *, chain);
switch (request->dataType)
{
case kAggressivesRequestTypeRecord:
found = false;
for (i = 0, record = start; i < count; i++, record++)
{
if (record->type == request->data.record.type)
{
found = true;
if (request->options & kAggressivesOptionQuickSpindownEnable)
{
if ((record->flags & kAggressivesRecordFlagMinValue) == 0)
{
broadcast = true;
record->flags |= (kAggressivesRecordFlagMinValue |
kAggressivesRecordFlagModified);
DLOG("quick spindown accelerated, was %u min\n",
record->value);
}
}
else if (request->options & kAggressivesOptionQuickSpindownDisable)
{
if (record->flags & kAggressivesRecordFlagMinValue)
{
broadcast = true;
record->flags |= kAggressivesRecordFlagModified;
record->flags &= ~kAggressivesRecordFlagMinValue;
DLOG("disk spindown restored to %u min\n",
record->value);
}
}
else if (record->value != request->data.record.value)
{
record->value = request->data.record.value;
if ((record->flags & kAggressivesRecordFlagMinValue) == 0)
{
broadcast = true;
record->flags |= kAggressivesRecordFlagModified;
}
}
break;
}
}
if (!found &&
((request->options & kAggressivesOptionQuickSpindownDisable) == 0))
{
AggressivesRecord newRecord;
newRecord.flags = kAggressivesRecordFlagModified;
newRecord.type = request->data.record.type;
newRecord.value = request->data.record.value;
if (request->options & kAggressivesOptionQuickSpindownEnable)
{
newRecord.flags |= kAggressivesRecordFlagMinValue;
DLOG("disk spindown accelerated\n");
}
aggressivesData->appendBytes(&newRecord, sizeof(newRecord));
count = aggressivesData->getLength() / sizeof(AggressivesRecord);
start = (AggressivesRecord *) aggressivesData->getBytesNoCopy();
broadcast = true;
}
IODelete(request, AggressivesRequest, 1);
break;
case kAggressivesRequestTypeService:
queue_enter(&joinedQueue, request, AggressivesRequest *, chain);
break;
default:
panic("bad aggressives request type %x\n", request->dataType);
break;
}
} while (!queue_empty(&aggressivesQueue));
if (!queue_empty(&joinedQueue) || broadcast)
{
AGGRESSIVES_UNLOCK();
if (!queue_empty(&joinedQueue))
synchronizeAggressives(&joinedQueue, start, count);
if (broadcast)
broadcastAggressives(start, count);
AGGRESSIVES_LOCK();
}
for (i = 0, record = start; i < count; i++, record++)
{
if ((record->flags & kAggressivesRecordFlagModified) &&
((record->type == kPMMinutesToDim) ||
(record->type == kPMMinutesToSleep)))
pingSelf = true;
record->flags &= ~kAggressivesRecordFlagModified;
}
} while (!queue_empty(&aggressivesQueue));
gAggressivesState &= ~kAggressivesStateBusy;
unlock_done:
AGGRESSIVES_UNLOCK();
if (pingSelf && pmPowerStateQueue) {
pmPowerStateQueue->submitPowerEvent( kPowerEventAggressivenessChanged );
}
}
void IOPMrootDomain::synchronizeAggressives(
queue_head_t * joinedQueue,
const AggressivesRecord * array,
int count )
{
IOService * service;
AggressivesRequest * request;
const AggressivesRecord * record;
uint32_t value;
int i;
while (!queue_empty(joinedQueue))
{
queue_remove_first(joinedQueue, request, AggressivesRequest *, chain);
if (request->dataType == kAggressivesRequestTypeService)
service = request->data.service;
else
service = 0;
IODelete(request, AggressivesRequest, 1);
request = 0;
if (service)
{
if (service->assertPMThreadCall())
{
for (i = 0, record = array; i < count; i++, record++)
{
value = record->value;
if (record->flags & kAggressivesRecordFlagMinValue)
value = kAggressivesMinValue;
DLOG("synchronizeAggressives 0x%x = %u to %s\n",
record->type, value, service->getName());
service->setAggressiveness(record->type, value);
}
service->deassertPMThreadCall();
}
service->release(); }
}
}
void IOPMrootDomain::broadcastAggressives(
const AggressivesRecord * array,
int count )
{
IORegistryIterator * iter;
IORegistryEntry * entry;
IOPowerConnection * connect;
IOService * service;
const AggressivesRecord * record;
uint32_t value;
int i;
iter = IORegistryIterator::iterateOver(
this, gIOPowerPlane, kIORegistryIterateRecursively);
if (iter)
{
do
{
iter->reset();
while ((entry = iter->getNextObject()))
{
connect = OSDynamicCast(IOPowerConnection, entry);
if (!connect || !connect->getReadyFlag())
continue;
if ((service = (IOService *) connect->copyChildEntry(gIOPowerPlane)))
{
if (service->assertPMThreadCall())
{
for (i = 0, record = array; i < count; i++, record++)
{
if (record->flags & kAggressivesRecordFlagModified)
{
value = record->value;
if (record->flags & kAggressivesRecordFlagMinValue)
value = kAggressivesMinValue;
DLOG("broadcastAggressives %x = %u to %s\n",
record->type, value, service->getName());
service->setAggressiveness(record->type, value);
}
}
service->deassertPMThreadCall();
}
service->release();
}
}
}
while (!entry && !iter->isValid());
iter->release();
}
}
void IOPMrootDomain::startIdleSleepTimer( uint32_t inSeconds )
{
AbsoluteTime deadline;
ASSERT_GATED();
if (inSeconds)
{
clock_interval_to_deadline(inSeconds, kSecondScale, &deadline);
thread_call_enter_delayed(extraSleepTimer, deadline);
idleSleepTimerPending = true;
DLOG("idle timer set for %u seconds\n", inSeconds);
}
}
void IOPMrootDomain::cancelIdleSleepTimer( void )
{
ASSERT_GATED();
if (idleSleepTimerPending)
{
DLOG("idle timer cancelled\n");
thread_call_cancel(extraSleepTimer);
idleSleepTimerPending = false;
}
}
static void idleSleepTimerExpired(
thread_call_param_t us, thread_call_param_t )
{
((IOPMrootDomain *)us)->handleSleepTimerExpiration();
}
static void wakeupClamshellTimerExpired(
thread_call_param_t us, thread_call_param_t )
{
((IOPMrootDomain *)us)->stopIgnoringClamshellEventsDuringWakeup();
}
void IOPMrootDomain::handleSleepTimerExpiration( void )
{
if (!getPMworkloop()->inGate())
{
getPMworkloop()->runAction(
OSMemberFunctionCast(IOWorkLoop::Action, this,
&IOPMrootDomain::handleSleepTimerExpiration),
this);
return;
}
AbsoluteTime time;
DLOG("sleep timer expired\n");
ASSERT_GATED();
idleSleepTimerPending = false;
clock_get_uptime(&time);
if ((AbsoluteTime_to_scalar(&time) > autoWakeStart) &&
(AbsoluteTime_to_scalar(&time) < autoWakeEnd))
{
thread_call_enter_delayed(extraSleepTimer, *((AbsoluteTime *) &autoWakeEnd));
return;
}
setQuickSpinDownTimeout();
sleepASAP = true;
adjustPowerState();
}
void IOPMrootDomain::stopIgnoringClamshellEventsDuringWakeup( void )
{
if (!getPMworkloop()->inGate())
{
getPMworkloop()->runAction(
OSMemberFunctionCast(IOWorkLoop::Action, this,
&IOPMrootDomain::stopIgnoringClamshellEventsDuringWakeup),
this);
return;
}
ASSERT_GATED();
ignoringClamshellOnWake = false;
if (clamshellIsClosed)
handlePowerNotification( kLocalEvalClamshellCommand );
}
IOReturn IOPMrootDomain::sleepSystem( void )
{
return sleepSystemOptions(NULL);
}
IOReturn IOPMrootDomain::sleepSystemOptions( OSDictionary *options )
{
if (options && options->getObject("OSSwitch"))
{
return privateSleepSystem( kIOPMSleepReasonOSSwitchHibernation);
} else {
return privateSleepSystem( kIOPMSleepReasonSoftware);
}
}
IOReturn IOPMrootDomain::privateSleepSystem( uint32_t sleepReason )
{
static const char * IOPMSleepReasons[kIOPMSleepReasonMax] = {
"",
kIOPMClamshellSleepKey,
kIOPMPowerButtonSleepKey,
kIOPMSoftwareSleepKey,
kIOPMOSSwitchHibernationKey,
kIOPMIdleSleepKey,
kIOPMLowPowerSleepKey,
kIOPMClamshellSleepKey,
kIOPMThermalEmergencySleepKey
};
if ( userDisabledAllSleep )
{
LOG("Sleep prevented by user disable\n");
return kIOReturnNotPermitted;
}
if ( systemBooting || systemShutdown || !allowSleep )
{
LOG("Sleep prevented by SB %d, SS %d, AS %d\n",
systemBooting, systemShutdown, allowSleep);
return kIOReturnError;
}
lastSleepReason = sleepReason;
if (sleepReason && (sleepReason < kIOPMSleepReasonMax)) {
setProperty(kRootDomainSleepReasonKey, IOPMSleepReasons[sleepReason]);
}
patriarch->sleepSystem();
return kIOReturnSuccess;
}
IOReturn IOPMrootDomain::shutdownSystem( void )
{
return kIOReturnUnsupported;
}
IOReturn IOPMrootDomain::restartSystem( void )
{
return kIOReturnUnsupported;
}
void IOPMrootDomain::powerChangeDone( unsigned long previousState )
{
ASSERT_GATED();
DLOG("PowerChangeDone: %u->%u\n",
(uint32_t) previousState, (uint32_t) getPowerState());
switch ( getPowerState() ) {
case SLEEP_STATE:
if ( previousState != ON_STATE )
break;
if ( canSleep )
{
cancelIdleSleepTimer();
wranglerTickled = true;
clock_sec_t secs;
clock_usec_t microsecs;
clock_get_calendar_microtime(&secs, µsecs);
logtime(secs);
gIOLastSleepTime.tv_sec = secs;
gIOLastSleepTime.tv_usec = microsecs;
gIOLastWakeTime.tv_sec = 0;
gIOLastWakeTime.tv_usec = 0;
#if HIBERNATION
LOG("System %sSleep\n", gIOHibernateState ? "Safe" : "");
tracePoint(kIOPMTracePointSystemHibernatePhase);
IOHibernateSystemHasSlept();
evaluateSystemSleepPolicyFinal();
#else
LOG("System Sleep\n");
#endif
tracePoint(kIOPMTracePointSystemSleepPlatformPhase);
getPlatform()->sleepKernel();
tracePoint(kIOPMTracePointSystemWakeDriversPhase);
#if HIBERNATION
IOHibernateSystemWake();
#endif
gSleepOrShutdownPending = 0;
clock_wakeup_calendar();
patriarch->wakeSystem();
if (getProperty(kIOPMSleepWakeUUIDKey))
gSleepWakeUUIDIsSet = true;
#if !ROOT_DOMAIN_RUN_STATES
tellClients(kIOMessageSystemWillPowerOn, clientMessageFilter);
#endif
#if HIBERNATION
LOG("System %sWake\n", gIOHibernateState ? "SafeSleep " : "");
#endif
getPlatform()->PMLog(kIOPMrootDomainClass, kPMLogSystemWake, 0, 0);
lowBatteryCondition = false;
#ifndef __LP64__
systemWake();
#endif
#if defined(__i386__) || defined(__x86_64__)
sleepTimerMaintenance = false;
#if ROOT_DOMAIN_RUN_STATES
OSString * wakeType = OSDynamicCast(
OSString, getProperty(kIOPMRootDomainWakeTypeKey));
if (wakeType && wakeType->isEqualTo(kIOPMrootDomainWakeTypeLowBattery))
{
lowBatteryCondition = true;
updateRunState(kRStateMaintenance);
wranglerTickled = false;
}
else if (wakeType && !hibernateAborted && wakeType->isEqualTo(kIOPMRootDomainWakeTypeSleepTimer))
{
sleepTimerMaintenance = true;
updateRunState(kRStateMaintenance);
wranglerTickled = false;
}
else if (wakeType && !hibernateAborted && wakeType->isEqualTo(kIOPMRootDomainWakeTypeMaintenance))
{
updateRunState(kRStateMaintenance);
wranglerTickled = false;
}
else
#endif
{
updateRunState(kRStateNormal);
reportUserInput();
}
#else
startIdleSleepTimer(30);
reportUserInput();
#endif
changePowerStateToPriv(ON_STATE);
} else {
updateRunState(kRStateNormal);
patriarch->sleepToDoze();
changePowerStateWithOverrideTo(DOZE_STATE);
}
break;
case DOZE_STATE:
if ( previousState != DOZE_STATE )
{
LOG("System Doze\n");
}
cancelIdleSleepTimer();
gSleepOrShutdownPending = 0;
if (wrangler) wrangler->changePowerStateTo(0);
break;
#if ROOT_DOMAIN_RUN_STATES
case ON_STATE:
if ((previousState == SLEEP_STATE) &&
(runStateIndex == kRStateMaintenance) &&
!wranglerTickled)
{
if (lowBatteryCondition)
{
lastSleepReason = kIOPMSleepReasonLowPower;
setProperty(kRootDomainSleepReasonKey, kIOPMLowPowerSleepKey);
}
else
{
lastSleepReason = kIOPMSleepReasonMaintenance;
setProperty(kRootDomainSleepReasonKey, kIOPMMaintenanceSleepKey);
}
changePowerStateWithOverrideTo(SLEEP_STATE);
}
if ((previousState == ON_STATE) &&
(runStateIndex != nextRunStateIndex) &&
(nextRunStateIndex < kRStateCount))
{
LOG("R-state changed %u->%u\n",
runStateIndex, nextRunStateIndex);
updateRunState(nextRunStateIndex);
DLOG("kIOMessageSystemHasPoweredOn (%u)\n",
gMessageClientType);
tellClients(kIOMessageSystemHasPoweredOn, clientMessageFilter);
}
break;
#endif
}
}
void IOPMrootDomain::wakeFromDoze( void )
{
if ( getPowerState() == DOZE_STATE )
{
tracePoint(kIOPMTracePointSystemWakeDriversPhase);
changePowerStateToPriv(ON_STATE);
patriarch->wakeSystem();
}
}
void IOPMrootDomain::publishFeature( const char * feature )
{
publishFeature(feature, kRD_AllPowerSources, NULL);
}
void IOPMrootDomain::publishFeature(
const char *feature,
uint32_t supportedWhere,
uint32_t *uniqueFeatureID)
{
static uint16_t next_feature_id = 500;
OSNumber *new_feature_data = NULL;
OSNumber *existing_feature = NULL;
OSArray *existing_feature_arr = NULL;
OSObject *osObj = NULL;
uint32_t feature_value = 0;
supportedWhere &= kRD_AllPowerSources;
if(!supportedWhere) {
return;
}
if(next_feature_id > 5000) {
return;
}
if(featuresDictLock) IOLockLock(featuresDictLock);
OSDictionary *features =
(OSDictionary *) getProperty(kRootDomainSupportedFeatures);
if ( features && OSDynamicCast(OSDictionary, features)) {
features = OSDictionary::withDictionary(features);
} else {
features = OSDictionary::withCapacity(1);
}
next_feature_id += 1;
if( uniqueFeatureID ) {
*uniqueFeatureID = next_feature_id;
}
feature_value = (uint32_t)next_feature_id;
feature_value <<= 16;
feature_value += supportedWhere;
new_feature_data = OSNumber::withNumber(
(unsigned long long)feature_value, 32);
if( (osObj = features->getObject(feature)) )
{
if(( existing_feature = OSDynamicCast(OSNumber, osObj) ))
{
existing_feature_arr = OSArray::withObjects(
(const OSObject **)&existing_feature, 1, 2);
} else if(( existing_feature_arr = OSDynamicCast(OSArray, osObj) ))
{
existing_feature_arr = OSArray::withArray(
existing_feature_arr,
existing_feature_arr->getCount() + 1);
}
if (existing_feature_arr)
{
existing_feature_arr->setObject(new_feature_data);
features->setObject(feature, existing_feature_arr);
existing_feature_arr->release();
existing_feature_arr = 0;
}
} else {
features->setObject(feature, new_feature_data);
}
new_feature_data->release();
setProperty(kRootDomainSupportedFeatures, features);
features->release();
if(featuresDictLock) IOLockUnlock(featuresDictLock);
if(pmPowerStateQueue) {
pmPowerStateQueue->submitPowerEvent( kPowerEventFeatureChanged );
}
}
IOReturn IOPMrootDomain::removePublishedFeature( uint32_t removeFeatureID )
{
IOReturn ret = kIOReturnError;
uint32_t feature_value = 0;
uint16_t feature_id = 0;
bool madeAChange = false;
OSSymbol *dictKey = NULL;
OSCollectionIterator *dictIterator = NULL;
OSArray *arrayMember = NULL;
OSNumber *numberMember = NULL;
OSObject *osObj = NULL;
OSNumber *osNum = NULL;
OSArray *arrayMemberCopy;
if(featuresDictLock) IOLockLock(featuresDictLock);
OSDictionary *features =
(OSDictionary *) getProperty(kRootDomainSupportedFeatures);
if ( features && OSDynamicCast(OSDictionary, features) )
{
features = OSDictionary::withDictionary(features);
} else {
features = NULL;
ret = kIOReturnNotFound;
goto exit;
}
dictIterator = OSCollectionIterator::withCollection(features);
if(!dictIterator) {
goto exit;
}
while( (dictKey = OSDynamicCast(OSSymbol, dictIterator->getNextObject())) )
{
osObj = features->getObject(dictKey);
if( osObj && (numberMember = OSDynamicCast(OSNumber, osObj)) )
{
feature_value = numberMember->unsigned32BitValue();
feature_id = (uint16_t)(feature_value >> 16);
if( feature_id == (uint16_t)removeFeatureID )
{
features->removeObject(dictKey);
madeAChange = true;
break;
}
} else if( osObj && (arrayMember = OSDynamicCast(OSArray, osObj)) )
{
unsigned int arrayCount = arrayMember->getCount();
for(unsigned int i=0; i<arrayCount; i++)
{
osNum = OSDynamicCast(OSNumber, arrayMember->getObject(i));
if(!osNum) {
continue;
}
feature_value = osNum->unsigned32BitValue();
feature_id = (uint16_t)(feature_value >> 16);
if( feature_id == (uint16_t)removeFeatureID )
{
if( 1 == arrayCount ) {
features->removeObject(dictKey);
} else {
arrayMemberCopy = OSArray::withArray(arrayMember);
if (arrayMemberCopy)
{
arrayMemberCopy->removeObject(i);
features->setObject(dictKey, arrayMemberCopy);
arrayMemberCopy->release();
}
}
madeAChange = true;
break;
}
}
}
}
dictIterator->release();
if( madeAChange )
{
ret = kIOReturnSuccess;
setProperty(kRootDomainSupportedFeatures, features);
if(pmPowerStateQueue) {
pmPowerStateQueue->submitPowerEvent( kPowerEventFeatureChanged );
}
} else {
ret = kIOReturnNotFound;
}
exit:
if(features) features->release();
if(featuresDictLock) IOLockUnlock(featuresDictLock);
return ret;
}
void IOPMrootDomain::announcePowerSourceChange( void )
{
#ifdef __ppc__
IORegistryEntry *_batteryRegEntry = (IORegistryEntry *) getProperty("BatteryEntry");
if(_batteryRegEntry)
{
OSArray *batt_info;
batt_info = (OSArray *) _batteryRegEntry->getProperty(kIOBatteryInfoKey);
if(batt_info)
setProperty(kIOBatteryInfoKey, batt_info);
}
#endif
}
IOReturn IOPMrootDomain::setPMSetting(
const OSSymbol *type,
OSObject *obj)
{
OSArray *arr = NULL;
PMSettingObject *p_obj = NULL;
int count;
int i;
if(NULL == type) return kIOReturnBadArgument;
IORecursiveLockLock(settingsCtrlLock);
fPMSettingsDict->setObject(type, obj);
arr = (OSArray *)settingsCallbacks->getObject(type);
if(NULL == arr) goto exit;
count = arr->getCount();
for(i=0; i<count; i++) {
p_obj = (PMSettingObject *)OSDynamicCast(PMSettingObject, arr->getObject(i));
if(p_obj) p_obj->setPMSetting(type, obj);
}
exit:
IORecursiveLockUnlock(settingsCtrlLock);
return kIOReturnSuccess;
}
OSObject * IOPMrootDomain::copyPMSetting(
OSSymbol *whichSetting)
{
OSObject *obj = NULL;
if(!whichSetting) return NULL;
IORecursiveLockLock(settingsCtrlLock);
obj = fPMSettingsDict->getObject(whichSetting);
if(obj) {
obj->retain();
}
IORecursiveLockUnlock(settingsCtrlLock);
return obj;
}
IOReturn IOPMrootDomain::registerPMSettingController(
const OSSymbol * settings[],
IOPMSettingControllerCallback func,
OSObject *target,
uintptr_t refcon,
OSObject **handle)
{
return registerPMSettingController(
settings,
(kIOPMSupportedOnAC | kIOPMSupportedOnBatt | kIOPMSupportedOnUPS),
func, target, refcon, handle);
}
IOReturn IOPMrootDomain::registerPMSettingController(
const OSSymbol * settings[],
uint32_t supportedPowerSources,
IOPMSettingControllerCallback func,
OSObject *target,
uintptr_t refcon,
OSObject **handle)
{
PMSettingObject *pmso = NULL;
OSArray *list = NULL;
IOReturn ret = kIOReturnSuccess;
int i;
if( NULL == settings ||
NULL == func ||
NULL == handle)
{
return kIOReturnBadArgument;
}
pmso = PMSettingObject::pmSettingObject(
(IOPMrootDomain *)this, func, target,
refcon, supportedPowerSources, settings);
if(!pmso) {
ret = kIOReturnInternalError;
goto bail_no_unlock;
}
IORecursiveLockLock(settingsCtrlLock);
for(i=0; settings[i]; i++)
{
list = (OSArray *)settingsCallbacks->getObject(settings[i]);
if(!list) {
list = OSArray::withCapacity(1);
settingsCallbacks->setObject(settings[i], list);
list->release();
}
list->setObject(pmso);
}
IORecursiveLockUnlock(settingsCtrlLock);
ret = kIOReturnSuccess;
*handle = pmso;
bail_no_unlock:
if(kIOReturnSuccess != ret)
{
if(pmso) pmso->release();
if(handle) *handle = NULL;
}
return ret;
}
bool IOPMrootDomain::shouldSleepOnClamshellClosed( void )
{
DLOG("clamshell state %d, EX %d, IG %d, IW %d, DT %d, AC %d\n",
clamshellIsClosed, clamshellExists, ignoringClamshell,
ignoringClamshellOnWake, desktopMode, acAdaptorConnected);
return ( !ignoringClamshell
&& !ignoringClamshellOnWake
&& !(desktopMode && acAdaptorConnected) );
}
void IOPMrootDomain::sendClientClamshellNotification( void )
{
if (!clamshellExists)
return;
setProperty(kAppleClamshellStateKey,
clamshellIsClosed ? kOSBooleanTrue : kOSBooleanFalse);
setProperty(kAppleClamshellCausesSleepKey,
shouldSleepOnClamshellClosed() ? kOSBooleanTrue : kOSBooleanFalse);
messageClients(kIOPMMessageClamshellStateChange,
(void *) ( (clamshellIsClosed ? kClamshellStateBit : 0)
| ( shouldSleepOnClamshellClosed() ? kClamshellSleepBit : 0)) );
}
void IOPMrootDomain::informCPUStateChange(
uint32_t type,
uint32_t value )
{
#if defined(__i386__) || defined(__x86_64__)
pmioctlVariableInfo_t varInfoStruct;
int pmCPUret = 0;
const char *varNameStr = NULL;
int32_t *varIndex = NULL;
if (kInformAC == type) {
varNameStr = kIOPMRootDomainBatPowerCString;
varIndex = &idxPMCPULimitedPower;
} else if (kInformLid == type) {
varNameStr = kIOPMRootDomainLidCloseCString;
varIndex = &idxPMCPUClamshell;
} else {
return;
}
bzero(&varInfoStruct, sizeof(pmioctlVariableInfo_t));
varInfoStruct.varID = *varIndex;
varInfoStruct.varType = vBool;
varInfoStruct.varInitValue = value;
varInfoStruct.varCurValue = value;
strncpy( (char *)varInfoStruct.varName,
(const char *)varNameStr,
strlen(varNameStr) + 1 );
pmCPUret = pmCPUControl( PMIOCSETVARINFO, (void *)&varInfoStruct );
if ((0 == pmCPUret)
&& (*varIndex == kCPUUnknownIndex))
{
pmCPUret = pmCPUControl( PMIOCGETVARNAMEINFO, (void *)&varInfoStruct );
if (0 == pmCPUret)
{
*varIndex = varInfoStruct.varID;
}
}
return;
#endif
}
#if HIBERNATION
struct IOPMSystemSleepPolicyEntry
{
uint32_t factorMask;
uint32_t factorBits;
uint32_t sleepFlags;
uint32_t wakeEvents;
};
struct IOPMSystemSleepPolicyTable
{
uint8_t signature[4];
uint16_t version;
uint16_t entryCount;
IOPMSystemSleepPolicyEntry entries[];
};
enum {
kIOPMSleepFactorSleepTimerWake = 0x00000001,
kIOPMSleepFactorLidOpen = 0x00000002,
kIOPMSleepFactorACPower = 0x00000004,
kIOPMSleepFactorLowBattery = 0x00000008,
kIOPMSleepFactorDeepSleepNoDelay = 0x00000010,
kIOPMSleepFactorDeepSleepDemand = 0x00000020,
kIOPMSleepFactorDeepSleepDisable = 0x00000040,
kIOPMSleepFactorUSBExternalDevice = 0x00000080,
kIOPMSleepFactorBluetoothHIDDevice = 0x00000100,
kIOPMSleepFactorExternalMediaMounted = 0x00000200,
kIOPMSleepFactorDriverAssertBit5 = 0x00000400,
kIOPMSleepFactorDriverAssertBit6 = 0x00000800,
kIOPMSleepFactorDriverAssertBit7 = 0x00001000
};
bool IOPMrootDomain::evaluateSystemSleepPolicy( IOPMSystemSleepParameters * p )
{
const IOPMSystemSleepPolicyTable * pt;
OSObject * prop = 0;
OSData * policyData;
uint32_t currentFactors;
uint32_t deepSleepDelay = 0;
bool success = false;
if (getProperty(kIOPMDeepSleepEnabledKey) != kOSBooleanTrue)
return false;
getSleepOption(kIOPMDeepSleepDelayKey, &deepSleepDelay);
prop = getServiceRoot()->copyProperty(kIOPlatformSystemSleepPolicyKey);
if (!prop)
return false;
policyData = OSDynamicCast(OSData, prop);
if (!policyData ||
(policyData->getLength() < sizeof(IOPMSystemSleepPolicyTable)))
{
goto done;
}
pt = (const IOPMSystemSleepPolicyTable *) policyData->getBytesNoCopy();
if ((pt->signature[0] != 'S') ||
(pt->signature[1] != 'L') ||
(pt->signature[2] != 'P') ||
(pt->signature[3] != 'T') ||
(pt->version != 1) ||
(pt->entryCount == 0))
{
goto done;
}
if ((policyData->getLength() - sizeof(IOPMSystemSleepPolicyTable)) !=
(sizeof(IOPMSystemSleepPolicyEntry) * pt->entryCount))
{
goto done;
}
currentFactors = 0;
if (getPMAssertionLevel(kIOPMDriverAssertionUSBExternalDeviceBit) !=
kIOPMDriverAssertionLevelOff)
currentFactors |= kIOPMSleepFactorUSBExternalDevice;
if (getPMAssertionLevel(kIOPMDriverAssertionBluetoothHIDDevicePairedBit) !=
kIOPMDriverAssertionLevelOff)
currentFactors |= kIOPMSleepFactorBluetoothHIDDevice;
if (getPMAssertionLevel(kIOPMDriverAssertionExternalMediaMountedBit) !=
kIOPMDriverAssertionLevelOff)
currentFactors |= kIOPMSleepFactorExternalMediaMounted;
if (getPMAssertionLevel(kIOPMDriverAssertionReservedBit5) !=
kIOPMDriverAssertionLevelOff)
currentFactors |= kIOPMSleepFactorDriverAssertBit5;
if (getPMAssertionLevel(kIOPMDriverAssertionReservedBit6) !=
kIOPMDriverAssertionLevelOff)
currentFactors |= kIOPMSleepFactorDriverAssertBit6;
if (getPMAssertionLevel(kIOPMDriverAssertionReservedBit7) !=
kIOPMDriverAssertionLevelOff)
currentFactors |= kIOPMSleepFactorDriverAssertBit7;
if (0 == deepSleepDelay)
currentFactors |= kIOPMSleepFactorDeepSleepNoDelay;
if (!clamshellIsClosed)
currentFactors |= kIOPMSleepFactorLidOpen;
if (acAdaptorConnected)
currentFactors |= kIOPMSleepFactorACPower;
if (lowBatteryCondition)
currentFactors |= kIOPMSleepFactorLowBattery;
if (sleepTimerMaintenance)
currentFactors |= kIOPMSleepFactorSleepTimerWake;
if ((hibernateMode & kIOHibernateModeOn) == 0)
currentFactors |= kIOPMSleepFactorDeepSleepDisable;
else if ((hibernateMode & kIOHibernateModeSleep) == 0)
currentFactors |= kIOPMSleepFactorDeepSleepDemand;
DLOG("Sleep policy %u entries, current factors 0x%x\n",
pt->entryCount, currentFactors);
for (uint32_t i = 0; i < pt->entryCount; i++)
{
const IOPMSystemSleepPolicyEntry * policyEntry = &pt->entries[i];
DLOG("factor mask 0x%08x, bits 0x%08x, flags 0x%08x, wake 0x%08x\n",
policyEntry->factorMask, policyEntry->factorBits,
policyEntry->sleepFlags, policyEntry->wakeEvents);
if ((currentFactors ^ policyEntry->factorBits) & policyEntry->factorMask)
continue;
if (p)
{
p->version = 1;
p->sleepFlags = policyEntry->sleepFlags;
p->sleepTimer = 0;
p->wakeEvents = policyEntry->wakeEvents;
if (p->sleepFlags & kIOPMSleepFlagSleepTimerEnable)
{
p->sleepTimer = deepSleepDelay;
}
}
DLOG("matched policy entry %u\n", i);
success = true;
break;
}
done:
if (prop)
prop->release();
return success;
}
void IOPMrootDomain::evaluateSystemSleepPolicyEarly( void )
{
IOPMSystemSleepParameters params;
DLOG("%s\n", __FUNCTION__);
removeProperty(kIOPMSystemSleepParametersKey);
hibernateDisabled = false;
hibernateMode = 0;
getSleepOption(kIOHibernateModeKey, &hibernateMode);
if (!hibernateNoDefeat &&
evaluateSystemSleepPolicy(¶ms) &&
((params.sleepFlags & kIOPMSleepFlagHibernate) == 0))
{
hibernateDisabled = true;
}
}
void IOPMrootDomain::evaluateSystemSleepPolicyFinal( void )
{
IOPMSystemSleepParameters params;
OSData * paramsData;
DLOG("%s\n", __FUNCTION__);
if (evaluateSystemSleepPolicy(¶ms))
{
if ((hibernateDisabled || hibernateAborted) &&
(params.sleepFlags & kIOPMSleepFlagHibernate))
{
params.sleepFlags &= ~kIOPMSleepFlagHibernate;
params.sleepFlags |= kIOPMSleepFlagSleepTimerEnable;
params.sleepTimer = 1;
hibernateNoDefeat = true;
DLOG("wake in %u secs for hibernateDisabled %d, hibernateAborted %d\n",
params.sleepTimer, hibernateDisabled, hibernateAborted);
}
else
hibernateNoDefeat = false;
paramsData = OSData::withBytes(¶ms, sizeof(params));
if (paramsData)
{
setProperty(kIOPMSystemSleepParametersKey, paramsData);
paramsData->release();
}
if (params.sleepFlags & kIOPMSleepFlagHibernate)
{
gIOHibernateMode &= ~kIOHibernateModeSleep;
}
}
}
bool IOPMrootDomain::getHibernateSettings(
uint32_t * hibernateMode,
uint32_t * hibernateFreeRatio,
uint32_t * hibernateFreeTime )
{
bool ok = getSleepOption(kIOHibernateModeKey, hibernateMode);
getSleepOption(kIOHibernateFreeRatioKey, hibernateFreeRatio);
getSleepOption(kIOHibernateFreeTimeKey, hibernateFreeTime);
if (hibernateDisabled)
*hibernateMode = 0;
DLOG("hibernateMode 0x%x\n", *hibernateMode);
return ok;
}
bool IOPMrootDomain::getSleepOption( const char * key, uint32_t * option )
{
OSObject * optionsProp;
OSDictionary * optionsDict;
OSObject * obj = 0;
OSNumber * num;
bool ok = false;
optionsProp = copyProperty(kRootDomainSleepOptionsKey);
optionsDict = OSDynamicCast(OSDictionary, optionsProp);
if (optionsDict)
{
obj = optionsDict->getObject(key);
if (obj) obj->retain();
}
if (!obj)
{
obj = copyProperty(key);
}
if (obj && (num = OSDynamicCast(OSNumber, obj)))
{
*option = num->unsigned32BitValue();
ok = true;
}
if (obj)
obj->release();
if (optionsProp)
optionsProp->release();
return true;
}
#endif
void IOPMrootDomain::dispatchPowerEvent(
uint32_t event, void * arg0, uint64_t arg1 )
{
DLOG("power event %u args %p 0x%llx\n", event, arg0, arg1);
ASSERT_GATED();
switch (event)
{
case kPowerEventFeatureChanged:
messageClients(kIOPMMessageFeatureChange, this);
break;
case kPowerEventReceivedPowerNotification:
handlePowerNotification( (UInt32)(uintptr_t) arg0 );
break;
case kPowerEventSystemBootCompleted:
if (systemBooting)
{
systemBooting = false;
adjustPowerState();
if( clamshellIsClosed )
{
handlePowerNotification(kLocalEvalClamshellCommand);
}
}
break;
case kPowerEventSystemShutdown:
if (kOSBooleanTrue == (OSBoolean *) arg0)
{
LOG("systemShutdown true\n");
systemShutdown = true;
} else {
LOG("systemShutdown false\n");
systemShutdown = false;
}
break;
case kPowerEventUserDisabledSleep:
userDisabledAllSleep = (kOSBooleanTrue == (OSBoolean *) arg0);
break;
#if ROOT_DOMAIN_RUN_STATES
case kPowerEventConfigdRegisteredInterest:
if (gConfigdNotifier)
{
gConfigdNotifier->release();
gConfigdNotifier = 0;
}
if (arg0)
{
gConfigdNotifier = (IONotifier *) arg0;
}
break;
#endif
case kPowerEventAggressivenessChanged:
aggressivenessChanged();
break;
case kPowerEventAssertionCreate:
if (pmAssertions) {
pmAssertions->handleCreateAssertion((OSData *)arg0);
}
break;
case kPowerEventAssertionRelease:
if (pmAssertions) {
pmAssertions->handleReleaseAssertion(arg1);
}
break;
case kPowerEventAssertionSetLevel:
if (pmAssertions) {
pmAssertions->handleSetAssertionLevel(arg1, (IOPMDriverAssertionLevel)(uintptr_t)arg0);
}
break;
}
}
IOReturn IOPMrootDomain::systemPowerEventOccurred(
const OSSymbol *event,
uint32_t intValue)
{
IOReturn attempt = kIOReturnSuccess;
OSNumber *newNumber = NULL;
if (!event)
return kIOReturnBadArgument;
newNumber = OSNumber::withNumber(intValue, 8*sizeof(intValue));
if (!newNumber)
return kIOReturnInternalError;
attempt = systemPowerEventOccurred(event, (OSObject *)newNumber);
newNumber->release();
return attempt;
}
IOReturn IOPMrootDomain::systemPowerEventOccurred(
const OSSymbol *event,
OSObject *value)
{
OSDictionary *thermalsDict = NULL;
bool shouldUpdate = true;
if (!event || !value)
return kIOReturnBadArgument;
if (featuresDictLock) IOLockLock(featuresDictLock);
thermalsDict = (OSDictionary *)getProperty(kIOPMRootDomainPowerStatusKey);
if (thermalsDict && OSDynamicCast(OSDictionary, thermalsDict)) {
thermalsDict = OSDictionary::withDictionary(thermalsDict);
} else {
thermalsDict = OSDictionary::withCapacity(1);
}
if (!thermalsDict) {
shouldUpdate = false;
goto exit;
}
thermalsDict->setObject (event, value);
setProperty (kIOPMRootDomainPowerStatusKey, thermalsDict);
thermalsDict->release();
exit:
if (featuresDictLock) IOLockUnlock(featuresDictLock);
if (shouldUpdate)
messageClients (kIOPMMessageSystemPowerEventOccurred, (void *)NULL);
return kIOReturnSuccess;
}
IOReturn IOPMrootDomain::receivePowerNotification( UInt32 msg )
{
pmPowerStateQueue->submitPowerEvent(
kPowerEventReceivedPowerNotification, (void *) msg );
return kIOReturnSuccess;
}
void IOPMrootDomain::handlePowerNotification( UInt32 msg )
{
bool eval_clamshell = false;
ASSERT_GATED();
if (msg & kLocalEvalClamshellCommand)
{
eval_clamshell = true;
}
if (msg & kIOPMOverTemp)
{
LOG("PowerManagement emergency overtemp signal. Going to sleep!");
privateSleepSystem (kIOPMSleepReasonThermalEmergency);
}
#ifdef __ppc__
if (msg & kIOPMProcessorSpeedChange)
{
IOService *pmu = waitForService(serviceMatching("ApplePMU"));
pmu->callPlatformFunction("prepareForSleep", false, 0, 0, 0, 0);
getPlatform()->sleepKernel();
pmu->callPlatformFunction("recoverFromSleep", false, 0, 0, 0, 0);
}
#endif
if (msg & kIOPMSleepNow)
{
privateSleepSystem (kIOPMSleepReasonSoftware);
}
if (msg & kIOPMPowerEmergency)
{
lowBatteryCondition = true;
privateSleepSystem (kIOPMSleepReasonLowPower);
}
if (msg & kIOPMClamshellOpened)
{
clamshellIsClosed = false;
clamshellExists = true;
informCPUStateChange(kInformLid, 0);
sendClientClamshellNotification();
bool aborting = ((lastSleepReason == kIOPMSleepReasonClamshell)
|| (lastSleepReason == kIOPMSleepReasonIdle)
|| (lastSleepReason == kIOPMSleepReasonMaintenance));
if (aborting) userActivityCount++;
DLOG("clamshell tickled %d lastSleepReason %d\n", userActivityCount, lastSleepReason);
}
if (msg & kIOPMClamshellClosed)
{
clamshellIsClosed = true;
clamshellExists = true;
informCPUStateChange(kInformLid, 1);
sendClientClamshellNotification();
eval_clamshell = true;
}
if (msg & kIOPMSetDesktopMode)
{
desktopMode = (0 != (msg & kIOPMSetValue));
msg &= ~(kIOPMSetDesktopMode | kIOPMSetValue);
sendClientClamshellNotification();
if( clamshellIsClosed )
{
eval_clamshell = true;
}
}
if (msg & kIOPMSetACAdaptorConnected)
{
acAdaptorConnected = (0 != (msg & kIOPMSetValue));
msg &= ~(kIOPMSetACAdaptorConnected | kIOPMSetValue);
informCPUStateChange(kInformAC, !acAdaptorConnected);
post_sys_powersource(acAdaptorConnected ? 0:1);
sendClientClamshellNotification();
if( clamshellIsClosed )
{
eval_clamshell = true;
}
}
if (msg & kIOPMEnableClamshell)
{
if( clamshellIsClosed && (true == ignoringClamshell) )
{
eval_clamshell = true;
}
ignoringClamshell = false;
sendClientClamshellNotification();
}
if (msg & kIOPMDisableClamshell)
{
ignoringClamshell = true;
sendClientClamshellNotification();
}
if ( eval_clamshell && shouldSleepOnClamshellClosed() )
{
privateSleepSystem (kIOPMSleepReasonClamshell);
}
if (msg & kIOPMPowerButton)
{
if ( getPowerState() == DOZE_STATE )
{
#ifndef __LP64__
systemWake();
#endif
reportUserInput();
}
else {
OSString *pbs = OSString::withCString("DisablePowerButtonSleep");
if( pbs ) {
if( kOSBooleanTrue != getProperty(pbs))
privateSleepSystem (kIOPMSleepReasonPowerButton);
}
}
}
if ( (msg & kIOPMAllowSleep) && !allowSleep )
{
allowSleep = true;
adjustPowerState();
}
if (msg & kIOPMPreventSleep) {
allowSleep = false;
if ( getPowerState() == DOZE_STATE ) {
#ifndef __LP64__
systemWake();
#endif
adjustPowerState();
reportUserInput();
} else {
adjustPowerState();
patriarch->wakeSystem();
}
}
}
IOOptionBits IOPMrootDomain::getSleepSupported( void )
{
return( platformSleepSupport );
}
void IOPMrootDomain::setSleepSupported( IOOptionBits flags )
{
DLOG("setSleepSupported(%x)\n", (uint32_t) flags);
OSBitOrAtomic(flags, &platformSleepSupport);
}
IOReturn IOPMrootDomain::requestPowerDomainState (
IOPMPowerFlags desiredFlags,
IOPowerConnection * whichChild,
unsigned long specification )
{
OSIterator *iter;
OSObject *next;
IOPowerConnection *connection;
IOPMPowerFlags powerRequestFlag = 0;
IOPMPowerFlags editedDesire;
ASSERT_GATED();
if (kIOLogPMRootDomain & gIOKitDebug)
{
IOService * powerChild =
(IOService *) whichChild->getChildEntry(gIOPowerPlane);
DLOG("child %p, flags %lx, spec %lx - %s\n",
powerChild, desiredFlags, specification,
powerChild ? powerChild->getName() : "?");
}
if (desiredFlags & kIOPMPreventIdleSleep)
editedDesire = kIOPMPreventIdleSleep | kIOPMPowerOn;
else
editedDesire = 0;
sleepIsSupported = true;
iter = getChildIterator(gIOPowerPlane);
if ( iter )
{
while ( (next = iter->getNextObject()) )
{
if ( (connection = OSDynamicCast(IOPowerConnection, next)) )
{
if (connection->getReadyFlag() == false)
continue;
if (connection == whichChild)
{
powerRequestFlag |= editedDesire;
if ( desiredFlags & kIOPMPreventSystemSleep )
sleepIsSupported = false;
}
else
{
if (kIOLogPMRootDomain & gIOKitDebug)
{
IOService * powerChild =
(IOService *) connection->getChildEntry(gIOPowerPlane);
DLOG("child %p, state %ld, noIdle %d, noSleep %d - %s\n",
powerChild,
connection->getDesiredDomainState(),
connection->getPreventIdleSleepFlag(),
connection->getPreventSystemSleepFlag(),
powerChild ? powerChild->getName() : "?");
}
powerRequestFlag |= connection->getDesiredDomainState();
if ( connection->getPreventSystemSleepFlag() )
sleepIsSupported = false;
}
}
}
iter->release();
}
DLOG("childPowerFlags 0x%lx, extraSleepDelay %ld\n",
powerRequestFlag, extraSleepDelay);
if ( !powerRequestFlag && !systemBooting )
{
if (!wrangler)
{
sleepASAP = false;
changePowerStateToPriv(ON_STATE);
if (idleSeconds)
{
startIdleSleepTimer(idleSeconds);
}
}
else if (!extraSleepDelay && !idleSleepTimerPending)
{
sleepASAP = true;
}
}
adjustPowerState();
editedDesire |= (desiredFlags & kIOPMPreventSystemSleep);
return super::requestPowerDomainState(
editedDesire, whichChild, specification);
}
struct HaltRestartApplierContext {
IOPMrootDomain * RootDomain;
unsigned long PowerState;
IOPMPowerFlags PowerFlags;
UInt32 MessageType;
UInt32 Counter;
};
static void
platformHaltRestartApplier( OSObject * object, void * context )
{
IOPowerStateChangeNotification notify;
HaltRestartApplierContext * ctx;
AbsoluteTime startTime;
UInt32 deltaTime;
ctx = (HaltRestartApplierContext *) context;
memset(¬ify, 0, sizeof(notify));
notify.powerRef = (void *)ctx->Counter;
notify.returnValue = 0;
notify.stateNumber = ctx->PowerState;
notify.stateFlags = ctx->PowerFlags;
clock_get_uptime(&startTime);
ctx->RootDomain->messageClient( ctx->MessageType, object, (void *)¬ify );
deltaTime = computeDeltaTimeMS(&startTime);
if ((deltaTime > kPMHaltTimeoutMS) || (gIOKitDebug & kIOLogDebugPower))
{
_IOServiceInterestNotifier * notifier;
notifier = OSDynamicCast(_IOServiceInterestNotifier, object);
if (notifier)
{
KLOG("%s handler %p took %u ms\n",
(ctx->MessageType == kIOMessageSystemWillPowerOff) ?
"PowerOff" : "Restart",
notifier->handler, (uint32_t) deltaTime );
}
}
ctx->Counter++;
}
void IOPMrootDomain::handlePlatformHaltRestart( UInt32 pe_type )
{
HaltRestartApplierContext ctx;
AbsoluteTime startTime;
UInt32 deltaTime;
memset(&ctx, 0, sizeof(ctx));
ctx.RootDomain = this;
clock_get_uptime(&startTime);
switch (pe_type)
{
case kPEHaltCPU:
case kPEUPSDelayHaltCPU:
ctx.PowerState = OFF_STATE;
ctx.MessageType = kIOMessageSystemWillPowerOff;
break;
case kPERestartCPU:
ctx.PowerState = RESTART_STATE;
ctx.MessageType = kIOMessageSystemWillRestart;
break;
default:
return;
}
applyToInterested(gIOPriorityPowerStateInterest, platformHaltRestartApplier, &ctx);
if (kPEUPSDelayHaltCPU != pe_type)
{
const OSSymbol * setting = OSSymbol::withCString(kIOPMSettingRestartOnPowerLossKey);
OSNumber * num = OSNumber::withNumber((unsigned long long) 0, 32);
if (setting && num)
{
setPMSetting(setting, num);
setting->release();
num->release();
}
}
notifySystemShutdown(this, ctx.MessageType);
deltaTime = computeDeltaTimeMS(&startTime);
KLOG("%s all drivers took %u ms\n",
(ctx.MessageType == kIOMessageSystemWillPowerOff) ?
"PowerOff" : "Restart",
(uint32_t) deltaTime );
}
IONotifier * IOPMrootDomain::registerInterest(
const OSSymbol * typeOfInterest,
IOServiceInterestHandler handler,
void * target, void * ref )
{
IONotifier * notifier;
bool isConfigd;
isConfigd = typeOfInterest &&
typeOfInterest->isEqualTo(kIOPMPrivilegedPowerInterest);
if (isConfigd)
typeOfInterest = gIOAppPowerStateInterest;
notifier = super::registerInterest(typeOfInterest, handler, target, ref);
#if ROOT_DOMAIN_RUN_STATES
if (isConfigd && notifier && pmPowerStateQueue)
{
notifier->retain();
if (pmPowerStateQueue->submitPowerEvent(
kPowerEventConfigdRegisteredInterest, notifier) == false)
notifier->release();
}
#endif
return notifier;
}
static bool clientMessageFilter( OSObject * object, void * arg )
{
#if ROOT_DOMAIN_RUN_STATES
#if LOG_INTEREST_CLIENTS
IOPMInterestContext * context = (IOPMInterestContext *) arg;
#endif
bool allow = false;
switch (gMessageClientType)
{
case kMessageClientNone:
allow = false;
break;
case kMessageClientAll:
allow = true;
break;
case kMessageClientConfigd:
allow = ((object == (OSObject *) gConfigdNotifier) ||
(object == (OSObject *) gSysPowerDownNotifier));
break;
}
#if LOG_INTEREST_CLIENTS
if (allow)
DLOG("system message %x to %p\n",
context->msgType, object);
#endif
return allow;
#else
return true;
#endif
}
bool IOPMrootDomain::tellChangeDown( unsigned long stateNum )
{
bool done;
DLOG("tellChangeDown %u->%u, R-state %u\n",
(uint32_t) getPowerState(), (uint32_t) stateNum, runStateIndex);
switch ( stateNum ) {
case DOZE_STATE:
case SLEEP_STATE:
if (!ignoreChangeDown)
{
userActivityAtSleep = userActivityCount;
hibernateAborted = false;
DLOG("tellChangeDown::userActivityAtSleep %d\n", userActivityAtSleep);
OSKextSystemSleepOrWake( kIOMessageSystemWillSleep );
if ( (SLEEP_STATE == stateNum) && sleepSupportedPEFunction )
{
OSBitAndAtomic(~kPCICantSleep, &platformSleepSupport);
if ((runStateFlags & kRStateFlagSuppressPCICheck) == 0)
{
getPlatform()->callPlatformFunction(
sleepSupportedPEFunction, false,
NULL, NULL, NULL, NULL);
}
}
getPlatform()->callPlatformFunction(
sleepMessagePEFunction, false,
(void *)(uintptr_t) kIOMessageSystemWillSleep,
NULL, NULL, NULL);
#if CONFIG_SLEEP
canSleep = true;
#else
canSleep = false;
#endif
if (!sleepIsSupported)
canSleep = false;
if (platformSleepSupport & kPCICantSleep)
canSleep = false;
setProperty(kIOSleepSupportedKey, canSleep);
DLOG("canSleep %d\n", canSleep);
publishSleepWakeUUID(true);
ignoreChangeDown = true;
tracePoint( kIOPMTracePointSystemSleepAppsPhase);
}
DLOG("kIOMessageSystemWillSleep (%d)\n", gMessageClientType);
done = super::tellClientsWithResponse(
kIOMessageSystemWillSleep, clientMessageFilter);
break;
default:
done = super::tellChangeDown(stateNum);
break;
}
return done;
}
bool IOPMrootDomain::askChangeDown( unsigned long stateNum )
{
DLOG("askChangeDown %u->%u, R-state %u\n",
(uint32_t) getPowerState(), (uint32_t) stateNum, runStateIndex);
DLOG("kIOMessageCanSystemSleep (%d)\n", gMessageClientType);
return super::tellClientsWithResponse(
kIOMessageCanSystemSleep,
clientMessageFilter);
}
void IOPMrootDomain::tellNoChangeDown( unsigned long stateNum )
{
DLOG("tellNoChangeDown %u->%u, R-state %u\n",
(uint32_t) getPowerState(), (uint32_t) stateNum, runStateIndex);
tracePoint(kIOPMTracePointSystemUp);
if (idleSeconds && !wrangler)
{
sleepASAP = false;
startIdleSleepTimer(idleSeconds);
}
DLOG("kIOMessageSystemWillNotSleep (%d)\n", gMessageClientType);
return tellClients(kIOMessageSystemWillNotSleep, clientMessageFilter);
}
void IOPMrootDomain::tellChangeUp( unsigned long stateNum )
{
OSData *publishPMStats = NULL;
DLOG("tellChangeUp %u->%u, R-state %u\n",
(uint32_t) getPowerState(), (uint32_t) stateNum, runStateIndex);
ignoreChangeDown = false;
if ( stateNum == ON_STATE )
{
OSKextSystemSleepOrWake( kIOMessageSystemHasPoweredOn );
getPlatform()->callPlatformFunction(
sleepMessagePEFunction, false,
(void *)(uintptr_t) kIOMessageSystemHasPoweredOn,
NULL, NULL, NULL);
if (getPowerState() == ON_STATE)
{
if (idleSeconds && !wrangler)
{
sleepASAP = false;
startIdleSleepTimer(idleSeconds);
}
DLOG("kIOMessageSystemWillPowerOn (%d)\n", gMessageClientType);
tellClients(kIOMessageSystemWillPowerOn, clientMessageFilter);
}
#if HIBERNATION
else
{
IOHibernateSystemPostWake();
}
#endif
tracePoint(kIOPMTracePointSystemWakeAppsPhase);
publishPMStats = OSData::withBytes(&pmStats, sizeof(pmStats));
setProperty(kIOPMSleepStatisticsKey, publishPMStats);
publishPMStats->release();
bzero(&pmStats, sizeof(pmStats));
if (pmStatsAppResponses)
{
setProperty(kIOPMSleepStatisticsAppsKey, pmStatsAppResponses);
pmStatsAppResponses->release();
pmStatsAppResponses = OSArray::withCapacity(5);
}
DLOG("kIOMessageSystemHasPoweredOn (%d)\n", gMessageClientType);
tellClients(kIOMessageSystemHasPoweredOn, clientMessageFilter);
tracePoint(kIOPMTracePointSystemUp);
}
}
void IOPMrootDomain::reportUserInput( void )
{
#if !NO_KERNEL_HID
OSIterator * iter;
if(!wrangler)
{
iter = getMatchingServices(serviceMatching("IODisplayWrangler"));
if(iter)
{
wrangler = (IOService *) iter->getNextObject();
iter->release();
}
}
if(wrangler)
wrangler->activityTickle(0,0);
#endif
}
void IOPMrootDomain::setQuickSpinDownTimeout( void )
{
ASSERT_GATED();
setAggressiveness(
kPMMinutesToSpinDown, 0, kAggressivesOptionQuickSpindownEnable );
}
void IOPMrootDomain::restoreUserSpinDownTimeout( void )
{
ASSERT_GATED();
setAggressiveness(
kPMMinutesToSpinDown, 0, kAggressivesOptionQuickSpindownDisable );
}
IOReturn IOPMrootDomain::changePowerStateTo( unsigned long ordinal )
{
return kIOReturnUnsupported; }
IOReturn IOPMrootDomain::changePowerStateToPriv( unsigned long ordinal )
{
DLOG("changePowerStateToPriv(%lu)\n", ordinal);
if ( (getPowerState() == DOZE_STATE) && (ordinal != ON_STATE) )
{
return kIOReturnSuccess;
}
if ( (userDisabledAllSleep || systemBooting || systemShutdown) &&
(ordinal == SLEEP_STATE) )
{
DLOG("SLEEP rejected, forced to ON state (UD %d, SB %d, SS %d)\n",
userDisabledAllSleep, systemBooting, systemShutdown);
super::changePowerStateToPriv(ON_STATE);
}
return super::changePowerStateToPriv(ordinal);
}
bool IOPMrootDomain::activitySinceSleep(void)
{
return (userActivityCount != userActivityAtSleep);
}
bool IOPMrootDomain::abortHibernation(void)
{
bool ret = activitySinceSleep();
if (ret && !hibernateAborted)
{
DLOG("activitySinceSleep ABORT [%d, %d]\n", userActivityCount, userActivityAtSleep);
hibernateAborted = true;
}
return (ret);
}
extern "C" int
hibernate_should_abort(void)
{
if (gRootDomain)
return (gRootDomain->abortHibernation());
else
return (0);
}
void IOPMrootDomain::updateRunState( uint32_t inRunState )
{
#if ROOT_DOMAIN_RUN_STATES
if (inRunState < kRStateCount)
{
runStateIndex = nextRunStateIndex = inRunState;
runStateFlags = gRStateFlags[inRunState];
setProperty(
kIOPMRootDomainRunStateKey,
(unsigned long long) inRunState, 32);
}
#endif
}
#if ROOT_DOMAIN_RUN_STATES
void IOPMrootDomain::tagPowerPlaneService(
IOService * service,
uint32_t * rdFlags )
{
*rdFlags = 0;
if (service->getProperty("IOPMStrictTreeOrder") ||
service->metaCast("IODisplayWrangler") ||
OSDynamicCast(OSNumber,
service->getProperty("IOPMUnattendedWakePowerState")))
{
*rdFlags |= kServiceFlagGraphics;
DLOG("tagged device %s %x\n", service->getName(), *rdFlags);
}
if (!pciHostBridgeDevice && service->metaCast("IOPCIBridge"))
{
IOService * provider = service->getProvider();
if (OSDynamicCast(IOPlatformDevice, provider) &&
provider->inPlane(gIODTPlane))
{
pciHostBridgeDevice = provider;
DLOG("PMTrace found PCI host bridge %s->%s\n",
provider->getName(), service->getName());
}
}
if (pciHostBridgeDevice && service->metaCast("IOPCIDevice"))
{
IORegistryEntry * parent = service->getParentEntry(gIODTPlane);
if ((parent == pciHostBridgeDevice) && service->getProperty("acpi-device"))
{
int bit = pmTracer->recordTopLevelPCIDevice( service );
if (bit >= 0)
{
bit &= 0xff;
*rdFlags |= (kServiceFlagTopLevelPCI | (bit << 8));
}
}
}
}
void IOPMrootDomain::handleActivityTickleForService( IOService * service,
unsigned long type,
unsigned long currentPowerState,
uint32_t activityTickleCount )
{
if ((service == wrangler)
)
{
bool aborting = ((lastSleepReason == kIOPMSleepReasonIdle)
|| (lastSleepReason == kIOPMSleepReasonMaintenance));
if (aborting) userActivityCount++;
DLOG("display wrangler tickled1 %d lastSleepReason %d\n", userActivityCount, lastSleepReason);
}
if ((!currentPowerState) &&
(service == wrangler) &&
(runStateIndex > kRStateNormal) &&
(false == wranglerTickled) &&
(false == lowBatteryCondition))
{
DLOG("display wrangler tickled\n");
if (kIOLogPMRootDomain & gIOKitDebug)
OSReportWithBacktrace("Display Tickle");
wranglerTickled = true;
synchronizePowerTree();
}
}
void IOPMrootDomain::handlePowerChangeStartForService(
IOService * service,
uint32_t * rdFlags,
uint32_t newPowerState,
uint32_t changeFlags )
{
if (service == this)
{
uint32_t currentPowerState = (uint32_t) getPowerState();
uint32_t nextRunStateFlags;
assert(nextRunStateIndex < kRStateCount);
nextRunStateFlags = gRStateFlags[nextRunStateIndex];
gMessageClientType = kMessageClientNone;
if ((currentPowerState != newPowerState) &&
((ON_STATE == newPowerState) || (ON_STATE == currentPowerState)))
{
if ((runStateFlags & kRStateFlagSuppressMessages) == 0)
gMessageClientType = kMessageClientAll;
else
gMessageClientType = kMessageClientConfigd;
}
if ((ON_STATE == newPowerState) &&
(ON_STATE == currentPowerState) &&
((runStateFlags ^ nextRunStateFlags) & kRStateFlagSuppressMessages))
{
gMessageClientType = kMessageClientAll;
}
if (ON_STATE == newPowerState)
{
DLOG("kIOMessageSystemWillPowerOn (%d)\n",
gMessageClientType);
tellClients(kIOMessageSystemWillPowerOn, clientMessageFilter);
}
if (SLEEP_STATE == newPowerState)
{
tracePoint(kIOPMTracePointSleepStarted);
}
}
if (*rdFlags & kServiceFlagTopLevelPCI)
{
pmTracer->tracePCIPowerChange(
PMTraceWorker::kPowerChangeStart,
service, changeFlags,
(*rdFlags >> 8) & 0xff);
}
}
void IOPMrootDomain::handlePowerChangeDoneForService(
IOService * service,
uint32_t * rdFlags,
uint32_t newPowerState,
uint32_t changeFlags )
{
if (*rdFlags & kServiceFlagTopLevelPCI)
{
pmTracer->tracePCIPowerChange(
PMTraceWorker::kPowerChangeCompleted,
service, changeFlags,
(*rdFlags >> 8) & 0xff);
}
}
void IOPMrootDomain::overridePowerStateForService(
IOService * service,
uint32_t * rdFlags,
unsigned long * powerState,
uint32_t changeFlags )
{
uint32_t inPowerState = (uint32_t) *powerState;
if ((service == this) && (inPowerState == ON_STATE) &&
(changeFlags & kIOPMSynchronize))
{
DLOG("sync root domain %u->%u\n",
(uint32_t) getPowerState(), inPowerState);
if (runStateIndex != kRStateNormal)
{
sleepTimerMaintenance = false;
hibernateNoDefeat = false;
nextRunStateIndex = kRStateNormal;
setProperty(
kIOPMRootDomainRunStateKey,
(unsigned long long) kRStateNormal, 32);
}
}
if (*rdFlags & kServiceFlagGraphics)
{
DLOG("graphics device %s %u->%u (flags 0x%x)\n",
service->getName(), (uint32_t) service->getPowerState(),
inPowerState, changeFlags);
if (inPowerState == 0)
{
if ((*rdFlags & kServiceFlagNoPowerUp) == 0)
{
*rdFlags |= kServiceFlagNoPowerUp;
DLOG("asserted power limit for %s\n",
service->getName());
}
}
else
{
uint32_t nextRunStateFlags;
assert(nextRunStateIndex < kRStateCount);
nextRunStateFlags = gRStateFlags[nextRunStateIndex];
if (changeFlags & kIOPMSynchronize)
{
if ((runStateFlags & kRStateFlagSuppressGraphics) &&
((nextRunStateFlags & kRStateFlagSuppressGraphics) == 0) &&
(changeFlags & kIOPMDomainDidChange))
{
*rdFlags &= ~kServiceFlagNoPowerUp;
DLOG("removed power limit for %s\n",
service->getName());
}
}
else if ((runStateFlags & kRStateFlagSuppressGraphics) == 0)
{
*rdFlags &= ~kServiceFlagNoPowerUp;
}
if (*rdFlags & kServiceFlagNoPowerUp)
{
DLOG("limited %s to power state 0\n",
service->getName());
*powerState = 0;
}
}
}
}
IOReturn IOPMrootDomain::setMaintenanceWakeCalendar(
const IOPMCalendarStruct * calendar )
{
OSData * data;
IOReturn ret;
if (!calendar)
return kIOReturnBadArgument;
data = OSData::withBytesNoCopy((void *) calendar, sizeof(*calendar));
if (!data)
return kIOReturnNoMemory;
ret = setPMSetting(gIOPMSettingMaintenanceWakeCalendarKey, data);
data->release();
return ret;
}
#endif
IOReturn IOPMrootDomain::sysPowerDownHandler( void * target, void * refCon,
UInt32 messageType, IOService * service,
void * messageArgument, vm_size_t argSize )
{
IOReturn ret;
IOPowerStateChangeNotification *params = (IOPowerStateChangeNotification *) messageArgument;
IOPMrootDomain *rootDomain = OSDynamicCast(IOPMrootDomain, service);
DLOG("sysPowerDownHandler message %x\n", (uint32_t) messageType);
if(!rootDomain)
return kIOReturnUnsupported;
switch (messageType) {
case kIOMessageSystemWillSleep:
#if HIBERNATION
rootDomain->evaluateSystemSleepPolicyEarly();
if (rootDomain->hibernateMode && !rootDomain->hibernateDisabled)
{
params->returnValue = 240 * 1000 * 1000;
}
else
#endif
params->returnValue = 20 * 1000 * 1000;
DLOG("sysPowerDownHandler timeout %d s\n", (int) (params->returnValue / 1000 / 1000));
if ( ! OSCompareAndSwap( 0, 1, &gSleepOrShutdownPending ) )
{
AbsoluteTime deadline;
clock_interval_to_deadline( 30, kSecondScale, &deadline );
thread_call_enter1_delayed( rootDomain->diskSyncCalloutEntry,
(thread_call_param_t)params->powerRef,
deadline );
}
else
thread_call_enter1(rootDomain->diskSyncCalloutEntry, (thread_call_param_t)params->powerRef);
ret = kIOReturnSuccess;
break;
case kIOMessageSystemWillPowerOff:
case kIOMessageSystemWillRestart:
ret = kIOReturnUnsupported;
break;
default:
ret = kIOReturnUnsupported;
break;
}
return ret;
}
void IOPMrootDomain::publishSleepWakeUUID( bool shouldPublish )
{
if (shouldPublish)
{
if (queuedSleepWakeUUIDString)
{
if (OSCompareAndSwap( true, false, &gSleepWakeUUIDIsSet))
{
messageClients( kIOPMMessageSleepWakeUUIDChange,
kIOPMMessageSleepWakeUUIDCleared );
DLOG("SleepWake UUID forced clear\n");
}
setProperty(kIOPMSleepWakeUUIDKey, queuedSleepWakeUUIDString);
DLOG("SleepWake UUID published: %s\n", queuedSleepWakeUUIDString->getCStringNoCopy());
queuedSleepWakeUUIDString->release();
queuedSleepWakeUUIDString = NULL;
messageClients(kIOPMMessageSleepWakeUUIDChange,
kIOPMMessageSleepWakeUUIDSet);
}
} else {
if (OSCompareAndSwap( true, false, &gSleepWakeUUIDIsSet))
{
DLOG("SleepWake UUID cleared\n");
removeProperty(kIOPMSleepWakeUUIDKey);
messageClients(kIOPMMessageSleepWakeUUIDChange,
kIOPMMessageSleepWakeUUIDCleared);
}
}
}
IOReturn IOPMrootDomain::displayWranglerNotification(
void * target, void * refCon,
UInt32 messageType, IOService * service,
void * messageArgument, vm_size_t argSize )
{
#if !NO_KERNEL_HID
int displayPowerState;
IOPowerStateChangeNotification * params =
(IOPowerStateChangeNotification *) messageArgument;
if ((messageType != kIOMessageDeviceWillPowerOff) &&
(messageType != kIOMessageDeviceHasPoweredOn))
return kIOReturnUnsupported;
ASSERT_GATED();
if (!gRootDomain)
return kIOReturnUnsupported;
displayPowerState = params->stateNumber;
DLOG("DisplayWrangler message 0x%x, new power state %d\n",
(uint32_t) messageType, displayPowerState);
switch (messageType) {
case kIOMessageDeviceWillPowerOff:
if (gRootDomain->wranglerAsleep || (displayPowerState > 2))
break;
gRootDomain->wranglerAsleep = true;
clock_get_uptime(&gRootDomain->wranglerSleepTime);
if ( gRootDomain->extraSleepDelay )
{
gRootDomain->startIdleSleepTimer(gRootDomain->extraSleepDelay * 60);
}
else if ( gRootDomain->sleepSlider )
{
gRootDomain->setQuickSpinDownTimeout();
}
break;
case kIOMessageDeviceHasPoweredOn:
if ( 4 != displayPowerState )
break;
gRootDomain->wranglerAsleep = false;
gRootDomain->adjustPowerState();
gRootDomain->cancelIdleSleepTimer();
gRootDomain->restoreUserSpinDownTimeout();
break;
default:
break;
}
#endif
return kIOReturnUnsupported;
}
bool IOPMrootDomain::displayWranglerPublished(
void * target,
void * refCon,
IOService * newService)
{
#if !NO_KERNEL_HID
if(!gRootDomain)
return false;
gRootDomain->wrangler = newService;
if( !gRootDomain->wrangler->registerInterest( gIOGeneralInterest,
&displayWranglerNotification, target, 0) )
{
return false;
}
#endif
return true;
}
bool IOPMrootDomain::batteryPublished(
void * target,
void * root_domain,
IOService * resourceService )
{
((IOPMrootDomain *)root_domain)->publishFeature("DisplayDims");
return (true);
}
void IOPMrootDomain::adjustPowerState( void )
{
DLOG("adjustPowerState "
"PS %u, ASAP %d, SL %ld, AS %d, SB %d, SS %d, UD %d\n",
(uint32_t) getPowerState(), sleepASAP, sleepSlider,
allowSleep, systemBooting, systemShutdown, userDisabledAllSleep);
ASSERT_GATED();
if ( (sleepSlider == 0)
|| !allowSleep
|| systemBooting
|| systemShutdown
|| userDisabledAllSleep
|| (runStateFlags & kRStateFlagDisableIdleSleep) )
{
changePowerStateToPriv(ON_STATE);
} else {
if ( sleepASAP )
{
lastSleepReason = kIOPMSleepReasonIdle;
setProperty(kRootDomainSleepReasonKey, kIOPMIdleSleepKey);
sleepASAP = false;
changePowerStateToPriv(SLEEP_STATE);
}
}
}
void IOPMrootDomain::pmStatsRecordEvent(
int eventIndex,
AbsoluteTime timestamp)
{
bool starting = eventIndex & kIOPMStatsEventStartFlag ? true:false;
bool stopping = eventIndex & kIOPMStatsEventStopFlag ? true:false;
uint64_t delta;
uint64_t nsec;
eventIndex &= ~(kIOPMStatsEventStartFlag | kIOPMStatsEventStopFlag);
absolutetime_to_nanoseconds(timestamp, &nsec);
switch (eventIndex) {
case kIOPMStatsHibernateImageWrite:
if (starting)
pmStats.hibWrite.start = nsec;
else if (stopping)
pmStats.hibWrite.stop = nsec;
if (stopping) {
delta = pmStats.hibWrite.stop - pmStats.hibWrite.start;
IOLog("PMStats: Hibernate write took %qd ms\n", delta/1000000ULL);
}
break;
case kIOPMStatsHibernateImageRead:
if (starting)
pmStats.hibRead.start = nsec;
else if (stopping)
pmStats.hibRead.stop = nsec;
if (stopping) {
delta = pmStats.hibRead.stop - pmStats.hibRead.start;
IOLog("PMStats: Hibernate read took %qd ms\n", delta/1000000ULL);
}
break;
}
}
void IOPMrootDomain::pmStatsRecordApplicationResponse(
const OSSymbol *response,
const char *name,
int messageType,
uint32_t delay_ms,
int app_pid)
{
OSDictionary *responseDescription = NULL;
OSNumber *delayNum = NULL;
OSNumber *pidNum = NULL;
OSNumber *msgNum = NULL;
const OSSymbol *appname;
const OSSymbol *entryName;
OSObject *entryType;
int i;
if (!pmStatsAppResponses || pmStatsAppResponses->getCount() > 50)
return;
i = 0;
while ((responseDescription = (OSDictionary *) pmStatsAppResponses->getObject(i++)))
{
entryType = responseDescription->getObject(_statsResponseTypeKey);
entryName = (OSSymbol *) responseDescription->getObject(_statsNameKey);
if (entryName && (entryType == response) && entryName->isEqualTo(name))
{
OSNumber * entryValue;
entryValue = (OSNumber *) responseDescription->getObject(_statsTimeMSKey);
if (entryValue && (entryValue->unsigned32BitValue() < delay_ms))
entryValue->setValue(delay_ms);
return;
}
}
responseDescription = OSDictionary::withCapacity(5);
if (responseDescription)
{
if (response) {
responseDescription->setObject(_statsResponseTypeKey, response);
}
if (messageType != 0) {
msgNum = OSNumber::withNumber(messageType, 32);
if (msgNum) {
responseDescription->setObject(_statsMessageTypeKey, msgNum);
msgNum->release();
}
}
if (name && (strlen(name) > 0))
{
appname = OSSymbol::withCString(name);
if (appname) {
responseDescription->setObject(_statsNameKey, appname);
appname->release();
}
}
if (app_pid != -1) {
pidNum = OSNumber::withNumber(app_pid, 32);
if (pidNum) {
responseDescription->setObject(_statsPIDKey, pidNum);
pidNum->release();
}
}
delayNum = OSNumber::withNumber(delay_ms, 32);
if (delayNum) {
responseDescription->setObject(_statsTimeMSKey, delayNum);
delayNum->release();
}
if (pmStatsAppResponses) {
pmStatsAppResponses->setObject(responseDescription);
}
responseDescription->release();
}
return;
}
#define kIOPMRegisterNVRAMTracePointHandlerKey \
"IOPMRegisterNVRAMTracePointHandler"
IOReturn IOPMrootDomain::callPlatformFunction(
const OSSymbol * functionName,
bool waitForFunction,
void * param1, void * param2,
void * param3, void * param4 )
{
if (pmTracer && functionName &&
functionName->isEqualTo(kIOPMRegisterNVRAMTracePointHandlerKey) &&
!pmTracer->tracePointHandler && !pmTracer->tracePointTarget)
{
uint32_t tracePointPhases, tracePointPCI;
uint64_t statusCode;
pmTracer->tracePointHandler = (IOPMTracePointHandler) param1;
pmTracer->tracePointTarget = (void *) param2;
tracePointPCI = (uint32_t)(uintptr_t) param3;
tracePointPhases = (uint32_t)(uintptr_t) param4;
statusCode = (((uint64_t)tracePointPCI) << 32) | tracePointPhases;
if ((tracePointPhases >> 24) != kIOPMTracePointSystemUp)
{
LOG("Sleep failure code 0x%08x 0x%08x\n",
tracePointPCI, tracePointPhases);
}
setProperty(kIOPMSleepWakeFailureCodeKey, statusCode, 64);
pmTracer->tracePointHandler( pmTracer->tracePointTarget, 0, 0 );
return kIOReturnSuccess;
}
return super::callPlatformFunction(
functionName, waitForFunction, param1, param2, param3, param4);
}
void IOPMrootDomain::tracePoint( uint8_t point )
{
pmTracer->tracePoint(point);
}
#undef super
#define super OSObject
OSDefineMetaClassAndStructors(PMTraceWorker, OSObject)
#define kPMBestGuessPCIDevicesCount 25
#define kPMMaxRTCBitfieldSize 32
PMTraceWorker *PMTraceWorker::tracer(IOPMrootDomain *owner)
{
PMTraceWorker *me;
me = OSTypeAlloc( PMTraceWorker );
if (!me || !me->init())
{
return NULL;
}
DLOG("PMTraceWorker %p\n", me);
me->owner = owner;
me->pciDeviceBitMappings = NULL;
me->pciMappingLock = IOLockAlloc();
me->tracePhase = kIOPMTracePointSystemUp;
me->loginWindowPhase = 0;
me->pciBusyBitMask = 0;
return me;
}
void PMTraceWorker::RTC_TRACE(void)
{
if (tracePointHandler && tracePointTarget)
{
uint32_t wordA;
wordA = tracePhase; wordA <<= 8;
wordA |= loginWindowPhase; wordA <<= 16;
tracePointHandler( tracePointTarget, pciBusyBitMask, wordA );
DLOG("RTC_TRACE wrote 0x%08x 0x%08x\n", pciBusyBitMask, wordA);
}
}
int PMTraceWorker::recordTopLevelPCIDevice(IOService * pciDevice)
{
const OSSymbol * deviceName;
int index = -1;
IOLockLock(pciMappingLock);
if (!pciDeviceBitMappings)
{
pciDeviceBitMappings = OSArray::withCapacity(kPMBestGuessPCIDevicesCount);
if (!pciDeviceBitMappings)
goto exit;
}
if (pciDeviceBitMappings->getCount() >= kPMMaxRTCBitfieldSize)
goto exit;
if ((deviceName = pciDevice->copyName()) &&
(pciDeviceBitMappings->getNextIndexOfObject(deviceName, 0) == (unsigned int)-1) &&
pciDeviceBitMappings->setObject(deviceName))
{
index = pciDeviceBitMappings->getCount() - 1;
DLOG("PMTrace PCI array: set object %s => %d\n",
deviceName->getCStringNoCopy(), index);
}
if (deviceName)
deviceName->release();
if (!addedToRegistry && (index >= 0))
addedToRegistry = owner->setProperty("PCITopLevel", this);
exit:
IOLockUnlock(pciMappingLock);
return index;
}
bool PMTraceWorker::serialize(OSSerialize *s) const
{
bool ok = false;
if (pciDeviceBitMappings)
{
IOLockLock(pciMappingLock);
ok = pciDeviceBitMappings->serialize(s);
IOLockUnlock(pciMappingLock);
}
return ok;
}
void PMTraceWorker::tracePoint(uint8_t phase)
{
tracePhase = phase;
DLOG("IOPMrootDomain: trace point 0x%02x\n", tracePhase);
RTC_TRACE();
}
void PMTraceWorker::traceLoginWindowPhase(uint8_t phase)
{
loginWindowPhase = phase;
DLOG("IOPMrootDomain: loginwindow tracepoint 0x%02x\n", loginWindowPhase);
RTC_TRACE();
}
void PMTraceWorker::tracePCIPowerChange(
change_t type, IOService *service, uint32_t changeFlags, uint32_t bitNum)
{
uint32_t bitMask;
uint32_t expectedFlag;
if ((kIOPMTracePointSystemSleepDriversPhase != tracePhase) &&
(kIOPMTracePointSystemWakeDriversPhase != tracePhase))
return;
changeFlags &= (kIOPMDomainWillChange | kIOPMDomainDidChange);
expectedFlag = (kIOPMTracePointSystemSleepDriversPhase == tracePhase) ?
kIOPMDomainWillChange : kIOPMDomainDidChange;
if (changeFlags != expectedFlag)
return;
if (bitNum < kPMMaxRTCBitfieldSize)
{
bitMask = (1 << bitNum);
if (kPowerChangeStart == type)
{
pciBusyBitMask |= bitMask;
DLOG("PMTrace: Device %s started - bit %2d mask 0x%08x => 0x%08x\n",
service->getName(), bitNum, bitMask, pciBusyBitMask);
}
else
{
pciBusyBitMask &= ~bitMask;
DLOG("PMTrace: Device %s finished - bit %2d mask 0x%08x => 0x%08x\n",
service->getName(), bitNum, bitMask, pciBusyBitMask);
}
RTC_TRACE();
}
}
static unsigned int gPMHaltBusyCount;
static unsigned int gPMHaltIdleCount;
static int gPMHaltDepth;
static unsigned long gPMHaltEvent;
static IOLock * gPMHaltLock = 0;
static OSArray * gPMHaltArray = 0;
static const OSSymbol * gPMHaltClientAcknowledgeKey = 0;
PMHaltWorker * PMHaltWorker::worker( void )
{
PMHaltWorker * me;
IOThread thread;
do {
me = OSTypeAlloc( PMHaltWorker );
if (!me || !me->init())
break;
me->lock = IOLockAlloc();
if (!me->lock)
break;
DLOG("PMHaltWorker %p\n", me);
me->retain(); if (KERN_SUCCESS != kernel_thread_start(&PMHaltWorker::main, (void *) me, &thread))
{
me->release();
break;
}
thread_deallocate(thread);
return me;
} while (false);
if (me) me->release();
return 0;
}
void PMHaltWorker::free( void )
{
DLOG("PMHaltWorker free %p\n", this);
if (lock)
{
IOLockFree(lock);
lock = 0;
}
return OSObject::free();
}
void PMHaltWorker::main( void * arg, wait_result_t waitResult )
{
PMHaltWorker * me = (PMHaltWorker *) arg;
IOLockLock( gPMHaltLock );
gPMHaltBusyCount++;
me->depth = gPMHaltDepth;
IOLockUnlock( gPMHaltLock );
while (me->depth >= 0)
{
PMHaltWorker::work( me );
IOLockLock( gPMHaltLock );
if (++gPMHaltIdleCount >= gPMHaltBusyCount)
{
gPMHaltDepth--;
me->depth = gPMHaltDepth;
gPMHaltIdleCount = 0;
thread_wakeup((event_t) &gPMHaltIdleCount);
}
else
{
me->depth = gPMHaltDepth - 1;
do {
IOLockSleep(gPMHaltLock, &gPMHaltIdleCount, THREAD_UNINT);
} while (me->depth != gPMHaltDepth);
}
IOLockUnlock( gPMHaltLock );
}
DLOG("All done for worker: %p (visits = %u)\n", me, me->visits);
thread_wakeup( &gPMHaltDepth );
me->release();
}
void PMHaltWorker::work( PMHaltWorker * me )
{
IOService * service;
OSSet * inner;
AbsoluteTime startTime;
UInt32 deltaTime;
bool timeout;
while (true)
{
service = 0;
timeout = false;
IOLockLock( gPMHaltLock );
inner = (OSSet *)gPMHaltArray->getObject(me->depth);
if (inner)
{
service = (IOService *)inner->getAnyObject();
if (service)
{
service->retain();
inner->removeObject(service);
}
}
IOLockUnlock( gPMHaltLock );
if (!service)
break;
clock_get_uptime(&startTime);
if (!service->isInactive() &&
service->setProperty(gPMHaltClientAcknowledgeKey, me))
{
IOLockLock(me->lock);
me->startTime = startTime;
me->service = service;
me->timeout = false;
IOLockUnlock(me->lock);
service->systemWillShutdown( gPMHaltEvent );
IOLockLock(me->lock);
while (service->getProperty(gPMHaltClientAcknowledgeKey))
{
IOLockSleep(me->lock, me, THREAD_UNINT);
}
me->service = 0;
timeout = me->timeout;
IOLockUnlock(me->lock);
}
deltaTime = computeDeltaTimeMS(&startTime);
if ((deltaTime > kPMHaltTimeoutMS) || timeout ||
(gIOKitDebug & (kIOLogDebugPower | kIOLogPMRootDomain)))
{
KLOG("%s driver %s (%p) took %u ms\n",
(gPMHaltEvent == kIOMessageSystemWillPowerOff) ?
"PowerOff" : "Restart",
service->getName(), service,
(uint32_t) deltaTime );
}
service->release();
me->visits++;
}
}
void PMHaltWorker::checkTimeout( PMHaltWorker * me, AbsoluteTime * now )
{
UInt64 nano;
AbsoluteTime startTime;
AbsoluteTime endTime;
endTime = *now;
IOLockLock(me->lock);
if (me->service && !me->timeout)
{
startTime = me->startTime;
nano = 0;
if (CMP_ABSOLUTETIME(&endTime, &startTime) > 0)
{
SUB_ABSOLUTETIME(&endTime, &startTime);
absolutetime_to_nanoseconds(endTime, &nano);
}
if (nano > 3000000000ULL)
{
me->timeout = true;
LOG("%s still waiting on %s\n",
(gPMHaltEvent == kIOMessageSystemWillPowerOff) ?
"PowerOff" : "Restart",
me->service->getName());
}
}
IOLockUnlock(me->lock);
}
void IOPMrootDomain::acknowledgeSystemWillShutdown( IOService * from )
{
PMHaltWorker * worker;
OSObject * prop;
if (!from)
return;
prop = from->copyProperty( gPMHaltClientAcknowledgeKey );
if (prop)
{
worker = (PMHaltWorker *) prop;
IOLockLock(worker->lock);
from->removeProperty( gPMHaltClientAcknowledgeKey );
thread_wakeup((event_t) worker);
IOLockUnlock(worker->lock);
worker->release();
}
else
{
DLOG("%s acknowledged without worker property\n",
from->getName());
}
}
static void
notifySystemShutdown( IOService * root, unsigned long event )
{
#define PLACEHOLDER ((OSSet *)gPMHaltArray)
IORegistryIterator * iter;
IORegistryEntry * entry;
IOService * node;
OSSet * inner;
PMHaltWorker * workers[kPMHaltMaxWorkers];
AbsoluteTime deadline;
unsigned int totalNodes = 0;
unsigned int depth;
unsigned int rootDepth;
unsigned int numWorkers;
unsigned int count;
int waitResult;
void * baseFunc;
bool ok;
DLOG("%s event = %lx\n", __FUNCTION__, event);
baseFunc = OSMemberFunctionCast(void *, root, &IOService::systemWillShutdown);
rootDepth = root->getDepth( gIOPowerPlane );
if (!rootDepth) goto done;
while (PMHaltWorker::metaClass->getInstanceCount())
IOSleep(1);
if (!gPMHaltArray)
{
gPMHaltArray = OSArray::withCapacity(40);
if (!gPMHaltArray) goto done;
}
else gPMHaltArray->flushCollection();
if (!gPMHaltLock)
{
gPMHaltLock = IOLockAlloc();
if (!gPMHaltLock) goto done;
}
if (!gPMHaltClientAcknowledgeKey)
{
gPMHaltClientAcknowledgeKey =
OSSymbol::withCStringNoCopy("PMShutdown");
if (!gPMHaltClientAcknowledgeKey) goto done;
}
gPMHaltEvent = event;
iter = IORegistryIterator::iterateOver(
root, gIOPowerPlane, kIORegistryIterateRecursively);
if (iter)
{
while ((entry = iter->getNextObject()))
{
node = OSDynamicCast(IOService, entry);
if (!node)
continue;
if (baseFunc ==
OSMemberFunctionCast(void *, node, &IOService::systemWillShutdown))
continue;
depth = node->getDepth( gIOPowerPlane );
if (depth <= rootDepth)
continue;
ok = false;
depth -= (rootDepth + 1);
count = gPMHaltArray->getCount();
while (depth >= count)
{
gPMHaltArray->setObject(PLACEHOLDER);
count++;
}
count = gPMHaltArray->getCount();
if (depth < count)
{
inner = (OSSet *)gPMHaltArray->getObject(depth);
if (inner == PLACEHOLDER)
{
inner = OSSet::withCapacity(40);
if (inner)
{
gPMHaltArray->replaceObject(depth, inner);
inner->release();
}
}
if (inner)
ok = inner->setObject(node);
}
if (!ok)
DLOG("Skipped PM node %s\n", node->getName());
}
iter->release();
}
for (int i = 0; (inner = (OSSet *)gPMHaltArray->getObject(i)); i++)
{
count = 0;
if (inner != PLACEHOLDER)
count = inner->getCount();
DLOG("Nodes at depth %u = %u\n", i, count);
}
numWorkers = 0;
for (int i = 0; (inner = (OSSet *)gPMHaltArray->getObject(i)); )
{
if (inner == PLACEHOLDER)
{
gPMHaltArray->removeObject(i);
continue;
}
count = inner->getCount();
if (count > numWorkers)
numWorkers = count;
totalNodes += count;
i++;
}
if (gPMHaltArray->getCount() == 0 || !numWorkers)
goto done;
gPMHaltBusyCount = 0;
gPMHaltIdleCount = 0;
gPMHaltDepth = gPMHaltArray->getCount() - 1;
if (numWorkers > kPMHaltMaxWorkers)
numWorkers = kPMHaltMaxWorkers;
DLOG("PM nodes = %u, maxDepth = %u, workers = %u\n",
totalNodes, gPMHaltArray->getCount(), numWorkers);
for (unsigned int i = 0; i < numWorkers; i++)
workers[i] = PMHaltWorker::worker();
IOLockLock(gPMHaltLock);
while (gPMHaltDepth >= 0)
{
clock_interval_to_deadline(1000, kMillisecondScale, &deadline);
waitResult = IOLockSleepDeadline(
gPMHaltLock, &gPMHaltDepth, deadline, THREAD_UNINT);
if (THREAD_TIMED_OUT == waitResult)
{
AbsoluteTime now;
clock_get_uptime(&now);
IOLockUnlock(gPMHaltLock);
for (unsigned int i = 0 ; i < numWorkers; i++)
{
if (workers[i])
PMHaltWorker::checkTimeout(workers[i], &now);
}
IOLockLock(gPMHaltLock);
}
}
IOLockUnlock(gPMHaltLock);
for (unsigned int i = 0; i < numWorkers; i++)
{
if (workers[i])
workers[i]->release();
}
done:
DLOG("%s done\n", __FUNCTION__);
return;
}
IOPMDriverAssertionID IOPMrootDomain::createPMAssertion(
IOPMDriverAssertionType whichAssertionBits,
IOPMDriverAssertionLevel assertionLevel,
IOService *ownerService,
const char *ownerDescription)
{
IOReturn ret;
IOPMDriverAssertionID newAssertion;
if (!pmAssertions)
return 0;
ret = pmAssertions->createAssertion(whichAssertionBits, assertionLevel, ownerService, ownerDescription, &newAssertion);
if (kIOReturnSuccess == ret)
return newAssertion;
else
return 0;
}
IOReturn IOPMrootDomain::releasePMAssertion(IOPMDriverAssertionID releaseAssertion)
{
if (!pmAssertions)
return kIOReturnInternalError;
return pmAssertions->releaseAssertion(releaseAssertion);
}
IOReturn IOPMrootDomain::setPMAssertionLevel(
IOPMDriverAssertionID assertionID,
IOPMDriverAssertionLevel assertionLevel)
{
return pmAssertions->setAssertionLevel(assertionID, assertionLevel);
}
IOPMDriverAssertionLevel IOPMrootDomain::getPMAssertionLevel(IOPMDriverAssertionType whichAssertion)
{
IOPMDriverAssertionType sysLevels;
if (!pmAssertions || whichAssertion == 0)
return kIOPMDriverAssertionLevelOff;
sysLevels = pmAssertions->getActivatedAssertions();
if ((sysLevels & whichAssertion) == whichAssertion)
return kIOPMDriverAssertionLevelOn;
else
return kIOPMDriverAssertionLevelOff;
}
IOReturn IOPMrootDomain::setPMAssertionUserLevels(IOPMDriverAssertionType inLevels)
{
if (!pmAssertions)
return kIOReturnNotFound;
return pmAssertions->setUserAssertionLevels(inLevels);
}
bool IOPMrootDomain::serializeProperties( OSSerialize * s ) const
{
if (pmAssertions)
{
pmAssertions->publishProperties();
}
return( IOService::serializeProperties(s) );
}
#undef super
#define super OSObject
OSDefineMetaClassAndFinalStructors(PMSettingObject, OSObject)
void PMSettingObject::setPMSetting(const OSSymbol *type, OSObject *obj)
{
(*func)(target, type, obj, refcon);
}
PMSettingObject *PMSettingObject::pmSettingObject(
IOPMrootDomain *parent_arg,
IOPMSettingControllerCallback handler_arg,
OSObject *target_arg,
uintptr_t refcon_arg,
uint32_t supportedPowerSources,
const OSSymbol * settings[])
{
uint32_t objCount = 0;
PMSettingObject *pmso;
if( !parent_arg || !handler_arg || !settings ) return NULL;
while( settings[objCount] ) {
objCount++;
}
if(0 == objCount) return NULL;
pmso = new PMSettingObject;
if(!pmso || !pmso->init()) return NULL;
pmso->parent = parent_arg;
pmso->func = handler_arg;
pmso->target = target_arg;
pmso->refcon = refcon_arg;
pmso->releaseAtCount = objCount + 1;
pmso->publishedFeatureID = (uint32_t *)IOMalloc(sizeof(uint32_t)*objCount);
if(pmso->publishedFeatureID) {
for(unsigned int i=0; i<objCount; i++) {
parent_arg->publishFeature( settings[i]->getCStringNoCopy(),
supportedPowerSources, &pmso->publishedFeatureID[i] );
}
}
return pmso;
}
void PMSettingObject::free(void)
{
OSCollectionIterator *settings_iter;
OSSymbol *sym;
OSArray *arr;
int arr_idx;
int i;
int objCount = releaseAtCount - 1;
if(publishedFeatureID) {
for(i=0; i<objCount; i++) {
if(0 != publishedFeatureID[i]) {
parent->removePublishedFeature( publishedFeatureID[i] );
}
}
IOFree(publishedFeatureID, sizeof(uint32_t) * objCount);
}
IORecursiveLockLock(parent->settingsCtrlLock);
settings_iter = OSCollectionIterator::withCollection(parent->settingsCallbacks);
if(settings_iter)
{
while(( sym = OSDynamicCast(OSSymbol, settings_iter->getNextObject()) ))
{
arr = (OSArray *)parent->settingsCallbacks->getObject(sym);
arr_idx = arr->getNextIndexOfObject(this, 0);
if(-1 != arr_idx) {
arr->removeObject(arr_idx);
}
}
settings_iter->release();
}
IORecursiveLockUnlock(parent->settingsCtrlLock);
super::free();
}
void PMSettingObject::taggedRelease(const void *tag, const int when) const
{
super::taggedRelease(tag, releaseAtCount);
}
#define kAssertUniqueIDStart 500
PMAssertionsTracker *PMAssertionsTracker::pmAssertionsTracker( IOPMrootDomain *rootDomain )
{
PMAssertionsTracker *myself;
myself = new PMAssertionsTracker;
if (myself) {
myself->init();
myself->owner = rootDomain;
myself->issuingUniqueID = kAssertUniqueIDStart;
myself->assertionsArray = OSArray::withCapacity(5);
myself->assertionsKernel = 0;
myself->assertionsUser = 0;
myself->assertionsCombined = 0;
myself->assertionsArrayLock = IOLockAlloc();
myself->tabulateProducerCount = myself->tabulateConsumerCount = 0;
if (!myself->assertionsArray || !myself->assertionsArrayLock)
myself = NULL;
}
return myself;
}
void PMAssertionsTracker::tabulate(void)
{
int i;
int count;
PMAssertStruct *_a = NULL;
OSData *_d = NULL;
IOPMDriverAssertionType oldKernel = assertionsKernel;
IOPMDriverAssertionType oldCombined = assertionsCombined;
ASSERT_GATED();
assertionsKernel = 0;
assertionsCombined = 0;
if (!assertionsArray)
return;
if ((count = assertionsArray->getCount()))
{
for (i=0; i<count; i++)
{
_d = OSDynamicCast(OSData, assertionsArray->getObject(i));
if (_d)
{
_a = (PMAssertStruct *)_d->getBytesNoCopy();
if (_a && (kIOPMDriverAssertionLevelOn == _a->level))
assertionsKernel |= _a->assertionBits;
}
}
}
tabulateProducerCount++;
assertionsCombined = assertionsKernel | assertionsUser;
if ((assertionsKernel != oldKernel) ||
(assertionsCombined != oldCombined))
{
owner->messageClients(kIOPMMessageDriverAssertionsChanged);
}
}
void PMAssertionsTracker::publishProperties( void )
{
OSArray *assertionsSummary = NULL;
if (tabulateConsumerCount != tabulateProducerCount)
{
IOLockLock(assertionsArrayLock);
tabulateConsumerCount = tabulateProducerCount;
assertionsSummary = copyAssertionsArray();
if (assertionsSummary)
{
owner->setProperty(kIOPMAssertionsDriverDetailedKey, assertionsSummary);
assertionsSummary->release();
}
else
{
owner->removeProperty(kIOPMAssertionsDriverDetailedKey);
}
owner->setProperty(kIOPMAssertionsDriverKey, assertionsKernel, 64);
IOLockUnlock(assertionsArrayLock);
}
}
PMAssertionsTracker::PMAssertStruct *PMAssertionsTracker::detailsForID(IOPMDriverAssertionID _id, int *index)
{
PMAssertStruct *_a = NULL;
OSData *_d = NULL;
int found = -1;
int count = 0;
int i = 0;
if (assertionsArray
&& (count = assertionsArray->getCount()))
{
for (i=0; i<count; i++)
{
_d = OSDynamicCast(OSData, assertionsArray->getObject(i));
if (_d)
{
_a = (PMAssertStruct *)_d->getBytesNoCopy();
if (_a && (_id == _a->id)) {
found = i;
break;
}
}
}
}
if (-1 == found) {
return NULL;
} else {
if (index)
*index = found;
return _a;
}
}
IOReturn PMAssertionsTracker::handleCreateAssertion(OSData *newAssertion)
{
ASSERT_GATED();
if (newAssertion)
{
IOLockLock(assertionsArrayLock);
assertionsArray->setObject(newAssertion);
IOLockUnlock(assertionsArrayLock);
newAssertion->release();
tabulate();
}
return kIOReturnSuccess;
}
IOReturn PMAssertionsTracker::createAssertion(
IOPMDriverAssertionType which,
IOPMDriverAssertionLevel level,
IOService *serviceID,
const char *whoItIs,
IOPMDriverAssertionID *outID)
{
OSData *dataStore = NULL;
PMAssertStruct track;
#ifdef __ppc__
track.id = issuingUniqueID++; #else
track.id = OSIncrementAtomic64((SInt64*) &issuingUniqueID);
#endif
track.level = level;
track.assertionBits = which;
track.ownerString = whoItIs ? OSSymbol::withCString(whoItIs) : 0;
track.ownerService = serviceID;
track.modifiedTime = 0;
pmEventTimeStamp(&track.createdTime);
dataStore = OSData::withBytes(&track, sizeof(PMAssertStruct));
if (!dataStore)
{
if (track.ownerString)
track.ownerString->release();
return kIOReturnNoMemory;
}
*outID = track.id;
if (owner && owner->pmPowerStateQueue) {
owner->pmPowerStateQueue->submitPowerEvent(kPowerEventAssertionCreate, (void *)dataStore);
}
return kIOReturnSuccess;
}
IOReturn PMAssertionsTracker::handleReleaseAssertion(
IOPMDriverAssertionID _id)
{
ASSERT_GATED();
int index;
PMAssertStruct *assertStruct = detailsForID(_id, &index);
if (!assertStruct)
return kIOReturnNotFound;
IOLockLock(assertionsArrayLock);
if (assertStruct->ownerString)
assertStruct->ownerString->release();
assertionsArray->removeObject(index);
IOLockUnlock(assertionsArrayLock);
tabulate();
return kIOReturnSuccess;
}
IOReturn PMAssertionsTracker::releaseAssertion(
IOPMDriverAssertionID _id)
{
if (owner && owner->pmPowerStateQueue) {
owner->pmPowerStateQueue->submitPowerEvent(kPowerEventAssertionRelease, 0, _id);
}
return kIOReturnSuccess;
}
IOReturn PMAssertionsTracker::handleSetAssertionLevel(
IOPMDriverAssertionID _id,
IOPMDriverAssertionLevel _level)
{
PMAssertStruct *assertStruct = detailsForID(_id, NULL);
ASSERT_GATED();
if (!assertStruct) {
return kIOReturnNotFound;
}
IOLockLock(assertionsArrayLock);
pmEventTimeStamp(&assertStruct->modifiedTime);
assertStruct->level = _level;
IOLockUnlock(assertionsArrayLock);
tabulate();
return kIOReturnSuccess;
}
IOReturn PMAssertionsTracker::setAssertionLevel(
IOPMDriverAssertionID _id,
IOPMDriverAssertionLevel _level)
{
if (owner && owner->pmPowerStateQueue) {
owner->pmPowerStateQueue->submitPowerEvent(kPowerEventAssertionSetLevel,
(void *)_level, _id);
}
return kIOReturnSuccess;
}
IOReturn PMAssertionsTracker::handleSetUserAssertionLevels(void * arg0)
{
IOPMDriverAssertionType new_user_levels = *(IOPMDriverAssertionType *) arg0;
ASSERT_GATED();
if (new_user_levels != assertionsUser)
{
assertionsUser = new_user_levels;
DLOG("assertionsUser 0x%llx\n", assertionsUser);
}
tabulate();
return kIOReturnSuccess;
}
IOReturn PMAssertionsTracker::setUserAssertionLevels(
IOPMDriverAssertionType new_user_levels)
{
if (gIOPMWorkLoop) {
gIOPMWorkLoop->runAction(
OSMemberFunctionCast(
IOWorkLoop::Action,
this,
&PMAssertionsTracker::handleSetUserAssertionLevels),
this,
(void *) &new_user_levels, 0, 0, 0);
}
return kIOReturnSuccess;
}
OSArray *PMAssertionsTracker::copyAssertionsArray(void)
{
int count;
int i;
OSArray *outArray = NULL;
if (!assertionsArray ||
(0 == (count = assertionsArray->getCount())) ||
(NULL == (outArray = OSArray::withCapacity(count))))
{
goto exit;
}
for (i=0; i<count; i++)
{
PMAssertStruct *_a = NULL;
OSData *_d = NULL;
OSDictionary *details = NULL;
_d = OSDynamicCast(OSData, assertionsArray->getObject(i));
if (_d && (_a = (PMAssertStruct *)_d->getBytesNoCopy()))
{
OSNumber *_n = NULL;
details = OSDictionary::withCapacity(7);
if (!details)
continue;
outArray->setObject(details);
details->release();
_n = OSNumber::withNumber(_a->id, 64);
if (_n) {
details->setObject(kIOPMDriverAssertionIDKey, _n);
_n->release();
}
_n = OSNumber::withNumber(_a->createdTime, 64);
if (_n) {
details->setObject(kIOPMDriverAssertionCreatedTimeKey, _n);
_n->release();
}
_n = OSNumber::withNumber(_a->modifiedTime, 64);
if (_n) {
details->setObject(kIOPMDriverAssertionModifiedTimeKey, _n);
_n->release();
}
_n = OSNumber::withNumber((uintptr_t)_a->ownerService, 64);
if (_n) {
details->setObject(kIOPMDriverAssertionOwnerServiceKey, _n);
_n->release();
}
_n = OSNumber::withNumber(_a->level, 64);
if (_n) {
details->setObject(kIOPMDriverAssertionLevelKey, _n);
_n->release();
}
_n = OSNumber::withNumber(_a->assertionBits, 64);
if (_n) {
details->setObject(kIOPMDriverAssertionAssertedKey, _n);
_n->release();
}
if (_a->ownerString) {
details->setObject(kIOPMDriverAssertionOwnerStringKey, _a->ownerString);
}
}
}
exit:
return outArray;
}
IOPMDriverAssertionType PMAssertionsTracker::getActivatedAssertions(void)
{
return assertionsCombined;
}
IOPMDriverAssertionLevel PMAssertionsTracker::getAssertionLevel(
IOPMDriverAssertionType type)
{
if (type && ((type & assertionsKernel) == assertionsKernel))
{
return kIOPMDriverAssertionLevelOn;
} else {
return kIOPMDriverAssertionLevelOff;
}
}
static void pmEventTimeStamp(uint64_t *recordTS)
{
clock_sec_t tsec;
clock_usec_t tusec;
if (!recordTS)
return;
clock_get_calendar_microtime(&tsec, &tusec);
*recordTS = 0;
*recordTS |= (uint32_t)tusec;
*recordTS |= ((uint64_t)tsec << 32);
return;
}
#undef super
#define super IOService
OSDefineMetaClassAndFinalStructors(IORootParent, IOService)
static IOPMPowerState patriarchPowerStates[NUM_POWER_STATES] =
{
{1,0,0,0,0,0,0,0,0,0,0,0}, {1,0,RESTART_POWER,0,0,0,0,0,0,0,0,0}, {1,0,SLEEP_POWER,0,0,0,0,0,0,0,0,0}, {1,0,DOZE_POWER,0,0,0,0,0,0,0,0,0}, {1,0,ON_POWER,0,0,0,0,0,0,0,0,0}, };
bool IORootParent::start( IOService * nub )
{
mostRecentChange = ON_STATE;
super::start(nub);
attachToParent( getRegistryRoot(), gIOPowerPlane );
PMinit();
registerPowerDriver(this, patriarchPowerStates, NUM_POWER_STATES);
wakeSystem();
powerOverrideOnPriv();
return true;
}
void IORootParent::shutDownSystem( void )
{
}
void IORootParent::restartSystem( void )
{
}
void IORootParent::sleepSystem( void )
{
mostRecentChange = SLEEP_STATE;
changePowerStateToPriv(SLEEP_STATE);
}
void IORootParent::dozeSystem( void )
{
mostRecentChange = DOZE_STATE;
changePowerStateToPriv(DOZE_STATE);
}
void IORootParent::sleepToDoze( void )
{
if ( mostRecentChange == SLEEP_STATE ) {
changePowerStateToPriv(DOZE_STATE);
}
}
void IORootParent::wakeSystem( void )
{
mostRecentChange = ON_STATE;
changePowerStateToPriv(ON_STATE);
}