// IOFireWireIRMAllocation::free
//
//
void IOFireWireIRMAllocation::free( void )
{
DebugLog( "IOFireWireIRMAllocation::free\n") ;
// Take the lock
IORecursiveLockLock(fLock);
// If we need to release the isoch resources, do so now!
if (isAllocated)
{
if (fReleaseIRMResourcesOnFree)
{
if (fBandwidthUnits > 0)
fControl->releaseIRMBandwidthInGeneration(fBandwidthUnits,fAllocationGeneration);
if (fIsochChannel < 64)
fControl->releaseIRMChannelInGeneration(fIsochChannel,fAllocationGeneration);
}
// Note: we already removed this allocation from the controller's array! Don't need to do it here!
}
// Free the lock
if ( fLock )
IORecursiveLockFree( fLock ) ;
OSObject::free();
}
bool
IOFireWireUserClientIniter::init(OSDictionary * propTable)
{
fProvider = NULL ;
if( sIniterLock == NULL )
{
IORecursiveLock * lock = IORecursiveLockAlloc();
//IOLog( "IOFireWireUserClientIniter<0x%08lx>::init - IORecursiveLockAlloc = 0x%08lx\n", this, lock );
bool result = false;
while( sIniterLock == NULL && result == false )
{
result = OSCompareAndSwapPtr( NULL, lock, (void * volatile *)&sIniterLock );
}
if( result == false )
{
//IOLog( "IOFireWireUserClientIniter<0x%08lx>::init - IORecursiveLockFree = 0x%08lx\n", this, lock );
IORecursiveLockFree( lock );
}
}
//IOLog( "IOFireWireUserClientIniter<0x%08lx>::init - sIniterLock = 0x%08lx\n", this, sIniterLock );
return super::init(propTable) ;
}
// Free is called twice:
// First when the atomic retainCount transitions from 1 -> 0
// Secondly when the work loop itself is commiting hari kari
// Hence the each leg of the free must be single threaded.
void IOWorkLoop::free()
{
if (workThread) {
IOInterruptState is;
// If we are here then we must be trying to shut down this work loop
// in this case disable all of the event source, mark the loop
// as terminating and wakeup the work thread itself and return
// Note: we hold the gate across the entire operation mainly for the
// benefit of our event sources so we can disable them cleanly.
closeGate();
disableAllEventSources();
is = IOSimpleLockLockDisableInterrupt(workToDoLock);
SETP(&fFlags, kLoopTerminate);
thread_wakeup_one((void *) &workToDo);
IOSimpleLockUnlockEnableInterrupt(workToDoLock, is);
openGate();
}
else /* !workThread */ {
IOEventSource *event, *next;
for (event = eventChain; event; event = next) {
next = event->getNext();
event->setWorkLoop(0);
event->setNext(0);
event->release();
}
eventChain = 0;
// Either we have a partial initialization to clean up
// or the workThread itself is performing hari-kari.
// Either way clean up all of our resources and return.
if (controlG) {
controlG->release();
controlG = 0;
}
if (workToDoLock) {
IOSimpleLockFree(workToDoLock);
workToDoLock = 0;
}
if (gateLock) {
IORecursiveLockFree(gateLock);
gateLock = 0;
}
if (reserved) {
IODelete(reserved, ExpansionData, 1);
reserved = 0;
}
super::free();
}
}
AppleRAIDGlobals::~AppleRAIDGlobals()
{
IOLog1("AppleRAIDGlobals::~AppleRAIDGlobals called.\n");
assert(raidControllerReferences == 0);
if (raidGlobalLock) {
IORecursiveLockFree(raidGlobalLock);
raidGlobalLock = 0;
}
}
void FakeSMCKeyStore::free()
{
if (keysLock) {
IORecursiveLockFree(keysLock);
keysLock = 0;
}
OSSafeRelease(keys);
OSSafeRelease(types);
super::free();
}
void ACPIBacklightPanel::stop( IOService * provider )
{
DbgLog("%s::%s()\n", this->getName(),__FUNCTION__);
IOWorkLoop* workLoop = getWorkLoop();
if (workLoop)
{
if (_workSource)
{
workLoop->removeEventSource(_workSource);
_workSource->release();
_workSource = NULL;
}
if (_smoothTimer)
{
workLoop->removeEventSource(_smoothTimer);
_smoothTimer->release();
_smoothTimer = NULL;
}
if (_cmdGate)
{
workLoop->removeEventSource(_cmdGate);
_cmdGate->release();
_cmdGate = NULL;
}
}
_extended = false;
if (_lock)
{
IORecursiveLockFree(_lock);
_lock = NULL;
}
#if 0
OSSafeReleaseNULL(_provider);
#endif
_backlightHandler = NULL;
super::stop(provider);
}
void BatteryTracker::stop(IOService* provider)
{
DEBUG_LOG("BatteryTracker::stop: entering stop\n");
OSSafeReleaseNULL(m_pBatteryList);
if (NULL != m_pLock)
{
IORecursiveLockFree(m_pLock);
m_pLock = NULL;
}
if (m_pCmdGate)
{
IOWorkLoop* pWorkLoop = getWorkLoop();
if (pWorkLoop)
pWorkLoop->removeEventSource(m_pCmdGate);
m_pCmdGate->release();
m_pCmdGate = NULL;
}
IOService::stop(provider);
}
void
IOFWUserLocalIsochPort::free()
{
// release DCL pool (if we have one)
if ( fDCLPool )
{
fDCLPool->release() ;
fDCLPool = NULL ;
}
// release fProgramBuffer (if we have one)
delete [] (UInt8*)fProgramBuffer ;
fProgramBuffer = NULL ;
if ( fLock )
{
IORecursiveLockFree( fLock ) ;
}
delete[] fDCLTable ;
fDCLTable = NULL ;
super::free() ;
}
