IOPMrootDomain.cpp [plain text]
#include <IOKit/IOWorkLoop.h>
#include <IOKit/IOCommandGate.h>
#include <IOKit/IOTimerEventSource.h>
#include <IOKit/IOPlatformExpert.h>
#include <IOKit/IOKitDebug.h>
#include <IOKit/IOTimeStamp.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>
#if HIBERNATION
#include <IOKit/IOHibernatePrivate.h>
#endif
#include <sys/syslog.h>
#include <sys/sysctl.h>
#include <sys/time.h>
#include "IOServicePrivate.h" // _IOServiceInterestNotifier
#if __i386__
__BEGIN_DECLS
#include "IOPMrootDomainInternal.h"
__END_DECLS
#endif
#if DEBUG
#define DEBUG_LOG(x...) do { kprintf(x); } while (0)
#else
#define DEBUG_LOG(x...)
#endif
#define HaltRestartLog(x...) do { kprintf(x); } while (0)
extern "C" {
IOReturn OSMetaClassSystemSleepOrWake( UInt32 );
}
extern const IORegistryPlane * gIOPowerPlane;
IOReturn broadcast_aggressiveness ( OSObject *, void *, void *, void *, void * );
static void sleepTimerExpired(thread_call_param_t);
static void wakeupClamshellTimerExpired ( thread_call_param_t us);
static void notifySystemShutdown( IOService * root, unsigned long event );
static const OSSymbol *sleepSupportedPEFunction = NULL;
#define kIOSleepSupportedKey "IOSleepSupported"
#define kRD_AllPowerSources (kIOPMSupportedOnAC \
| kIOPMSupportedOnBatt \
| kIOPMSupportedOnUPS)
#define number_of_power_states 5
#define OFF_STATE 0
#define RESTART_STATE 1
#define SLEEP_STATE 2
#define DOZE_STATE 3
#define ON_STATE 4
#define ON_POWER kIOPMPowerOn
#define RESTART_POWER kIOPMRestart
#define SLEEP_POWER kIOPMAuxPowerOn
#define DOZE_POWER kIOPMDoze
enum
{
kAutoWakePreWindow = 45,
kAutoWakePostWindow = 15
};
#define kLocalEvalClamshellCommand (1 << 15)
static IOPMPowerState ourPowerStates[number_of_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},
};
static IOPMrootDomain * gRootDomain;
static UInt32 gSleepOrShutdownPending = 0;
struct timeval gIOLastSleepTime;
struct timeval gIOLastWakeTime;
#define kCPUUnknownIndex 9999999
enum {
kInformAC = 0,
kInformLid = 1,
kInformableCount = 2
};
class PMSettingObject : public OSObject
{
OSDeclareDefaultStructors(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);
};
#define kPMHaltMaxWorkers 8
#define kPMHaltTimeoutMS 100
class PMHaltWorker : public OSObject
{
OSDeclareDefaultStructors( PMHaltWorker )
public:
IOService * service; AbsoluteTime startTime; int depth; int visits; IOLock * lock;
bool timeout;
static PMHaltWorker * worker( void );
static void main( void * arg );
static void work( PMHaltWorker * me );
static void checkTimeout( PMHaltWorker * me, AbsoluteTime * now );
virtual void free( void );
};
OSDefineMetaClassAndStructors( PMHaltWorker, OSObject )
#define super IOService
OSDefineMetaClassAndStructors(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 )
{
IOCatalogue::disableExternalLinker();
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;
DEBUG_LOG("disk_sync_callout: start\n");
#if HIBERNATION
IOHibernateSystemSleep();
#endif
sync_internal();
rootDomain->allowPowerChange(pmRef);
DEBUG_LOG("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);
}
#define kRootDomainSettingsCount 14
static SYSCTL_STRUCT(_kern, OID_AUTO, sleeptime,
CTLFLAG_RD | CTLFLAG_NOAUTO | CTLFLAG_KERN,
&gIOLastSleepTime, timeval, "");
static SYSCTL_STRUCT(_kern, OID_AUTO, waketime,
CTLFLAG_RD | CTLFLAG_NOAUTO | CTLFLAG_KERN,
&gIOLastWakeTime, timeval, "");
static const OSSymbol * gIOPMSettingAutoWakeSecondsKey;
bool IOPMrootDomain::start ( IOService * nub )
{
OSIterator *psIterator;
OSDictionary *tmpDict;
gIOPMSettingAutoWakeSecondsKey = OSSymbol::withCString(kIOPMSettingAutoWakeSecondsKey);
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)
};
pmPowerStateQueue = 0;
_reserved = (ExpansionData *)IOMalloc(sizeof(ExpansionData));
if(!_reserved) return false;
super::start(nub);
gRootDomain = this;
PMinit();
sleepSupportedPEFunction = OSSymbol::withCString("IOPMSetSleepSupported");
canSleep = true;
setProperty(kIOSleepSupportedKey,true);
userDisabledAllSleep = false;
allowSleep = true;
sleepIsSupported = true;
systemBooting = true;
sleepSlider = 0;
idleSleepPending = false;
wrangler = NULL;
sleepASAP = false;
clamshellIsClosed = false;
clamshellExists = false;
ignoringClamshell = true;
ignoringClamshellDuringWakeup = false;
acAdaptorConnect = true;
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);
pmPowerStateQueue = IOPMPowerStateQueue::PMPowerStateQueue(this);
getPMworkloop()->addEventSource(pmPowerStateQueue);
featuresDictLock = IOLockAlloc();
settingsCtrlLock = IORecursiveLockAlloc();
extraSleepTimer = thread_call_allocate(
(thread_call_func_t)sleepTimerExpired,
(thread_call_param_t) this);
clamshellWakeupIgnore = thread_call_allocate(
(thread_call_func_t)wakeupClamshellTimerExpired,
(thread_call_param_t) this);
diskSyncCalloutEntry = thread_call_allocate(
&disk_sync_callout,
(thread_call_param_t) this);
patriarch = new IORootParent;
patriarch->init();
patriarch->attach(this);
patriarch->start(this);
patriarch->addPowerChild(this);
registerPowerDriver(this,ourPowerStates,number_of_power_states);
setPMRootDomain(this);
changePowerStateToPriv(ON_STATE);
registerPrioritySleepWakeInterest( &sysPowerDownHandler, this, 0);
#if !NO_KERNEL_HID
_displayWranglerNotifier = addNotification(
gIOPublishNotification, serviceMatching("IODisplayWrangler"),
&displayWranglerPublished, this, 0);
#endif
_batteryPublishNotifier = addNotification(
gIOPublishNotification, serviceMatching("IOPMPowerSource"),
&batteryPublished, this, this);
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);
#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");
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( systemBooting
&& boot_complete_string
&& dict->getObject(boot_complete_string))
{
systemBooting = false;
adjustPowerState();
if( clamshellIsClosed )
{
this->receivePowerNotification(kLocalEvalClamshellCommand);
}
}
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))))
{
if(kOSBooleanTrue == b)
{
kprintf("systemShutdown true\n");
systemShutdown = true;
} else {
kprintf("systemShutdown false\n");
systemShutdown = false;
}
}
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);
userDisabledAllSleep = (kOSBooleanTrue == b);
}
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(sleepdisabled_string) sleepdisabled_string->release();
if(boot_complete_string) boot_complete_string->release();
if(stall_halt_string) stall_halt_string->release();
if(idle_seconds_string) idle_seconds_string->release();
return return_value;
}
IOReturn IOPMrootDomain::youAreRoot ( void )
{
return IOPMNoErr;
}
void IOPMrootDomain::command_received ( void * w, void * x, void * y, void * z )
{
super::command_received(w,x,y,z);
}
IOReturn broadcast_aggressiveness ( OSObject * root, void * x, void * y, void *, void * )
{
((IOPMrootDomain *)root)->broadcast_it((unsigned long)x,(unsigned long)y);
return IOPMNoErr;
}
void IOPMrootDomain::broadcast_it (unsigned long type, unsigned long value)
{
super::setAggressiveness(type,value);
if( type == kPMMinutesToSpinDown ) user_spindown = value;
if (getAggressiveness(kPMMinutesToDim, (unsigned long *)&longestNonSleepSlider)
!= kIOReturnSuccess)
longestNonSleepSlider = 0;
if ( type == kPMMinutesToSleep ) {
DEBUG_LOG("PM idle time -> %ld secs (ena %d)\n", idleSeconds, (value != 0));
if (0x7fffffff == value)
value = idleSeconds;
if ( (sleepSlider == 0) && (value != 0) ) {
if (!wrangler)
{
sleepASAP = false;
changePowerStateToPriv(ON_STATE);
if (idleSeconds)
{
AbsoluteTime deadline;
clock_interval_to_deadline(idleSeconds, kSecondScale, &deadline);
thread_call_enter_delayed(extraSleepTimer, deadline);
idleSleepPending = true;
}
}
else
{
if (sleepASAP)
{
AbsoluteTime deadline;
clock_interval_to_deadline(value * 60, kSecondScale, &deadline);
thread_call_enter_delayed(extraSleepTimer, deadline);
idleSleepPending = true;
sleepASAP = false;
}
}
}
sleepSlider = value;
if ( sleepSlider == 0 ) {
adjustPowerState();
patriarch->wakeSystem();
}
}
if ( sleepSlider > longestNonSleepSlider ) {
extraSleepDelay = sleepSlider - longestNonSleepSlider ;
}
else {
extraSleepDelay = 0;
}
}
static void sleepTimerExpired ( thread_call_param_t us)
{
((IOPMrootDomain *)us)->handleSleepTimerExpiration();
}
static void wakeupClamshellTimerExpired ( thread_call_param_t us)
{
((IOPMrootDomain *)us)->stopIgnoringClamshellEventsDuringWakeup();
}
void IOPMrootDomain::handleSleepTimerExpiration ( void )
{
DEBUG_LOG("SleepTimerExpired\n");
AbsoluteTime time;
clock_get_uptime(&time);
if ((AbsoluteTime_to_scalar(&time) > autoWakeStart) && (AbsoluteTime_to_scalar(&time) < autoWakeEnd))
{
thread_call_enter_delayed(extraSleepTimer, *((AbsoluteTime *) &autoWakeEnd));
return;
}
if(0 != user_spindown)
setQuickSpinDownTimeout();
sleepASAP = true;
adjustPowerState();
}
void IOPMrootDomain::stopIgnoringClamshellEventsDuringWakeup(void)
{
ignoringClamshellDuringWakeup = false;
if(clamshellIsClosed)
this->receivePowerNotification( kLocalEvalClamshellCommand );
}
IOReturn IOPMrootDomain::setAggressiveness ( unsigned long type, unsigned long newLevel )
{
IOWorkLoop * pmWorkLoop = getPMworkloop();
if (pmWorkLoop)
pmWorkLoop->runAction(broadcast_aggressiveness,this,(void *)type,(void *)newLevel);
return kIOReturnSuccess;
}
IOReturn IOPMrootDomain::sleepSystem ( void )
{
return sleepSystemOptions (NULL);
}
IOReturn IOPMrootDomain::sleepSystemOptions ( OSDictionary *options )
{
if (options && options->getObject("OSSwitch"))
{
return privateSleepSystem( kIOPMOSSwitchHibernationKey) ;
} else {
return privateSleepSystem( kIOPMSoftwareSleepKey);
}
}
IOReturn IOPMrootDomain::privateSleepSystem ( const char *sleepReason )
{
if (sleepReason) {
setProperty(kRootDomainSleepReasonKey, sleepReason);
}
if(systemShutdown) {
kprintf("Preventing system sleep on grounds of systemShutdown.\n");
}
if( userDisabledAllSleep )
{
return kIOReturnNotPermitted;
}
if ( !systemBooting
&& !systemShutdown
&& allowSleep)
{
if ( !sleepIsSupported ) {
setSleepSupported( kPCICantSleep );
kprintf("Sleep prevented by kIOPMPreventSystemSleep flag\n");
}
patriarch->sleepSystem();
return kIOReturnSuccess;
} else {
return kIOReturnError;
}
}
IOReturn IOPMrootDomain::shutdownSystem ( void )
{
return kIOReturnUnsupported;
}
IOReturn IOPMrootDomain::restartSystem ( void )
{
return kIOReturnUnsupported;
}
void IOPMrootDomain::powerChangeDone ( unsigned long previousState )
{
OSNumber * propertyPtr;
unsigned short theProperty;
AbsoluteTime deadline;
DEBUG_LOG("PowerChangeDone: %ld -> %ld\n", previousState, getPowerState());
switch ( getPowerState() ) {
case SLEEP_STATE:
if ( previousState != ON_STATE )
break;
if ( canSleep && sleepIsSupported )
{
idleSleepPending = false;
uint32_t secs, microsecs;
clock_get_calendar_microtime(&secs, µsecs);
logtime(secs);
gIOLastSleepTime.tv_sec = secs;
gIOLastSleepTime.tv_usec = microsecs;
#if HIBERNATION
IOLog("System %sSleep\n", gIOHibernateState ? "Safe" : "");
IOHibernateSystemHasSlept();
#else
IOLog("System Sleep\n");
#endif
getPlatform()->sleepKernel();
#if HIBERNATION
IOHibernateSystemWake();
#endif
clock_interval_to_deadline(30, kSecondScale, &deadline);
thread_call_enter_delayed(extraSleepTimer, deadline);
idleSleepPending = true;
ignoringClamshellDuringWakeup = true;
gSleepOrShutdownPending = 0;
clock_wakeup_calendar();
patriarch->wakeSystem();
tellClients(kIOMessageSystemWillPowerOn);
#if HIBERNATION
IOLog("System %sWake\n", gIOHibernateState ? "SafeSleep " : "");
#endif
systemWake();
if(getProperty(kIOREMSleepEnabledKey)) {
clock_interval_to_deadline(5, kSecondScale, &deadline);
if(clamshellWakeupIgnore) {
thread_call_enter_delayed(clamshellWakeupIgnore, deadline);
}
} else ignoringClamshellDuringWakeup = false;
propertyPtr = OSDynamicCast(OSNumber,getProperty("WakeEvent"));
if ( propertyPtr ) {
theProperty = propertyPtr->unsigned16BitValue();
IOLog("Wake event %04x\n",theProperty);
if ( (theProperty & 0x0008) || (theProperty & 0x0800) || (theProperty & 0x0020) || (theProperty & 0x0001) ) { reportUserInput();
}
} else {
reportUserInput();
}
changePowerStateToPriv(ON_STATE);
} else {
patriarch->sleepToDoze();
powerOverrideOnPriv();
changePowerStateToPriv(DOZE_STATE);
}
break;
case DOZE_STATE:
if ( previousState != DOZE_STATE )
{
IOLog("System Doze\n");
}
idleSleepPending = false;
gSleepOrShutdownPending = 0;
if (wrangler) wrangler->changePowerStateTo(0);
break;
case RESTART_STATE:
IOLog("System Restart\n");
PEHaltRestart(kPERestartCPU);
break;
case OFF_STATE:
IOLog("System Halt\n");
PEHaltRestart(kPEHaltCPU);
break;
}
}
void IOPMrootDomain::wakeFromDoze( void )
{
if ( getPowerState() == DOZE_STATE )
{
setSleepSupported(0);
changePowerStateToPriv(ON_STATE);
powerOverrideOffPriv();
tellClients(kIOMessageSystemWillPowerOn);
patriarch->wakeSystem();
}
}
void IOPMrootDomain::publishFeature( const char * feature )
{
publishFeature(feature, kIOPMSupportedOnAC
| kIOPMSupportedOnBatt
| kIOPMSupportedOnUPS,
NULL);
return;
}
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 = supportedWhere + (next_feature_id << 16);
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);
existing_feature_arr->setObject(new_feature_data);
features->setObject(feature, existing_feature_arr);
} else if(( existing_feature_arr = OSDynamicCast(OSArray, osObj) ))
{
existing_feature_arr->setObject(new_feature_data);
}
} else {
features->setObject(feature, new_feature_data);
}
new_feature_data->release();
setProperty(kRootDomainSupportedFeatures, features);
features->release();
if(featuresDictLock) IOLockUnlock(featuresDictLock);
if(pmPowerStateQueue) {
pmPowerStateQueue->featureChangeOccurred(
kIOPMMessageFeatureChange, this);
}
}
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;
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 {
arrayMember->removeObject(i);
}
madeAChange = true;
break;
}
}
}
}
dictIterator->release();
if( madeAChange )
{
ret = kIOReturnSuccess;
setProperty(kRootDomainSupportedFeatures, features);
if(pmPowerStateQueue) {
pmPowerStateQueue->featureChangeOccurred(
kIOPMMessageFeatureChange, this);
}
} else {
ret = kIOReturnNotFound;
}
exit:
if(features) features->release();
if(featuresDictLock) IOLockUnlock(featuresDictLock);
return ret;
}
void IOPMrootDomain::unIdleDevice( IOService *theDevice, unsigned long theState )
{
if(pmPowerStateQueue)
pmPowerStateQueue->unIdleOccurred(theDevice, theState);
}
void IOPMrootDomain::announcePowerSourceChange( void )
{
IORegistryEntry *_batteryRegEntry = (IORegistryEntry *) getProperty("BatteryEntry");
if(_batteryRegEntry)
{
OSArray *batt_info;
batt_info = (OSArray *) _batteryRegEntry->getProperty(kIOBatteryInfoKey);
if(batt_info)
setProperty(kIOBatteryInfoKey, batt_info);
}
}
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 )
{
return ( !ignoringClamshell
&& !ignoringClamshellDuringWakeup
&& !(desktopMode && acAdaptorConnect) );
}
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 )
{
#ifdef __i386__
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 __i386__
}
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)
{
bool eval_clamshell = false;
if (msg & kLocalEvalClamshellCommand)
{
eval_clamshell = true;
}
if (msg & kIOPMOverTemp)
{
IOLog("PowerManagement emergency overtemp signal. Going to sleep!");
privateSleepSystem (kIOPMThermalEmergencySleepKey);
}
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);
}
if (msg & kIOPMSleepNow)
{
privateSleepSystem (kIOPMSoftwareSleepKey);
}
if (msg & kIOPMPowerEmergency)
{
privateSleepSystem (kIOPMLowPowerSleepKey);
}
if (msg & kIOPMClamshellOpened)
{
clamshellIsClosed = false;
clamshellExists = true;
informCPUStateChange(kInformLid, 0);
sendClientClamshellNotification();
}
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)
{
acAdaptorConnect = (0 != (msg & kIOPMSetValue));
msg &= ~(kIOPMSetACAdaptorConnected | kIOPMSetValue);
informCPUStateChange(kInformAC, !acAdaptorConnect);
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 (kIOPMClamshellSleepKey);
}
if (msg & kIOPMPowerButton)
{
if ( getPowerState() == DOZE_STATE )
{
systemWake();
reportUserInput();
}
else {
OSString *pbs = OSString::withCString("DisablePowerButtonSleep");
if( pbs ) {
if( kOSBooleanTrue != getProperty(pbs))
privateSleepSystem (kIOPMPowerButtonSleepKey);
}
}
}
if ( (msg & kIOPMAllowSleep) && !allowSleep )
{
allowSleep = true;
adjustPowerState();
}
if (msg & kIOPMPreventSleep) {
allowSleep = false;
if ( getPowerState() == DOZE_STATE ) {
systemWake();
adjustPowerState();
reportUserInput();
} else {
adjustPowerState();
patriarch->wakeSystem();
}
}
return 0;
}
void IOPMrootDomain::setSleepSupported( IOOptionBits flags )
{
if ( flags & kPCICantSleep )
{
canSleep = false;
} else {
canSleep = true;
platformSleepSupport = flags;
}
setProperty(kIOSleepSupportedKey, canSleep);
}
IOReturn IOPMrootDomain::requestPowerDomainState (
IOPMPowerFlags desiredState,
IOPowerConnection * whichChild,
unsigned long specification )
{
OSIterator *iter;
OSObject *next;
IOPowerConnection *connection;
unsigned long powerRequestFlag = 0;
IOPMPowerFlags editedDesire;
#if DEBUG
IOService *powerChild;
powerChild = (IOService *) whichChild->getChildEntry(gIOPowerPlane);
#endif
DEBUG_LOG("RequestPowerDomainState: flags %lx, child %p [%s], spec %lx\n",
desiredState, powerChild, powerChild ? powerChild->getName() : "?",
specification);
if (desiredState & kIOPMPreventIdleSleep)
editedDesire = desiredState;
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 ( desiredState & kIOPMPreventSystemSleep )
sleepIsSupported = false;
}
else
{
#if DEBUG
powerChild = (IOService *) connection->getChildEntry(gIOPowerPlane);
#endif
DEBUG_LOG(" child %p, PState %ld, noIdle %d, noSleep %d, valid %d %s\n",
powerChild,
connection->getDesiredDomainState(),
connection->getPreventIdleSleepFlag(),
connection->getPreventSystemSleepFlag(),
connection->getReadyFlag(),
powerChild ? powerChild->getName() : "?");
powerRequestFlag |= connection->getDesiredDomainState();
if ( connection->getPreventSystemSleepFlag() )
sleepIsSupported = false;
}
}
}
iter->release();
}
if ( !powerRequestFlag && !systemBooting )
{
if (!wrangler)
{
sleepASAP = false;
changePowerStateToPriv(ON_STATE);
if (idleSeconds)
{
AbsoluteTime deadline;
clock_interval_to_deadline(idleSeconds, kSecondScale, &deadline);
thread_call_enter_delayed(extraSleepTimer, deadline);
idleSleepPending = true;
}
}
else if (extraSleepDelay == 0)
{
sleepASAP = true;
}
}
DEBUG_LOG(" sleepDelay %lx, mergedFlags %lx, sleepASAP %x, booting %x\n",
extraSleepDelay, powerRequestFlag, sleepASAP, systemBooting);
adjustPowerState();
editedDesire |= (desiredState & kIOPMPreventSystemSleep);
return super::requestPowerDomainState(editedDesire, whichChild, specification);
}
IOOptionBits IOPMrootDomain::getSleepSupported( void )
{
return( platformSleepSupport );
}
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)
{
HaltRestartLog("%s handler %p took %lu ms\n",
(ctx->MessageType == kIOMessageSystemWillPowerOff) ?
"PowerOff" : "Restart",
notifier->handler, 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:
ctx.PowerState = OFF_STATE;
ctx.MessageType = kIOMessageSystemWillPowerOff;
break;
case kPERestartCPU:
ctx.PowerState = RESTART_STATE;
ctx.MessageType = kIOMessageSystemWillRestart;
break;
default:
return;
}
applyToInterested(gIOPriorityPowerStateInterest, platformHaltRestartApplier, &ctx);
notifySystemShutdown(this, ctx.MessageType);
deltaTime = computeDeltaTimeMS(&startTime);
HaltRestartLog("%s all drivers took %lu ms\n",
(ctx.MessageType == kIOMessageSystemWillPowerOff) ?
"PowerOff" : "Restart",
deltaTime );
}
bool IOPMrootDomain::tellChangeDown ( unsigned long stateNum )
{
switch ( stateNum ) {
case DOZE_STATE:
case SLEEP_STATE:
OSMetaClassSystemSleepOrWake( kIOMessageSystemWillSleep );
return super::tellClientsWithResponse(kIOMessageSystemWillSleep);
}
return super::tellChangeDown(stateNum);
}
bool IOPMrootDomain::askChangeDown ( unsigned long )
{
return super::tellClientsWithResponse(kIOMessageCanSystemSleep);
}
void IOPMrootDomain::tellNoChangeDown ( unsigned long )
{
if (idleSeconds && !wrangler)
{
AbsoluteTime deadline;
sleepASAP = false;
clock_interval_to_deadline(idleSeconds, kSecondScale, &deadline);
thread_call_enter_delayed(extraSleepTimer, deadline);
idleSleepPending = true;
}
return tellClients(kIOMessageSystemWillNotSleep);
}
void IOPMrootDomain::tellChangeUp ( unsigned long stateNum)
{
if ( stateNum == ON_STATE )
{
#if HIBERNATION
OSMetaClassSystemSleepOrWake( kIOMessageSystemHasPoweredOn );
IOHibernateSystemPostWake();
#endif
return tellClients(kIOMessageSystemHasPoweredOn);
}
}
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 )
{
super::setAggressiveness((unsigned long)kPMMinutesToSpinDown,(unsigned long)1);
}
void IOPMrootDomain::restoreUserSpinDownTimeout ( void )
{
super::setAggressiveness((unsigned long)kPMMinutesToSpinDown,(unsigned long)user_spindown);
}
IOReturn IOPMrootDomain::changePowerStateTo ( unsigned long ordinal )
{
return super::changePowerStateTo(ordinal);
}
IOReturn IOPMrootDomain::changePowerStateToPriv ( unsigned long ordinal )
{
IOReturn ret;
DEBUG_LOG("ChangePowerStateToPriv: power state %ld\n", ordinal);
if ( (getPowerState() == DOZE_STATE) && (ordinal != ON_STATE) )
{
return kIOReturnSuccess;
}
if( (userDisabledAllSleep || systemBooting || systemShutdown)
&& (ordinal == SLEEP_STATE) )
{
DEBUG_LOG(" sleep denied: disableAllSleep %d, booting %d, shutdown %d\n",
userDisabledAllSleep, systemBooting, systemShutdown);
super::changePowerStateToPriv(ON_STATE);
}
if( (SLEEP_STATE == ordinal) && sleepSupportedPEFunction )
{
ret = getPlatform()->callPlatformFunction(
sleepSupportedPEFunction, false,
NULL, NULL, NULL, NULL);
}
return super::changePowerStateToPriv(ordinal);
}
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);
if(!rootDomain)
return kIOReturnUnsupported;
switch (messageType) {
case kIOMessageSystemWillSleep:
DEBUG_LOG("SystemWillSleep\n");
params->returnValue = 20 * 1000 * 1000;
#if HIBERNATION
if (gIOHibernateState)
params->returnValue += gIOHibernateFreeTime * 1000; #endif
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;
}
IOReturn IOPMrootDomain::displayWranglerNotification(
void * target, void * refCon,
UInt32 messageType, IOService * service,
void * messageArgument, vm_size_t argSize )
{
#if !NO_KERNEL_HID
IOPMrootDomain * rootDomain = OSDynamicCast(IOPMrootDomain, (IOService *)target);
AbsoluteTime deadline;
static int displayPowerState = 4;
if (!rootDomain)
return kIOReturnUnsupported;
switch (messageType) {
case kIOMessageDeviceWillPowerOff:
DEBUG_LOG("DisplayWranglerWillPowerOff: new p-state %d\n",
displayPowerState - 1);
displayPowerState--;
if ( 2 != displayPowerState )
return kIOReturnUnsupported;
if ( rootDomain->extraSleepDelay )
{
clock_interval_to_deadline(rootDomain->extraSleepDelay*60, kSecondScale, &deadline);
thread_call_enter_delayed(rootDomain->extraSleepTimer, deadline);
rootDomain->idleSleepPending = true;
DEBUG_LOG(" sleep timer set to expire in %ld min\n",
rootDomain->extraSleepDelay);
} else {
if ( (0 != rootDomain->user_spindown) && (0 != rootDomain->sleepSlider) )
{
DEBUG_LOG(" accelerate quick disk spindown, was %d min\n",
rootDomain->user_spindown);
rootDomain->setQuickSpinDownTimeout();
}
}
break;
case kIOMessageDeviceHasPoweredOn:
DEBUG_LOG("DisplayWranglerHasPoweredOn: previous p-state %d\n",
displayPowerState);
displayPowerState = 4;
rootDomain->adjustPowerState();
if (rootDomain->idleSleepPending)
{
DEBUG_LOG(" extra-sleep timer stopped\n");
thread_call_cancel(rootDomain->extraSleepTimer);
rootDomain->idleSleepPending = false;
}
if (0 != rootDomain->user_spindown)
{
DEBUG_LOG(" restoring disk spindown to %d min\n",
rootDomain->user_spindown);
rootDomain->restoreUserSpinDownTimeout();
}
break;
default:
break;
}
#endif
return kIOReturnUnsupported;
}
bool IOPMrootDomain::displayWranglerPublished(
void * target,
void * refCon,
IOService * newService)
{
#if !NO_KERNEL_HID
IOPMrootDomain *rootDomain =
OSDynamicCast(IOPMrootDomain, (IOService *)target);
if(!rootDomain)
return false;
rootDomain->wrangler = newService;
if( !rootDomain->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 )
{
if ( (sleepSlider == 0)
|| !allowSleep
|| systemBooting
|| systemShutdown
|| userDisabledAllSleep )
{
DEBUG_LOG("AdjustPowerState %ld -> ON: slider %ld, allowSleep %d, "
"booting %d, shutdown %d, userDisabled %d\n",
getPowerState(), sleepSlider, allowSleep, systemBooting,
systemShutdown, userDisabledAllSleep);
changePowerStateToPriv(ON_STATE);
} else {
if ( sleepASAP )
{
DEBUG_LOG("AdjustPowerState SLEEP\n");
setProperty(kRootDomainSleepReasonKey, kIOPMIdleSleepKey);
sleepASAP = false;
if ( !sleepIsSupported )
{
setSleepSupported( kPCICantSleep );
kprintf("Sleep prevented by kIOPMPreventSystemSleep flag\n");
}
changePowerStateToPriv(SLEEP_STATE);
}
}
}
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;
DEBUG_LOG("PMHaltWorker %p\n", me);
me->retain(); thread = IOCreateThread( &PMHaltWorker::main, me );
if (!thread)
{
me->release();
break;
}
return me;
} while (false);
if (me) me->release();
return 0;
}
void PMHaltWorker::free( void )
{
DEBUG_LOG("PMHaltWorker free %p\n", this);
if (lock)
{
IOLockFree(lock);
lock = 0;
}
return OSObject::free();
}
void PMHaltWorker::main( void * arg )
{
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 );
}
DEBUG_LOG("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))
{
HaltRestartLog("%s driver %s (%p) took %lu ms\n",
(gPMHaltEvent == kIOMessageSystemWillPowerOff) ?
"PowerOff" : "Restart",
service->getName(), service,
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;
HaltRestartLog("%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
{
DEBUG_LOG("%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;
DEBUG_LOG("%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)
DEBUG_LOG("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();
DEBUG_LOG("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;
DEBUG_LOG("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:
DEBUG_LOG("%s done\n", __FUNCTION__);
return;
}
#if DEBUG_TEST
bool IOPMrootDomain::serializeProperties( OSSerialize * s ) const
{
IOPMrootDomain * root = (IOPMrootDomain *) this;
notifySystemShutdown( root, kIOMessageSystemWillPowerOff );
return( super::serializeProperties(s) );
}
#endif
#undef super
#define super OSObject
OSDefineMetaClassAndStructors(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);
}
#undef super
#define super IOService
OSDefineMetaClassAndStructors(IORootParent, IOService)
static IOPMPowerState patriarchPowerStates[number_of_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);
PMinit();
youAreRoot();
registerPowerDriver(this,patriarchPowerStates,number_of_power_states);
wakeSystem();
powerOverrideOnPriv();
return true;
}
void IORootParent::shutDownSystem ( void )
{
mostRecentChange = OFF_STATE;
changePowerStateToPriv(OFF_STATE);
}
void IORootParent::restartSystem ( void )
{
mostRecentChange = RESTART_STATE;
changePowerStateToPriv(RESTART_STATE);
}
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);
}
IOReturn IORootParent::changePowerStateToPriv ( unsigned long ordinal )
{
IOReturn ret;
if( (SLEEP_STATE == ordinal) && sleepSupportedPEFunction )
{
ret = getPlatform()->callPlatformFunction(
sleepSupportedPEFunction, false,
NULL, NULL, NULL, NULL);
}
return super::changePowerStateToPriv(ordinal);
}