#include <IOKit/assert.h>
#include <IOKit/IOKitDebug.h>
#include <IOKit/IOLib.h>
#include <IOKit/IOMessage.h>
#include <IOKit/IOPlatformExpert.h>
#include <IOKit/IOService.h>
#include <IOKit/IOTimerEventSource.h>
#include <IOKit/IOWorkLoop.h>
#include <IOKit/IOCommand.h>
#include <IOKit/pwr_mgt/IOPMlog.h>
#include <IOKit/pwr_mgt/IOPMinformee.h>
#include <IOKit/pwr_mgt/IOPMinformeeList.h>
#include <IOKit/pwr_mgt/IOPowerConnection.h>
#include <IOKit/pwr_mgt/RootDomain.h>
#include <sys/proc.h>
#include "IOServicePrivate.h"
#include "IOServicePMPrivate.h"
#include "IOKitKernelInternal.h"
static void settle_timer_expired(thread_call_param_t, thread_call_param_t);
static void PM_idle_timer_expired(OSObject *, IOTimerEventSource *);
void tellAppWithResponse(OSObject * object, void * context) { }
void tellClientWithResponse(OSObject * object, void * context) { }
void tellClient(OSObject * object, void * context);
IOReturn serializedAllowPowerChange(OSObject *, void *, void *, void *, void *);
static uint64_t computeTimeDeltaNS( const AbsoluteTime * start )
{
AbsoluteTime now;
uint64_t nsec;
clock_get_uptime(&now);
SUB_ABSOLUTETIME(&now, start);
absolutetime_to_nanoseconds(now, &nsec);
return nsec;
}
OSDefineMetaClassAndStructors(IOPMprot, OSObject)
#define LOG_SETPOWER_TIMES (50ULL * 1000ULL * 1000ULL)
#define LOG_APP_RESPONSE_TIMES (100ULL * 1000ULL * 1000ULL)
static bool gIOPMInitialized = false;
static IOItemCount gIOPMBusyCount = 0;
static IOWorkLoop * gIOPMWorkLoop = 0;
static IOPMRequestQueue * gIOPMRequestQueue = 0;
static IOPMRequestQueue * gIOPMReplyQueue = 0;
static IOPMRequestQueue * gIOPMFreeQueue = 0;
#define PM_ERROR(x...) do { kprintf(x); IOLog(x); } while (false)
#define PM_DEBUG(x...) do { kprintf(x); } while (false)
#define PM_TRACE(x...) do { \
if (kIOLogDebugPower & gIOKitDebug) kprintf(x); } while (false)
#define PM_CONNECT(x...)
#define PM_ASSERT_IN_GATE(x) \
do { \
assert(gIOPMWorkLoop->inGate()); \
} while(false)
#define PM_LOCK() IOLockLock(fPMLock)
#define PM_UNLOCK() IOLockUnlock(fPMLock)
#define ns_per_us 1000
#define k30seconds (30*1000000)
#define kMinAckTimeoutTicks (10*1000000)
#define kIOPMTardyAckSPSKey "IOPMTardyAckSetPowerState"
#define kIOPMTardyAckPSCKey "IOPMTardyAckPowerStateChange"
#define kPwrMgtKey "IOPowerManagement"
#define OUR_PMLog(t, a, b) \
do { fPlatform->PMLog( fName, t, a, b); } while(0)
#define NS_TO_MS(nsec) ((int)((nsec) / 1000000ULL))
#if CONFIG_EMBEDDED
#define SUPPORT_IDLE_CANCEL 1
#endif
enum {
kIOPM_OurChangeTellClientsPowerDown = 1,
kIOPM_OurChangeTellPriorityClientsPowerDown = 2,
kIOPM_OurChangeNotifyInterestedDriversWillChange = 3,
kIOPM_OurChangeSetPowerState = 4,
kIOPM_OurChangeWaitForPowerSettle = 5,
kIOPM_OurChangeNotifyInterestedDriversDidChange = 6,
kIOPM_OurChangeFinish = 7,
kIOPM_ParentDownTellPriorityClientsPowerDown = 8,
kIOPM_ParentDownNotifyInterestedDriversWillChange = 9,
kIOPM_ParentDownNotifyDidChangeAndAcknowledgeChange = 11,
kIOPM_ParentDownSetPowerState = 12,
kIOPM_ParentDownWaitForPowerSettle = 13,
kIOPM_ParentDownAcknowledgeChange = 14,
kIOPM_ParentUpSetPowerState = 15,
kIOPM_ParentUpWaitForSettleTime = 17,
kIOPM_ParentUpNotifyInterestedDriversDidChange = 18,
kIOPM_ParentUpAcknowledgePowerChange = 19,
kIOPM_Finished = 20,
kIOPM_DriverThreadCallDone = 21,
kIOPM_NotifyChildrenDone = 22
};
void IOService::PMinit ( void )
{
if ( !initialized )
{
if ( !gIOPMInitialized )
{
gIOPMWorkLoop = IOWorkLoop::workLoop();
if (gIOPMWorkLoop)
{
gIOPMRequestQueue = IOPMRequestQueue::create(
this, OSMemberFunctionCast(IOPMRequestQueue::Action,
this, &IOService::servicePMRequestQueue));
gIOPMReplyQueue = IOPMRequestQueue::create(
this, OSMemberFunctionCast(IOPMRequestQueue::Action,
this, &IOService::servicePMReplyQueue));
gIOPMFreeQueue = IOPMRequestQueue::create(
this, OSMemberFunctionCast(IOPMRequestQueue::Action,
this, &IOService::servicePMFreeQueue));
if (gIOPMWorkLoop->addEventSource(gIOPMRequestQueue) !=
kIOReturnSuccess)
{
gIOPMRequestQueue->release();
gIOPMRequestQueue = 0;
}
if (gIOPMWorkLoop->addEventSource(gIOPMReplyQueue) !=
kIOReturnSuccess)
{
gIOPMReplyQueue->release();
gIOPMReplyQueue = 0;
}
if (gIOPMWorkLoop->addEventSource(gIOPMFreeQueue) !=
kIOReturnSuccess)
{
gIOPMFreeQueue->release();
gIOPMFreeQueue = 0;
}
}
if (gIOPMRequestQueue && gIOPMReplyQueue && gIOPMFreeQueue)
gIOPMInitialized = true;
}
if (!gIOPMInitialized)
return;
pwrMgt = new IOServicePM;
pwrMgt->init();
setProperty(kPwrMgtKey, pwrMgt);
fOwner = this;
fWeAreRoot = false;
fPMLock = IOLockAlloc();
fInterestedDrivers = new IOPMinformeeList;
fInterestedDrivers->initialize();
fDesiredPowerState = 0;
fDriverDesire = 0;
fDeviceDesire = 0;
fInitialChange = true;
fNeedToBecomeUsable = false;
fPreviousRequest = 0;
fDeviceOverrides = false;
fMachineState = kIOPM_Finished;
fIdleTimerEventSource = NULL;
fIdleTimerMinPowerState = 0;
fActivityLock = IOLockAlloc();
fClampOn = false;
fStrictTreeOrder = false;
fActivityTicklePowerState = -1;
fControllingDriver = NULL;
fPowerStates = NULL;
fNumberOfPowerStates = 0;
fCurrentPowerState = 0;
fParentsCurrentPowerFlags = 0;
fMaxCapability = 0;
fName = getName();
fPlatform = getPlatform();
fParentsKnowState = false;
fSerialNumber = 0;
fResponseArray = NULL;
fDoNotPowerDown = true;
fCurrentPowerConsumption = kIOPMUnknown;
for (unsigned int i = 0; i <= kMaxType; i++)
{
fAggressivenessValue[i] = 0;
fAggressivenessValid[i] = false;
}
fAckTimer = thread_call_allocate(
&IOService::ack_timer_expired, (thread_call_param_t)this);
fSettleTimer = thread_call_allocate(
&settle_timer_expired, (thread_call_param_t)this);
fDriverCallEntry = thread_call_allocate(
(thread_call_func_t) &IOService::pmDriverCallout, this);
assert(fDriverCallEntry);
#if PM_VARS_SUPPORT
IOPMprot * prot = new IOPMprot;
if (prot)
{
prot->init();
prot->ourName = fName;
prot->thePlatform = fPlatform;
fPMVars = prot;
pm_vars = prot;
}
#else
pm_vars = (IOPMprot *) true;
#endif
initialized = true;
}
}
void IOService::PMfree ( void )
{
initialized = false;
pm_vars = 0;
if ( pwrMgt )
{
assert(fMachineState == kIOPM_Finished);
assert(fInsertInterestSet == NULL);
assert(fRemoveInterestSet == NULL);
assert(fNotifyChildArray == NULL);
if ( fIdleTimerEventSource != NULL ) {
getPMworkloop()->removeEventSource(fIdleTimerEventSource);
fIdleTimerEventSource->release();
fIdleTimerEventSource = NULL;
}
if ( fSettleTimer ) {
thread_call_cancel(fSettleTimer);
thread_call_free(fSettleTimer);
fSettleTimer = NULL;
}
if ( fAckTimer ) {
thread_call_cancel(fAckTimer);
thread_call_free(fAckTimer);
fAckTimer = NULL;
}
if ( fDriverCallEntry ) {
thread_call_free(fDriverCallEntry);
fDriverCallEntry = NULL;
}
if ( fPMLock ) {
IOLockFree(fPMLock);
fPMLock = NULL;
}
if ( fActivityLock ) {
IOLockFree(fActivityLock);
fActivityLock = NULL;
}
if ( fInterestedDrivers ) {
fInterestedDrivers->release();
fInterestedDrivers = NULL;
}
if ( fPMWorkQueue ) {
getPMworkloop()->removeEventSource(fPMWorkQueue);
fPMWorkQueue->release();
fPMWorkQueue = 0;
}
if (fDriverCallParamSlots && fDriverCallParamPtr) {
IODelete(fDriverCallParamPtr, DriverCallParam, fDriverCallParamSlots);
fDriverCallParamPtr = 0;
fDriverCallParamSlots = 0;
}
if ( fResponseArray ) {
fResponseArray->release();
fResponseArray = NULL;
}
if (fPowerStates && fNumberOfPowerStates) {
IODelete(fPowerStates, IOPMPowerState, fNumberOfPowerStates);
fNumberOfPowerStates = 0;
fPowerStates = NULL;
}
#if PM_VARS_SUPPORT
if (fPMVars)
{
fPMVars->release();
fPMVars = 0;
}
#endif
pwrMgt->release();
pwrMgt = 0;
}
}
void IOService::joinPMtree ( IOService * driver )
{
IOPlatformExpert * platform;
platform = getPlatform();
assert(platform != 0);
platform->PMRegisterDevice(this, driver);
}
IOReturn IOService::youAreRoot ( void )
{
fWeAreRoot = true;
fParentsKnowState = true;
attachToParent( getRegistryRoot(), gIOPowerPlane );
return IOPMNoErr;
}
void IOService::PMstop ( void )
{
IOPMRequest * request;
if (!initialized)
return;
PM_LOCK();
fWillPMStop = true;
if (fDriverCallBusy)
PM_DEBUG("%s::PMstop() driver call busy\n", getName());
PM_UNLOCK();
request = acquirePMRequest( this, kIOPMRequestTypePMStop );
if (request)
{
PM_TRACE("[%s] %p PMstop\n", getName(), this);
submitPMRequest( request );
}
}
void IOService::handlePMstop ( IOPMRequest * request )
{
OSIterator * iter;
OSObject * next;
IOPowerConnection * connection;
IOService * theChild;
IOService * theParent;
PM_ASSERT_IN_GATE();
PM_TRACE("[%s] %p %s start\n", getName(), this, __FUNCTION__);
removeProperty(kPwrMgtKey);
iter = getParentIterator(gIOPowerPlane);
if ( iter )
{
while ( (next = iter->getNextObject()) )
{
if ( (connection = OSDynamicCast(IOPowerConnection, next)) )
{
theParent = (IOService *)connection->copyParentEntry(gIOPowerPlane);
if ( theParent )
{
theParent->removePowerChild(connection);
theParent->release();
}
}
}
iter->release();
}
detachAbove( gIOPowerPlane );
fParentsKnowState = false;
iter = getChildIterator(gIOPowerPlane);
if ( iter )
{
while ( (next = iter->getNextObject()) )
{
if ( (connection = OSDynamicCast(IOPowerConnection, next)) )
{
theChild = ((IOService *)(connection->copyChildEntry(gIOPowerPlane)));
if ( theChild )
{
connection->detachFromChild(theChild, gIOPowerPlane);
theChild->release();
}
detachFromChild(connection, gIOPowerPlane);
}
}
iter->release();
}
if ( fInterestedDrivers )
{
IOPMinformeeList * list = fInterestedDrivers;
IOPMinformee * item;
PM_LOCK();
while ((item = list->firstInList()))
{
list->removeFromList(item->whatObject);
}
PM_UNLOCK();
}
fIdleTimerPeriod = 0;
fWillPMStop = false;
PM_TRACE("[%s] %p %s done\n", getName(), this, __FUNCTION__);
}
IOReturn IOService::addPowerChild ( IOService * child )
{
IOPowerConnection * connection = 0;
IOPMRequest * requests[3] = {0, 0, 0};
OSIterator * iter;
bool ok = true;
if (!child)
return kIOReturnBadArgument;
if (!initialized || !child->initialized)
return IOPMNotYetInitialized;
OUR_PMLog( kPMLogAddChild, 0, 0 );
do {
iter = child->getParentIterator( gIOPowerPlane );
if ( iter )
{
IORegistryEntry * entry;
OSObject * next;
while ((next = iter->getNextObject()))
{
if ((entry = OSDynamicCast(IORegistryEntry, next)) &&
isChild(entry, gIOPowerPlane))
{
ok = false;
break;
}
}
iter->release();
}
if (!ok)
{
PM_DEBUG("[%s] %s (%p) is already a child\n",
getName(), child->getName(), child);
break;
}
connection = new IOPowerConnection;
if (!connection)
break;
requests[0] = acquirePMRequest(
this,
kIOPMRequestTypeAddPowerChild1 );
requests[1] = acquirePMRequest(
child,
kIOPMRequestTypeAddPowerChild2 );
requests[2] = acquirePMRequest(
this,
kIOPMRequestTypeAddPowerChild3 );
if (!requests[0] || !requests[1] || !requests[2])
break;
requests[0]->setParentRequest( requests[1] );
requests[1]->setParentRequest( requests[2] );
connection->init();
connection->start(this);
connection->setAwaitingAck(false);
connection->setReadyFlag(false);
attachToChild( connection, gIOPowerPlane );
connection->attachToChild( child, gIOPowerPlane );
requests[0]->fArg0 = connection;
requests[1]->fArg0 = connection;
requests[2]->fArg0 = connection;
submitPMRequest( requests, 3 );
return kIOReturnSuccess;
}
while (false);
if (connection) connection->release();
if (requests[0]) releasePMRequest(requests[0]);
if (requests[1]) releasePMRequest(requests[1]);
if (requests[2]) releasePMRequest(requests[2]);
return IOPMNoErr;
}
void IOService::addPowerChild1 ( IOPMRequest * request )
{
unsigned long tempDesire = 0;
PM_ASSERT_IN_GATE();
OUR_PMLog( kPMLogMakeUsable, kPMLogMakeUsable, fDeviceDesire );
if (fControllingDriver && inPlane(gIOPowerPlane) && fParentsKnowState)
{
tempDesire = fNumberOfPowerStates - 1;
}
if (tempDesire && (fWeAreRoot || (fMaxCapability >= tempDesire)))
{
computeDesiredState( tempDesire );
changeState();
}
}
void IOService::addPowerChild2 ( IOPMRequest * request )
{
IOPowerConnection * connection = (IOPowerConnection *) request->fArg0;
IOService * parent;
IOPMPowerFlags powerFlags;
bool knowsState;
unsigned long powerState;
unsigned long tempDesire;
PM_ASSERT_IN_GATE();
parent = (IOService *) connection->getParentEntry(gIOPowerPlane);
if (!parent || !inPlane(gIOPowerPlane))
{
PM_DEBUG("[%s] addPowerChild2 not in power plane\n", getName());
return;
}
knowsState = (parent->fPowerStates) && (parent->fParentsKnowState);
powerState = parent->fCurrentPowerState;
if (knowsState)
powerFlags = parent->fPowerStates[powerState].outputPowerCharacter;
else
powerFlags = 0;
OUR_PMLog(kPMLogSetParent, knowsState, powerFlags);
setParentInfo( powerFlags, connection, knowsState );
connection->setReadyFlag(true);
if ( fControllingDriver && fParentsKnowState )
{
fMaxCapability = fControllingDriver->maxCapabilityForDomainState(fParentsCurrentPowerFlags);
tempDesire = fControllingDriver->initialPowerStateForDomainState(fParentsCurrentPowerFlags);
computeDesiredState(tempDesire);
fPreviousRequest = 0xffffffff;
changeState();
}
}
void IOService::addPowerChild3 ( IOPMRequest * request )
{
IOPowerConnection * connection = (IOPowerConnection *) request->fArg0;
IOService * child;
unsigned int i;
PM_ASSERT_IN_GATE();
child = (IOService *) connection->getChildEntry(gIOPowerPlane);
if (child && inPlane(gIOPowerPlane))
{
if (child->getProperty("IOPMStrictTreeOrder"))
{
PM_DEBUG("[%s] strict ordering enforced\n", getName());
fStrictTreeOrder = true;
}
for (i = 0; i <= kMaxType; i++)
{
if ( fAggressivenessValid[i] )
{
child->setAggressiveness(i, fAggressivenessValue[i]);
}
}
}
else
{
PM_DEBUG("[%s] addPowerChild3 not in power plane\n", getName());
}
connection->release();
}
IOReturn IOService::setPowerParent (
IOPowerConnection * theParent, bool stateKnown, IOPMPowerFlags powerFlags )
{
return kIOReturnUnsupported;
}
IOReturn IOService::removePowerChild ( IOPowerConnection * theNub )
{
IORegistryEntry * theChild;
PM_ASSERT_IN_GATE();
OUR_PMLog( kPMLogRemoveChild, 0, 0 );
theNub->retain();
theChild = theNub->copyChildEntry(gIOPowerPlane);
if ( theChild )
{
theNub->detachFromChild(theChild, gIOPowerPlane);
theChild->release();
}
detachFromChild(theNub, gIOPowerPlane);
if ( theNub->getAwaitingAck() )
{
theNub->setAwaitingAck(false);
if (fHeadNotePendingAcks != 0 )
{
fHeadNotePendingAcks--;
if ( fHeadNotePendingAcks == 0 )
{
stop_ack_timer();
}
}
}
theNub->release();
if (!fWillAdjustPowerState)
{
IOPMRequest * request;
request = acquirePMRequest( this, kIOPMRequestTypeAdjustPowerState );
if (request)
{
submitPMRequest( request );
fWillAdjustPowerState = true;
}
}
return IOPMNoErr;
}
IOReturn IOService::registerPowerDriver (
IOService * powerDriver,
IOPMPowerState * powerStates,
unsigned long numberOfStates )
{
IOPMRequest * request;
IOPMPowerState * powerStatesCopy = 0;
if (!initialized)
return IOPMNotYetInitialized;
if (!powerStates || (numberOfStates < 2))
{
OUR_PMLog(kPMLogControllingDriverErr5, numberOfStates, 0);
return kIOReturnBadArgument;
}
if (!powerDriver)
{
OUR_PMLog(kPMLogControllingDriverErr4, 0, 0);
return kIOReturnBadArgument;
}
if (powerStates[0].version != kIOPMPowerStateVersion1)
{
OUR_PMLog(kPMLogControllingDriverErr1, powerStates[0].version, 0);
return kIOReturnBadArgument;
}
do {
powerStatesCopy = IONew(IOPMPowerState, numberOfStates);
if (!powerStatesCopy)
break;
bcopy( powerStates, powerStatesCopy,
sizeof(IOPMPowerState) * numberOfStates );
request = acquirePMRequest( this, kIOPMRequestTypeRegisterPowerDriver );
if (!request)
break;
powerDriver->retain();
request->fArg0 = (void *) powerDriver;
request->fArg1 = (void *) powerStatesCopy;
request->fArg2 = (void *) numberOfStates;
submitPMRequest( request );
return kIOReturnSuccess;
}
while (false);
if (powerStatesCopy)
IODelete(powerStatesCopy, IOPMPowerState, numberOfStates);
return kIOReturnNoMemory;
}
void IOService::handleRegisterPowerDriver ( IOPMRequest * request )
{
IOService * powerDriver = (IOService *) request->fArg0;
IOPMPowerState * powerStates = (IOPMPowerState *) request->fArg1;
unsigned long numberOfStates = (unsigned long) request->fArg2;
unsigned long i;
IOService * root;
PM_ASSERT_IN_GATE();
assert(powerStates);
assert(powerDriver);
assert(numberOfStates > 1);
if ( !fNumberOfPowerStates )
{
OUR_PMLog(kPMLogControllingDriver,
(unsigned long) numberOfStates,
(unsigned long) powerStates[0].version);
fPowerStates = powerStates;
fNumberOfPowerStates = numberOfStates;
fControllingDriver = powerDriver;
fCurrentCapabilityFlags = fPowerStates[0].capabilityFlags;
fOutputPowerCharacterFlags = 0;
for ( i = 0; i < numberOfStates; i++ ) {
fOutputPowerCharacterFlags |= fPowerStates[i].outputPowerCharacter;
}
root = getPlatform()->getProvider();
assert(root);
if (!root ||
((OSMemberFunctionCast(void (*)(void),
root, &IOService::powerStateDidChangeTo)) !=
((OSMemberFunctionCast(void (*)(void),
this, &IOService::powerStateDidChangeTo)))) ||
((OSMemberFunctionCast(void (*)(void),
root, &IOService::powerStateWillChangeTo)) !=
((OSMemberFunctionCast(void (*)(void),
this, &IOService::powerStateWillChangeTo)))))
{
if (fInterestedDrivers->findItem(powerDriver) == NULL)
{
PM_LOCK();
fInterestedDrivers->appendNewInformee(powerDriver);
PM_UNLOCK();
}
}
if ( fNeedToBecomeUsable ) {
fNeedToBecomeUsable = false;
fDeviceDesire = fNumberOfPowerStates - 1;
}
if ( inPlane(gIOPowerPlane) && fParentsKnowState )
{
unsigned long tempDesire;
fMaxCapability = fControllingDriver->maxCapabilityForDomainState(fParentsCurrentPowerFlags);
tempDesire = fControllingDriver->initialPowerStateForDomainState(fParentsCurrentPowerFlags);
computeDesiredState(tempDesire);
changeState();
}
}
else
{
OUR_PMLog(kPMLogControllingDriverErr2, numberOfStates, 0);
IODelete(powerStates, IOPMPowerState, numberOfStates);
}
powerDriver->release();
}
IOPMPowerFlags IOService::registerInterestedDriver ( IOService * driver )
{
IOPMRequest * request;
bool signal;
if (!initialized || !fInterestedDrivers)
return IOPMNotPowerManaged;
PM_LOCK();
signal = (!fInsertInterestSet && !fRemoveInterestSet);
if (fInsertInterestSet == NULL)
fInsertInterestSet = OSSet::withCapacity(4);
if (fInsertInterestSet)
fInsertInterestSet->setObject(driver);
PM_UNLOCK();
if (signal)
{
request = acquirePMRequest( this, kIOPMRequestTypeInterestChanged );
if (request)
submitPMRequest( request );
}
OUR_PMLog(kPMLogInterestedDriver, kIOPMDeviceUsable, 2);
return kIOPMDeviceUsable;
}
IOReturn IOService::deRegisterInterestedDriver ( IOService * driver )
{
IOPMinformeeList * list;
IOPMinformee * item;
IOPMRequest * request;
bool signal;
if (!initialized || !fInterestedDrivers)
return IOPMNotPowerManaged;
PM_LOCK();
signal = (!fRemoveInterestSet && !fInsertInterestSet);
if (fRemoveInterestSet == NULL)
fRemoveInterestSet = OSSet::withCapacity(4);
if (fRemoveInterestSet)
{
fRemoveInterestSet->setObject(driver);
list = fInterestedDrivers;
item = list->findItem(driver);
if (item && item->active)
{
item->active = false;
}
if (fDriverCallBusy)
PM_DEBUG("%s::deRegisterInterestedDriver() driver call busy\n", getName());
}
PM_UNLOCK();
if (signal)
{
request = acquirePMRequest( this, kIOPMRequestTypeInterestChanged );
if (request)
submitPMRequest( request );
}
return IOPMNoErr;
}
void IOService::handleInterestChanged( IOPMRequest * request )
{
IOService * driver;
IOPMinformee * informee;
IOPMinformeeList * list = fInterestedDrivers;
PM_LOCK();
if (fInsertInterestSet)
{
while ((driver = (IOService *) fInsertInterestSet->getAnyObject()))
{
if ((list->findItem(driver) == NULL) &&
(!fRemoveInterestSet ||
!fRemoveInterestSet->containsObject(driver)))
{
informee = list->appendNewInformee(driver);
}
fInsertInterestSet->removeObject(driver);
}
fInsertInterestSet->release();
fInsertInterestSet = 0;
}
if (fRemoveInterestSet)
{
while ((driver = (IOService *) fRemoveInterestSet->getAnyObject()))
{
informee = list->findItem(driver);
if (informee)
{
if (fHeadNotePendingAcks && informee->timer)
{
informee->timer = 0;
fHeadNotePendingAcks--;
}
list->removeFromList(driver);
}
fRemoveInterestSet->removeObject(driver);
}
fRemoveInterestSet->release();
fRemoveInterestSet = 0;
}
PM_UNLOCK();
}
IOReturn IOService::acknowledgePowerChange ( IOService * whichObject )
{
IOPMRequest * request;
if (!initialized)
return IOPMNotYetInitialized;
if (!whichObject)
return kIOReturnBadArgument;
request = acquirePMRequest( this, kIOPMRequestTypeAckPowerChange );
if (!request)
{
PM_ERROR("%s::%s no memory\n", getName(), __FUNCTION__);
return kIOReturnNoMemory;
}
whichObject->retain();
request->fArg0 = whichObject;
submitPMRequest( request );
return IOPMNoErr;
}
bool IOService::handleAcknowledgePowerChange ( IOPMRequest * request )
{
IOPMinformee * informee;
unsigned long childPower = kIOPMUnknown;
IOService * theChild;
IOService * whichObject;
bool all_acked = false;
PM_ASSERT_IN_GATE();
whichObject = (IOService *) request->fArg0;
assert(whichObject);
informee = fInterestedDrivers->findItem( whichObject );
if ( informee == NULL )
{
if ( !isChild(whichObject, gIOPowerPlane) )
{
OUR_PMLog(kPMLogAcknowledgeErr1, 0, 0);
goto no_err;
} else {
OUR_PMLog(kPMLogChildAcknowledge, fHeadNotePendingAcks, 0);
}
} else {
OUR_PMLog(kPMLogDriverAcknowledge, fHeadNotePendingAcks, 0);
}
if ( fHeadNotePendingAcks != 0 )
{
assert(fPowerStates != NULL);
if ( informee != NULL )
{
if ( informee->timer != 0 )
{
#if LOG_SETPOWER_TIMES
if (informee->timer > 0)
{
uint64_t nsec = computeTimeDeltaNS(&informee->startTime);
if (nsec > LOG_SETPOWER_TIMES)
PM_DEBUG("%s::powerState%sChangeTo(%p, %s, %lu -> %lu) async took %d ms\n",
informee->whatObject->getName(),
(fDriverCallReason == kDriverCallInformPreChange) ? "Will" : "Did",
informee->whatObject,
fName, fCurrentPowerState, fHeadNoteState, NS_TO_MS(nsec));
}
#endif
informee->timer = 0;
fHeadNotePendingAcks--;
} else {
OUR_PMLog(kPMLogAcknowledgeErr2, 0, 0);
}
} else {
if ( ((IOPowerConnection *)whichObject)->getAwaitingAck() )
{
fHeadNotePendingAcks--;
((IOPowerConnection *)whichObject)->setAwaitingAck(false);
theChild = (IOService *)whichObject->copyChildEntry(gIOPowerPlane);
if ( theChild )
{
childPower = theChild->currentPowerConsumption();
theChild->release();
}
if ( childPower == kIOPMUnknown )
{
fPowerStates[fHeadNoteState].staticPower = kIOPMUnknown;
} else {
if ( fPowerStates[fHeadNoteState].staticPower != kIOPMUnknown )
{
fPowerStates[fHeadNoteState].staticPower += childPower;
}
}
}
}
if ( fHeadNotePendingAcks == 0 ) {
stop_ack_timer();
all_acked = true;
}
} else {
OUR_PMLog(kPMLogAcknowledgeErr3, 0, 0); }
no_err:
if (whichObject)
whichObject->release();
return all_acked;
}
IOReturn IOService::acknowledgeSetPowerState ( void )
{
IOPMRequest * request;
if (!initialized)
return IOPMNotYetInitialized;
request = acquirePMRequest( this, kIOPMRequestTypeAckSetPowerState );
if (!request)
{
PM_ERROR("%s::%s no memory\n", getName(), __FUNCTION__);
return kIOReturnNoMemory;
}
submitPMRequest( request );
return kIOReturnSuccess;
}
void IOService::adjustPowerState( void )
{
PM_ASSERT_IN_GATE();
if (inPlane(gIOPowerPlane))
{
rebuildChildClampBits();
computeDesiredState();
if ( fControllingDriver && fParentsKnowState )
changeState();
}
else
{
PM_DEBUG("[%s] %s: not in power tree\n", getName(), __FUNCTION__);
return;
}
fWillAdjustPowerState = false;
}
IOReturn IOService::powerDomainWillChangeTo (
IOPMPowerFlags newPowerFlags,
IOPowerConnection * whichParent )
{
assert(false);
return kIOReturnUnsupported;
}
void IOService::handlePowerDomainWillChangeTo ( IOPMRequest * request )
{
IOPMPowerFlags newPowerFlags = (IOPMPowerFlags) request->fArg0;
IOPowerConnection * whichParent = (IOPowerConnection *) request->fArg1;
bool powerWillDrop = (bool) request->fArg2;
OSIterator * iter;
OSObject * next;
IOPowerConnection * connection;
unsigned long newPowerState;
IOPMPowerFlags combinedPowerFlags;
bool savedParentsKnowState;
IOReturn result = IOPMAckImplied;
PM_ASSERT_IN_GATE();
OUR_PMLog(kPMLogWillChange, newPowerFlags, 0);
if (!inPlane(gIOPowerPlane) || !whichParent || !whichParent->getAwaitingAck())
{
PM_DEBUG("[%s] %s: not in power tree\n", getName(), __FUNCTION__);
goto exit_no_ack;
}
savedParentsKnowState = fParentsKnowState;
combinedPowerFlags = 0;
iter = getParentIterator(gIOPowerPlane);
if ( iter )
{
while ( (next = iter->getNextObject()) )
{
if ( (connection = OSDynamicCast(IOPowerConnection, next)) )
{
if ( connection == whichParent )
combinedPowerFlags |= newPowerFlags;
else
combinedPowerFlags |= connection->parentCurrentPowerFlags();
}
}
iter->release();
}
if ( fControllingDriver )
{
newPowerState = fControllingDriver->maxCapabilityForDomainState(
combinedPowerFlags);
result = enqueuePowerChange(
IOPMParentInitiated | IOPMDomainWillChange,
newPowerState,
combinedPowerFlags,
whichParent,
newPowerFlags);
}
if (powerWillDrop)
{
setParentInfo(newPowerFlags, whichParent, true);
}
if (IOPMAckImplied == result)
{
IOService * parent;
parent = (IOService *) whichParent->copyParentEntry(gIOPowerPlane);
assert(parent);
if ( parent )
{
parent->acknowledgePowerChange( whichParent );
parent->release();
}
}
if (!savedParentsKnowState && fParentsKnowState)
{
PM_TRACE("[%s] powerDomainWillChangeTo: parentsKnowState = true\n",
getName());
ask_parent( fDesiredPowerState );
}
exit_no_ack:
if (whichParent) whichParent->release();
}
IOReturn IOService::powerDomainDidChangeTo (
IOPMPowerFlags newPowerFlags,
IOPowerConnection * whichParent )
{
assert(false);
return kIOReturnUnsupported;
}
void IOService::handlePowerDomainDidChangeTo ( IOPMRequest * request )
{
IOPMPowerFlags newPowerFlags = (IOPMPowerFlags) request->fArg0;
IOPowerConnection * whichParent = (IOPowerConnection *) request->fArg1;
unsigned long newPowerState;
bool savedParentsKnowState;
IOReturn result = IOPMAckImplied;
PM_ASSERT_IN_GATE();
OUR_PMLog(kPMLogDidChange, newPowerFlags, 0);
if (!inPlane(gIOPowerPlane) || !whichParent || !whichParent->getAwaitingAck())
{
PM_DEBUG("[%s] %s: not in power tree\n", getName(), __FUNCTION__);
goto exit_no_ack;
}
savedParentsKnowState = fParentsKnowState;
setParentInfo(newPowerFlags, whichParent, true);
if ( fControllingDriver )
{
newPowerState = fControllingDriver->maxCapabilityForDomainState(
fParentsCurrentPowerFlags);
result = enqueuePowerChange(
IOPMParentInitiated | IOPMDomainDidChange,
newPowerState,
fParentsCurrentPowerFlags,
whichParent,
0);
}
if (IOPMAckImplied == result)
{
IOService * parent;
parent = (IOService *) whichParent->copyParentEntry(gIOPowerPlane);
assert(parent);
if ( parent )
{
parent->acknowledgePowerChange( whichParent );
parent->release();
}
}
if (!savedParentsKnowState && fParentsKnowState)
{
PM_TRACE("[%s] powerDomainDidChangeTo: parentsKnowState = true\n",
getName());
ask_parent( fDesiredPowerState );
}
exit_no_ack:
if (whichParent) whichParent->release();
}
void IOService::setParentInfo (
IOPMPowerFlags newPowerFlags,
IOPowerConnection * whichParent,
bool knowsState )
{
OSIterator * iter;
OSObject * next;
IOPowerConnection * conn;
PM_ASSERT_IN_GATE();
whichParent->setParentCurrentPowerFlags(newPowerFlags);
whichParent->setParentKnowsState(knowsState);
fParentsCurrentPowerFlags = 0;
fParentsKnowState = true;
iter = getParentIterator(gIOPowerPlane);
if ( iter )
{
while ( (next = iter->getNextObject()) )
{
if ( (conn = OSDynamicCast(IOPowerConnection, next)) )
{
fParentsKnowState &= conn->parentKnowsState();
fParentsCurrentPowerFlags |= conn->parentCurrentPowerFlags();
}
}
iter->release();
}
}
void IOService::rebuildChildClampBits ( void )
{
unsigned long i;
OSIterator * iter;
OSObject * next;
IOPowerConnection * connection;
unsigned long powerState;
for ( i = 0; i < fNumberOfPowerStates; i++ )
{
fPowerStates[i].capabilityFlags &= ~(kIOPMChildClamp | kIOPMChildClamp2);
}
iter = getChildIterator(gIOPowerPlane);
if ( iter )
{
while ( (next = iter->getNextObject()) )
{
if ( (connection = OSDynamicCast(IOPowerConnection, next)) )
{
if (connection->getReadyFlag() == false)
{
PM_CONNECT("[%s] %s: connection not ready\n",
getName(), __FUNCTION__);
continue;
}
powerState = connection->getDesiredDomainState();
if (powerState < fNumberOfPowerStates)
{
if ( connection->getPreventIdleSleepFlag() )
fPowerStates[powerState].capabilityFlags |= kIOPMChildClamp;
if ( connection->getPreventSystemSleepFlag() )
fPowerStates[powerState].capabilityFlags |= kIOPMChildClamp2;
}
}
}
iter->release();
}
}
IOReturn IOService::requestPowerDomainState (
IOPMPowerFlags desiredState,
IOPowerConnection * whichChild,
unsigned long specification )
{
unsigned long i;
unsigned long computedState;
unsigned long theDesiredState;
IOService * child;
IOPMRequest * childRequest;
if (!initialized)
return IOPMNotYetInitialized;
if (gIOPMWorkLoop->onThread() == false)
{
PM_DEBUG("[%s] called requestPowerDomainState\n", getName());
return kIOReturnSuccess;
}
theDesiredState = desiredState & ~(kIOPMPreventIdleSleep | kIOPMPreventSystemSleep);
OUR_PMLog(kPMLogRequestDomain, desiredState, specification);
if (!isChild(whichChild, gIOPowerPlane))
return kIOReturnNotAttached;
if (fControllingDriver == NULL || !fPowerStates)
return IOPMNotYetInitialized;
child = (IOService *) whichChild->getChildEntry(gIOPowerPlane);
assert(child);
switch (specification) {
case IOPMLowestState:
i = 0;
while ( i < fNumberOfPowerStates )
{
if ( ( fPowerStates[i].outputPowerCharacter & theDesiredState) ==
(theDesiredState & fOutputPowerCharacterFlags) )
{
break;
}
i++;
}
if ( i >= fNumberOfPowerStates )
{
return IOPMNoSuchState;
}
break;
case IOPMNextLowerState:
i = fCurrentPowerState - 1;
while ( (int) i >= 0 )
{
if ( ( fPowerStates[i].outputPowerCharacter & theDesiredState) ==
(theDesiredState & fOutputPowerCharacterFlags) )
{
break;
}
i--;
}
if ( (int) i < 0 )
{
return IOPMNoSuchState;
}
break;
case IOPMHighestState:
i = fNumberOfPowerStates;
while ( (int) i >= 0 )
{
i--;
if ( ( fPowerStates[i].outputPowerCharacter & theDesiredState) ==
(theDesiredState & fOutputPowerCharacterFlags) )
{
break;
}
}
if ( (int) i < 0 )
{
return IOPMNoSuchState;
}
break;
case IOPMNextHigherState:
i = fCurrentPowerState + 1;
while ( i < fNumberOfPowerStates )
{
if ( ( fPowerStates[i].outputPowerCharacter & theDesiredState) ==
(theDesiredState & fOutputPowerCharacterFlags) )
{
break;
}
i++;
}
if ( i == fNumberOfPowerStates )
{
return IOPMNoSuchState;
}
break;
default:
return IOPMBadSpecification;
}
computedState = i;
if (fClampOn && !whichChild->childHasRequestedPower())
{
PM_TRACE("[%s] %p power clamp removed (child = %p)\n",
getName(), this, whichChild);
fClampOn = false;
fDeviceDesire = 0;
}
#if SUPPORT_IDLE_CANCEL
bool attemptCancel = ((kIOPMPreventIdleSleep & desiredState) && !whichChild->getPreventIdleSleepFlag());
#endif
whichChild->setDesiredDomainState( computedState );
whichChild->setPreventIdleSleepFlag( desiredState & kIOPMPreventIdleSleep );
whichChild->setPreventSystemSleepFlag( desiredState & kIOPMPreventSystemSleep );
whichChild->setChildHasRequestedPower();
if (whichChild->getReadyFlag() == false)
return IOPMNoErr;
if (!fWillAdjustPowerState && !fDeviceOverrides)
{
childRequest = acquirePMRequest( this, kIOPMRequestTypeAdjustPowerState );
if (childRequest)
{
submitPMRequest( childRequest );
fWillAdjustPowerState = true;
}
}
#if SUPPORT_IDLE_CANCEL
if (attemptCancel)
{
childRequest = acquirePMRequest( this, kIOPMRequestTypeIdleCancel );
if (childRequest)
{
submitPMRequest( childRequest );
}
}
#endif
return IOPMNoErr;
}
IOReturn IOService::temporaryPowerClampOn ( void )
{
IOPMRequest * request;
if (!initialized)
return IOPMNotYetInitialized;
request = acquirePMRequest( this, kIOPMRequestTypeTemporaryPowerClamp );
if (!request)
return kIOReturnNoMemory;
submitPMRequest( request );
return IOPMNoErr;
}
IOReturn IOService::makeUsable ( void )
{
IOPMRequest * request;
if (!initialized)
return IOPMNotYetInitialized;
OUR_PMLog(kPMLogMakeUsable, 0, 0);
request = acquirePMRequest( this, kIOPMRequestTypeMakeUsable );
if (!request)
return kIOReturnNoMemory;
submitPMRequest( request );
return IOPMNoErr;
}
void IOService::handleMakeUsable ( IOPMRequest * request )
{
PM_ASSERT_IN_GATE();
if ( fControllingDriver )
{
fDeviceDesire = fNumberOfPowerStates - 1;
computeDesiredState();
if ( inPlane(gIOPowerPlane) && fParentsKnowState )
{
changeState();
}
}
else
{
fNeedToBecomeUsable = true;
}
}
IOPMPowerFlags IOService::currentCapability ( void )
{
if (!initialized)
return IOPMNotPowerManaged;
return fCurrentCapabilityFlags;
}
IOReturn IOService::changePowerStateTo ( unsigned long ordinal )
{
IOPMRequest * request;
if (!initialized)
return IOPMNotYetInitialized;
OUR_PMLog(kPMLogChangeStateTo, ordinal, 0);
request = acquirePMRequest( this, kIOPMRequestTypeChangePowerStateTo );
if (!request)
return kIOReturnNoMemory;
request->fArg0 = (void *) ordinal;
request->fArg1 = (void *) false;
if (gIOPMWorkLoop->inGate())
{
fTempClampPowerState = max(fTempClampPowerState, ordinal);
fTempClampCount++;
request->fArg1 = (void *) true;
}
submitPMRequest( request );
return IOPMNoErr;
}
void IOService::handleChangePowerStateTo ( IOPMRequest * request )
{
unsigned long ordinal = (unsigned long) request->fArg0;
PM_ASSERT_IN_GATE();
if (request->fArg1)
{
assert(fTempClampCount != 0);
if (fTempClampCount)
fTempClampCount--;
if (!fTempClampCount)
fTempClampPowerState = 0;
}
if ( fControllingDriver && (ordinal < fNumberOfPowerStates))
{
fDriverDesire = ordinal;
computeDesiredState();
if ( inPlane(gIOPowerPlane) && fParentsKnowState )
{
changeState();
}
}
}
IOReturn IOService::changePowerStateToPriv ( unsigned long ordinal )
{
IOPMRequest * request;
if (!initialized)
return IOPMNotYetInitialized;
request = acquirePMRequest( this, kIOPMRequestTypeChangePowerStateToPriv );
if (!request)
return kIOReturnNoMemory;
request->fArg0 = (void *) ordinal;
request->fArg1 = (void *) false;
if (gIOPMWorkLoop->inGate())
{
fTempClampPowerState = max(fTempClampPowerState, ordinal);
fTempClampCount++;
request->fArg1 = (void *) true;
}
submitPMRequest( request );
return IOPMNoErr;
}
void IOService::handleChangePowerStateToPriv ( IOPMRequest * request )
{
unsigned long ordinal = (unsigned long) request->fArg0;
PM_ASSERT_IN_GATE();
OUR_PMLog(kPMLogChangeStateToPriv, ordinal, 0);
if (request->fArg1)
{
assert(fTempClampCount != 0);
if (fTempClampCount)
fTempClampCount--;
if (!fTempClampCount)
fTempClampPowerState = 0;
}
if ( fControllingDriver && (ordinal < fNumberOfPowerStates))
{
fDeviceDesire = ordinal;
computeDesiredState();
if ( inPlane(gIOPowerPlane) && fParentsKnowState )
{
changeState();
}
}
}
void IOService::computeDesiredState ( unsigned long tempDesire )
{
OSIterator * iter;
OSObject * next;
IOPowerConnection * connection;
unsigned long newDesiredState = 0;
unsigned long childDesire = 0;
unsigned long deviceDesire;
if (tempDesire)
deviceDesire = tempDesire;
else
deviceDesire = fDeviceDesire;
if (fClampOn && fNumberOfPowerStates)
deviceDesire = fNumberOfPowerStates - 1;
if ( !fDeviceOverrides )
{
iter = getChildIterator(gIOPowerPlane);
if ( iter )
{
while ( (next = iter->getNextObject()) )
{
if ( (connection = OSDynamicCast(IOPowerConnection, next)) )
{
if (connection->getReadyFlag() == false)
{
PM_CONNECT("[%s] %s: connection not ready\n",
getName(), __FUNCTION__);
continue;
}
if (connection->getDesiredDomainState() > childDesire)
childDesire = connection->getDesiredDomainState();
}
}
iter->release();
}
fChildrenDesire = childDesire;
newDesiredState = max(childDesire, fDriverDesire);
}
newDesiredState = max(deviceDesire, newDesiredState);
if (fTempClampCount && (fTempClampPowerState < fNumberOfPowerStates))
newDesiredState = max(fTempClampPowerState, newDesiredState);
fDesiredPowerState = newDesiredState;
if (fNumberOfPowerStates == 0)
fDesiredPowerState = 0;
else if (fDesiredPowerState >= fNumberOfPowerStates)
fDesiredPowerState = fNumberOfPowerStates - 1;
if (fDeviceDesire && fActivityTimerStopped)
{
fActivityTimerStopped = false;
start_PM_idle_timer();
}
if (fPMRequest && (fPMRequest->getType() != kIOPMRequestTypeActivityTickle) &&
(fActivityTicklePowerState != -1))
{
IOLockLock(fActivityLock);
fActivityTicklePowerState = -1;
IOLockUnlock(fActivityLock);
}
PM_TRACE(" NewState %ld, Child %ld, Driver %ld, Device %ld, Clamp %d (%ld)\n",
fDesiredPowerState, childDesire, fDriverDesire, deviceDesire,
fClampOn, fTempClampCount ? fTempClampPowerState : 0);
}
IOReturn IOService::changeState ( void )
{
IOReturn result;
PM_ASSERT_IN_GATE();
assert(inPlane(gIOPowerPlane));
assert(fParentsKnowState);
assert(fControllingDriver);
result = enqueuePowerChange(
IOPMWeInitiated,
fDesiredPowerState,
0,
0,
0);
return result;
}
unsigned long IOService::currentPowerConsumption ( void )
{
if (!initialized)
return kIOPMUnknown;
return fCurrentPowerConsumption;
}
IOWorkLoop * IOService::getPMworkloop ( void )
{
return gIOPMWorkLoop;
}
bool IOService::activityTickle ( unsigned long type, unsigned long stateNumber )
{
IOPMRequest * request;
bool noPowerChange = true;
if ( initialized && stateNumber && (type == kIOPMSuperclassPolicy1) )
{
IOLockLock(fActivityLock);
fDeviceActive = true;
clock_get_uptime(&fDeviceActiveTimestamp);
if (fActivityTicklePowerState < (long)stateNumber)
{
fActivityTicklePowerState = stateNumber;
noPowerChange = false;
request = acquirePMRequest( this, kIOPMRequestTypeActivityTickle );
if (request)
{
request->fArg0 = (void *) stateNumber; request->fArg1 = (void *) true; submitPMRequest(request);
}
}
IOLockUnlock(fActivityLock);
}
return noPowerChange;
}
IOReturn IOService::setIdleTimerPeriod ( unsigned long period )
{
IOWorkLoop * wl = getPMworkloop();
if (!initialized || !wl)
return IOPMNotYetInitialized;
OUR_PMLog(PMsetIdleTimerPeriod, period, 0);
fIdleTimerPeriod = period;
if ( period > 0 )
{
if ( fIdleTimerEventSource == NULL )
{
IOTimerEventSource * timerSrc;
timerSrc = IOTimerEventSource::timerEventSource(
this, PM_idle_timer_expired);
if (timerSrc && (wl->addEventSource(timerSrc) != kIOReturnSuccess))
{
timerSrc->release();
timerSrc = 0;
}
fIdleTimerEventSource = timerSrc;
}
start_PM_idle_timer();
}
return IOPMNoErr;
}
SInt32 IOService::nextIdleTimeout(
AbsoluteTime currentTime,
AbsoluteTime lastActivity,
unsigned int powerState)
{
AbsoluteTime delta;
UInt64 delta_ns;
SInt32 delta_secs;
SInt32 delay_secs;
delta = currentTime;
SUB_ABSOLUTETIME(&delta, &lastActivity);
absolutetime_to_nanoseconds(delta, &delta_ns);
delta_secs = (SInt32)(delta_ns / NSEC_PER_SEC);
if (delta_secs < (int) fIdleTimerPeriod )
delay_secs = (int) fIdleTimerPeriod - delta_secs;
else
delay_secs = (int) fIdleTimerPeriod;
return (SInt32)delay_secs;
}
void IOService::start_PM_idle_timer ( void )
{
static const int maxTimeout = 100000;
static const int minTimeout = 1;
AbsoluteTime uptime;
SInt32 idle_in = 0;
if (!initialized || !fIdleTimerEventSource)
return;
IOLockLock(fActivityLock);
clock_get_uptime(&uptime);
idle_in = nextIdleTimeout(uptime, fDeviceActiveTimestamp, fCurrentPowerState);
if (idle_in > maxTimeout)
{
idle_in = IOService::nextIdleTimeout(uptime,
fDeviceActiveTimestamp,
fCurrentPowerState);
} else if (idle_in < minTimeout) {
idle_in = fIdleTimerPeriod;
}
IOLockUnlock(fActivityLock);
fIdleTimerEventSource->setTimeout(idle_in, NSEC_PER_SEC);
}
void PM_idle_timer_expired ( OSObject * ourSelves, IOTimerEventSource * )
{
((IOService *)ourSelves)->PM_idle_timer_expiration();
}
void IOService::PM_idle_timer_expiration ( void )
{
IOPMRequest * request;
bool restartTimer = true;
if ( !initialized || !fIdleTimerPeriod )
return;
IOLockLock(fActivityLock);
if (fDeviceActive)
{
fDeviceActive = false;
}
else
{
if (fActivityTicklePowerState > 0)
{
fActivityTicklePowerState--;
}
request = acquirePMRequest( this, kIOPMRequestTypeActivityTickle );
if (request)
{
request->fArg0 = (void *) 0; request->fArg1 = (void *) false; submitPMRequest( request );
restartTimer = false;
}
}
IOLockUnlock(fActivityLock);
if (restartTimer)
start_PM_idle_timer();
}
void IOService::command_received ( void *statePtr , void *, void * , void * )
{
}
IOReturn IOService::setAggressiveness ( unsigned long type, unsigned long newLevel )
{
OSIterator * iter;
OSObject * next;
IOPowerConnection * connection;
IOService * child;
if (!initialized)
return IOPMNotYetInitialized;
if (getPMRootDomain() == this)
OUR_PMLog(kPMLogSetAggressiveness, type, newLevel);
if ( type <= kMaxType )
{
fAggressivenessValue[type] = newLevel;
fAggressivenessValid[type] = true;
}
iter = getChildIterator(gIOPowerPlane);
if ( iter )
{
while ( (next = iter->getNextObject()) )
{
if ( (connection = OSDynamicCast(IOPowerConnection, next)) )
{
if (connection->getReadyFlag() == false)
{
PM_CONNECT("[%s] %s: connection not ready\n",
getName(), __FUNCTION__);
continue;
}
child = ((IOService *)(connection->copyChildEntry(gIOPowerPlane)));
if ( child )
{
child->setAggressiveness(type, newLevel);
child->release();
}
}
}
iter->release();
}
return IOPMNoErr;
}
IOReturn IOService::getAggressiveness ( unsigned long type, unsigned long * currentLevel )
{
if ( !initialized || (type > kMaxType) )
return kIOReturnBadArgument;
if ( !fAggressivenessValid[type] )
return kIOReturnInvalid;
*currentLevel = fAggressivenessValue[type];
return kIOReturnSuccess;
}
UInt32 IOService::getPowerState ( void )
{
if (!initialized)
return 0;
return fCurrentPowerState;
}
IOReturn IOService::systemWake ( void )
{
OSIterator * iter;
OSObject * next;
IOPowerConnection * connection;
IOService * theChild;
OUR_PMLog(kPMLogSystemWake, 0, 0);
iter = getChildIterator(gIOPowerPlane);
if ( iter )
{
while ( (next = iter->getNextObject()) )
{
if ( (connection = OSDynamicCast(IOPowerConnection, next)) )
{
if (connection->getReadyFlag() == false)
{
PM_CONNECT("[%s] %s: connection not ready\n",
getName(), __FUNCTION__);
continue;
}
theChild = (IOService *)connection->copyChildEntry(gIOPowerPlane);
if ( theChild )
{
theChild->systemWake();
theChild->release();
}
}
}
iter->release();
}
if ( fControllingDriver != NULL )
{
if ( fControllingDriver->didYouWakeSystem() )
{
makeUsable();
}
}
return IOPMNoErr;
}
IOReturn IOService::temperatureCriticalForZone ( IOService * whichZone )
{
IOService * theParent;
IOService * theNub;
OUR_PMLog(kPMLogCriticalTemp, 0, 0);
if ( inPlane(gIOPowerPlane) && !fWeAreRoot )
{
theNub = (IOService *)copyParentEntry(gIOPowerPlane);
if ( theNub )
{
theParent = (IOService *)theNub->copyParentEntry(gIOPowerPlane);
theNub->release();
if ( theParent )
{
theParent->temperatureCriticalForZone(whichZone);
theParent->release();
}
}
}
return IOPMNoErr;
}
IOReturn IOService::powerOverrideOnPriv ( void )
{
IOPMRequest * request;
if (!initialized)
return IOPMNotYetInitialized;
if (gIOPMWorkLoop->inGate())
{
fDeviceOverrides = true;
return IOPMNoErr;
}
request = acquirePMRequest( this, kIOPMRequestTypePowerOverrideOnPriv );
if (!request)
return kIOReturnNoMemory;
submitPMRequest( request );
return IOPMNoErr;
}
IOReturn IOService::powerOverrideOffPriv ( void )
{
IOPMRequest * request;
if (!initialized)
return IOPMNotYetInitialized;
if (gIOPMWorkLoop->inGate())
{
fDeviceOverrides = false;
return IOPMNoErr;
}
request = acquirePMRequest( this, kIOPMRequestTypePowerOverrideOffPriv );
if (!request)
return kIOReturnNoMemory;
submitPMRequest( request );
return IOPMNoErr;
}
void IOService::handlePowerOverrideChanged ( IOPMRequest * request )
{
PM_ASSERT_IN_GATE();
if (request->getType() == kIOPMRequestTypePowerOverrideOnPriv)
{
OUR_PMLog(kPMLogOverrideOn, 0, 0);
fDeviceOverrides = true;
}
else
{
OUR_PMLog(kPMLogOverrideOff, 0, 0);
fDeviceOverrides = false;
}
if (fControllingDriver && inPlane(gIOPowerPlane) && fParentsKnowState)
{
computeDesiredState();
changeState();
}
}
IOReturn IOService::enqueuePowerChange (
unsigned long flags,
unsigned long whatStateOrdinal,
unsigned long domainState,
IOPowerConnection * whichParent,
unsigned long singleParentState )
{
changeNoteItem changeNote;
IOPMPowerState * powerStatePtr;
PM_ASSERT_IN_GATE();
assert( fMachineState == kIOPM_Finished );
assert( whatStateOrdinal < fNumberOfPowerStates );
if (whatStateOrdinal >= fNumberOfPowerStates)
return IOPMAckImplied;
powerStatePtr = &fPowerStates[whatStateOrdinal];
changeNote.flags = flags;
changeNote.newStateNumber = whatStateOrdinal;
changeNote.outputPowerCharacter = powerStatePtr->outputPowerCharacter;
changeNote.inputPowerRequirement = powerStatePtr->inputPowerRequirement;
changeNote.capabilityFlags = powerStatePtr->capabilityFlags;
changeNote.parent = NULL;
if (flags & IOPMParentInitiated )
{
changeNote.domainState = domainState;
changeNote.parent = whichParent;
changeNote.singleParentState = singleParentState;
}
if (flags & IOPMWeInitiated )
{
start_our_change(&changeNote);
return 0;
}
else
{
return start_parent_change(&changeNote);
}
}
bool IOService::notifyInterestedDrivers ( void )
{
IOPMinformee * informee;
IOPMinformeeList * list = fInterestedDrivers;
DriverCallParam * param;
IOItemCount count;
PM_ASSERT_IN_GATE();
assert( fDriverCallBusy == false );
assert( fDriverCallParamCount == 0 );
assert( fHeadNotePendingAcks == 0 );
count = list->numberOfItems();
if (!count)
goto done;
param = (DriverCallParam *) fDriverCallParamPtr;
if (count > fDriverCallParamSlots)
{
if (fDriverCallParamSlots)
{
assert(fDriverCallParamPtr);
IODelete(fDriverCallParamPtr, DriverCallParam, fDriverCallParamSlots);
fDriverCallParamPtr = 0;
fDriverCallParamSlots = 0;
}
param = IONew(DriverCallParam, count);
if (!param)
goto done;
fDriverCallParamPtr = (void *) param;
fDriverCallParamSlots = count;
}
informee = list->firstInList();
assert(informee);
for (IOItemCount i = 0; i < count; i++)
{
informee->timer = -1;
param[i].Target = informee;
informee->retain();
informee = list->nextInList( informee );
}
fDriverCallParamCount = count;
fHeadNotePendingAcks = count;
PM_LOCK();
fDriverCallBusy = true;
PM_UNLOCK();
thread_call_enter( fDriverCallEntry );
return true;
done:
return false;
}
void IOService::notifyInterestedDriversDone ( void )
{
IOPMinformee * informee;
IOItemCount count;
DriverCallParam * param;
IOReturn result;
PM_ASSERT_IN_GATE();
param = (DriverCallParam *) fDriverCallParamPtr;
count = fDriverCallParamCount;
assert( fDriverCallBusy == false );
assert( fMachineState == kIOPM_DriverThreadCallDone );
if (param && count)
{
for (IOItemCount i = 0; i < count; i++, param++)
{
informee = (IOPMinformee *) param->Target;
result = param->Result;
if ((result == IOPMAckImplied) || (result < 0))
{
informee->timer = 0;
fHeadNotePendingAcks--;
}
else if (informee->timer)
{
assert(informee->timer == -1);
if (result < kMinAckTimeoutTicks)
result = kMinAckTimeoutTicks;
informee->timer = (result / (ACK_TIMER_PERIOD / ns_per_us)) + 1;
}
informee->release();
}
fDriverCallParamCount = 0;
if ( fHeadNotePendingAcks )
{
OUR_PMLog(kPMLogStartAckTimer, 0, 0);
start_ack_timer();
}
}
fMachineState = fNextMachineState;
notifyChildren();
}
void IOService::notifyChildren ( void )
{
OSIterator * iter;
OSObject * next;
IOPowerConnection * connection;
OSArray * children = 0;
if (fStrictTreeOrder)
children = OSArray::withCapacity(8);
fPowerStates[fHeadNoteState].staticPower = 0;
iter = getChildIterator(gIOPowerPlane);
if ( iter )
{
while ((next = iter->getNextObject()))
{
if ((connection = OSDynamicCast(IOPowerConnection, next)))
{
if (connection->getReadyFlag() == false)
{
PM_CONNECT("[%s] %s: connection not ready\n",
getName(), __FUNCTION__);
continue;
}
if (children)
children->setObject( connection );
else
notifyChild( connection,
fDriverCallReason == kDriverCallInformPreChange );
}
}
iter->release();
}
if (children)
{
if (children->getCount() == 0)
{
children->release();
children = 0;
}
else
{
assert(fNotifyChildArray == 0);
fNotifyChildArray = children;
fNextMachineState = fMachineState;
fMachineState = kIOPM_NotifyChildrenDone;
}
}
}
void IOService::notifyChildrenDone ( void )
{
PM_ASSERT_IN_GATE();
assert(fNotifyChildArray);
assert(fMachineState == kIOPM_NotifyChildrenDone);
if (fNotifyChildArray->getCount())
{
IOPowerConnection * connection;
connection = (IOPowerConnection *) fNotifyChildArray->getObject(0);
fNotifyChildArray->removeObject(0);
notifyChild( connection, fDriverCallReason == kDriverCallInformPreChange );
}
else
{
fNotifyChildArray->release();
fNotifyChildArray = 0;
fMachineState = fNextMachineState;
}
}
IOReturn IOService::notifyAll ( bool is_prechange )
{
PM_ASSERT_IN_GATE();
fNextMachineState = fMachineState;
fMachineState = kIOPM_DriverThreadCallDone;
fDriverCallReason = is_prechange ?
kDriverCallInformPreChange : kDriverCallInformPostChange;
if (!notifyInterestedDrivers())
notifyInterestedDriversDone();
return IOPMWillAckLater;
}
IOReturn IOService::actionDriverCalloutDone (
OSObject * target,
void * arg0, void * arg1,
void * arg2, void * arg3 )
{
IOServicePM * pwrMgt = (IOServicePM *) arg0;
PM_LOCK();
fDriverCallBusy = false;
PM_UNLOCK();
if (gIOPMReplyQueue)
gIOPMReplyQueue->signalWorkAvailable();
return kIOReturnSuccess;
}
void IOService::pmDriverCallout ( IOService * from )
{
assert(from);
switch (from->fDriverCallReason)
{
case kDriverCallSetPowerState:
from->driverSetPowerState();
break;
case kDriverCallInformPreChange:
case kDriverCallInformPostChange:
from->driverInformPowerChange();
break;
default:
IOPanic("IOService::pmDriverCallout bad machine state");
}
gIOPMWorkLoop->runAction(actionDriverCalloutDone,
from,
(void *) from->pwrMgt );
}
void IOService::driverSetPowerState ( void )
{
IOService * driver;
unsigned long powerState;
DriverCallParam * param;
IOReturn result;
AbsoluteTime end;
assert( fDriverCallBusy );
param = (DriverCallParam *) fDriverCallParamPtr;
assert( param );
assert( fDriverCallParamCount == 1 );
driver = fControllingDriver;
powerState = fHeadNoteState;
if (!fWillPMStop)
{
OUR_PMLog( kPMLogProgramHardware, (UInt32) this, powerState);
clock_get_uptime(&fDriverCallStartTime);
result = driver->setPowerState( powerState, this );
clock_get_uptime(&end);
OUR_PMLog((UInt32) -kPMLogProgramHardware, (UInt32) this, (UInt32) result);
#if LOG_SETPOWER_TIMES
if ((result == IOPMAckImplied) || (result < 0))
{
uint64_t nsec;
SUB_ABSOLUTETIME(&end, &fDriverCallStartTime);
absolutetime_to_nanoseconds(end, &nsec);
if (nsec > LOG_SETPOWER_TIMES)
PM_DEBUG("%s::setPowerState(%p, %lu -> %lu) took %d ms\n",
fName, this, fCurrentPowerState, powerState, NS_TO_MS(nsec));
}
#endif
}
else
result = kIOPMAckImplied;
param->Result = result;
}
void IOService::driverInformPowerChange ( void )
{
IOItemCount count;
IOPMinformee * informee;
IOService * driver;
IOReturn result;
IOPMPowerFlags powerFlags;
unsigned long powerState;
DriverCallParam * param;
AbsoluteTime end;
assert( fDriverCallBusy );
param = (DriverCallParam *) fDriverCallParamPtr;
count = fDriverCallParamCount;
assert( count && param );
powerFlags = fHeadNoteCapabilityFlags;
powerState = fHeadNoteState;
for (IOItemCount i = 0; i < count; i++)
{
informee = (IOPMinformee *) param->Target;
driver = informee->whatObject;
if (!fWillPMStop && informee->active)
{
if (fDriverCallReason == kDriverCallInformPreChange)
{
OUR_PMLog(kPMLogInformDriverPreChange, (UInt32) this, powerState);
clock_get_uptime(&informee->startTime);
result = driver->powerStateWillChangeTo(powerFlags, powerState, this);
clock_get_uptime(&end);
OUR_PMLog((UInt32)-kPMLogInformDriverPreChange, (UInt32) this, result);
}
else
{
OUR_PMLog(kPMLogInformDriverPostChange, (UInt32) this, powerState);
clock_get_uptime(&informee->startTime);
result = driver->powerStateDidChangeTo(powerFlags, powerState, this);
clock_get_uptime(&end);
OUR_PMLog((UInt32)-kPMLogInformDriverPostChange, (UInt32) this, result);
}
#if LOG_SETPOWER_TIMES
if ((result == IOPMAckImplied) || (result < 0))
{
uint64_t nsec;
SUB_ABSOLUTETIME(&end, &informee->startTime);
absolutetime_to_nanoseconds(end, &nsec);
if (nsec > LOG_SETPOWER_TIMES)
PM_DEBUG("%s::powerState%sChangeTo(%p, %s, %lu -> %lu) took %d ms\n",
driver->getName(),
(fDriverCallReason == kDriverCallInformPreChange) ? "Will" : "Did",
driver, fName, fCurrentPowerState, powerState, NS_TO_MS(nsec));
}
#endif
}
else
result = kIOPMAckImplied;
param->Result = result;
param++;
}
}
bool IOService::notifyChild ( IOPowerConnection * theNub, bool is_prechange )
{
IOReturn k = IOPMAckImplied;
unsigned long childPower;
IOService * theChild;
IOPMRequest * childRequest;
int requestType;
PM_ASSERT_IN_GATE();
theChild = (IOService *)(theNub->copyChildEntry(gIOPowerPlane));
if (!theChild)
{
assert(false);
return true;
}
fHeadNotePendingAcks++;
theNub->setAwaitingAck(true);
requestType = is_prechange ?
kIOPMRequestTypePowerDomainWillChange :
kIOPMRequestTypePowerDomainDidChange;
childRequest = acquirePMRequest( theChild, requestType );
if (childRequest)
{
theNub->retain();
childRequest->fArg0 = (void *) fHeadNoteOutputFlags;
childRequest->fArg1 = (void *) theNub;
childRequest->fArg2 = (void *) (fHeadNoteState < fCurrentPowerState);
theChild->submitPMRequest( childRequest );
k = IOPMWillAckLater;
}
else
{
k = IOPMAckImplied;
fHeadNotePendingAcks--;
theNub->setAwaitingAck(false);
childPower = theChild->currentPowerConsumption();
if ( childPower == kIOPMUnknown )
{
fPowerStates[fHeadNoteState].staticPower = kIOPMUnknown;
} else {
if ( fPowerStates[fHeadNoteState].staticPower != kIOPMUnknown )
{
fPowerStates[fHeadNoteState].staticPower += childPower;
}
}
}
theChild->release();
return (k == IOPMAckImplied);
}
void IOService::OurChangeTellClientsPowerDown ( void )
{
fMachineState = kIOPM_OurChangeTellPriorityClientsPowerDown;
tellChangeDown1(fHeadNoteState);
}
void IOService::OurChangeTellPriorityClientsPowerDown ( void )
{
fMachineState = kIOPM_OurChangeNotifyInterestedDriversWillChange;
tellChangeDown2(fHeadNoteState);
}
void IOService::OurChangeNotifyInterestedDriversWillChange ( void )
{
fMachineState = kIOPM_OurChangeSetPowerState;
notifyAll( true );
}
void IOService::OurChangeSetPowerState ( void )
{
fNextMachineState = kIOPM_OurChangeWaitForPowerSettle;
fMachineState = kIOPM_DriverThreadCallDone;
fDriverCallReason = kDriverCallSetPowerState;
if (notifyControllingDriver() == false)
notifyControllingDriverDone();
}
void IOService::OurChangeWaitForPowerSettle ( void )
{
fMachineState = kIOPM_OurChangeNotifyInterestedDriversDidChange;
fSettleTimeUS = compute_settle_time();
if ( fSettleTimeUS )
{
startSettleTimer(fSettleTimeUS);
}
}
void IOService::OurChangeNotifyInterestedDriversDidChange ( void )
{
fMachineState = kIOPM_OurChangeFinish;
notifyAll(false);
}
void IOService::OurChangeFinish ( void )
{
all_done();
}
void IOService::ParentDownTellPriorityClientsPowerDown ( void )
{
fMachineState = kIOPM_ParentDownNotifyInterestedDriversWillChange;
tellChangeDown2(fHeadNoteState);
}
void IOService::ParentDownNotifyInterestedDriversWillChange ( void )
{
fMachineState = kIOPM_ParentDownSetPowerState;
notifyAll( true );
}
void IOService::ParentDownSetPowerState ( void )
{
fNextMachineState = kIOPM_ParentDownWaitForPowerSettle;
fMachineState = kIOPM_DriverThreadCallDone;
fDriverCallReason = kDriverCallSetPowerState;
if (notifyControllingDriver() == false)
notifyControllingDriverDone();
}
void IOService::ParentDownWaitForPowerSettle ( void )
{
fMachineState = kIOPM_ParentDownNotifyDidChangeAndAcknowledgeChange;
fSettleTimeUS = compute_settle_time();
if ( fSettleTimeUS )
{
startSettleTimer(fSettleTimeUS);
}
}
void IOService::ParentDownNotifyDidChangeAndAcknowledgeChange ( void )
{
fMachineState = kIOPM_ParentDownAcknowledgeChange;
notifyAll(false);
}
void IOService::ParentDownAcknowledgeChange ( void )
{
IORegistryEntry * nub;
IOService * parent;
nub = fHeadNoteParent;
nub->retain();
all_done();
parent = (IOService *)nub->copyParentEntry(gIOPowerPlane);
if ( parent )
{
parent->acknowledgePowerChange((IOService *)nub);
parent->release();
}
nub->release();
}
void IOService::ParentUpSetPowerState ( void )
{
fNextMachineState = kIOPM_ParentUpWaitForSettleTime;
fMachineState = kIOPM_DriverThreadCallDone;
fDriverCallReason = kDriverCallSetPowerState;
if (notifyControllingDriver() == false)
notifyControllingDriverDone();
}
void IOService::ParentUpWaitForSettleTime ( void )
{
fMachineState = kIOPM_ParentUpNotifyInterestedDriversDidChange;
fSettleTimeUS = compute_settle_time();
if ( fSettleTimeUS )
{
startSettleTimer(fSettleTimeUS);
}
}
void IOService::ParentUpNotifyInterestedDriversDidChange ( void )
{
fMachineState = kIOPM_ParentUpAcknowledgePowerChange;
notifyAll(false);
}
void IOService::ParentUpAcknowledgePowerChange ( void )
{
IORegistryEntry * nub;
IOService * parent;
nub = fHeadNoteParent;
nub->retain();
all_done();
parent = (IOService *)nub->copyParentEntry(gIOPowerPlane);
if ( parent )
{
parent->acknowledgePowerChange((IOService *)nub);
parent->release();
}
nub->release();
}
void IOService::all_done ( void )
{
unsigned long previous_state;
fMachineState = kIOPM_Finished;
if ( fHeadNoteFlags & IOPMWeInitiated )
{
if ( !( fHeadNoteFlags & IOPMNotDone) )
{
if ( !fWeAreRoot )
{
ask_parent(fHeadNoteState);
}
if ( fCurrentPowerState < fHeadNoteState )
{
tellChangeUp (fHeadNoteState);
}
previous_state = fCurrentPowerState;
fCurrentPowerState = fHeadNoteState;
#if PM_VARS_SUPPORT
fPMVars->myCurrentState = fCurrentPowerState;
#endif
OUR_PMLog(kPMLogChangeDone, fCurrentPowerState, 0);
if (!fWillPMStop && fParentsKnowState)
powerChangeDone(previous_state);
else
PM_DEBUG("%s::powerChangeDone() skipped\n", getName());
}
}
if ( fHeadNoteFlags & IOPMParentInitiated)
{
if (((fHeadNoteFlags & IOPMDomainWillChange) && (fCurrentPowerState >= fHeadNoteState)) ||
((fHeadNoteFlags & IOPMDomainDidChange) && (fCurrentPowerState < fHeadNoteState)))
{
if ( fCurrentPowerState < fHeadNoteState )
{
tellChangeUp (fHeadNoteState);
}
previous_state = fCurrentPowerState;
fCurrentPowerState = fHeadNoteState;
#if PM_VARS_SUPPORT
fPMVars->myCurrentState = fCurrentPowerState;
#endif
fMaxCapability = fControllingDriver->maxCapabilityForDomainState(fHeadNoteDomainState);
OUR_PMLog(kPMLogChangeDone, fCurrentPowerState, 0);
if (!fWillPMStop && fParentsKnowState)
powerChangeDone(previous_state);
else
PM_DEBUG("%s::powerChangeDone() skipped\n", getName());
}
}
if (fCurrentPowerState < fNumberOfPowerStates)
{
const IOPMPowerState * powerStatePtr = &fPowerStates[fCurrentPowerState];
fCurrentCapabilityFlags = powerStatePtr->capabilityFlags;
if (fCurrentCapabilityFlags & kIOPMStaticPowerValid)
fCurrentPowerConsumption = powerStatePtr->staticPower;
}
if (fCurrentPowerState >= fIdleTimerMinPowerState)
{
fIdleTimerMinPowerState = 0;
}
}
void IOService::settleTimerExpired ( void )
{
fSettleTimeUS = 0;
}
unsigned long IOService::compute_settle_time ( void )
{
unsigned long totalTime;
unsigned long i;
PM_ASSERT_IN_GATE();
totalTime = 0;
i = fCurrentPowerState;
if ( fHeadNoteState < fCurrentPowerState )
{
while ( i > fHeadNoteState )
{
totalTime += fPowerStates[i].settleDownTime;
i--;
}
}
if ( fHeadNoteState > fCurrentPowerState )
{
while ( i < fHeadNoteState )
{
totalTime += fPowerStates[i+1].settleUpTime;
i++;
}
}
return totalTime;
}
IOReturn IOService::startSettleTimer ( unsigned long delay )
{
AbsoluteTime deadline;
boolean_t pending;
retain();
clock_interval_to_deadline(delay, kMicrosecondScale, &deadline);
pending = thread_call_enter_delayed(fSettleTimer, deadline);
if (pending) release();
return IOPMNoErr;
}
void IOService::ack_timer_ticked ( void )
{
assert(false);
}
bool IOService::ackTimerTick( void )
{
IOPMinformee * nextObject;
bool done = false;
PM_ASSERT_IN_GATE();
switch (fMachineState) {
case kIOPM_OurChangeWaitForPowerSettle:
case kIOPM_ParentDownWaitForPowerSettle:
case kIOPM_ParentUpWaitForSettleTime:
if ( fDriverTimer > 0 )
{
fDriverTimer--;
if ( fDriverTimer == 0 )
{
uint64_t nsec = computeTimeDeltaNS(&fDriverCallStartTime);
OUR_PMLog(kPMLogCtrlDriverTardy, 0, 0);
setProperty(kIOPMTardyAckSPSKey, kOSBooleanTrue);
PM_ERROR("%s::setPowerState(%p, %lu -> %lu) timed out after %d ms\n",
fName, this, fCurrentPowerState, fHeadNoteState, NS_TO_MS(nsec));
if (gIOKitDebug & kIOLogDebugPower)
{
panic("%s::setPowerState(%p, %lu -> %lu) timed out after %d ms",
fName, this, fCurrentPowerState, fHeadNoteState, NS_TO_MS(nsec));
}
else
{
done = true;
}
} else {
start_ack_timer();
}
}
break;
case kIOPM_OurChangeSetPowerState:
case kIOPM_OurChangeFinish:
case kIOPM_ParentDownSetPowerState:
case kIOPM_ParentDownAcknowledgeChange:
case kIOPM_ParentUpSetPowerState:
case kIOPM_ParentUpAcknowledgePowerChange:
case kIOPM_NotifyChildrenDone:
if ( fHeadNotePendingAcks != 0 )
{
nextObject = fInterestedDrivers->firstInList();
while ( nextObject != NULL )
{
if ( nextObject->timer > 0 )
{
nextObject->timer--;
if ( nextObject->timer == 0 )
{
uint64_t nsec = computeTimeDeltaNS(&nextObject->startTime);
OUR_PMLog(kPMLogIntDriverTardy, 0, 0);
nextObject->whatObject->setProperty(kIOPMTardyAckPSCKey, kOSBooleanTrue);
PM_ERROR("%s::powerState%sChangeTo(%p, %s, %lu -> %lu) timed out after %d ms\n",
nextObject->whatObject->getName(),
(fDriverCallReason == kDriverCallInformPreChange) ? "Will" : "Did",
nextObject->whatObject, fName, fCurrentPowerState, fHeadNoteState,
NS_TO_MS(nsec));
fHeadNotePendingAcks--;
}
}
nextObject = fInterestedDrivers->nextInList(nextObject);
}
if ( fHeadNotePendingAcks == 0 )
{
done = true;
} else {
start_ack_timer();
}
}
break;
case kIOPM_ParentDownTellPriorityClientsPowerDown:
case kIOPM_ParentDownNotifyInterestedDriversWillChange:
case kIOPM_OurChangeTellClientsPowerDown:
case kIOPM_OurChangeTellPriorityClientsPowerDown:
case kIOPM_OurChangeNotifyInterestedDriversWillChange:
cleanClientResponses(true);
OUR_PMLog(kPMLogClientTardy, 0, 1);
done = true;
break;
default:
PM_TRACE("[%s] unexpected ack timer tick (state = %ld)\n",
getName(), fMachineState);
break;
}
return done;
}
void IOService::start_ack_timer ( void )
{
start_ack_timer( ACK_TIMER_PERIOD, kNanosecondScale );
}
void IOService::start_ack_timer ( UInt32 interval, UInt32 scale )
{
AbsoluteTime deadline;
boolean_t pending;
clock_interval_to_deadline(interval, scale, &deadline);
retain();
pending = thread_call_enter_delayed(fAckTimer, deadline);
if (pending) release();
}
void IOService::stop_ack_timer ( void )
{
boolean_t pending;
pending = thread_call_cancel(fAckTimer);
if (pending) release();
}
IOReturn
IOService::actionAckTimerExpired (
OSObject * target,
void * arg0, void * arg1,
void * arg2, void * arg3 )
{
IOService * me = (IOService *) target;
bool done;
done = me->ackTimerTick();
if (done && gIOPMReplyQueue)
gIOPMReplyQueue->signalWorkAvailable();
return kIOReturnSuccess;
}
void
IOService::ack_timer_expired ( thread_call_param_t arg0, thread_call_param_t arg1 )
{
IOService * me = (IOService *) arg0;
if (gIOPMWorkLoop)
{
gIOPMWorkLoop->runAction(&actionAckTimerExpired, me);
}
me->release();
}
static IOReturn
settleTimerExpired (
OSObject * target,
void * arg0, void * arg1,
void * arg2, void * arg3 )
{
IOService * me = (IOService *) target;
me->settleTimerExpired();
return kIOReturnSuccess;
}
static void
settle_timer_expired ( thread_call_param_t arg0, thread_call_param_t arg1 )
{
IOService * me = (IOService *) arg0;
if (gIOPMWorkLoop && gIOPMReplyQueue)
{
gIOPMWorkLoop->runAction(settleTimerExpired, me);
gIOPMReplyQueue->signalWorkAvailable();
}
me->release();
}
IOReturn IOService::start_parent_change ( const changeNoteItem * changeNote )
{
fHeadNoteFlags = changeNote->flags;
fHeadNoteState = changeNote->newStateNumber;
fHeadNoteOutputFlags = changeNote->outputPowerCharacter;
fHeadNoteDomainState = changeNote->domainState;
fHeadNoteParent = changeNote->parent;
fHeadNoteCapabilityFlags = changeNote->capabilityFlags;
PM_ASSERT_IN_GATE();
OUR_PMLog( kPMLogStartParentChange, fHeadNoteState, fCurrentPowerState );
if ( fHeadNoteState < fCurrentPowerState )
{
setParentInfo(
changeNote->singleParentState,
fHeadNoteParent, true );
fInitialChange = false;
fMachineState = kIOPM_ParentDownTellPriorityClientsPowerDown;
tellChangeDown1(fHeadNoteState);
return IOPMWillAckLater;
}
if ( fHeadNoteState > fCurrentPowerState )
{
IOPMPowerState * powerStatePtr;
if ( fDesiredPowerState > fCurrentPowerState )
{
if ( fDesiredPowerState < fHeadNoteState )
{
fHeadNoteState = fDesiredPowerState;
powerStatePtr = &fPowerStates[fHeadNoteState];
fHeadNoteOutputFlags = powerStatePtr->outputPowerCharacter;
fHeadNoteCapabilityFlags = powerStatePtr->capabilityFlags;
OUR_PMLog(kPMLogAmendParentChange, fHeadNoteState, 0);
}
} else {
fHeadNoteState = fCurrentPowerState;
powerStatePtr = &fPowerStates[fHeadNoteState];
fHeadNoteOutputFlags = powerStatePtr->outputPowerCharacter;
fHeadNoteCapabilityFlags = powerStatePtr->capabilityFlags;
OUR_PMLog(kPMLogAmendParentChange, fHeadNoteState, 0);
}
}
if ((fHeadNoteState > fCurrentPowerState) &&
(fHeadNoteFlags & IOPMDomainDidChange))
{
fInitialChange = false;
fMachineState = kIOPM_ParentUpSetPowerState;
notifyAll( true );
return IOPMWillAckLater;
}
all_done();
return IOPMAckImplied;
}
void IOService::start_our_change ( const changeNoteItem * changeNote )
{
fHeadNoteFlags = changeNote->flags;
fHeadNoteState = changeNote->newStateNumber;
fHeadNoteOutputFlags = changeNote->outputPowerCharacter;
fHeadNoteCapabilityFlags = changeNote->capabilityFlags;
PM_ASSERT_IN_GATE();
OUR_PMLog( kPMLogStartDeviceChange, fHeadNoteState, fCurrentPowerState );
if (( fHeadNoteCapabilityFlags & IOPMNotAttainable ) ||
((fMaxCapability < fHeadNoteState) && (!fWeAreRoot)))
{
fHeadNoteFlags |= IOPMNotDone;
if ( !fWeAreRoot )
{
ask_parent(fHeadNoteState);
}
all_done();
return;
}
if ( !fInitialChange )
{
if ( fHeadNoteState == fCurrentPowerState )
{
all_done();
return;
}
}
fInitialChange = false;
if ( fHeadNoteState < fCurrentPowerState )
{
fMachineState = kIOPM_OurChangeTellClientsPowerDown;
fDoNotPowerDown = false;
fOutOfBandParameter = kNotifyApps;
askChangeDown(fHeadNoteState);
} else {
fMachineState = kIOPM_OurChangeSetPowerState;
notifyAll(true);
}
}
IOReturn IOService::ask_parent ( unsigned long requestedState )
{
OSIterator * iter;
OSObject * next;
IOPowerConnection * connection;
IOService * parent;
const IOPMPowerState * powerStatePtr;
unsigned long ourRequest;
PM_ASSERT_IN_GATE();
if (requestedState >= fNumberOfPowerStates)
return IOPMNoErr;
powerStatePtr = &fPowerStates[requestedState];
ourRequest = powerStatePtr->inputPowerRequirement;
if ( powerStatePtr->capabilityFlags & (kIOPMChildClamp | kIOPMPreventIdleSleep) )
{
ourRequest |= kIOPMPreventIdleSleep;
}
if ( powerStatePtr->capabilityFlags & (kIOPMChildClamp2 | kIOPMPreventSystemSleep) )
{
ourRequest |= kIOPMPreventSystemSleep;
}
if ( fPreviousRequest == ourRequest )
{
return IOPMNoErr;
}
if ( fWeAreRoot )
{
return IOPMNoErr;
}
fPreviousRequest = ourRequest;
iter = getParentIterator(gIOPowerPlane);
if ( iter )
{
while ( (next = iter->getNextObject()) )
{
if ( (connection = OSDynamicCast(IOPowerConnection, next)) )
{
parent = (IOService *)connection->copyParentEntry(gIOPowerPlane);
if ( parent ) {
if ( parent->requestPowerDomainState(
ourRequest, connection, IOPMLowestState) != IOPMNoErr )
{
OUR_PMLog(kPMLogRequestDenied, fPreviousRequest, 0);
}
parent->release();
}
}
}
iter->release();
}
return IOPMNoErr;
}
bool IOService::notifyControllingDriver ( void )
{
DriverCallParam * param;
unsigned long powerState;
PM_ASSERT_IN_GATE();
assert( fDriverCallBusy == false );
assert( fDriverCallParamCount == 0 );
assert( fControllingDriver );
powerState = fHeadNoteState;
if (fPowerStates[powerState].capabilityFlags & IOPMNotAttainable )
return false;
param = (DriverCallParam *) fDriverCallParamPtr;
if (!param)
{
param = IONew(DriverCallParam, 1);
if (!param)
return false;
fDriverCallParamPtr = (void *) param;
fDriverCallParamSlots = 1;
}
param->Target = fControllingDriver;
fDriverCallParamCount = 1;
fDriverTimer = -1;
PM_LOCK();
fDriverCallBusy = true;
PM_UNLOCK();
thread_call_enter( fDriverCallEntry );
return true;
}
void IOService::notifyControllingDriverDone( void )
{
DriverCallParam * param;
IOReturn result;
PM_ASSERT_IN_GATE();
param = (DriverCallParam *) fDriverCallParamPtr;
assert( fDriverCallBusy == false );
assert( fMachineState == kIOPM_DriverThreadCallDone );
if (param)
{
assert(fDriverCallParamCount == 1);
result = param->Result;
if ((result == IOPMAckImplied) || (result < 0))
{
fDriverTimer = 0;
}
else if (fDriverTimer)
{
assert(fDriverTimer == -1);
if (result < kMinAckTimeoutTicks)
result = kMinAckTimeoutTicks;
fDriverTimer = (result / (ACK_TIMER_PERIOD / ns_per_us)) + 1;
}
fDriverCallParamCount = 0;
if ( fDriverTimer )
{
OUR_PMLog(kPMLogStartAckTimer, 0, 0);
start_ack_timer();
}
}
fMachineState = fNextMachineState;
}
bool IOService::askChangeDown ( unsigned long stateNum )
{
return tellClientsWithResponse( kIOMessageCanDevicePowerOff );
}
bool IOService::tellChangeDown1 ( unsigned long stateNum )
{
fOutOfBandParameter = kNotifyApps;
return tellChangeDown(stateNum);
}
bool IOService::tellChangeDown2 ( unsigned long stateNum )
{
fOutOfBandParameter = kNotifyPriority;
return tellChangeDown(stateNum);
}
bool IOService::tellChangeDown ( unsigned long stateNum )
{
return tellClientsWithResponse( kIOMessageDeviceWillPowerOff );
}
static void logAppTimeouts ( OSObject * object, void * context)
{
struct context *theContext = (struct context *)context;
OSObject *flag;
if( !OSDynamicCast( IOService, object) ) {
flag = theContext->responseFlags->getObject(theContext->counter);
if (kOSBooleanTrue != flag)
{
OSString * clientID = 0;
theContext->us->messageClient(theContext->msgType, object, &clientID);
PM_ERROR(theContext->errorLog, clientID ? clientID->getCStringNoCopy() : "");
if (clientID)
clientID->release();
}
theContext->counter += 1;
}
}
void IOService::cleanClientResponses ( bool logErrors )
{
struct context theContext;
if (logErrors && fResponseArray) {
theContext.responseFlags = fResponseArray;
theContext.serialNumber = fSerialNumber;
theContext.counter = 0;
theContext.msgType = kIOMessageCopyClientID;
theContext.us = this;
theContext.maxTimeRequested = 0;
theContext.stateNumber = fHeadNoteState;
theContext.stateFlags = fHeadNoteCapabilityFlags;
theContext.errorLog = "PM notification timeout (%s)\n";
switch ( fOutOfBandParameter ) {
case kNotifyApps:
applyToInterested(gIOAppPowerStateInterest, logAppTimeouts, (void *) &theContext);
case kNotifyPriority:
default:
break;
}
}
if (fResponseArray)
{
fResponseArray->release();
fResponseArray = NULL;
}
return;
}
bool IOService::tellClientsWithResponse ( int messageType )
{
struct context theContext;
PM_ASSERT_IN_GATE();
fResponseArray = OSArray::withCapacity( 1 );
fSerialNumber += 1;
theContext.responseFlags = fResponseArray;
theContext.serialNumber = fSerialNumber;
theContext.counter = 0;
theContext.msgType = messageType;
theContext.us = this;
theContext.maxTimeRequested = 0;
theContext.stateNumber = fHeadNoteState;
theContext.stateFlags = fHeadNoteCapabilityFlags;
switch ( fOutOfBandParameter ) {
case kNotifyApps:
applyToInterested(gIOAppPowerStateInterest,
pmTellAppWithResponse, (void *)&theContext);
applyToInterested(gIOGeneralInterest,
pmTellClientWithResponse, (void *)&theContext);
break;
case kNotifyPriority:
applyToInterested(gIOPriorityPowerStateInterest,
pmTellClientWithResponse, (void *)&theContext);
break;
}
if ( !checkForDone() )
{
OUR_PMLog(kPMLogStartAckTimer,theContext.maxTimeRequested, 0);
start_ack_timer( theContext.maxTimeRequested / 1000, kMillisecondScale );
return false;
}
fResponseArray->release();
fResponseArray = NULL;
return true;
}
void IOService::pmTellAppWithResponse ( OSObject * object, void * context )
{
struct context * theContext = (struct context *) context;
IOServicePM * pwrMgt = theContext->us->pwrMgt;
AbsoluteTime now;
if( OSDynamicCast( IOService, object) )
{
theContext->responseFlags->setObject(theContext->counter, kOSBooleanTrue);
const char *who = ((IOService *) object)->getName();
fPlatform->PMLog(who,
kPMLogClientAcknowledge, theContext->msgType, * (UInt32 *) object);
} else {
UInt32 refcon = ((theContext->serialNumber & 0xFFFF)<<16)
+ (theContext->counter & 0xFFFF);
OUR_PMLog(kPMLogAppNotify, theContext->msgType, refcon);
#if LOG_APP_RESPONSE_TIMES
OSNumber * num;
clock_get_uptime(&now);
num = OSNumber::withNumber(AbsoluteTime_to_scalar(&now), sizeof(uint64_t) * 8);
if (num)
{
theContext->responseFlags->setObject(theContext->counter, num);
num->release();
}
else
#endif
theContext->responseFlags->setObject(theContext->counter, kOSBooleanFalse);
theContext->us->messageClient(theContext->msgType, object, (void *)refcon);
if ( theContext->maxTimeRequested < k30seconds )
{
theContext->maxTimeRequested = k30seconds;
}
theContext->counter += 1;
}
}
void IOService::pmTellClientWithResponse ( OSObject * object, void * context )
{
struct context *theContext = (struct context *)context;
IOPowerStateChangeNotification notify;
UInt32 refcon;
IOReturn retCode;
OSObject *theFlag;
refcon = ((theContext->serialNumber & 0xFFFF)<<16) + (theContext->counter & 0xFFFF);
theContext->responseFlags->setObject(theContext->counter, kOSBooleanFalse);
IOServicePM * pwrMgt = theContext->us->pwrMgt;
if (gIOKitDebug & kIOLogPower) {
OUR_PMLog(kPMLogClientNotify, refcon, (UInt32) theContext->msgType);
if (OSDynamicCast(IOService, object)) {
const char *who = ((IOService *) object)->getName();
fPlatform->PMLog(who,
kPMLogClientNotify, * (UInt32 *) object, (UInt32) object);
} else if (OSDynamicCast(_IOServiceInterestNotifier, object)) {
_IOServiceInterestNotifier *n = (_IOServiceInterestNotifier *) object;
OUR_PMLog(kPMLogClientNotify, (UInt32) n->handler, 0);
}
}
notify.powerRef = (void *)refcon;
notify.returnValue = 0;
notify.stateNumber = theContext->stateNumber;
notify.stateFlags = theContext->stateFlags;
retCode = theContext->us->messageClient(theContext->msgType,object,(void *)¬ify);
if ( retCode == kIOReturnSuccess )
{
if ( notify.returnValue == 0 )
{
theContext->responseFlags->replaceObject(theContext->counter, kOSBooleanTrue);
OUR_PMLog(kPMLogClientAcknowledge, refcon, (UInt32) object);
} else {
theFlag = theContext->responseFlags->getObject(theContext->counter);
if ( kOSBooleanTrue != theFlag )
{
if ( theContext->maxTimeRequested < notify.returnValue )
{
theContext->maxTimeRequested = notify.returnValue;
}
}
}
} else {
OUR_PMLog(kPMLogClientAcknowledge, refcon, 0);
theContext->responseFlags->replaceObject(theContext->counter, kOSBooleanTrue);
}
theContext->counter += 1;
}
void IOService::tellNoChangeDown ( unsigned long )
{
return tellClients( kIOMessageDeviceWillNotPowerOff );
}
void IOService::tellChangeUp ( unsigned long )
{
return tellClients( kIOMessageDeviceHasPoweredOn );
}
void IOService::tellClients ( int messageType )
{
struct context theContext;
theContext.msgType = messageType;
theContext.us = this;
theContext.stateNumber = fHeadNoteState;
theContext.stateFlags = fHeadNoteCapabilityFlags;
applyToInterested(gIOPriorityPowerStateInterest,tellClient,(void *)&theContext);
applyToInterested(gIOAppPowerStateInterest,tellClient, (void *)&theContext);
applyToInterested(gIOGeneralInterest,tellClient, (void *)&theContext);
}
void tellClient ( OSObject * object, void * context )
{
struct context * theContext = (struct context *) context;
IOPowerStateChangeNotification notify;
notify.powerRef = (void *) 0;
notify.returnValue = 0;
notify.stateNumber = theContext->stateNumber;
notify.stateFlags = theContext->stateFlags;
theContext->us->messageClient(theContext->msgType, object, ¬ify);
}
bool IOService::checkForDone ( void )
{
int i = 0;
OSObject * theFlag;
if ( fResponseArray == NULL )
{
return true;
}
for ( i = 0; ; i++ )
{
theFlag = fResponseArray->getObject(i);
if ( theFlag == NULL )
{
break;
}
if ( kOSBooleanTrue != theFlag )
{
return false;
}
}
return true;
}
bool IOService::responseValid ( unsigned long x, int pid )
{
UInt16 serialComponent;
UInt16 ordinalComponent;
OSObject * theFlag;
unsigned long refcon = (unsigned long) x;
serialComponent = (refcon >> 16) & 0xFFFF;
ordinalComponent = (refcon & 0xFFFF);
if ( serialComponent != fSerialNumber )
{
return false;
}
if ( fResponseArray == NULL )
{
return false;
}
theFlag = fResponseArray->getObject(ordinalComponent);
if ( theFlag == 0 )
{
return false;
}
OSNumber * num;
if ((num = OSDynamicCast(OSNumber, theFlag)))
{
#if LOG_APP_RESPONSE_TIMES
AbsoluteTime now;
AbsoluteTime start;
uint64_t nsec;
clock_get_uptime(&now);
AbsoluteTime_to_scalar(&start) = num->unsigned64BitValue();
SUB_ABSOLUTETIME(&now, &start);
absolutetime_to_nanoseconds(now, &nsec);
if (nsec > LOG_APP_RESPONSE_TIMES)
{
OSString * name = IOCopyLogNameForPID(pid);
PM_DEBUG("PM response took %d ms (%s)\n", NS_TO_MS(nsec),
name ? name->getCStringNoCopy() : "");
if (name)
name->release();
}
#endif
theFlag = kOSBooleanFalse;
}
if ( kOSBooleanFalse == theFlag )
{
fResponseArray->replaceObject(ordinalComponent, kOSBooleanTrue);
}
return true;
}
IOReturn IOService::allowPowerChange ( unsigned long refcon )
{
IOPMRequest * request;
if ( !initialized )
{
return kIOReturnSuccess;
}
request = acquirePMRequest( this, kIOPMRequestTypeAllowPowerChange );
if (!request)
{
PM_ERROR("%s::%s no memory\n", getName(), __FUNCTION__);
return kIOReturnNoMemory;
}
request->fArg0 = (void *) refcon;
request->fArg1 = (void *) proc_selfpid();
submitPMRequest( request );
return kIOReturnSuccess;
}
IOReturn serializedAllowPowerChange ( OSObject *owner, void * refcon, void *, void *, void *)
{
return kIOReturnUnsupported;
}
IOReturn IOService::serializedAllowPowerChange2 ( unsigned long refcon )
{
return kIOReturnUnsupported;
}
IOReturn IOService::cancelPowerChange ( unsigned long refcon )
{
IOPMRequest * request;
if ( !initialized )
{
return kIOReturnSuccess;
}
OSString * name = IOCopyLogNameForPID(proc_selfpid());
PM_ERROR("PM notification cancel (%s)\n", name ? name->getCStringNoCopy() : "");
if (name)
name->release();
request = acquirePMRequest( this, kIOPMRequestTypeCancelPowerChange );
if (!request)
{
PM_ERROR("%s::%s no memory\n", getName(), __FUNCTION__);
return kIOReturnNoMemory;
}
request->fArg0 = (void *) refcon;
request->fArg1 = (void *) proc_selfpid();
submitPMRequest( request );
return kIOReturnSuccess;
}
IOReturn serializedCancelPowerChange ( OSObject *owner, void * refcon, void *, void *, void *)
{
return kIOReturnUnsupported;
}
IOReturn IOService::serializedCancelPowerChange2 ( unsigned long refcon )
{
return kIOReturnUnsupported;
}
#if 0
static void c_PM_Clamp_Timer_Expired ( OSObject * client, IOTimerEventSource * )
{
if (client)
((IOService *)client)->PM_Clamp_Timer_Expired ();
}
#endif
void IOService::PM_Clamp_Timer_Expired ( void )
{
#if 0
if ( ! initialized )
{
return;
}
changePowerStateToPriv (0);
#endif
}
#define kFiveMinutesInNanoSeconds (300 * NSEC_PER_SEC)
void IOService::clampPowerOn ( unsigned long duration )
{
#if 0
changePowerStateToPriv (fNumberOfPowerStates-1);
if ( pwrMgt->clampTimerEventSrc == NULL ) {
pwrMgt->clampTimerEventSrc = IOTimerEventSource::timerEventSource(this,
c_PM_Clamp_Timer_Expired);
IOWorkLoop * workLoop = getPMworkloop ();
if ( !pwrMgt->clampTimerEventSrc || !workLoop ||
( workLoop->addEventSource( pwrMgt->clampTimerEventSrc) != kIOReturnSuccess) ) {
}
}
pwrMgt->clampTimerEventSrc->setTimeout(300*USEC_PER_SEC, USEC_PER_SEC);
#endif
}
IOReturn IOService::setPowerState (
unsigned long powerStateOrdinal, IOService * whatDevice )
{
return IOPMNoErr;
}
unsigned long IOService::maxCapabilityForDomainState ( IOPMPowerFlags domainState )
{
int i;
if (fNumberOfPowerStates == 0 )
{
return 0;
}
for ( i = fNumberOfPowerStates - 1; i >= 0; i-- )
{
if ( (domainState & fPowerStates[i].inputPowerRequirement) ==
fPowerStates[i].inputPowerRequirement )
{
return i;
}
}
return 0;
}
unsigned long IOService::initialPowerStateForDomainState ( IOPMPowerFlags domainState )
{
int i;
if (fNumberOfPowerStates == 0 )
{
return 0;
}
for ( i = fNumberOfPowerStates - 1; i >= 0; i-- )
{
if ( (domainState & fPowerStates[i].inputPowerRequirement) ==
fPowerStates[i].inputPowerRequirement )
{
return i;
}
}
return 0;
}
unsigned long IOService::powerStateForDomainState ( IOPMPowerFlags domainState )
{
int i;
if (fNumberOfPowerStates == 0 )
{
return 0;
}
for ( i = fNumberOfPowerStates - 1; i >= 0; i-- )
{
if ( (domainState & fPowerStates[i].inputPowerRequirement) ==
fPowerStates[i].inputPowerRequirement )
{
return i;
}
}
return 0;
}
bool IOService::didYouWakeSystem ( void )
{
return false;
}
IOReturn IOService::powerStateWillChangeTo ( IOPMPowerFlags, unsigned long, IOService * )
{
return kIOPMAckImplied;
}
IOReturn IOService::powerStateDidChangeTo ( IOPMPowerFlags, unsigned long, IOService * )
{
return kIOPMAckImplied;
}
void IOService::powerChangeDone ( unsigned long )
{
}
IOReturn IOService::newTemperature ( long currentTemp, IOService * whichZone )
{
return IOPMNoErr;
}
void IOService::systemWillShutdown( IOOptionBits specifier )
{
IOPMrootDomain * rootDomain = IOService::getPMRootDomain();
if (rootDomain)
rootDomain->acknowledgeSystemWillShutdown( this );
}
IOPMRequest *
IOService::acquirePMRequest( IOService * target, IOOptionBits requestType )
{
IOPMRequest * request;
assert(target);
request = IOPMRequest::create();
if (request)
{
request->init( target, requestType );
}
return request;
}
void IOService::releasePMRequest( IOPMRequest * request )
{
if (request)
{
request->reset();
request->release();
}
}
void IOService::submitPMRequest( IOPMRequest * request )
{
assert( request );
assert( gIOPMReplyQueue );
assert( gIOPMRequestQueue );
PM_TRACE("[+ %02lx] %p [%p %s] %p %p %p\n",
request->getType(), request,
request->getTarget(), request->getTarget()->getName(),
request->fArg0, request->fArg1, request->fArg2);
if (request->isReply())
gIOPMReplyQueue->queuePMRequest( request );
else
gIOPMRequestQueue->queuePMRequest( request );
}
void IOService::submitPMRequest( IOPMRequest ** requests, IOItemCount count )
{
assert( requests );
assert( count > 0 );
assert( gIOPMRequestQueue );
for (IOItemCount i = 0; i < count; i++)
{
IOPMRequest * req = requests[i];
PM_TRACE("[+ %02lx] %p [%p %s] %p %p %p\n",
req->getType(), req,
req->getTarget(), req->getTarget()->getName(),
req->fArg0, req->fArg1, req->fArg2);
}
gIOPMRequestQueue->queuePMRequestChain( requests, count );
}
bool IOService::servicePMRequestQueue(
IOPMRequest * request,
IOPMRequestQueue * queue )
{
if (!initialized)
{
PM_DEBUG("[%s] %s: PM not initialized\n", getName(), __FUNCTION__);
goto done;
}
if (!fPMWorkQueue)
{
fPMWorkQueue = IOPMWorkQueue::create(
this,
OSMemberFunctionCast(IOPMWorkQueue::Action, this,
&IOService::servicePMRequest),
OSMemberFunctionCast(IOPMWorkQueue::Action, this,
&IOService::retirePMRequest)
);
if (fPMWorkQueue &&
(gIOPMWorkLoop->addEventSource(fPMWorkQueue) != kIOReturnSuccess))
{
PM_ERROR("[%s] %s: addEventSource failed\n",
getName(), __FUNCTION__);
fPMWorkQueue->release();
fPMWorkQueue = 0;
}
if (!fPMWorkQueue)
{
PM_ERROR("[%s] %s: not ready (type %02lx)\n",
getName(), __FUNCTION__, request->getType());
goto done;
}
}
fPMWorkQueue->queuePMRequest(request);
return false;
done:
gIOPMFreeQueue->queuePMRequest( request );
return false; }
bool IOService::servicePMFreeQueue(
IOPMRequest * request,
IOPMRequestQueue * queue )
{
bool more = request->hasParentRequest();
releasePMRequest( request );
return more;
}
bool IOService::retirePMRequest( IOPMRequest * request, IOPMWorkQueue * queue )
{
assert(request && queue);
PM_TRACE("[- %02lx] %p [%p %s] State %ld, Busy %ld\n",
request->getType(), request, this, getName(),
fMachineState, gIOPMBusyCount);
if ((request->getType() == kIOPMRequestTypeActivityTickle) &&
(request->fArg1 == (void *) false))
{
if (fDeviceDesire > 0)
start_PM_idle_timer();
else
fActivityTimerStopped = true;
}
gIOPMFreeQueue->queuePMRequest( request );
return true;
}
bool IOService::isPMBlocked ( IOPMRequest * request, int count )
{
int reason = 0;
do {
if (kIOPM_Finished == fMachineState)
break;
if (kIOPM_DriverThreadCallDone == fMachineState)
{
if (fDriverCallBusy) reason = 5 + fDriverCallReason;
break;
}
if (fDriverTimer)
{
reason = 1; break;
}
if (fHeadNotePendingAcks)
{
reason = 2; break;
}
if (fResponseArray)
{
reason = 3; break;
}
if (fSettleTimeUS)
{
reason = 4; break;
}
} while (false);
fWaitReason = reason;
if (reason)
{
if (count)
{
PM_TRACE("[B %02lx] %p [%p %s] State %ld, Reason %d\n",
request->getType(), request, this, getName(),
fMachineState, reason);
}
return true;
}
return false;
}
bool IOService::servicePMRequest( IOPMRequest * request, IOPMWorkQueue * queue )
{
bool done = false;
int loop = 0;
assert(request && queue);
while (isPMBlocked(request, loop++) == false)
{
PM_TRACE("[W %02lx] %p [%p %s] State %ld\n",
request->getType(), request, this, getName(), fMachineState);
fPMRequest = request;
switch ( fMachineState )
{
case kIOPM_Finished:
executePMRequest( request );
break;
case kIOPM_OurChangeTellClientsPowerDown:
if (!fDoNotPowerDown)
{
OurChangeTellClientsPowerDown();
}
else
{
OUR_PMLog(kPMLogIdleCancel, (uintptr_t) this, fMachineState);
PM_ERROR("%s: idle cancel\n", fName);
tellNoChangeDown(fHeadNoteState);
fHeadNoteFlags |= IOPMNotDone;
all_done();
}
break;
case kIOPM_OurChangeTellPriorityClientsPowerDown:
#if SUPPORT_IDLE_CANCEL
if (fDoNotPowerDown)
{
OUR_PMLog(kPMLogIdleCancel, (uintptr_t) this, fMachineState);
PM_ERROR("%s: idle revert\n", fName);
tellChangeUp(fCurrentPowerState);
fHeadNoteFlags |= IOPMNotDone;
all_done();
}
else
#endif
{
OurChangeTellPriorityClientsPowerDown();
}
break;
case kIOPM_OurChangeNotifyInterestedDriversWillChange:
OurChangeNotifyInterestedDriversWillChange();
break;
case kIOPM_OurChangeSetPowerState:
OurChangeSetPowerState();
break;
case kIOPM_OurChangeWaitForPowerSettle:
OurChangeWaitForPowerSettle();
break;
case kIOPM_OurChangeNotifyInterestedDriversDidChange:
OurChangeNotifyInterestedDriversDidChange();
break;
case kIOPM_OurChangeFinish:
OurChangeFinish();
break;
case kIOPM_ParentDownTellPriorityClientsPowerDown:
ParentDownTellPriorityClientsPowerDown();
break;
case kIOPM_ParentDownNotifyInterestedDriversWillChange:
ParentDownNotifyInterestedDriversWillChange();
break;
case kIOPM_ParentDownNotifyDidChangeAndAcknowledgeChange:
ParentDownNotifyDidChangeAndAcknowledgeChange();
break;
case kIOPM_ParentDownSetPowerState:
ParentDownSetPowerState();
break;
case kIOPM_ParentDownWaitForPowerSettle:
ParentDownWaitForPowerSettle();
break;
case kIOPM_ParentDownAcknowledgeChange:
ParentDownAcknowledgeChange();
break;
case kIOPM_ParentUpSetPowerState:
ParentUpSetPowerState();
break;
case kIOPM_ParentUpWaitForSettleTime:
ParentUpWaitForSettleTime();
break;
case kIOPM_ParentUpNotifyInterestedDriversDidChange:
ParentUpNotifyInterestedDriversDidChange();
break;
case kIOPM_ParentUpAcknowledgePowerChange:
ParentUpAcknowledgePowerChange();
break;
case kIOPM_DriverThreadCallDone:
if (fDriverCallReason == kDriverCallSetPowerState)
notifyControllingDriverDone();
else
notifyInterestedDriversDone();
break;
case kIOPM_NotifyChildrenDone:
notifyChildrenDone();
break;
default:
IOPanic("servicePMWorkQueue: unknown machine state");
}
fPMRequest = 0;
if (fMachineState == kIOPM_Finished)
{
done = true;
break;
}
}
return done;
}
void IOService::executePMRequest( IOPMRequest * request )
{
assert( kIOPM_Finished == fMachineState );
switch (request->getType())
{
case kIOPMRequestTypePMStop:
handlePMstop( request );
break;
case kIOPMRequestTypeAddPowerChild1:
addPowerChild1( request );
break;
case kIOPMRequestTypeAddPowerChild2:
addPowerChild2( request );
break;
case kIOPMRequestTypeAddPowerChild3:
addPowerChild3( request );
break;
case kIOPMRequestTypeRegisterPowerDriver:
handleRegisterPowerDriver( request );
break;
case kIOPMRequestTypeAdjustPowerState:
adjustPowerState();
break;
case kIOPMRequestTypeMakeUsable:
handleMakeUsable( request );
break;
case kIOPMRequestTypeTemporaryPowerClamp:
fClampOn = true;
handleMakeUsable( request );
break;
case kIOPMRequestTypePowerDomainWillChange:
handlePowerDomainWillChangeTo( request );
break;
case kIOPMRequestTypePowerDomainDidChange:
handlePowerDomainDidChangeTo( request );
break;
case kIOPMRequestTypeChangePowerStateTo:
handleChangePowerStateTo( request );
break;
case kIOPMRequestTypeChangePowerStateToPriv:
handleChangePowerStateToPriv( request );
break;
case kIOPMRequestTypePowerOverrideOnPriv:
case kIOPMRequestTypePowerOverrideOffPriv:
handlePowerOverrideChanged( request );
break;
case kIOPMRequestTypeActivityTickle:
if (request)
{
bool setDeviceDesire = false;
if (request->fArg1)
{
unsigned long ticklePowerState = (unsigned long) request->fArg0;
if ((fDeviceDesire < ticklePowerState) &&
(ticklePowerState < fNumberOfPowerStates))
{
setDeviceDesire = true;
fIdleTimerMinPowerState = ticklePowerState;
}
}
else if (fDeviceDesire > fIdleTimerMinPowerState)
{
request->fArg0 = (void *) (fDeviceDesire - 1);
setDeviceDesire = true;
}
if (setDeviceDesire)
{
request->fArg1 = (void *) false;
handleChangePowerStateToPriv( request );
}
}
break;
default:
IOPanic("executePMRequest: unknown request type");
}
}
bool IOService::servicePMReplyQueue( IOPMRequest * request, IOPMRequestQueue * queue )
{
bool more = false;
assert( request && queue );
assert( request->isReply() );
PM_TRACE("[A %02lx] %p [%p %s] State %ld\n",
request->getType(), request, this, getName(), fMachineState);
switch ( request->getType() )
{
case kIOPMRequestTypeAllowPowerChange:
case kIOPMRequestTypeCancelPowerChange:
if (responseValid((unsigned long) request->fArg0, (int) request->fArg1))
{
if (kIOPMRequestTypeCancelPowerChange == request->getType())
fDoNotPowerDown = true;
if (checkForDone())
{
stop_ack_timer();
if ( fResponseArray )
{
fResponseArray->release();
fResponseArray = NULL;
}
more = true;
}
}
break;
case kIOPMRequestTypeAckPowerChange:
more = handleAcknowledgePowerChange( request );
break;
case kIOPMRequestTypeAckSetPowerState:
if (fDriverTimer == -1)
{
OUR_PMLog(kPMLogDriverAcknowledgeSet,
(UInt32) this, fDriverTimer);
fDriverTimer = 0;
}
else if (fDriverTimer > 0)
{
stop_ack_timer();
#if LOG_SETPOWER_TIMES
uint64_t nsec = computeTimeDeltaNS(&fDriverCallStartTime);
if (nsec > LOG_SETPOWER_TIMES)
PM_DEBUG("%s::setPowerState(%p, %lu -> %lu) async took %d ms\n",
fName, this, fCurrentPowerState, fHeadNoteState, NS_TO_MS(nsec));
#endif
OUR_PMLog(kPMLogDriverAcknowledgeSet, (UInt32) this, fDriverTimer);
fDriverTimer = 0;
more = true;
}
else
{
OUR_PMLog(kPMLogAcknowledgeErr4, (UInt32) this, 0);
}
break;
case kIOPMRequestTypeInterestChanged:
handleInterestChanged( request );
more = true;
break;
#if SUPPORT_IDLE_CANCEL
case kIOPMRequestTypeIdleCancel:
if ((fMachineState == kIOPM_OurChangeTellClientsPowerDown)
|| (fMachineState == kIOPM_OurChangeTellPriorityClientsPowerDown))
{
OUR_PMLog(kPMLogIdleCancel, (uintptr_t) this, 0);
fDoNotPowerDown = true;
if (fMachineState == kIOPM_OurChangeTellPriorityClientsPowerDown)
cleanClientResponses(false);
more = true;
}
break;
#endif
default:
IOPanic("servicePMReplyQueue: unknown reply type");
}
releasePMRequest( request );
return more;
}
OSDefineMetaClassAndStructors( IOPMRequest, IOCommand );
IOPMRequest * IOPMRequest::create( void )
{
IOPMRequest * me = OSTypeAlloc(IOPMRequest);
if (me && !me->init(0, kIOPMRequestTypeInvalid))
{
me->release();
me = 0;
}
return me;
}
bool IOPMRequest::init( IOService * target, IOOptionBits type )
{
if (!IOCommand::init())
return false;
fType = type;
fTarget = target;
fParent = 0;
fChildCount = 0;
fArg0 = fArg1 = fArg2 = 0;
if (fTarget)
fTarget->retain();
return true;
}
void IOPMRequest::reset( void )
{
assert( fChildCount == 0 );
fType = kIOPMRequestTypeInvalid;
if (fParent)
{
fParent->fChildCount--;
fParent = 0;
}
if (fTarget)
{
fTarget->release();
fTarget = 0;
}
}
OSDefineMetaClassAndStructors( IOPMRequestQueue, IOEventSource );
IOPMRequestQueue * IOPMRequestQueue::create( IOService * inOwner, Action inAction )
{
IOPMRequestQueue * me = OSTypeAlloc(IOPMRequestQueue);
if (me && !me->init(inOwner, inAction))
{
me->release();
me = 0;
}
return me;
}
bool IOPMRequestQueue::init( IOService * inOwner, Action inAction )
{
if (!inAction || !IOEventSource::init(inOwner, (IOEventSourceAction)inAction))
return false;
queue_init(&fQueue);
fLock = IOLockAlloc();
return (fLock != 0);
}
void IOPMRequestQueue::free( void )
{
if (fLock)
{
IOLockFree(fLock);
fLock = 0;
}
return IOEventSource::free();
}
void IOPMRequestQueue::queuePMRequest( IOPMRequest * request )
{
assert(request);
IOLockLock(fLock);
queue_enter(&fQueue, request, IOPMRequest *, fCommandChain);
IOLockUnlock(fLock);
if (workLoop) signalWorkAvailable();
}
void
IOPMRequestQueue::queuePMRequestChain( IOPMRequest ** requests, IOItemCount count )
{
IOPMRequest * next;
assert(requests && count);
IOLockLock(fLock);
while (count--)
{
next = *requests;
requests++;
queue_enter(&fQueue, next, IOPMRequest *, fCommandChain);
}
IOLockUnlock(fLock);
if (workLoop) signalWorkAvailable();
}
bool IOPMRequestQueue::checkForWork( void )
{
Action dqAction = (Action) action;
IOPMRequest * request;
IOService * target;
bool more = false;
IOLockLock( fLock );
while (!queue_empty(&fQueue))
{
queue_remove_first( &fQueue, request, IOPMRequest *, fCommandChain );
IOLockUnlock( fLock );
target = request->getTarget();
assert(target);
more |= (*dqAction)( target, request, this );
IOLockLock( fLock );
}
IOLockUnlock( fLock );
return more;
}
void IOPMRequestQueue::signalWorkAvailable( void )
{
IOEventSource::signalWorkAvailable();
}
OSDefineMetaClassAndStructors( IOPMWorkQueue, IOEventSource );
IOPMWorkQueue *
IOPMWorkQueue::create( IOService * inOwner, Action work, Action retire )
{
IOPMWorkQueue * me = OSTypeAlloc(IOPMWorkQueue);
if (me && !me->init(inOwner, work, retire))
{
me->release();
me = 0;
}
return me;
}
bool IOPMWorkQueue::init( IOService * inOwner, Action work, Action retire )
{
if (!work || !retire ||
!IOEventSource::init(inOwner, (IOEventSourceAction)0))
return false;
queue_init(&fWorkQueue);
fWorkAction = work;
fRetireAction = retire;
return true;
}
void IOPMWorkQueue::queuePMRequest( IOPMRequest * request )
{
assert( request );
assert( onThread() );
gIOPMBusyCount++;
queue_enter(&fWorkQueue, request, IOPMRequest *, fCommandChain);
checkForWork();
}
bool IOPMWorkQueue::checkForWork( void )
{
IOPMRequest * request;
IOService * target = (IOService *) owner;
bool done;
while (!queue_empty(&fWorkQueue))
{
request = (IOPMRequest *) queue_first(&fWorkQueue);
assert(request->getTarget() == target);
if (request->hasChildRequest()) break;
done = (*fWorkAction)( target, request, this );
if (!done) break;
assert(gIOPMBusyCount > 0);
if (gIOPMBusyCount) gIOPMBusyCount--;
queue_remove_first(&fWorkQueue, request, IOPMRequest *, fCommandChain);
(*fRetireAction)( target, request, this );
}
return false;
}
OSDefineMetaClassAndStructors(IOServicePM, OSObject)
static void
setPMProperty( OSDictionary * dict, const char * key, unsigned long value )
{
OSNumber * num = OSNumber::withNumber(value, sizeof(value) * 8);
if (num)
{
dict->setObject(key, num);
num->release();
}
}
bool IOServicePM::serialize( OSSerialize * s ) const
{
OSDictionary * dict;
bool ok = false;
dict = OSDictionary::withCapacity(8);
if (dict)
{
setPMProperty( dict, "CurrentPowerState", CurrentPowerState );
if (DesiredPowerState != CurrentPowerState)
setPMProperty( dict, "DesiredPowerState", DesiredPowerState );
if (kIOPM_Finished != MachineState)
setPMProperty( dict, "MachineState", MachineState );
if (ChildrenDesire)
setPMProperty( dict, "ChildrenPowerState", ChildrenDesire );
if (DeviceDesire)
setPMProperty( dict, "DeviceChangePowerState", DeviceDesire );
if (DriverDesire)
setPMProperty( dict, "DriverChangePowerState", DriverDesire );
if (DeviceOverrides)
dict->setObject( "PowerOverrideOn", kOSBooleanTrue );
ok = dict->serialize(s);
dict->release();
}
return ok;
}