/*FUNCTION********************************************************************** * * Function Name : RTC_DRV_Deinit * Description : Disable RTC module clock gate control * This function will disable clock gate to RTC module. * *END**************************************************************************/ void RTC_DRV_Deinit(uint32_t instance) { /* Disable RTC interrupts.*/ INT_SYS_DisableIRQ(g_rtcIrqId[instance]); INT_SYS_DisableIRQ(g_rtcSecondsIrqId[instance]); /* Disable the RTC counter */ RTC_HAL_Disable(g_rtcBaseAddr[instance]); /* Disable clock gate to RTC module */ CLOCK_SYS_DisableRtcClock( 0U); s_rtcRepeatAlarmState = NULL; }
/*FUNCTION********************************************************************** * * Function Name : ENC_DRV_Deinit * Description : De-initialize the Quadrature Encoder module. It will * shut down its clock to reduce the power consumption. * *END**************************************************************************/ void ENC_DRV_Deinit(uint32_t instance) { assert(instance < ENC_INSTANCE_COUNT); /* Disables Clock to Quadrature Encoder peripheral. */ CLOCK_SYS_DisableEncClock(instance); /* Disable ENC interrupt on NVIC level. */ INT_SYS_DisableIRQ(g_encCmpIrqId[instance]); INT_SYS_DisableIRQ(g_encWdtIrqId[instance]); INT_SYS_DisableIRQ(g_encHomeIrqId[instance]); INT_SYS_DisableIRQ(g_encIndexIrqId[instance]); }
/*FUNCTION********************************************************************** * * Function Name : LPUART_DRV_Deinit * Description : This function shuts down the UART by disabling interrupts and * transmitter/receiver. * *END**************************************************************************/ lpuart_status_t LPUART_DRV_Deinit(uint32_t instance) { assert(instance < LPUART_INSTANCE_COUNT); /* Exit if current instance is already de-initialized or is gated.*/ if ((!g_lpuartStatePtr[instance]) || (!CLOCK_SYS_GetLpuartGateCmd(instance))) { return kStatus_LPUART_Fail; } LPUART_Type * base = g_lpuartBase[instance]; lpuart_state_t * lpuartState = (lpuart_state_t *)g_lpuartStatePtr[instance]; /* Wait until the data is completely shifted out of shift register */ while (!LPUART_BRD_STAT_TC(base)) {} /* Disable LPUART interrupt. */ INT_SYS_DisableIRQ(g_lpuartRxTxIrqId[instance]); /* disable tx and rx */ LPUART_HAL_SetTransmitterCmd(base, false); LPUART_HAL_SetReceiverCmd(base, false); /* Destroy TX and RX sema. */ OSA_SemaDestroy(&lpuartState->txIrqSync); OSA_SemaDestroy(&lpuartState->rxIrqSync); /* Clear our saved pointer to the state structure */ g_lpuartStatePtr[instance] = NULL; /* gate lpuart module clock */ CLOCK_SYS_DisableLpuartClock(instance); return kStatus_LPUART_Success; }
/*FUNCTION********************************************************************* * * Function Name : PDB_DRV_Init * Description : Initialize the PDB counter and trigger input for PDB module. * It resets PDB registers and enables the clock for PDB. So it should be * called before any operation to PDB module. After initialized, the PDB can * ack as a triggered timer, which lays the foundation for other features in * PDB module. * *END*************************************************************************/ pdb_status_t PDB_DRV_Init(uint32_t instance, const pdb_timer_config_t *userConfigPtr) { assert(instance < PDB_INSTANCE_COUNT); PDB_Type * base = g_pdbBase[instance]; if (!userConfigPtr) { return kStatus_PDB_InvalidArgument; } /* Enable the clock gate from clock manager. */ CLOCK_SYS_EnablePdbClock(instance); /* Reset the registers for PDB module to reset state. */ PDB_HAL_Init(base); PDB_HAL_Enable(base); PDB_HAL_ConfigTimer(base, userConfigPtr); /* Configure NVIC. */ if (userConfigPtr->intEnable) { INT_SYS_EnableIRQ(g_pdbIrqId[instance] );/* Enable PDB interrupt in NVIC level.*/ } else { INT_SYS_DisableIRQ(g_pdbIrqId[instance] );/* Disable PDB interrupt in NVIC level.*/ } return kStatus_PDB_Success; }
/*FUNCTION********************************************************************** * * Function Name : SPI_DRV_DmaMasterDeinit * Description : Shuts down a SPI instance with DMA support. * * This function resets the SPI peripheral, gates its clock, disables any used interrupts to * the core, and releases any used DMA channels. * *END**************************************************************************/ spi_status_t SPI_DRV_DmaMasterDeinit(uint32_t instance) { /* instantiate local variable of type spi_dma_master_state_t and point to global state */ spi_dma_master_state_t * spiDmaState = (spi_dma_master_state_t *)g_spiStatePtr[instance]; SPI_Type *base = g_spiBase[instance]; /* Restore the module to defaults which includes disabling the SPI then power it down.*/ SPI_HAL_Init(base); /* destroy the interrupt sync object.*/ OSA_SemaDestroy(&spiDmaState->irqSync); /* Disable SPI interrupt.*/ INT_SYS_DisableIRQ(g_spiIrqId[instance]); /* Gate the clock for SPI.*/ CLOCK_SYS_DisableSpiClock(instance); /* Free DMA channels */ DMA_DRV_FreeChannel(&spiDmaState->dmaReceive); DMA_DRV_FreeChannel(&spiDmaState->dmaTransmit); /* Clear state pointer. */ g_spiStatePtr[instance] = NULL; return kStatus_SPI_Success; }
/*FUNCTION********************************************************************** * * Function Name : I2C_DRV_SlaveDeinit * Description : Shuts down the I2C slave driver. * This function will clear the control register and turn off the clock to the * module. * *END**************************************************************************/ void I2C_DRV_SlaveDeinit(uint32_t instance) { assert(instance < HW_I2C_INSTANCE_COUNT); uint32_t baseAddr = g_i2cBaseAddr[instance]; i2c_slave_state_t * i2cSlaveState = (i2c_slave_state_t *)g_i2cStatePtr[instance]; #if FSL_FEATURE_I2C_HAS_START_STOP_DETECT /* Disable I2C START&STOP signal detect interrupt in the peripheral.*/ I2C_HAL_SetStartStopIntCmd(baseAddr,false); #endif #if FSL_FEATURE_I2C_HAS_STOP_DETECT /* Disable STOP signal detect interrupt in the peripheral.*/ I2C_HAL_SetStopIntCmd(baseAddr,false); #endif /* Disable I2C interrupt. */ I2C_HAL_SetIntCmd(baseAddr, false); /* Turn off I2C.*/ I2C_HAL_Disable(baseAddr); /* Disable clock for I2C.*/ CLOCK_SYS_DisableI2cClock(instance); /* Disable I2C NVIC interrupt */ INT_SYS_DisableIRQ(g_i2cIrqId[instance]); /* Destroy sema. */ OSA_EventDestroy(&i2cSlaveState->irqEvent); /* Clear runtime structure poniter.*/ g_i2cStatePtr[instance] = NULL; }
/*FUNCTION********************************************************************** * * Function Name : LPSCI_DRV_Deinit * Description : This function shuts down the LPSCI by disabling interrupts * and the transmitter/receiver. * *END**************************************************************************/ void LPSCI_DRV_Deinit(uint32_t instance) { assert(instance < HW_UART0_INSTANCE_COUNT); uint32_t baseAddr = g_lpsciBaseAddr[instance]; lpsci_state_t * lpsciState = (lpsci_state_t *)g_lpsciStatePtr[instance]; /* Wait until the data is completely shifted out of shift register */ while(!(LPSCI_HAL_IsTxComplete(baseAddr))) { } /* Disable the interrupt */ INT_SYS_DisableIRQ(g_lpsciRxTxIrqId[instance]); /* Disable TX and RX */ LPSCI_HAL_DisableTransmitter(baseAddr); LPSCI_HAL_DisableReceiver(baseAddr); /* Destroy TX and RX sema. */ OSA_SemaDestroy(&lpsciState->txIrqSync); OSA_SemaDestroy(&lpsciState->rxIrqSync); /* Cleared state pointer. */ g_lpsciStatePtr[instance] = NULL; /* Gate LPSCI module clock */ CLOCK_SYS_DisableUartClock(instance); }
/*FUNCTION********************************************************************** * * Function Name : PIT_DRV_Deinit * Description : Disable PIT module and gate control * This function will disable all PIT interrupts and PIT clock. Then gate the * PIT clock control. pit_init must be called in order to use PIT again. * *END**************************************************************************/ pit_status_t PIT_DRV_Deinit(uint32_t instance) { assert(instance < PIT_INSTANCE_COUNT); PIT_Type * base = g_pitBase[instance]; uint32_t i; /* Exit if current instance is gated.*/ if (!CLOCK_SYS_GetPitGateCmd(instance)) { return kStatus_PIT_Fail; } /* Disable all PIT interrupts. Clear the chain bit if available */ for (i=0; i < FSL_FEATURE_PIT_TIMER_COUNT; i++) { PIT_HAL_SetIntCmd(base, i, false); INT_SYS_DisableIRQ(g_pitIrqId[i]); #if FSL_FEATURE_PIT_HAS_CHAIN_MODE PIT_HAL_SetTimerChainCmd(base, i, false); #endif } /* Disable PIT module clock*/ PIT_HAL_Disable(base); /* Gate PIT clock control*/ CLOCK_SYS_DisablePitClock(instance); return kStatus_PIT_Success; }
/*FUNCTION********************************************************************** * * Function Name : DSPI_DRV_MasterDeinit * Description : Shutdown a DSPI instance. * This function resets the DSPI peripheral, gates its clock, and disables the interrupt to * the core. * *END**************************************************************************/ dspi_status_t DSPI_DRV_MasterDeinit(uint32_t instance) { /* instantiate local variable of type dspi_master_state_t and point to global state */ dspi_master_state_t * dspiState = (dspi_master_state_t *)g_dspiStatePtr[instance]; SPI_Type *base = g_dspiBase[instance]; /* First stop transfers */ DSPI_HAL_StopTransfer(base); /* Restore the module to defaults then power it down. This also disables the DSPI module.*/ DSPI_HAL_Init(base); /* destroy the interrupt sync object.*/ OSA_SemaDestroy(&dspiState->irqSync); /* disable the interrupt*/ INT_SYS_DisableIRQ(g_dspiIrqId[instance]); /* Gate the clock for DSPI.*/ CLOCK_SYS_DisableSpiClock(instance); /* Clear state pointer. */ g_dspiStatePtr[instance] = NULL; return kStatus_DSPI_Success; }
/*FUNCTION********************************************************************* * * Function Name : XBAR_DRV_Deinit * Description : De-initialize the XBAR module. It shuts down XBAR module * clock to reduce the power consumption and resets XBAR's registers to a known * state. * *END*************************************************************************/ void XBAR_DRV_Deinit(void) { XBARA_Type * xbara_base = g_xbaraBase[0]; /* Cleared state pointer. */ g_xbarState = NULL; /* Disable XBAR interrupt on NVIC level. */ INT_SYS_DisableIRQ(g_xbarIrqId[0]); /*Initialize module to reset state - clears all configurations*/ XBARA_HAL_Init(xbara_base); /* Disable XBARB module clock */ CLOCK_SYS_DisableXbarClock(XBARA_MODULE); #if !defined(FSL_FEATURE_XBAR_HAS_SINGLE_MODULE) XBARB_Type * xbarb_base = g_xbarbBase[0]; /*Initialize module to reset state - clears all configurations*/ XBARB_HAL_Init(xbarb_base); /* Disable XBARB module clock */ CLOCK_SYS_DisableXbarClock(XBARB_MODULE); #endif /* FSL_FEATURE_XBAR_HAS_SINGLE_MODULE */ }
/*FUNCTION********************************************************************** * * Function Name : DSPI_DRV_DmaMasterDeinit * Description : Shuts down a DSPI instance with DMA support. * * This function resets the DSPI peripheral, gates its clock, disables any used interrupts to * the core, and releases any used DMA channels. * *END**************************************************************************/ dspi_status_t DSPI_DRV_DmaMasterDeinit(uint32_t instance) { /* instantiate local variable of type dspi_dma_master_state_t and point to global state */ dspi_dma_master_state_t * dspiDmaState = (dspi_dma_master_state_t *)g_dspiStatePtr[instance]; SPI_Type *base = g_dspiBase[instance]; /* First stop transfers */ DSPI_HAL_StopTransfer(base); /* Restore the module to defaults then power it down. This also disables the DSPI module.*/ DSPI_HAL_Init(base); /* destroy the interrupt sync object.*/ OSA_SemaDestroy(&dspiDmaState->irqSync); /* disable the interrupt*/ INT_SYS_DisableIRQ(g_dspiIrqId[instance]); /* Gate the clock for DSPI.*/ CLOCK_SYS_DisableSpiClock(instance); /* Release all of the DMA channels used in the driver. DMA channel structures are stored in * the run-time state structure. */ DMA_DRV_FreeChannel(&dspiDmaState->dmaTxDataChannel); DMA_DRV_FreeChannel(&dspiDmaState->dmaTxCmdChannel); DMA_DRV_FreeChannel(&dspiDmaState->dmaRxChannel); /* Clear state pointer. */ g_dspiStatePtr[instance] = NULL; return kStatus_DSPI_Success; }
/*FUNCTION********************************************************************** * * Function Name : TSI_DRV_DeInit * Description : De initialize whole the TSI peripheral and driver to be ready * for any future use and don't load the system. * *END**************************************************************************/ tsi_status_t TSI_DRV_DeInit(uint32_t instance) { assert(instance < TSI_INSTANCE_COUNT); TSI_Type * base = g_tsiBase[instance]; tsi_state_t * tsiState = g_tsiStatePtr[instance]; if (tsiState == NULL) { return kStatus_TSI_Error; } TSI_HAL_DisableInterrupt(base); tsiState->opModesData[tsiState->opMode].enabledElectrodes = 0; TSI_HAL_ClearOutOfRangeFlag(base); TSI_HAL_ClearEndOfScanFlag(base); TSI_HAL_DisableModule(base); /* Disable the interrupt */ INT_SYS_DisableIRQ(g_tsiIrqId[instance]); /* Destroy the interrupt synch object*/ OSA_SemaDestroy(&tsiState->irqSync); /* Clear runtime structure pointer.*/ tsiState = NULL; /* Gate TSI module clock */ CLOCK_SYS_DisableTsiClock(instance); return kStatus_TSI_Success; }
void gpioDisableWakeUp(void) { // disables interrupt PORT_HAL_SetPinIntMode(BOARD_SW_LLWU_BASE, BOARD_SW_LLWU_PIN, kPortIntDisabled); INT_SYS_DisableIRQ(BOARD_SW_LLWU_IRQ_NUM); LLWU_HAL_ClearExternalPinWakeupFlag(LLWU_BASE_PTR, (llwu_wakeup_pin_t)BOARD_SW_LLWU_EXT_PIN); LLWU_HAL_SetExternalInputPinMode(LLWU_BASE_PTR,kLlwuExternalPinDisabled, (llwu_wakeup_pin_t)BOARD_SW_LLWU_EXT_PIN); }
/*FUNCTION********************************************************************** * * Function Name : FTM_DRV_Deinit * Description : Shuts down the FTM driver. * *END**************************************************************************/ void FTM_DRV_Deinit(uint32_t instance) { assert(instance < FTM_INSTANCE_COUNT); /* disable clock for FTM.*/ CLOCK_SYS_DisableFtmClock(instance); INT_SYS_DisableIRQ(g_ftmIrqId[instance]); }
/*FUNCTION********************************************************************** * * Function Name : SLCD_DRV_Deinit * Description : Deinit the SLCD driver. * This function will deinit the SLCD driver with reset SLCD driver to reset state and * close SLCD clock. * *END**************************************************************************/ void SLCD_DRV_Deinit(uint32_t instance) { assert(instance < LCD_INSTANCE_COUNT); LCD_Type * base = g_slcdBase[instance]; INT_SYS_DisableIRQ(g_slcdIrqId[instance]); /*!< Disables SLCD interrupt in NVIC */ SLCD_HAL_Init(base); /*!< Sets the SLCD to a workable state */ CLOCK_SYS_DisableSlcdClock(instance); /*!< Disables SLCD clock */ }
/*FUNCTION********************************************************************** * * Function Name : QUADTMR_DRV_Deinit * Description : Shuts down the Quad Timer driver. * Gates the module clock and disables the interrupt in the system interrupt controller. * *END**************************************************************************/ void QUADTMR_DRV_Deinit(uint32_t instance) { assert(instance < TMR_INSTANCE_COUNT); /* disable clock for Quad timer.*/ CLOCK_SYS_DisableQuadTmrClock(instance); INT_SYS_DisableIRQ(g_quadtmrIrqId[instance]); }
/*FUNCTION********************************************************************** * * Function Name : MMAU_DRV_Deinit * Description : Deinitilize the MMAU module * *END**************************************************************************/ mmau_status_t MMAU_DRV_Deinit(void){ MMAU_HAL_Init(MMAU); /* Enable MMAU interrupt on NVIC level. */ INT_SYS_DisableIRQ(g_mmauIrqId[0]); return kStatus_MMAU_Success; }
/*FUNCTION********************************************************************* * * Function Name : PDB_DRV_Deinit * Description : De-initialize the PDB module. * When the PDB module is not used. Calling this function would shutdown the * PDB module and reduce the power consumption. * *END*************************************************************************/ pdb_status_t PDB_DRV_Deinit(uint32_t instance) { assert(instance < PDB_INSTANCE_COUNT); PDB_Type * base = g_pdbBase[instance]; INT_SYS_DisableIRQ( g_pdbIrqId[instance] ); PDB_HAL_Disable(base); CLOCK_SYS_DisablePdbClock(instance); return kStatus_PDB_Success; }
/*FUNCTION********************************************************************* * * Function Name : ADC16_DRV_Deinit * Description : De-initialize the comparator in ADC module. It will gate * the clock to ADC module. When ADC is no long used in application, calling * this API will shut down the device to reduce power consumption. * *END*************************************************************************/ adc16_status_t ADC16_DRV_Deinit(uint32_t instance) { assert(instance < ADC_INSTANCE_COUNT); ADC_Type * base = g_adcBase[instance]; /* Disable ADC interrupt in NVIC level. */ INT_SYS_DisableIRQ( g_adcIrqId[instance] ); ADC16_HAL_Init(base); /* Disable clock for ADC. */ CLOCK_SYS_DisableAdcClock(instance); return kStatus_ADC16_Success; }
OSStatus MicoUartFinalize( mico_uart_t uart ) { uint32_t Instance = getInstanceBy(uart); // uart = MICO_UART_1; //test #ifdef UART_IRQ_APP UART_DRV_Deinit(Instance); #else UART_DRV_EdmaDeinit(Instance); EDMA_DRV_Deinit(); INT_SYS_DisableIRQ(g_uartRxTxIrqId[Instance]); #endif #ifndef NO_MICO_RTOS mico_rtos_deinit_semaphore(&uart_interfaces[uart].rx_complete); mico_rtos_deinit_semaphore(&uart_interfaces[uart].tx_complete); #endif return kNoErr; }
void SpiDeInit(Spi_t *obj) { /* First stop transfers */ DSPI_HAL_StopTransfer(obj->Spi); /* Restore the module to defaults then power it down. This also disables the DSPI module.*/ DSPI_HAL_Init(obj->Spi); /* disable the interrupt*/ INT_SYS_DisableIRQ (g_dspiIrqId[obj->instance]); /* Gate the clock for DSPI.*/ CLOCK_SYS_DisableSpiClock(obj->instance); GpioInit(&obj->Mosi, obj->Mosi.pin, PIN_OUTPUT, PIN_PUSH_PULL, PIN_NO_PULL, 0); GpioInit(&obj->Miso, obj->Miso.pin, PIN_OUTPUT, PIN_PUSH_PULL, PIN_PULL_DOWN, 0); GpioInit(&obj->Sclk, obj->Sclk.pin, PIN_OUTPUT, PIN_PUSH_PULL, PIN_NO_PULL, 0); GpioInit(&obj->Nss, obj->Nss.pin, PIN_OUTPUT, PIN_PUSH_PULL, PIN_NO_PULL, 1); }
/*FUNCTION********************************************************************** * * Function Name : I2C_DRV_SlaveDeinit * Description : Shuts down the I2C slave driver. * This function will clear the control register and turn off the clock to the * module. * *END*/ i2c_status_t I2C_DRV_SlaveDeinit(uint32_t instance) { assert(instance < I2C_INSTANCE_COUNT); /** Exit if current instance is already de-initialized or is gated.*/ if ((!g_i2cStatePtr[instance]) || (!CLOCK_SYS_GetI2cGateCmd(instance))) { return kStatus_I2C_Fail; } I2C_Type * base = g_i2cBase[instance]; i2c_slave_state_t * i2cSlaveState = (i2c_slave_state_t *)g_i2cStatePtr[instance]; #if FSL_FEATURE_I2C_HAS_START_STOP_DETECT /** Disable I2C START&STOP signal detect interrupt in the peripheral.*/ I2C_HAL_SetStartStopIntCmd(base,false); #endif #if FSL_FEATURE_I2C_HAS_STOP_DETECT /** Disable STOP signal detect interrupt in the peripheral.*/ I2C_HAL_SetStopIntCmd(base,false); #endif /** Disable I2C interrupt. */ I2C_HAL_SetIntCmd(base, false); /** Turn off I2C.*/ I2C_HAL_Disable(base); /** Disable clock for I2C.*/ CLOCK_SYS_DisableI2cClock(instance); /** Disable I2C NVIC interrupt */ INT_SYS_DisableIRQ(g_i2cIrqId[instance]); /** Destroy sema. */ OSA_EventDestroy(&i2cSlaveState->irqEvent); /** Clear runtime structure poniter.*/ g_i2cStatePtr[instance] = NULL; return kStatus_I2C_Success; }
OSStatus MicoUartFinalize( mico_uart_t uart ) { uart = MICO_UART_1; //test #ifdef UART_IRQ_APP UART_DRV_Deinit(BOARD_APP_UART_INSTANCE); #else UART_DRV_EdmaDeinit(BOARD_APP_UART_INSTANCE); EDMA_DRV_Deinit(); INT_SYS_DisableIRQ(g_uartRxTxIrqId[BOARD_APP_UART_INSTANCE]); #endif #if ADD_OS_CODE #ifndef NO_MICO_RTOS mico_rtos_deinit_semaphore(&uart_interfaces[uart].rx_complete); mico_rtos_deinit_semaphore(&uart_interfaces[uart].tx_complete); #endif #endif return kNoErr; }
/*FUNCTION********************************************************************** * * Function Name : SPI_DRV_DmaSlaveDeinit * Description : De-initializes the device. * Clears the control register and turns off the clock to the module. * *END**************************************************************************/ spi_status_t SPI_DRV_DmaSlaveDeinit(uint32_t instance) { spi_dma_slave_state_t * spiState = (spi_dma_slave_state_t *)g_spiStatePtr[instance]; SPI_Type *base = g_spiBase[instance]; assert(instance < SPI_INSTANCE_COUNT); /* Disable SPI interrupt */ INT_SYS_DisableIRQ(g_spiIrqId[instance]); /* Reset the SPI module to its default settings including disabling SPI and its interrupts */ SPI_HAL_Init(base); #if FSL_FEATURE_SPI_16BIT_TRANSFERS if (g_spiFifoSize[instance] != 0) { SPI_HAL_SetFifoIntCmd(base, kSpiRxFifoNearFullInt, false); } /* disable transmit interrupt */ SPI_HAL_SetIntMode(base, kSpiTxEmptyInt, false); #endif /* FSL_FEATURE_SPI_16BIT_TRANSFERS */ /* Free DMA channels */ DMA_DRV_FreeChannel(&spiState->dmaReceive); DMA_DRV_FreeChannel(&spiState->dmaTransmit); /* Disable clock for SPI */ CLOCK_SYS_DisableSpiClock(instance); /* Destroy the event */ OSA_EventDestroy(&spiState->event); /* Clear state pointer */ g_spiStatePtr[instance] = NULL; return kStatus_SPI_Success; }
void eth_arch_disable_interrupts(void) { INT_SYS_DisableIRQ(enet_irq_ids[BOARD_DEBUG_ENET_INSTANCE][enetIntMap[kEnetRxfInt]]); INT_SYS_DisableIRQ(enet_irq_ids[BOARD_DEBUG_ENET_INSTANCE][enetIntMap[kEnetTxfInt]]); }
/*FUNCTION********************************************************************** * * Function Name : LPTMR_DRV_Init * Description : initializes the LPTMR driver. * This function will initialize the LPTMR driver according to user configure * strcuture. * *END*/ lptmr_status_t LPTMR_DRV_Init(uint32_t instance, lptmr_state_t *userStatePtr, const lptmr_user_config_t* userConfigPtr) { assert(instance < LPTMR_INSTANCE_COUNT); LPTMR_Type * base = g_lptmrBase[instance]; lptmr_prescaler_user_config_t prescalerUserConfig; lptmr_working_mode_user_config_t workingModeUserConfig; if ((!userConfigPtr) || (!userStatePtr)) { return kStatus_LPTMR_NullArgument; } /** prescaler value 0 is invalid while working as pulse counter */ if ((kLptmrTimerModePulseCounter == userConfigPtr->timerMode) && (true == userConfigPtr->prescalerEnable) && (kLptmrPrescalerDivide2 == userConfigPtr->prescalerValue)) { return kStatus_LPTMR_InvalidPrescalerValue; } /** Enable clock for lptmr */ CLOCK_SYS_EnableLptmrClock(instance); /** Disable lptmr and reset lptmr logic */ LPTMR_HAL_Disable(base); /** LPTMR prescaler configure */ prescalerUserConfig.prescalerClockSelect = (lptmr_prescaler_clock_select_t)userConfigPtr->prescalerClockSource; prescalerUserConfig.prescalerBypass = (uint8_t)(userConfigPtr->prescalerEnable == false); prescalerUserConfig.prescalerValue = userConfigPtr->prescalerValue; LPTMR_HAL_SetPrescalerMode(base, prescalerUserConfig); /** Working Mode configure */ workingModeUserConfig.timerModeSelect = userConfigPtr->timerMode; workingModeUserConfig.freeRunningEnable = userConfigPtr->freeRunningEnable; workingModeUserConfig.pinPolarity = userConfigPtr->pinPolarity; workingModeUserConfig.pinSelect = userConfigPtr->pinSelect; LPTMR_HAL_SetTimerWorkingMode(base,workingModeUserConfig); /** Internal context */ lptmr_state_ptrs[instance] = userStatePtr; userStatePtr->userCallbackFunc = NULL; /** LPTMR interrupt */ if (userConfigPtr->isInterruptEnabled) { LPTMR_HAL_SetIntCmd(base,true); INT_SYS_EnableIRQ(g_lptmrIrqId[instance]); } else { LPTMR_HAL_SetIntCmd(base,false); INT_SYS_DisableIRQ(g_lptmrIrqId[instance]); } /** Caculate prescaler clock frequency */ if ( kLptmrTimerModeTimeCounter == userConfigPtr->timerMode) { userStatePtr->prescalerClockHz = CLOCK_SYS_GetLptmrFreq(instance, userConfigPtr->prescalerClockSource); if (userConfigPtr->prescalerEnable) { userStatePtr->prescalerClockHz = (userStatePtr->prescalerClockHz >> ((uint32_t)(userConfigPtr->prescalerValue+1))); }