/******************************************************************************* ** Name: SpiDevDeInit ** Input:HDC dev ** Return: rk_err_t ** Owner:Aaron.sun ** Date: 2014.5.30 ** Time: 9:18:00 *******************************************************************************/ _DRIVER_SPI_SPIDEVICE_INIT_ INIT FUN rk_err_t SpiDevDeInit(SPI_DEVICE_CLASS * pstSpiDev) { if(((DEVICE_CLASS*)pstSpiDev)->DevID == 0) { IntDisable(INT_ID_SPI0); IntPendingClear(INT_ID_SPI0); IntUnregister(INT_ID_SPI0); ScuClockGateCtr(PCLK_SPI0_GATE,0); } else { IntDisable(INT_ID_SPI1); IntPendingClear(INT_ID_SPI1); IntUnregister(INT_ID_SPI1); ScuClockGateCtr(PCLK_SPI1_GATE,0); } return RK_SUCCESS; }
//***************************************************************************** // //! Unregisters an interrupt handler for the quadrature encoder interrupt. //! //! \param ulBase is the base address of the quadrature encoder module. //! //! This function will clear the handler to be called when a quadrature encoder //! interrupt occurs. This will also mask off the interrupt in the interrupt //! controller so that the interrupt handler no longer is called. //! //! \sa IntRegister() for important information about registering interrupt //! handlers. //! //! \return None. // //***************************************************************************** void QEIIntUnregister(unsigned long ulBase) { unsigned long ulInt; // // Check the arguments. // ASSERT((ulBase == QEI0_BASE) || (ulBase == QEI1_BASE)); // // Determine the interrupt number based on the QEI module. // ulInt = (ulBase == QEI0_BASE) ? INT_QEI0 : INT_QEI1; // // Disable the interrupt. // IntDisable(ulInt); // // Unregister the interrupt handler. // IntUnregister(ulInt); }
void GPIOPortIntUnregister(unsigned long ulPort) { // // Check the arguments. // ASSERT((ulPort == GPIO_PORTA_BASE) || (ulPort == GPIO_PORTB_BASE) || (ulPort == GPIO_PORTC_BASE) || (ulPort == GPIO_PORTD_BASE) || (ulPort == GPIO_PORTE_BASE)); // // Get the interrupt number associated with the specified GPIO. // ulPort = GPIOGetIntNumber(ulPort); // // Disable the GPIO interrupt. // IntDisable(ulPort); // // Unregister the interrupt handler. // IntUnregister(ulPort); }
//***************************************************************************** // //! Unregisters an interrupt handler for the quadrature encoder interrupt. //! //! \param ui32Base is the base address of the quadrature encoder module. //! //! This function unregisters the handler to be called when a quadrature //! encoder interrupt occurs. This function also masks off the interrupt in //! the interrupt controller so that the interrupt handler no longer is called. //! //! \sa IntRegister() for important information about registering interrupt //! handlers. //! //! \return None. // //***************************************************************************** void QEIIntUnregister(uint32_t ui32Base) { uint32_t ui32Int; // // Check the arguments. // ASSERT((ui32Base == QEI0_BASE) || (ui32Base == QEI1_BASE)); // // Determine the interrupt number based on the QEI module. // ui32Int = _QEIIntNumberGet(ui32Base); ASSERT(ui32Int != 0); // // Disable the interrupt. // IntDisable(ui32Int); // // Unregister the interrupt handler. // IntUnregister(ui32Int); }
int NwpRegisterInterruptHandler(P_EVENT_HANDLER InterruptHdl , void* pValue) //do not know what to do with pValue { if(InterruptHdl == NULL) { //De-register Interprocessor communication interrupt between App and NWP #ifdef SL_PLATFORM_MULTI_THREADED osi_InterruptDeRegister(INT_NWPIC); #else IntDisable(INT_NWPIC); IntUnregister(INT_NWPIC); IntPendClear(INT_NWPIC); #endif g_pHostIntHdl = NULL; } else { g_pHostIntHdl = InterruptHdl; #if 0 //Setting the 14th and 13th bit to '01' to make the HOST_IRQ edge triggered HWREG(0x4402E168) |= 0x2000; #endif #ifdef SL_PLATFORM_MULTI_THREADED IntPendClear(INT_NWPIC); osi_InterruptRegister(INT_NWPIC, (P_OSI_INTR_ENTRY)HostIntHanlder,INT_PRIORITY_LVL_1); #else IntRegister(INT_NWPIC, HostIntHanlder); IntPrioritySet(INT_NWPIC, INT_PRIORITY_LVL_1); IntPendClear(INT_NWPIC); IntEnable(INT_NWPIC); #endif } return 0; }
//***************************************************************************** // //! Unregisters an interrupt handler for the synchronous serial interface. //! //! \param ulBase specifies the SSI module base address. //! //! This function clears the handler to be called when an SSI interrupt //! occurs. This function also masks off the interrupt in the interrupt //! controller so that the interrupt handler no longer is called. //! //! \sa IntRegister() for important information about registering interrupt //! handlers. //! //! \return None. // //***************************************************************************** void SSIIntUnregister(unsigned long ulBase) { unsigned long ulInt; // // Check the arguments. // ASSERT(SSIBaseValid(ulBase)); // // Determine the interrupt number based on the SSI port. // ulInt = SSIIntNumberGet(ulBase); // // Disable the interrupt. // IntDisable(ulInt); // // Unregister the interrupt handler. // IntUnregister(ulInt); }
//***************************************************************************** // //! Unregisters an interrupt handler for the synchronous serial interface. //! //! \param ui32Base specifies the SSI module base address. //! //! This function clears the handler to be called when an SSI interrupt //! occurs. This function also masks off the interrupt in the interrupt //! controller so that the interrupt handler no longer is called. //! //! \sa IntRegister() for important information about registering interrupt //! handlers. //! //! \return None. // //***************************************************************************** void SSIIntUnregister(uint32_t ui32Base) { uint32_t ui32Int; // // Check the arguments. // ASSERT(_SSIBaseValid(ui32Base)); // // Determine the interrupt number based on the SSI port. // ui32Int = _SSIIntNumberGet(ui32Base); ASSERT(ui32Int != 0); // // Disable the interrupt. // IntDisable(ui32Int); // // Unregister the interrupt handler. // IntUnregister(ui32Int); }
//***************************************************************************** // //! Unregisters an interrupt handler for a UART interrupt //! //! \param ui32Base is the base address of the UART port. //! //! This function does the actual unregistering of the interrupt handler. It //! clears the handler to be called when a UART interrupt occurs. This //! function also masks off the interrupt in the interrupt controller so that //! the interrupt handler no longer is called. //! //! \sa IntRegister() for important information about registering interrupt //! handlers. //! //! \return None // //***************************************************************************** void UARTIntUnregister(uint32_t ui32Base) { uint32_t ui32Int; // // Check the arguments. // ASSERT(UARTBaseValid(ui32Base)); // // Determine the interrupt number based on the UART port. // ui32Int = ((ui32Base == UART0_BASE) ? INT_UART0 : INT_UART1); // // Disable the interrupt. // IntDisable(ui32Int); // // Unregister the interrupt handler. // IntUnregister(ui32Int); }
void UARTIntUnregister(unsigned long ulBase) { unsigned long ulInt; // // Check the arguments. // ASSERT((ulBase == UART0_BASE) || (ulBase == UART1_BASE)); // // Determine the interrupt number based on the UART port. // ulInt = (ulBase == UART0_BASE) ? INT_UART0 : INT_UART1; // // Disable the interrupt. // IntDisable(ulInt); // // Unregister the interrupt handler. // IntUnregister(ulInt); }
//***************************************************************************** // //! Unregisters an interrupt handler for the synchronous serial port //! //! \param ui32Base specifies the SSI module base address. //! //! This function will clear the handler to be called when a SSI //! interrupt occurs. This will also mask off the interrupt in the interrupt //! controller so that the interrupt handler no longer is called. //! //! \sa IntRegister() for important information about registering interrupt //! handlers. //! //! \return None // //***************************************************************************** void SSIIntUnregister(uint32_t ui32Base) { uint32_t ui32Int; // // Check the arguments. // ASSERT(SSIBaseValid(ui32Base)); // // Determine the interrupt number based on the SSI port. // ui32Int = (ui32Base == SSI0_BASE) ? INT_SSI0 : INT_SSI1; // // Disable the interrupt. // IntDisable(ui32Int); // // Unregister the interrupt handler. // IntUnregister(ui32Int); }
//***************************************************************************** // //! Unregisters an interrupt handler for the I2C module. //! //! \param ulBase is the base address of the I2C Master module. //! //! This function will clear the handler to be called when an I2C interrupt //! occurs. This will also mask off the interrupt in the interrupt controller //! so that the interrupt handler no longer is called. //! //! \sa IntRegister() for important information about registering interrupt //! handlers. //! //! \return None. // //***************************************************************************** void I2CIntUnregister(unsigned long ulBase) { unsigned long ulInt; // // Check the arguments. // ASSERT((ulBase == I2C0_MASTER_BASE) || (ulBase == I2C1_MASTER_BASE)); // // Determine the interrupt number based on the I2C port. // ulInt = (ulBase == I2C0_MASTER_BASE) ? INT_I2C0 : INT_I2C1; // // Disable the interrupt. // IntDisable(ulInt); // // Unregister the interrupt handler. // IntUnregister(ulInt); }
/******************************************************************************* ** Name: SdcDevDeInit ** Input:HDC dev ** Return: rk_err_t ** Owner:Aaron.sun ** Date: 2014.2.19 ** Time: 15:59:49 *******************************************************************************/ _DRIVER_SDMMC_SDMMCDEVICE_INIT_ rk_err_t SdcDevDeInit(SDC_DEVICE_CLASS * pstSdcDev) { if (pstSdcDev->enSdMmcPort == SDC0) { IntDisable(INT_ID_EMMC); IntPendingClear(INT_ID_EMMC); IntUnregister(INT_ID_EMMC); } else if (pstSdcDev->enSdMmcPort == SDC1) { IntDisable(INT_ID_SDMMC); IntPendingClear(INT_ID_SDMMC); IntUnregister(INT_ID_SDMMC); } //ScuClockGateCtr(CLOCK_GATE_SDMMC,0); return RK_SUCCESS; }
//****************************************************************************** // //! Un-Register camera interrupt handler //! //! \param ulBase is the base address of the camera module. //! //! This function unregisters and disables global camera interrupt from the //! interrupt controller. //! //! \return None. // //****************************************************************************** void CameraIntUnregister(unsigned long ulBase) { // // Disable the interrupt. // IntDisable(INT_CAMERA); // // Unregister the interrupt handler. // IntUnregister(INT_CAMERA); }
//***************************************************************************** // //! Unregisters an interrupt handler for the uDMA controller. //! //! \param ulIntChannel identifies which uDMA interrupt to unregister. //! //! This function will disable and clear the handler to be called for the //! specified uDMA interrupt. The \e ulIntChannel parameter should be one of //! \b UDMA_INT_SW or \b UDMA_INT_ERR as documented for the function //! uDMAIntRegister(). //! //! \sa IntRegister() for important information about registering interrupt //! handlers. //! //! \return None. // //***************************************************************************** void uDMAIntUnregister(unsigned long ulIntChannel) { // // Disable the interrupt. // IntDisable(ulIntChannel); // // Unregister the interrupt handler. // IntUnregister(ulIntChannel); }
//***************************************************************************** // //! Unregisters an interrupt handler for the I2C module //! //! This function clears the handler to be called when an I2C interrupt //! occurs. The function also masks off the interrupt in the interrupt //! controller so that the interrupt handler no longer is called. //! //! \sa See IntRegister() for important information about registering interrupt //! handlers. //! //! \return None // //***************************************************************************** void I2CIntUnregister(void) { // // Disable the interrupt. // IntDisable(INT_I2C0); // // Unregister the interrupt handler. // IntUnregister(INT_I2C0); }
//***************************************************************************** // //! Unregisters the interrupt handler for the SysTick interrupt. //! //! This function will clear the handler to be called when a SysTick interrupt //! occurs. //! //! \sa IntRegister() for important information about registering interrupt //! handlers. //! //! \return None. // //***************************************************************************** void SysTickIntUnregister(void) { // // Disable the SysTick interrupt. // HWREG(NVIC_ST_CTRL) &= ~(NVIC_ST_CTRL_INTEN); // // Unregister the interrupt handler. // IntUnregister(FAULT_SYSTICK); }
//***************************************************************************** // //! Unregisters an interrupt handler for the Hibernation module interrupt. //! //! Unregisters the interrupt handler in the system interrupt controller. The //! interrupt is disabled at the global level, and the interrupt handler will //! no longer be called. //! //! \sa IntRegister() for important information about registering interrupt //! handlers. //! //! \return None. // //***************************************************************************** void HibernateIntUnregister(void) { // // Disable the hibernate interrupt. // IntDisable(INT_HIBERNATE); // // Unregister the interrupt handler. // IntUnregister(INT_HIBERNATE); }
//***************************************************************************** // //! Unregisters the system exception interrupt handler. //! //! This function removes the system exception interrupt handler from the //! vector table in SRAM. This function also masks off the system exception //! interrupt in the interrupt controller so that the interrupt handler is no //! longer called. //! //! \sa IntRegister() for important information about registering interrupt //! handlers. //! //! \return None. // //***************************************************************************** void SysExcIntUnregister(void) { // // Disable the system exception interrupt. // IntDisable(INT_SYSEXC); // // Unregister the system exception interrupt handler. // IntUnregister(INT_SYSEXC); }
//***************************************************************************** // //! Unregisters the interrupt handler for SDHost interrupt //! //! \param ulBase is the base address of SDHost module //! //! This function does the actual unregistering of the interrupt handler. It //! clears the handler to be called when a SDHost interrupt occurs. This //! function also masks off the interrupt in the interrupt controller so that //! the interrupt handler no longer is called. //! //! \sa IntRegister() for important information about registering interrupt //! handlers. //! //! \return None. // //***************************************************************************** void SDHostIntUnregister(unsigned long ulBase) { // // Disable the SDHost interrupt. // IntDisable(INT_MMCHS); // // Unregister the interrupt handler. // IntUnregister(INT_MMCHS); }
//***************************************************************************** // //! Unregisters an interrupt handler for the watchdog timer interrupt. //! //! \param ui32Base is the base address of the watchdog timer module. //! //! This function does the actual unregistering of the interrupt handler. This //! function clears the handler to be called when a watchdog timer interrupt //! occurs. This function also masks off the interrupt in the interrupt //! controller so that the interrupt handler no longer is called. //! //! \sa IntRegister() for important information about registering interrupt //! handlers. //! //! \note For parts with a watchdog timer module that has the ability to //! generate an NMI instead of a standard interrupt, this function unregisters //! the standard watchdog interrupt handler. To unregister the NMI watchdog //! handler, use IntUnregister() to unregister the handler for the //! \b FAULT_NMI interrupt. //! //! \return None. // //***************************************************************************** void WatchdogIntUnregister(uint32_t ui32Base) { // // Check the arguments. // ASSERT((ui32Base == WATCHDOG0_BASE) || (ui32Base == WATCHDOG1_BASE)); // // Disable the interrupt. // IntDisable(INT_WATCHDOG_TM4C123); // // Unregister the interrupt handler. // IntUnregister(INT_WATCHDOG_TM4C123); }
//***************************************************************************** // //! Unregisters an interrupt handler for the watchdog timer interrupt. //! //! \param ulBase is the base address of the watchdog timer module. //! //! This function does the actual unregistering of the interrupt handler. This //! function will clear the handler to be called when a watchdog timer //! interrupt occurs. This will also mask off the interrupt in the interrupt //! controller so that the interrupt handler no longer is called. //! //! \sa IntRegister() for important information about registering interrupt //! handlers. //! //! \note This function will only unregister the standard watchdog interrupt //! handler. To unregister the NMI watchdog handler, use IntUnregister() //! to unregister the handler for the \b FAULT_NMI interrupt. //! //! \return None. // //***************************************************************************** void WatchdogIntUnregister(unsigned long ulBase) { // // Check the arguments. // ASSERT((ulBase == WDT_BASE)); // // Disable the interrupt IntDisable(INT_WDT); // // Unregister the interrupt handler. // IntUnregister(INT_WDT); }
//***************************************************************************** // // Unregisters an interrupt handler for the I2C module // //***************************************************************************** void I2CIntUnregister(uint32_t ui32Base) { uint32_t ui32Int; // Check the arguments. ASSERT(I2CBaseValid(ui32Base)); // Get the interrupt number. ui32Int = INT_I2C_IRQ; // Disable the interrupt. IntDisable(ui32Int); // Unregister the interrupt handler. IntUnregister(ui32Int); }
//***************************************************************************** // //! Unregisters an interrupt handler for the EPI module. //! //! \param ulBase is the EPI module base address. //! //! This function will disable and clear the handler to be called when the //! EPI interrupt occurs. //! //! \sa IntRegister() for important information about registering interrupt //! handlers. //! //! \return None. // //***************************************************************************** void EPIIntUnregister(unsigned long ulBase) { // // Check the arguments. // ASSERT(ulBase == EPI0_BASE); // // Disable the EPI interface interrupt. // IntDisable(INT_EPI0); // // Unregister the interrupt handler. // IntUnregister(INT_EPI0); }
//***************************************************************************** // //! Unregisters an interrupt handler for the FAN module. //! //! @param ulBase is the base address of the FAN module. //! //! This function disables and clears the handler to be called when the //! FAN module interrupt occurs. //! //! \sa IntRegister() for important information about registering interrupt //! handlers. //! //! \return None. // //***************************************************************************** void FanIntUnregister(unsigned long ulBase) { // // Check the arguments. // ASSERT(ulBase == FAN0_BASE); // // Disable the FAN peripheral interrupt. // IntDisable(INT_FAN0); // // Unregister the interrupt handler. // IntUnregister(INT_FAN0); }
void SSIIntUnregister(unsigned long ulBase) { // // Check the arguments. // ASSERT(ulBase == SSI_BASE); // // Disable the interrupt. // IntDisable(INT_SSI); // // Unregister the interrupt handler. // IntUnregister(INT_SSI); }
//***************************************************************************** // //! Unregisters an interrupt handler for the I2S controller. //! //! @param ulBase is the I2S module base address. //! //! This function disables and clears the handler to be called when the //! I2S interrupt occurs. //! //! \sa IntRegister() for important information about registering interrupt //! handlers. //! //! \return None. // //***************************************************************************** void I2SIntUnregister(unsigned long ulBase) { // // Check the arguments. // ASSERT(ulBase == I2S0_BASE); // // Disable the I2S interface interrupt. // IntDisable(INT_I2S0); // // Unregister the interrupt handler. // IntUnregister(INT_I2S0); }
//***************************************************************************** // //! Unregisters the system exception interrupt handler. //! //! This function removes the system exception interrupt handler from the //! vector table in SRAM. This function also masks off the system exception //! interrupt in the interrupt controller so that the interrupt handler is no //! longer called. //! //! \sa IntRegister() for important information about registering interrupt //! handlers. //! //! \return None. // //***************************************************************************** void SysExcIntUnregister(void) { uint32_t ui32Int; // // Get the system exception interrupt number. // ui32Int = _SysExcIntNumberGet(); ASSERT(ui32Int != 0); // // Disable the system exception interrupt. // IntDisable(ui32Int); // // Unregister the system exception interrupt handler. // IntUnregister(ui32Int); }
//***************************************************************************** // //! Unregisters the interrupt handler for the flash interrupt. // //***************************************************************************** uint32_t FlashsafeIntUnregister(void) { if(FlashsafeSMPHTryAcquire()) { // // Disable the interrupts. // IntDisable(INT_FLASH); // // Unregister the interrupt handler. // IntUnregister(INT_FLASH); FlashsafeSMPHRelease(); return(FLASHSAFE_ACCESS_OK); } return(FLASHSAFE_ACCESS_DENIED); }
//***************************************************************************** // //! Unregisters an interrupt handler for a comparator interrupt. //! //! \param ui32Base is the base address of the comparator module. //! \param ui32Comp is the index of the comparator. //! //! This function clears the handler to be called when a comparator interrupt //! occurs. This function also masks off the interrupt in the interrupt //! controller so that the interrupt handler no longer is called. //! //! \sa IntRegister() for important information about registering interrupt //! handlers. //! //! \return None. // //***************************************************************************** void ComparatorIntUnregister(uint32_t ui32Base, uint32_t ui32Comp) { // // Check the arguments. // ASSERT(ui32Base == COMP_BASE); ASSERT(ui32Comp < 3); // // Disable the comparator interrupt. // HWREG(ui32Base + COMP_O_ACINTEN) &= ~(1 << ui32Comp); // // Disable the interrupt in the interrupt controller. // IntDisable(INT_COMP0_TM4C123 + ui32Comp); // // Unregister the interrupt handler. // IntUnregister(INT_COMP0_TM4C123 + ui32Comp); }
//***************************************************************************** // //! Removes an interrupt handler for a GPIO port. //! //! \param ulPort is the base address of the GPIO port. //! //! This function will unregister the interrupt handler for the specified //! GPIO port. This function will also disable the corresponding //! GPIO port interrupt in the interrupt controller; individual GPIO interrupts //! and interrupt sources must be disabled with GPIOIntDisable(). //! //! \sa IntRegister() for important information about registering interrupt //! handlers. //! //! \return None. // //***************************************************************************** void GPIOIntUnregister(unsigned long ulPort) { // // Check the arguments. // ASSERT(GPIOBaseValid(ulPort)); // // Get the interrupt number associated with the specified GPIO. // ulPort = GPIOGetIntNumber(ulPort); // // Disable the GPIO interrupt. // IntDisable(ulPort); // // Unregister the interrupt handler. // IntUnregister(ulPort); }