void BrcmPatchRAM::stop(IOService* provider) { uint64_t stop_time, nano_secs; clock_get_uptime(&stop_time); absolutetime_to_nanoseconds(stop_time - wake_time, &nano_secs); uint64_t milli_secs = nano_secs / 1000000; AlwaysLog("Time since wake %llu.%llu seconds.\n", milli_secs / 1000, milli_secs % 1000); DebugLog("stop\n"); OSSafeReleaseNULL(mFirmwareStore); IOWorkLoop* workLoop = getWorkLoop(); if (workLoop) { if (mTimer) { mTimer->cancelTimeout(); workLoop->removeEventSource(mTimer); mTimer->release(); mTimer = NULL; } if (mWorkSource) { workLoop->removeEventSource(mWorkSource); mWorkSource->release(); mWorkSource = NULL; mWorkPending = 0; } } PMstop(); if (mCompletionLock) { IOLockFree(mCompletionLock); mCompletionLock = NULL; } if (mWorkLock) { IOLockFree(mWorkLock); mWorkLock = NULL; } OSSafeReleaseNULL(mDevice); super::stop(provider); }
void SCSIPressurePathManager::free ( void ) { STATUS_LOG ( ( "SCSIPressurePathManager::free\n" ) ); if ( fPathSet != NULL ) { fPathSet->release ( ); fPathSet = NULL; } if ( fInactivePathSet != NULL ) { fInactivePathSet->release ( ); fInactivePathSet = NULL; } if ( fLock != NULL ) { IOLockFree ( fLock ); fLock = NULL; } super::free ( ); }
/* keep the pet thread around while we run */ int kperf_pet_init(void) { kern_return_t rc; thread_t t; if( pet_thread != NULL ) return 0; /* make the sync poing */ pet_lock = IOLockAlloc(); if( pet_lock == NULL ) return ENOMEM; /* create the thread */ BUF_INFO1(PERF_PET_THREAD, 0); rc = kernel_thread_start( pet_thread_loop, NULL, &t ); if( rc != KERN_SUCCESS ) { IOLockFree( pet_lock ); pet_lock = NULL; return ENOMEM; } /* OK! */ return 0; }
/****************************************************************************** * ACPIDebug::stop ******************************************************************************/ void ACPIDebug::stop(IOService *provider) { DEBUG_LOG("ACPIDebug::stop: called\n"); if (NULL != m_pTimer) { m_pTimer->cancelTimeout(); m_pWorkLoop->removeEventSource(m_pTimer); m_pTimer->release(); m_pTimer = NULL; } if (NULL != m_pCmdGate) { m_pWorkLoop->removeEventSource(m_pCmdGate); m_pCmdGate->release(); m_pCmdGate = NULL; } if (NULL != m_pWorkLoop) { m_pWorkLoop->release(); m_pWorkLoop = NULL; } if (NULL != m_pLock) { IOLockFree(m_pLock); m_pLock = NULL; } super::stop(provider); }
void AppleIntelPIIXATARoot::free( void ) { if ( _nubs ) { _nubs->release(); _nubs = 0; } if ( _openNubs ) { _openNubs->release(); _openNubs = 0; } if ( _provider ) { _provider->release(); _provider = 0; } if ( _pciConfigLock ) { IOLockFree( _pciConfigLock ); _pciConfigLock = 0; } super::free(); }
bool DldIODataQueue::initWithCapacity( __in UInt32 size ) { assert( 0x0 != size ); assert( preemption_enabled() ); if( !super::init() ){ return false; } this->lock = IOLockAlloc(); assert( this->lock ); if( !this->lock ) return false; this->dataQueue = (DldIODataQueueMemory*)IOMallocAligned(round_page(size + DLD_DATA_QUEUE_MEMORY_HEADER_SIZE), PAGE_SIZE); assert( this->dataQueue ); if( !this->dataQueue ){ IOLockFree( this->lock ); return false; } bzero( this->dataQueue, sizeof( *this->dataQueue ) ); this->dataQueue->queueSize = size; return true; }
void AppleNForceATARoot::free( void ) { if (fISABridgeNotifier) { fISABridgeNotifier->remove(); fISABridgeNotifier = 0; } if (fChannels) { fChannels->release(); fChannels = 0; } if (fOpenChannels) { fOpenChannels->release(); fOpenChannels = 0; } if (fProvider) { fProvider->release(); fProvider = 0; } if (fPCILock) { IOLockFree( fPCILock ); fPCILock = 0; } super::free(); }
static void free(IOLock*& lock) { IOLockLock(lock); IOLock* tmplock = lock; lock = NULL; IOLockUnlock(tmplock); IOLockFree(tmplock); }
void IOHIKeyboard::free() // Description: Go Away. Be careful when freeing the lock. { IOLock * lock = NULL; if ( _deviceLock ) { lock = _deviceLock; IOLockLock( lock); _deviceLock = NULL; } if ( _keyMap ) { _keyMap->release(); } if( _keyState ) IOFree( _keyState, _keyStateSize); // RY: MENTAL NOTE Do this last if ( lock ) { IOLockUnlock( lock); IOLockFree( lock); } super::free(); }
void I2CUserClient::stop(IOService *provider) { DLOG("+I2CUserClient::stop\n"); IOLockFree(fIsOpenLock); super::stop(provider); }
IOReturn IOSharedInterruptController::initInterruptController(IOInterruptController *parentController, OSData *parentSource) { int cnt, interruptType; IOReturn error; if (!super::init()) return kIOReturnNoResources; // Set provider to this so enable/disable nub stuff works. provider = this; // Allocate the IOInterruptSource so this can act like a nub. _interruptSources = (IOInterruptSource *)IOMalloc(sizeof(IOInterruptSource)); if (_interruptSources == 0) return kIOReturnNoMemory; _numInterruptSources = 1; // Set up the IOInterruptSource to point at this. _interruptSources[0].interruptController = parentController; _interruptSources[0].vectorData = parentSource; sourceIsLevel = false; error = provider->getInterruptType(0, &interruptType); if (error == kIOReturnSuccess) { if (interruptType & kIOInterruptTypeLevel) sourceIsLevel = true; } // Allocate the memory for the vectors numVectors = 32; // For now a constant number. vectors = (IOInterruptVector *)IOMalloc(numVectors * sizeof(IOInterruptVector)); if (vectors == NULL) { IOFree(_interruptSources, sizeof(IOInterruptSource)); return kIOReturnNoMemory; } bzero(vectors, numVectors * sizeof(IOInterruptVector)); // Allocate the lock for the controller. controllerLock = IOSimpleLockAlloc(); if (controllerLock == 0) return kIOReturnNoResources; // Allocate locks for the vectors. for (cnt = 0; cnt < numVectors; cnt++) { vectors[cnt].interruptLock = IOLockAlloc(); if (vectors[cnt].interruptLock == NULL) { for (cnt = 0; cnt < numVectors; cnt++) { if (vectors[cnt].interruptLock != NULL) IOLockFree(vectors[cnt].interruptLock); } return kIOReturnNoResources; } } vectorsRegistered = 0; vectorsEnabled = 0; controllerDisabled = 1; return kIOReturnSuccess; }
bool GenericInterruptController::start(IOService *provider) { IOInterruptAction handler; IOSymbol *interruptControllerName; // If needed call the parents start. if (!super::start(provider)) return false; // Map the device's memory and initalize its state. // For now you must allocate storage for the vectors. // This will probably changed to something like: initVectors(numVectors). // In the mean time something like this works well. #if 0 // Allocate the memory for the vectors. vectors = (IOInterruptVector *)IOMalloc(numVectors * sizeof(IOInterruptVector)); if (vectors == NULL) return false; bzero(vectors, numVectors * sizeof(IOInterruptVector)); // Allocate locks for the vectors. for (cnt = 0; cnt < numVectors; cnt++) { vectors[cnt].interruptLock = IOLockAlloc(); if (vectors[cnt].interruptLock == NULL) { for (cnt = 0; cnt < numVectors; cnt++) { if (vectors[cnt].interruptLock != NULL) IOLockFree(vectors[cnt].interruptLock); } } } #endif // If you know that this interrupt controller is the primary // interrupt controller, use this to set it nub properties properly. // This may be done by the nub's creator. getPlatform()->setCPUInterruptProperties(provider); // register the interrupt handler so it can receive interrupts. handler = getInterruptHandlerAddress(); provider->registerInterrupt(0, this, handler, 0); // Just like any interrupt source, you must enable it to receive interrupts. provider->enableInterrupt(0); // Set interruptControllerName to the proper symbol. //interruptControllerName = xxx; // Register this interrupt controller so clients can find it. getPlatform()->registerInterruptController(interruptControllerName, this); // All done, so return true. return true; }
IOReturn EMUUSBInputStream::free() { ReturnIf(!initialized, kIOReturnNotReady); ReturnIf(started, kIOReturnStillOpen); initialized=false; if (NULL != mLock) { IOLockFree(mLock); mLock = NULL; } return kIOReturnSuccess; }
kern_return_t BrcmPatchRAM_Stop(kmod_info_t* ki, void * d) { #ifndef NON_RESIDENT if (BrcmPatchRAM::mLoadFirmwareLock) { IOLockFree(BrcmPatchRAM::mLoadFirmwareLock); BrcmPatchRAM::mLoadFirmwareLock = NULL; } #endif return KERN_SUCCESS; }
void GlobalLock::terminate(void) { if (!lock_) return; IOLockLock(lock_); IOLock* tmp = lock_; lock_ = NULL; IOLockUnlock(tmp); // roughly sleep: IOSleep(200); IOLockFree(tmp); }
void DldIODataQueue::free() { assert( preemption_enabled() ); if( this->dataQueue ) IOFreeAligned( this->dataQueue, round_page(dataQueue->queueSize + DATA_QUEUE_MEMORY_HEADER_SIZE) ); if( this->lock ) IOLockFree( this->lock ); super::free(); return; }
void IOSharedEventQueue::free() { if(this->_lock) { IOLockFree(this->_lock); this->_lock=NULL; } if(this->_descriptor) { this->_descriptor->release(); this->_descriptor=NULL; } }
SCSIPressurePathManager::PortBandwidthGlobals::~PortBandwidthGlobals ( void ) { if ( fLock != NULL ) { IOLockFree ( fLock ); fLock = NULL; } IOFree ( fListHead, fCapacity ); fListHead = NULL; fCapacity = 0; }
void HoRNDIS::releaseResources() { int i; for (i = 0; i < N_OUT_BUFS; i++) if (outbufs[i].mdp) { outbufs[i].mdp->release(); outbufs[i].mdp = NULL; } if (inbuf.mdp) { inbuf.mdp->release(); inbuf.mdp = NULL; } if (outbuf_lock) IOLockFree(outbuf_lock); }
void BrcmPatchRAM::stop(IOService* provider) { DebugLog("stop\n"); OSSafeReleaseNULL(mFirmwareStore); PMstop(); if (mCompletionLock) { IOLockFree(mCompletionLock); mCompletionLock = NULL; } OSSafeReleaseNULL(mDevice); super::stop(provider); }
void IOFWUserAsyncStreamListener::free() { if ( fPacketQueuePrepared ) fPacketQueueBuffer->complete() ; if ( fPacketQueueBuffer ) fPacketQueueBuffer->release() ; delete fLastWrittenHeader ; if( fLock ) { IOLockFree( fLock ); fLock = NULL; } IOFWAsyncStreamListener::free() ; }
void IOHIDEventQueue::free() { if (_lock) { IOLockLock(_lock); IOLock* tempLock = _lock; _lock = NULL; IOLockUnlock(tempLock); IOLockFree(tempLock); } if ( _descriptor ) { _descriptor->release(); _descriptor = 0; } super::free(); }
void RadeonController::free( void ) { ScrnInfoPtr pScrn = xf86Screens[0]; if (pScrn) { IODelete(pScrn, ScrnInfoRec, 1); xf86Screens[0] = NULL; } #ifdef DEBUG DumpMsg.client--; if (DumpMsg.client == 0) { DumpMsg.mMsgBufferEnabled = false; if (DumpMsg.mMsgBuffer) { IOFree(DumpMsg.mMsgBuffer, DumpMsg.mMsgBufferSize); DumpMsg.mMsgBuffer = NULL; } if (DumpMsg.mMessageLock) { IOLockLock(DumpMsg.mMessageLock); IOLockFree(DumpMsg.mMessageLock); DumpMsg.mMessageLock = NULL; } getRegistryRoot()->removeProperty("RadeonDumpReady"); } #endif int i; for (i = 0;i < 2;i++) { if (options.EDID_Block[i]) { IOFree(options.EDID_Block[i], options.EDID_Length[i]); options.EDID_Block[i] = NULL; } } if (memoryMap.BIOSCopy) { IOFree(memoryMap.BIOSCopy, memoryMap.BIOSLength); memoryMap.BIOSCopy = NULL; } if (IOMap) IOMap->release(); if (FBMap) FBMap->release(); super::free(); }
void IOI2CDriveBayGPIO::stop(IOService *provider) { UInt32 i; DLOG("IOI2CDriveBayGPIO::stop\n"); for (i = 0; i < kNumGPIOs; i++) { fClient[i].isEnabled = false; fClient[i].self = 0; fClient[i].handler = 0; } // Un-Register with the combined PCA9554M if (fPCA9554M) fPCA9554M->callPlatformFunction("register9554MInterruptClient", false, (void *)fReg, (void *)&sProcess9554MInterrupt, (void *)this, (void *)false); if (fClientLock) { IOLockFree(fClientLock); fClientLock = 0; } super::stop(provider); }
void SPFramebuffer::free() { IOLockFree(lock); super::free(); }
void AppleGPIO::stop(IOService *provider) { UInt32 flags, i; IOPlatformFunction *func; AppleGPIOCallbackInfo *thisClient, *nextClient; // Execute any functions flagged as "on termination" UInt32 count = fPlatformFuncArray->getCount(); for (i = 0; i < count; i++) { if (func = OSDynamicCast(IOPlatformFunction, fPlatformFuncArray->getObject(i))) { flags = func->getCommandFlags(); if (flags & kIOPFFlagOnTerm) performFunction(func, (void *)1, (void *)0, (void *)0, (void *)0); } } // Unregister for interrupts if (fIntGen && amRegistered()) { disableWithParent(); unregisterWithParent(); fIntGen = false; } if (fPFLock) { IOLockFree (fPFLock); fPFLock = NULL; } IOSimpleLockLock(fClientsLock); if (fClients) { thisClient = fClients; while (thisClient) { nextClient = thisClient->next; IOFree(thisClient, sizeof(AppleGPIOCallbackInfo)); thisClient = nextClient; } fClients = 0; } IOSimpleLockUnlock(fClientsLock); IOSimpleLockFree(fClientsLock); fClientsLock = 0; IOLockFree(fAmRegisteredLock); fAmRegisteredLock = 0; IOSimpleLockFree(fAmEnabledLock); fAmEnabledLock = 0; fParent = 0; fGPIOID = kGPIOIDInvalid; if (fSymIntRegister) { fSymIntRegister->release(); fSymIntRegister = 0; } if (fSymIntUnRegister) { fSymIntUnRegister->release(); fSymIntUnRegister = 0; } if (fSymIntEnable) { fSymIntEnable->release(); fSymIntEnable = 0; } if (fSymIntDisable) { fSymIntDisable->release(); fSymIntDisable = 0; } #ifdef OLD_STYLE_COMPAT releaseStrings(); #endif super::stop(provider); }
// Free the extension void Xbox360Peripheral::free(void) { IOLockFree(mainLock); super::free(); }
void spin_lock_free(spinlock_t *lock) { IOLockFree(*lock); lock = NULL; }
void BrcmPatchRAM::stop(IOService* provider) { #ifdef DEBUG uint64_t stop_time, nano_secs; clock_get_uptime(&stop_time); absolutetime_to_nanoseconds(stop_time - wake_time, &nano_secs); uint64_t milli_secs = nano_secs / 1000000; AlwaysLog("Time since wake %llu.%llu seconds.\n", milli_secs / 1000, milli_secs % 1000); #endif DebugLog("stop\n"); #if 0 #ifndef TARGET_ELCAPITAN //REVIEW: so kext can be unloaded with kextunload -p // unload native bluetooth driver IOReturn result = gIOCatalogue->terminateDriversForModule(brcmBundleIdentifier, false); if (result != kIOReturnSuccess) AlwaysLog("[%04x:%04x]: failure terminating native Broadcom bluetooth (%08x)\n", mVendorId, mProductId, result); else DebugLog("[%04x:%04x]: success terminating native Broadcom bluetooth\n", mVendorId, mProductId); // unpublish native bluetooth personality removePersonality(); #endif #endif mStopping = true; // allow firmware load already started to finish IOLockLock(mLoadFirmwareLock); OSSafeReleaseNULL(mFirmwareStore); IOWorkLoop* workLoop = getWorkLoop(); if (workLoop) { if (mTimer) { mTimer->cancelTimeout(); workLoop->removeEventSource(mTimer); mTimer->release(); mTimer = NULL; } if (mWorkSource) { workLoop->removeEventSource(mWorkSource); mWorkSource->release(); mWorkSource = NULL; mWorkPending = 0; } } PMstop(); if (mCompletionLock) { IOLockFree(mCompletionLock); mCompletionLock = NULL; } #ifndef NON_RESIDENT if (mWorkLock) { IOLockFree(mWorkLock); mWorkLock = NULL; } IOLockUnlock(mLoadFirmwareLock); #endif // #ifndef NON_RESIDENT mDevice.setDevice(NULL); mStopping = false; super::stop(provider); }
~IOMapperLock() { IOLockFree(fWaitLock); }