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/IOMessage.h>
#include "RootDomainUserClient.h"
#include "IOKit/pwr_mgt/IOPowerConnection.h"
#include "IOPMPowerStateQueue.h"
extern "C" void kprintf(const char *, ...);
extern const IORegistryPlane * gIOPowerPlane;
static inline void
ioSPMTrace(unsigned int csc,
unsigned int a = 0, unsigned int b = 0,
unsigned int c = 0, unsigned int d = 0)
{
if (gIOKitDebug & kIOLogTracePower)
IOTimeStampConstant(IODBG_POWER(csc), a, b, c, d);
}
IOReturn broadcast_aggressiveness ( OSObject *, void *, void *, void *, void * );
static void sleepTimerExpired(thread_call_param_t);
static void wakeupClamshellTimerExpired ( thread_call_param_t us);
#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
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}, };
#define diskSyncCalloutEntry _reserved->diskSyncCalloutEntry
#define _settingController _reserved->_settingController
static IOPMrootDomain * gRootDomain;
static UInt32 gSleepOrShutdownPending = 0;
#define super IOService
OSDefineMetaClassAndStructors(IOPMrootDomain,IOService)
extern "C"
{
IONotifier * registerSleepWakeInterest(IOServiceInterestHandler handler, void * self, void * ref = 0)
{
return gRootDomain->registerInterest( gIOGeneralInterest, handler, self, ref );
}
IONotifier * registerPrioritySleepWakeInterest(IOServiceInterestHandler handler, void * self, void * ref = 0)
{
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 )
{
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;
sync_internal();
rootDomain->allowPowerChange(pmRef);
}
bool IOPMrootDomain::start ( IOService * nub )
{
OSDictionary *tmpDict;
pmPowerStateQueue = 0;
_reserved = (ExpansionData *)IOMalloc(sizeof(ExpansionData));
if(!_reserved) return false;
super::start(nub);
gRootDomain = this;
PMinit();
setProperty("IOSleepSupported","");
allowSleep = true;
sleepIsSupported = true;
systemBooting = true;
ignoringClamshell = true;
sleepSlider = 0;
idleSleepPending = false;
canSleep = true;
wrangler = NULL;
sleepASAP = false;
_settingController = NULL;
ignoringClamshellDuringWakeup = false;
tmpDict = OSDictionary::withCapacity(1);
setProperty(kRootDomainSupportedFeatures, tmpDict);
tmpDict->release();
pm_vars->PMworkloop = IOWorkLoop::workLoop();
pmPowerStateQueue = IOPMPowerStateQueue::PMPowerStateQueue(this);
pm_vars->PMworkloop->addEventSource(pmPowerStateQueue);
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->youAreRoot();
patriarch->wakeSystem();
patriarch->addPowerChild(this);
registerPowerDriver(this,ourPowerStates,number_of_power_states);
setPMRootDomain(this);
changePowerStateToPriv(ON_STATE);
registerPrioritySleepWakeInterest( &sysPowerDownHandler, this, 0);
addNotification( gIOPublishNotification, serviceMatching("IODisplayWrangler"), &displayWranglerPublished, this, 0);
const OSSymbol *ucClassName = OSSymbol::withCStringNoCopy("RootDomainUserClient");
setProperty(gIOUserClientClassKey, (OSMetaClassBase *) ucClassName);
ucClassName->release();
registerService();
return true;
}
IOReturn IOPMrootDomain::setPMSetting(int type, OSNumber *n)
{
if(_settingController && _settingController->func) {
int seconds;
seconds = n->unsigned32BitValue();
return (*(_settingController->func))(type, seconds, _settingController->refcon);
} else {
return kIOReturnNoDevice;
}
}
IOReturn IOPMrootDomain::setProperties ( OSObject *props_obj)
{
IOReturn return_value = kIOReturnSuccess;
OSDictionary *dict = OSDynamicCast(OSDictionary, props_obj);
OSBoolean *b;
OSNumber *n;
OSString *boot_complete_string = OSString::withCString("System Boot Complete");
OSString *power_button_string = OSString::withCString("DisablePowerButtonSleep");
OSString *stall_halt_string = OSString::withCString("StallSystemAtHalt");
OSString *auto_wake_string = OSString::withCString("wake");
OSString *auto_power_string = OSString::withCString("poweron");
OSString *wakeonring_string = OSString::withCString("WakeOnRing");
OSString *fileserver_string = OSString::withCString("AutoRestartOnPowerLoss");
OSString *wakeonlid_string = OSString::withCString("WakeOnLid");
OSString *wakeonac_string = OSString::withCString("WakeOnACChange");
if(!dict)
{
return_value = kIOReturnBadArgument;
goto exit;
}
if( systemBooting
&& boot_complete_string
&& dict->getObject(boot_complete_string))
{
systemBooting = false;
adjustPowerState();
}
if( power_button_string
&& (b = OSDynamicCast(OSBoolean, dict->getObject(power_button_string))) )
{
setProperty(power_button_string, b);
}
if( stall_halt_string
&& (b = OSDynamicCast(OSBoolean, dict->getObject(stall_halt_string))) )
{
setProperty(stall_halt_string, b);
}
if( auto_wake_string
&& (n = OSDynamicCast(OSNumber, dict->getObject(auto_wake_string))) )
{
return_value = setPMSetting(kIOPMAutoWakeSetting, n);
if(kIOReturnSuccess != return_value) goto exit;
}
if( auto_power_string
&& (n = OSDynamicCast(OSNumber, dict->getObject(auto_power_string))) )
{
return_value = setPMSetting(kIOPMAutoPowerOnSetting, n);
if(kIOReturnSuccess != return_value) goto exit;
}
if( wakeonring_string
&& (n = OSDynamicCast(OSNumber, dict->getObject(wakeonring_string))) )
{
return_value = setPMSetting(kIOPMWakeOnRingSetting, n);
if(kIOReturnSuccess != return_value) goto exit;
}
if( fileserver_string
&& (n = OSDynamicCast(OSNumber, dict->getObject(fileserver_string))) )
{
return_value = setPMSetting(kIOPMAutoRestartOnPowerLossSetting, n);
if(kIOReturnSuccess != return_value) goto exit;
}
if( wakeonlid_string
&& (n = OSDynamicCast(OSNumber, dict->getObject(wakeonlid_string))) )
{
return_value = setPMSetting(kIOPMWakeOnLidSetting, n);
if(kIOReturnSuccess != return_value) goto exit;
}
if( wakeonac_string
&& (n = OSDynamicCast(OSNumber, dict->getObject(wakeonac_string))) )
{
return_value = setPMSetting(kIOPMWakeOnACChangeSetting, n);
if(kIOReturnSuccess != return_value) goto exit;
}
exit:
if(boot_complete_string) boot_complete_string->release();
if(power_button_string) power_button_string->release();
if(stall_halt_string) stall_halt_string->release();
if(auto_wake_string) auto_wake_string->release();
if(auto_power_string) auto_power_string->release();
if(wakeonring_string) wakeonring_string->release();
if(fileserver_string) fileserver_string->release();
if(wakeonlid_string) wakeonlid_string->release();
if(wakeonac_string) wakeonac_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;
longestNonSleepSlider = pm_vars->current_aggressiveness_values[kPMMinutesToDim];
if ( type == kPMMinutesToSleep ) {
if ( (sleepSlider == 0) && (value != 0) ) {
sleepSlider = value;
adjustPowerState();
}
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 )
{
if(0 != user_spindown)
setQuickSpinDownTimeout();
sleepASAP = true;
adjustPowerState();
}
void IOPMrootDomain::stopIgnoringClamshellEventsDuringWakeup(void)
{
OSObject * state;
ignoringClamshellDuringWakeup = false;
if ((state = getProperty(kAppleClamshellStateKey)))
publishResource(kAppleClamshellStateKey, state);
}
IOReturn IOPMrootDomain::setAggressiveness ( unsigned long type, unsigned long newLevel )
{
if ( pm_vars->PMcommandGate ) {
pm_vars->PMcommandGate->runAction(broadcast_aggressiveness,(void *)type,(void *)newLevel);
}
return kIOReturnSuccess;
}
IOReturn IOPMrootDomain::sleepSystem ( void )
{
if ( !systemBooting && allowSleep && sleepIsSupported ) {
patriarch->sleepSystem();
return kIOReturnSuccess;
}
if ( !systemBooting && allowSleep && !sleepIsSupported ) {
patriarch->dozeSystem();
return kIOReturnSuccess;
}
return kIOReturnSuccess;
}
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;
switch ( pm_vars->myCurrentState ) {
case SLEEP_STATE:
if ( canSleep && sleepIsSupported )
{
idleSleepPending = false;
IOLog("System Sleep\n");
pm_vars->thePlatform->sleepKernel();
ioSPMTrace(IOPOWER_WAKE, * (int *) this);
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);
IOLog("System Wake\n");
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);
powerOverrideOffPriv();
} else {
patriarch->sleepToDoze();
changePowerStateToPriv(DOZE_STATE);
}
break;
case DOZE_STATE:
if ( previousState != DOZE_STATE )
{
IOLog("System Doze\n");
}
idleSleepPending = false;
gSleepOrShutdownPending = 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 ( pm_vars->myCurrentState == DOZE_STATE )
{
canSleep = true;
powerOverrideOffPriv();
tellClients(kIOMessageSystemWillPowerOn);
patriarch->wakeSystem();
}
}
void IOPMrootDomain::publishFeature( const char * feature )
{
OSDictionary *features = (OSDictionary *)getProperty(kRootDomainSupportedFeatures);
features->setObject(feature, kOSBooleanTrue);
}
void IOPMrootDomain::unIdleDevice( IOService *theDevice, unsigned long theState )
{
if(pmPowerStateQueue)
pmPowerStateQueue->unIdleOccurred(theDevice, theState);
}
void IOPMrootDomain::announcePowerSourceChange( void )
{
messageClients(kIOPMMessageBatteryStatusHasChanged);
}
IOReturn IOPMrootDomain::registerPMSettingController
(IOPMSettingControllerCallback func, void *info)
{
if(_settingController) return kIOReturnExclusiveAccess;
_settingController = (PMSettingCtrl *)IOMalloc(sizeof(PMSettingCtrl));
if(!_settingController) return kIOReturnNoMemory;
_settingController->func = func;
_settingController->refcon = info;
return kIOReturnSuccess;
}
IOReturn IOPMrootDomain::receivePowerNotification (UInt32 msg)
{
if (msg & kIOPMOverTemp)
{
IOLog("Power Management received emergency overtemp signal. Going to sleep.");
(void) sleepSystem ();
}
if (msg & kIOPMSetDesktopMode)
{
desktopMode = (0 != (msg & kIOPMSetValue));
msg &= ~(kIOPMSetDesktopMode | kIOPMSetValue);
}
if (msg & kIOPMSetACAdaptorConnected)
{
acAdaptorConnect = (0 != (msg & kIOPMSetValue));
msg &= ~(kIOPMSetACAdaptorConnected | kIOPMSetValue);
}
if (msg & kIOPMEnableClamshell)
{
ignoringClamshell = false;
}
if (msg & kIOPMDisableClamshell)
{
ignoringClamshell = true;
}
if (msg & kIOPMProcessorSpeedChange)
{
IOService *pmu = waitForService(serviceMatching("ApplePMU"));
pmu->callPlatformFunction("prepareForSleep", false, 0, 0, 0, 0);
pm_vars->thePlatform->sleepKernel();
pmu->callPlatformFunction("recoverFromSleep", false, 0, 0, 0, 0);
}
if (msg & kIOPMSleepNow)
{
(void) sleepSystem ();
}
if (msg & kIOPMPowerEmergency)
{
(void) sleepSystem ();
}
if (msg & kIOPMClamshellClosed)
{
if ( !ignoringClamshell && !ignoringClamshellDuringWakeup
&& (!desktopMode || !acAdaptorConnect) )
{
(void) sleepSystem ();
}
}
if (msg & kIOPMPowerButton)
{
if ( pm_vars->myCurrentState == DOZE_STATE )
{
systemWake();
reportUserInput();
}
else {
if(kOSBooleanTrue != getProperty(OSString::withCString("DisablePowerButtonSleep")))
sleepSystem();
}
}
if ( (msg & kIOPMAllowSleep) && !allowSleep )
{
allowSleep = true;
adjustPowerState();
}
if (msg & kIOPMPreventSleep) {
allowSleep = false;
if ( pm_vars->myCurrentState == DOZE_STATE ) {
systemWake();
adjustPowerState();
reportUserInput();
} else {
adjustPowerState();
patriarch->wakeSystem();
}
}
return 0;
}
void IOPMrootDomain::setSleepSupported( IOOptionBits flags )
{
if ( flags & kPCICantSleep )
{
canSleep = false;
} else {
platformSleepSupport = flags;
}
}
IOReturn IOPMrootDomain::requestPowerDomainState ( IOPMPowerFlags desiredState, IOPowerConnection * whichChild, unsigned long specification )
{
OSIterator *iter;
OSObject *next;
IOPowerConnection *connection;
unsigned long powerRequestFlag = 0;
IOPMPowerFlags editedDesire = desiredState;
if ( !(desiredState & kIOPMPreventIdleSleep) ) {
editedDesire = 0;
}
IOLockLock(pm_vars->childLock);
iter = getChildIterator(gIOPowerPlane);
sleepIsSupported = true;
if ( iter )
{
while ( (next = iter->getNextObject()) )
{
if ( (connection = OSDynamicCast(IOPowerConnection,next)) )
{
if ( connection == whichChild )
{
powerRequestFlag += editedDesire;
if ( desiredState & kIOPMPreventSystemSleep )
{
sleepIsSupported = false;
}
} else {
powerRequestFlag += connection->getDesiredDomainState();
if ( connection->getPreventSystemSleepFlag() )
{
sleepIsSupported = false;
}
}
}
}
iter->release();
}
if ( (extraSleepDelay == 0) && (powerRequestFlag == 0) )
{
sleepASAP = true;
}
adjustPowerState();
IOLockUnlock(pm_vars->childLock);
editedDesire |= desiredState & kIOPMPreventSystemSleep;
return super::requestPowerDomainState(editedDesire,whichChild,specification);
}
IOOptionBits IOPMrootDomain::getSleepSupported( void )
{
return( platformSleepSupport );
}
bool IOPMrootDomain::tellChangeDown ( unsigned long stateNum )
{
switch ( stateNum ) {
case DOZE_STATE:
case SLEEP_STATE:
return super::tellClientsWithResponse(kIOMessageSystemWillSleep);
case RESTART_STATE:
return super::tellClientsWithResponse(kIOMessageSystemWillRestart);
case OFF_STATE:
return super::tellClientsWithResponse(kIOMessageSystemWillPowerOff);
}
return super::tellChangeDown(stateNum);
}
bool IOPMrootDomain::askChangeDown ( unsigned long )
{
return super::tellClientsWithResponse(kIOMessageCanSystemSleep);
}
void IOPMrootDomain::tellNoChangeDown ( unsigned long )
{
return tellClients(kIOMessageSystemWillNotSleep);
}
void IOPMrootDomain::tellChangeUp ( unsigned long stateNum)
{
if ( stateNum == ON_STATE )
{
return tellClients(kIOMessageSystemHasPoweredOn);
}
}
void IOPMrootDomain::reportUserInput ( void )
{
OSIterator * iter;
if(!wrangler)
{
iter = getMatchingServices(serviceMatching("IODisplayWrangler"));
if(iter)
{
wrangler = (IOService *) iter->getNextObject();
iter->release();
}
}
if(wrangler)
wrangler->activityTickle(0,0);
}
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 )
{
ioSPMTrace(IOPOWER_ROOT, * (int *) this, (int) true, (int) ordinal);
return super::changePowerStateTo(ordinal);
}
IOReturn IOPMrootDomain::changePowerStateToPriv ( unsigned long ordinal )
{
ioSPMTrace(IOPOWER_ROOT, * (int *) this, (int) false, (int) ordinal);
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:
rootDomain->powerOverrideOnPriv();
params->returnValue = 20 * 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;
}
IOReturn IOPMrootDomain::displayWranglerNotification( void * target, void * refCon,
UInt32 messageType, IOService * service,
void * messageArgument, vm_size_t argSize )
{
IOPMrootDomain * rootDomain = OSDynamicCast(IOPMrootDomain, (IOService *)target);
AbsoluteTime deadline;
static bool deviceAlreadyPoweredOff = false;
if(!rootDomain)
return kIOReturnUnsupported;
switch (messageType) {
case kIOMessageDeviceWillPowerOff:
if( deviceAlreadyPoweredOff ) return kIOReturnUnsupported;
deviceAlreadyPoweredOff = true;
if( rootDomain->extraSleepDelay )
{
clock_interval_to_deadline(rootDomain->extraSleepDelay*60, kSecondScale, &deadline );
thread_call_enter_delayed(rootDomain->extraSleepTimer, deadline);
rootDomain->idleSleepPending = true;
} else {
if( (0 != rootDomain->user_spindown) && (0 != rootDomain->sleepSlider) )
rootDomain->setQuickSpinDownTimeout();
}
break;
case kIOMessageDeviceHasPoweredOn:
deviceAlreadyPoweredOff = false;
rootDomain->adjustPowerState();
if(rootDomain->idleSleepPending)
{
thread_call_cancel(rootDomain->extraSleepTimer);
rootDomain->idleSleepPending = false;
}
if(0 != rootDomain->user_spindown)
rootDomain->restoreUserSpinDownTimeout();
break;
default:
break;
}
return kIOReturnUnsupported;
}
bool IOPMrootDomain::displayWranglerPublished( void * target, void * refCon,
IOService * newService)
{
IOPMrootDomain * rootDomain = OSDynamicCast(IOPMrootDomain, (IOService *)target);
if(!rootDomain)
return false;
rootDomain->wrangler = newService;
if( !rootDomain->wrangler->registerInterest( gIOGeneralInterest, &displayWranglerNotification, target, 0) ) {
IOLog("IOPMrootDomain::displayWranglerPublished registerInterest failed\n");
return false;
}
return true;
}
void IOPMrootDomain::adjustPowerState( void )
{
if ( (sleepSlider == 0) ||
! allowSleep ||
systemBooting ) {
changePowerStateToPriv(ON_STATE);
} else {
if ( sleepASAP )
{
sleepASAP = false;
if ( sleepIsSupported )
{
changePowerStateToPriv(SLEEP_STATE);
} else {
changePowerStateToPriv(DOZE_STATE);
}
}
}
}
#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();
registerPowerDriver(this,patriarchPowerStates,number_of_power_states);
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);
}