/**
 * @file module_driver_ftu.c
 * @author flagchip
 * @brief FTU driver type definition and API
 * @version 2.0.0
 * @date 2024-08-20
 *
 * SDK Version: 2.6.0
 *

 * @copyright Copyright (c) 2020-2024 Flagchip Semiconductors Co., Ltd.
 *
 * @details
 */
/********************************************************************************
*   Revision History:
*
*   Version     Date          Initials       CR#          Descriptions
*   ---------   ----------    ------------   ----------   ---------------
*   00.02.01    2022-02-21    Flagchip032    N/A          FC7xxx internal release version
*   01.00.00    2022-04-19    Flagchip032    N/A          FC7300 release version
*   01.00.00	2022-08-19    Flagchip070    N/A		  Support FC7300 2M and 1M
*   01.01.00	2022-11-10    Flagchip070    N/A		  Release version 1.1.0
*   01.02.00	2022-11-10    Flagchip032    N/A		  Refactor ftu driver
********************************************************************************/

#include "module_driver_ftu.h"

#if FTU_INSTANCE_COUNT > 0U

#include "module_driver_pcc.h"
#ifndef FTU_TCKSEL_EXIST
#include "module_driver_smisc.h"
#endif

#ifndef FTU_DEV_ERROR_REPORT
#define FTU_DEV_ERROR_REPORT	STD_OFF
#endif

#if FTU_DEV_ERROR_REPORT == STD_ON
#define FTU_ReportDevError(func, error) ReportDevError(FTU_MODULE_ID, func, error)
#endif

/********* Local variable ************/
static FTU_Type * const s_pFtuBasePtrs[FTU_INSTANCE_COUNT] = FTU_BASE_PTRS;

/********* Local Functions ************/

/********* Global Functions ************/
/**
 * @brief Initialize FTU basic configuration
 *
 * @param pFtuHandle FTU processing handle
 * @param pCommonStruct the basic configurations of the FTU instance
 */
void FTU_CommonInit(FTU_HandleType *pFtuHandle, const FTU_CommonType *const pCommonStruct)
{
#if FTU_DEV_ERROR_REPORT == STD_ON
	if ((uint32_t)pFtuHandle->eInstance >= FTU_INSTANCE_COUNT)
	{
		FTU_ReportDevError(FTU_COMMON_INIT_ID, FTU_E_PARAM_INSTANCE);
	}
	else if (pCommonStruct->u32OverflowValue > FTU_GET_MAX_COUNTER(s_pFtuBasePtrs[pFtuHandle->eInstance]))
	{
		FTU_ReportDevError(FTU_COMMON_INIT_ID, FTU_E_PARAM_COUNT);
	}
#ifdef FTU_CNT_SEL_EXIST
	else if (	(pCommonStruct->eClkSrc == FTU_EFTU_CNT)
			&& 	(	(pFtuHandle->eInstance != FTU_INSTANCE_1)
				&& 	(pFtuHandle->eInstance != FTU_INSTANCE_2)))
	{
		FTU_ReportDevError(FTU_COMMON_INIT_ID, FTU_E_PARAM_INSTANCE);
	}
#endif
	else
	{
#endif
		FTU_Type * const pFtu = s_pFtuBasePtrs[pFtuHandle->eInstance];
		uint32_t u32Loop;
		if (true == pCommonStruct->bGtbEnable)
		{
			FTU_HWA_EnableGlobalTimeBase(pFtu);
		}
		else
		{
			FTU_HWA_DisableGlobalTimeBase(pFtu);
		}
		FTU_HWA_DisableModuleCpwmMode(pFtu);
		/* set FTU prescale */
		FTU_HWA_SetModulePrescale(pFtu, pCommonStruct->ePrescaler);
		/* configure fault filter prescaler */
		FTU_HWA_ConfigModuleFilterPrescale(pFtu, pCommonStruct->eFliterPrescaler);
		/*set the compare register as max value*/
		FTU_HWA_SetModuleCompareValue(pFtu, (uint32_t)pCommonStruct->u32OverflowValue);
		/*set initial value as 0*/
		FTU_HWA_SetCounterInitialValue(pFtu, 0u);
		/*set any value to clear the current counter register to initial value*/
		FTU_HWA_ClearModuleCounter(pFtu, (uint32_t)0x1U);
		/* set ftu OUTMASK sync mode, set bit SYNCHOM and OUTMASK register will update when then sync event happened */
		FTU_HWA_EnableOutputMaskBySync(pFtu);
		/* set ftu debug mode */
		FTU_HWA_ConfigDebugMode(pFtu, (uint32_t)pCommonStruct->eDbgMode);
#ifdef FTU_UPDOWN_DIS_FEATURE
		/* Disable channel match trigger/interrupt when count-up/down in CPWM/QUAD mode */
		FTU_HWA_ConfigUpDownDisable(s_pFtuBasePtrs[pFtuHandle->eInstance], pCommonStruct->eUpDownDisable);
#endif
		/* configure hardware trigger mode */
		FTU_HWA_ConfigTrigMode(pFtu, pCommonStruct->eHwTrigMode);
		/* configure the frequency of the reload opportunities*/
		FTU_HWA_ConfigFreqOfReloadOp(pFtu, pCommonStruct->u8ReloadFreq);


		pFtuHandle->tStatus.pChannelCallback = NULL;
		pFtuHandle->tStatus.pFaultCallback = NULL;
		pFtuHandle->tStatus.pOverflowCallback = NULL;
		pFtuHandle->tStatus.pReloadPointCallback = NULL;

		/* select clock source */
		if (FTU_INTERNAL_CLK == pCommonStruct->eClkSrc)
		{
			pFtuHandle->tStatus.eFtuClkSrc = FTU_INTERNAL_CLK;
		}
		else if (FTU_EXTERNAL_CLK0 == pCommonStruct->eClkSrc)
		{
			pFtuHandle->tStatus.eFtuClkSrc = FTU_EXTERNAL_CLK0;
#ifdef FTU_TCKSEL_EXIST
			FTU_HWA_ConfigExternalClkSrc(pFtu, FTU_TCLK0_USED);
#else
			SMISC_HWA_SetFtuExternalClkSrc(pFtuHandle->eInstance, FTU_TCLK0_USED);
#endif
		}
		else if (FTU_EXTERNAL_CLK1 == pCommonStruct->eClkSrc)
		{
			pFtuHandle->tStatus.eFtuClkSrc = FTU_EXTERNAL_CLK1;
#ifdef FTU_TCKSEL_EXIST
			FTU_HWA_ConfigExternalClkSrc(pFtu, FTU_TCLK1_USED);
#else
			SMISC_HWA_SetFtuExternalClkSrc(pFtuHandle->eInstance, FTU_TCLK1_USED);
#endif
		}
		else if (FTU_EXTERNAL_CLK2 == pCommonStruct->eClkSrc)
		{
			pFtuHandle->tStatus.eFtuClkSrc = FTU_EXTERNAL_CLK2;
#ifdef FTU_TCKSEL_EXIST
			FTU_HWA_ConfigExternalClkSrc(pFtu, FTU_TCLK2_USED);
#else
			SMISC_HWA_SetFtuExternalClkSrc(pFtuHandle->eInstance, FTU_TCLK2_USED);
#endif
		}
		else
		{
			pFtuHandle->tStatus.eFtuClkSrc = pCommonStruct->eClkSrc;
		}

		for(u32Loop = 0u; u32Loop < FTU_CHANNEL_CONTROLS_COUNT; u32Loop++)
		{
			if (0u != (pCommonStruct->u32InterruptMask & ((uint32_t)FTU_INTR_MASK_CHANNEL_0 << u32Loop)))
			{
				/* Enable Channel Interrupt */
				FTU_HWA_EnableChannelInterrupt(pFtu, (uint8_t)u32Loop);
			}
			else
			{
				/* Disable Channel Interrupt */
				FTU_HWA_DisableChannelInterrupt(pFtu, (uint8_t)u32Loop);
			}
		}

		if (0u != (pCommonStruct->u32InterruptMask & (uint32_t)FTU_INTR_MASK_OVERFLOW))
		{
			/* Enable Overflow Interrupt */
			FTU_HWA_EnableOverflowInterrupt(pFtu);
		}
		else
		{
			/* Disable Overflow Interrupt */
			FTU_HWA_DisableOverflowInterrupt(pFtu);
		}

		if (0u != (pCommonStruct->u32InterruptMask & (uint32_t)FTU_INTR_MASK_FAULT))
		{
			/* Enable Fault Interrupt */
			FTU_HWA_EnableModuleFaultInterrupt(pFtu);
		}
		else
		{
			/* Disable Fault Interrupt */
			FTU_HWA_DisableModuleFaultInterrupt(pFtu);
		}

		if (0u != (pCommonStruct->u32InterruptMask & (uint32_t)FTU_INTR_MASK_RELOAD_POINT))
		{
			/* Enable Reload Point Interrupt */
			FTU_HWA_EnableReloadPointInterrupt(pFtu);
		}
		else
		{
			/* Disable Reload Point Interrupt */
			FTU_HWA_DisableReloadPointInterrupt(pFtu);
		}
		/*register callback functions*/
		pFtuHandle->tStatus.pChannelCallback = pCommonStruct->pChannelCallback;
		pFtuHandle->tStatus.pFaultCallback = pCommonStruct->pFaultCallback;
		pFtuHandle->tStatus.pOverflowCallback = pCommonStruct->pOverflowCallback;
		pFtuHandle->tStatus.pReloadPointCallback = pCommonStruct->pReloadPointCallback;
#if FTU_DEV_ERROR_REPORT == STD_ON
	}
#endif
}

/**
 * @brief De-initialize the FTU instance
 *
 * @param pFtuHandle FTU processing handle
 */
void FTU_DeInit(FTU_HandleType *pFtuHandle)
{
#if FTU_DEV_ERROR_REPORT == STD_ON
	if ((uint32_t)pFtuHandle->eInstance >= FTU_INSTANCE_COUNT)
	{
		FTU_ReportDevError(FTU_DEINIT_ID, FTU_E_PARAM_INSTANCE);
	}
	else
	{
#endif
		pFtuHandle->tStatus.eFtuClkSrc = FTU_NO_CLK;
		pFtuHandle->tStatus.pChannelCallback = NULL;
		pFtuHandle->tStatus.pFaultCallback = NULL;
		pFtuHandle->tStatus.pOverflowCallback = NULL;
		pFtuHandle->tStatus.pReloadPointCallback = NULL;

		FTU_HWA_ClearModuleRegister(s_pFtuBasePtrs[pFtuHandle->eInstance]);
#if FTU_DEV_ERROR_REPORT == STD_ON
	}
#endif
}

/**
 * @brief Fills in the FTU configuration structure with the default settings.
 *
 * @param pCommonStruct Pointer to the user configuration structure
 */
void FTU_GetDefaultInitCfg(FTU_CommonType *pCommonStruct)
{
#if FTU_DEV_ERROR_REPORT == STD_ON
	if(NULL_PTR == pCommonStruct)
	{
		FTU_ReportDevError(FTU_GET_DEFAULT_INIT_CFG_ID, FTU_E_PARAM_POINTER);
	}
	else
	{
#endif
		pCommonStruct->ePrescaler 			= FTU_DIV_1;
		pCommonStruct->eFliterPrescaler		= FTU_FLT_DIV_1;
		pCommonStruct->u32OverflowValue		= 0xFFFF;
		pCommonStruct->eClkSrc				= FTU_INTERNAL_CLK;
		pCommonStruct->u8ReloadFreq			= 0;
		pCommonStruct->eHwTrigMode			= FTU_CLEARS_TRIG_WHEN_DETECTED;
		pCommonStruct->eDbgMode				= FTU_DBG_COUNTER_STOP_CHN_WORKS;
#ifdef FTU_UPDOWN_DIS_FEATURE
		pCommonStruct->eUpDownDisable		= FTU_DISABLE_TRIG_INTR_NONE;
#endif
		pCommonStruct->bGtbEnable			= false;
		pCommonStruct->u32InterruptMask		= 0u;
		pCommonStruct->pChannelCallback		= NULL;
		pCommonStruct->pFaultCallback		= NULL;
		pCommonStruct->pOverflowCallback	= NULL;
		pCommonStruct->pReloadPointCallback	= NULL;
#if FTU_DEV_ERROR_REPORT == STD_ON
	}
#endif
}

/**
 * @brief Configure FTU to counter mode
 *
 * @param pFtuHandle FTU processing handle
 * @param pCounterStruct the configurations of the counter mode
 * @note This function will stop timer
 */
void FTU_CounterModeInit(FTU_HandleType *pFtuHandle, const FTU_CounterModeType *const pCounterStruct)
{
#if FTU_DEV_ERROR_REPORT == STD_ON
	if (((uint32_t)pFtuHandle->eInstance >= FTU_INSTANCE_COUNT))
	{
		FTU_ReportDevError(FTU_COUNTER_INIT_ID, FTU_E_PARAM_INSTANCE);
	}
	else if (	(pCounterStruct->u32CounterValue > FTU_GET_MAX_COUNTER(s_pFtuBasePtrs[pFtuHandle->eInstance]))
			||	(pCounterStruct->u32InitialValue > FTU_GET_MAX_COUNTER(s_pFtuBasePtrs[pFtuHandle->eInstance]))
			)
	{
		FTU_ReportDevError(FTU_COUNTER_INIT_ID, FTU_E_PARAM_COUNT);
	}
	else
	{
#endif
		FTU_Type * const pFtu = s_pFtuBasePtrs[pFtuHandle->eInstance];
		/* disable ftu timer */
		FTU_HWA_ConfigModuleClkSrc(pFtu, FTU_MODULE_NO_CLK);
		/* set FTU MOD register value */
		FTU_HWA_SetModuleCompareValue(pFtu, (uint32_t)pCounterStruct->u32CounterValue);
		/*set initial value */
		FTU_HWA_SetCounterInitialValue(pFtu, (uint32_t)pCounterStruct->u32InitialValue);
#if FTU_DEV_ERROR_REPORT == STD_ON
	}
#endif
}

/**
 * @brief Update the duty cycle of the FTU Channel
 *
 * @param pFtuHandle FTU processing handle
 * @param pConfig The configuration option for update PWM Duty
 */
void FTU_PwmUpdateDuty(FTU_HandleType *pFtuHandle, FTU_PwmDutyUpdateType *pConfig)
{
#if FTU_DEV_ERROR_REPORT == STD_ON
	if ((uint32_t)pFtuHandle->eInstance >= FTU_INSTANCE_COUNT)
	{
		FTU_ReportDevError(FTU_PWM_UPDATE_DUTY_ID, FTU_E_PARAM_INSTANCE);
	}
	else if (pConfig->u8Channel >= FTU_CHANNEL_CONTROLS_COUNT)
	{
		FTU_ReportDevError(FTU_PWM_UPDATE_DUTY_ID, FTU_E_PARAM_CHANNEL);
	}
	else
	{
#endif
		FTU_Type * const pFtu = s_pFtuBasePtrs[pFtuHandle->eInstance];
		/* get the cpwm flag*/
		if(pFtuHandle->tStatus.aPwmAlignedMode == FTU_CENTER_ALIGNED_PWM)
		{
			/* Duty value div 2 if cpwm mode*/
			FTU_HWA_SetChannelValue(pFtu, pConfig->u8Channel, (uint32_t)pConfig->u32Duty >> 1u);
		}
		else
		{
			if (pFtuHandle->tStatus.u8PhaseShiftEnable & (1u << pConfig->u8Channel))
			{
#if FTU_DEV_ERROR_REPORT == STD_ON
				if (pConfig->u32PhaseShift > pFtuHandle->tStatus.u32PwmPeriod)
				{
					FTU_ReportDevError(FTU_PWM_UPDATE_DUTY_ID, FTU_E_PARAM_PHASE_SHIFT);
				}
				else
				{
#endif
					FTU_HWA_SetChannelValue(pFtu, pConfig->u8Channel, pConfig->u32PhaseShift);
					if ((pConfig->u32PhaseShift + pConfig->u32Duty) > pFtuHandle->tStatus.u32PwmPeriod)
					{
						FTU_HWA_SetChannelValue(pFtu, (uint8_t)(pConfig->u8Channel + 1u),
								pConfig->u32PhaseShift + pConfig->u32Duty - pFtuHandle->tStatus.u32PwmPeriod - 1);
					}
					else
					{
						FTU_HWA_SetChannelValue(pFtu, (uint8_t)(pConfig->u8Channel + 1),
								pConfig->u32PhaseShift + pConfig->u32Duty);
					}
#if FTU_DEV_ERROR_REPORT == STD_ON
				}
#endif
			}
			else
			{
				FTU_HWA_SetChannelValue(pFtu, pConfig->u8Channel, pConfig->u32Duty);
			}
		}

		if (pFtuHandle->tStatus.aPwmUpdateMode != FTU_PWM_UPDATE_IMMEDIATELY)
		{
			if (true == pConfig->bUpdate)
			{
				FTU_HWA_GenerateSwSync(pFtu);
			}
		}
		else
		{
			FTU_HWA_GenerateSwSync(pFtu);
		}
#if FTU_DEV_ERROR_REPORT == STD_ON
	}
#endif
}

/**
 * @brief Update the Period cycle of the FTU instance
 *
 * @param pFtuHandle FTU processing handle
 * @param u32Period period of the PWM mode
 */
void FTU_PwmUpdatePeriod(FTU_HandleType *pFtuHandle, uint32_t u32Period, bool bUpdate)
{
#if FTU_DEV_ERROR_REPORT == STD_ON
	if ((uint32_t)pFtuHandle->eInstance >= FTU_INSTANCE_COUNT)
	{
		FTU_ReportDevError(FTU_PWM_UPDATE_PERIOD_ID, FTU_E_PARAM_INSTANCE);
	}
	else if (u32Period > FTU_GET_MAX_COUNTER(s_pFtuBasePtrs[pFtuHandle->eInstance]))
	{
		FTU_ReportDevError(FTU_PWM_UPDATE_PERIOD_ID, FTU_E_PARAM_COUNT);
	}
	else
	{
#endif
		FTU_Type * const pFtu = s_pFtuBasePtrs[pFtuHandle->eInstance];

		/* get the cpwm flag*/
		if(pFtuHandle->tStatus.aPwmAlignedMode == FTU_CENTER_ALIGNED_PWM)
		{
			/* Period value div 2 if cpwm mode*/
			FTU_HWA_SetModuleCompareValue(pFtu, u32Period >> 1);
		}
		else
		{
			FTU_HWA_SetModuleCompareValue(pFtu, u32Period);
		}
		if (pFtuHandle->tStatus.aPwmUpdateMode != FTU_PWM_UPDATE_IMMEDIATELY)
		{
			if (true == bUpdate)
			{
				FTU_HWA_GenerateSwSync(pFtu);
			}
		}
		else
		{
			FTU_HWA_GenerateSwSync(pFtu);
		}
#if FTU_DEV_ERROR_REPORT == STD_ON
	}
#endif
}

/**
 * @brief Synchronous update cycle and period of the FTU instance
 *
 * @param pFtuHandle FTU processing handle
 */
void FTU_PwmSyncUpdate(FTU_HandleType *pFtuHandle)
{
#if FTU_DEV_ERROR_REPORT == STD_ON
	if ((uint32_t)pFtuHandle->eInstance >= FTU_INSTANCE_COUNT)
	{
		FTU_ReportDevError(FTU_PWM_SYNC_UPDATE_ID, FTU_E_PARAM_INSTANCE);
	}
	else
	{
#endif
		FTU_HWA_GenerateSwSync(s_pFtuBasePtrs[pFtuHandle->eInstance]);
#if FTU_DEV_ERROR_REPORT == STD_ON
	}
#endif
}

static void set_deadtime(FTU_Type *pFtu, uint8_t u8Channel, uint32_t u32Deadtime)
{
	if(u32Deadtime < 1024u)
	{
		FTU_HWA_ConfigPairDeadtimePrescaler(pFtu, u8Channel, FTU_DEADTIME_PRESCALER_DIV_1);
		FTU_HWA_ConfigPairDeadtimeValue(pFtu, u8Channel, u32Deadtime);
	}
	else if(u32Deadtime < 4096u)
	{
		/*deadtime should multiply 2*/
		FTU_HWA_ConfigPairDeadtimePrescaler(pFtu, u8Channel,
											FTU_DEADTIME_PRESCALER_DIV_4);
		FTU_HWA_ConfigPairDeadtimeValue(pFtu, (uint32_t)u8Channel, u32Deadtime >> 2u);
	}
	else
	{
		/*deadtime should multiply 4*/
		FTU_HWA_ConfigPairDeadtimePrescaler(pFtu, u8Channel, FTU_DEADTIME_PRESCALER_DIV_16);
		FTU_HWA_ConfigPairDeadtimeValue(pFtu, u8Channel, u32Deadtime >> 4u);

	}
}

/**
 * @brief Configure FTU to PWM mode
 *
 * @param pFtuHandle FTU processing handle
 * @param pPwmModeStruct the configurations of the PWM mode
 * @note This function will stop timer
 */
void FTU_PwmModeInit(FTU_HandleType *pFtuHandle, const FTU_PwmModeType *const pPwmModeStruct)
{
#if FTU_DEV_ERROR_REPORT == STD_ON
	if ((uint32_t)pFtuHandle->eInstance >= FTU_INSTANCE_COUNT)
	{
		FTU_ReportDevError(FTU_PWM_MODE_INIT_ID, FTU_E_PARAM_INSTANCE);
	}
	else if (pPwmModeStruct->u32PwmPeriod > FTU_GET_MAX_COUNTER(s_pFtuBasePtrs[pFtuHandle->eInstance]))
	{
		FTU_ReportDevError(FTU_PWM_MODE_INIT_ID, FTU_E_PARAM_COUNT);
	}
	else
	{
#endif
		uint8_t u8Channel;
		uint32_t u32Loop;
		FTU_Type * const pFtu = s_pFtuBasePtrs[pFtuHandle->eInstance];
		pFtuHandle->tStatus.u32PwmPeriod = pPwmModeStruct->u32PwmPeriod;
		pFtuHandle->tStatus.u8PhaseShiftEnable = 0u;
		pFtuHandle->tStatus.aPwmAlignedMode = pPwmModeStruct->eAlignedMode;
		pFtuHandle->tStatus.aPwmUpdateMode = pPwmModeStruct->eUpdateMode;
		FTU_HWA_SetModuleUpdateRegBySync(pFtu);
		FTU_HWA_ClearPwmSyncMode(pFtu);
		if (pPwmModeStruct->eUpdateMode == FTU_PWM_UPDATE_HALF_PERIOD)
		{
			FTU_HWA_EnableMaxLoadPoint(pFtu);
		}
		else if (pPwmModeStruct->eUpdateMode == FTU_PWM_UPDATE_END_PERIOD)
		{
			FTU_HWA_EnableMinLoadPoint(pFtu);
		}
		else if (pPwmModeStruct->eUpdateMode == FTU_PWM_UPDATE_BOTH_HALF_AND_END_PERIOD)
		{
			FTU_HWA_EnableMaxLoadPoint(pFtu);
			FTU_HWA_EnableMinLoadPoint(pFtu);
		}
		else
		{
			FTU_HWA_SetReinitBySync(pFtu);
		}

		/* disable ftu timer */
		FTU_HWA_ConfigModuleClkSrc(pFtu, FTU_MODULE_NO_CLK);
		if (FTU_EDGE_ALIGNED_PWM == pPwmModeStruct->eAlignedMode)
		{
			FTU_HWA_DisableModuleCpwmMode(pFtu);
			FTU_HWA_SetModuleCompareValue(pFtu, pPwmModeStruct->u32PwmPeriod);
		}
		else
		{
			FTU_HWA_EnableModuleCpwmMode(pFtu);
			FTU_HWA_SetModuleCompareValue(pFtu, pPwmModeStruct->u32PwmPeriod >> 1u);
#ifdef FTU_FDUTYCTL_EXIST
			/* Set whether to generate a channel flag when CPWM full duty cycle */
			if (true == pPwmModeStruct->bFullDutyCycleIntrEnable)
			{
				FTU_HWA_EnableFullDutyIntrEnable(pFtu);
			}
			else
			{
				FTU_HWA_DisableFullDutyIntrEnable(pFtu);
			}
#endif
		}

		for (u32Loop = 0u; u32Loop < pPwmModeStruct->u32ChannelCount; u32Loop++)
		{
#if FTU_DEV_ERROR_REPORT == STD_ON
			if (pPwmModeStruct->pPwmChannels[u32Loop].u8Channel >= FTU_CHANNEL_CONTROLS_COUNT)
			{
				FTU_ReportDevError(FTU_PWM_MODE_INIT_ID, FTU_E_PARAM_CHANNEL);
			}
			else
			{
#endif
				FTU_PwmChannelType *pChannelCfg = &pPwmModeStruct->pPwmChannels[u32Loop];
				u8Channel = pChannelCfg->u8Channel;


#if FTU_DEV_ERROR_REPORT == STD_ON
				if (pPwmModeStruct->pPwmChannels[u32Loop].u32PhaseShift >= FTU_GET_MAX_COUNTER(s_pFtuBasePtrs[pFtuHandle->eInstance]))
				{
					FTU_ReportDevError(FTU_PWM_MODE_INIT_ID, FTU_E_PARAM_PHASE_SHIFT);
				}
				else
				{
#endif
					if (pChannelCfg->u32PhaseShift)
					{
#if FTU_DEV_ERROR_REPORT == STD_ON
						if((pPwmModeStruct->pPwmChannels[u32Loop].u8Channel & 1u) != 0u)
						{
							FTU_ReportDevError(FTU_PWM_MODE_INIT_ID, FTU_E_PARAM_INVALID_CHANNEL);
						}
						else
						{
#endif
							/*Enable enhanced phase shift mode*/
							FTU_HWA_EnableChannelPhase(pFtu, u8Channel);
							FTU_HWA_EnableChannelEnhancedPhase(pFtu, u8Channel);
#if FTU_DEV_ERROR_REPORT == STD_ON
						}
#endif
					}
					else
					{
						/*Enable enhanced phase shift mode*/
						FTU_HWA_DisableChannelPhase(pFtu, u8Channel);
						FTU_HWA_DisableChannelEnhancedPhase(pFtu, u8Channel);
					}

#if FTU_DEV_ERROR_REPORT == STD_ON
				}
#endif

				if(pChannelCfg->bLinkMode)
				{
#if FTU_DEV_ERROR_REPORT == STD_ON
					if ((pPwmModeStruct->pPwmChannels[u32Loop].u8Channel & 1u) != 0u)
					{
						FTU_ReportDevError(FTU_PWM_MODE_INIT_ID, FTU_E_PARAM_INVALID_CHANNEL);
					}
					else
					{
#endif
						/* set channel(n+1) complement of channel(n) output */
						FTU_HWA_EnableChannelComplement(pFtu, u8Channel);
						if (!pChannelCfg->bLinkChannelComplement)
						{
							FTU_HWA_ClearChannelPolarity(pFtu, (uint8_t)(1U << u8Channel));
							FTU_HWA_SetChannelPolarity(pFtu, (uint8_t)(1U << (u8Channel + (uint8_t)1U)));
						}
						else
						{
							FTU_HWA_ClearChannelPolarity(pFtu,
														(uint8_t)(1U << u8Channel) | (uint8_t)(1U << (u8Channel  + 1u)));
						}
						/*link mode, the u8Channel+1->csc.ELSB bit must be set*/
						FTU_HWA_ConfigChannelPwmLinkMode(pFtu, (uint8_t)(u8Channel + (uint8_t)1U));

						/* enable FTU output */
						FTU_HWA_EnableChannelsOutput(pFtu, (uint8_t)(3U << u8Channel));
#if FTU_DEV_ERROR_REPORT == STD_ON
					}
#endif
				}
				else
				{
					FTU_HWA_ClearChannelPolarity(pFtu, (uint8_t)(1U << u8Channel));
					/* disable channel(n+1) complement of channel(n) output */
					FTU_HWA_DisableChannelComplement(pFtu, u8Channel);
					/* enable FTU output */
					FTU_HWA_EnableChannelsOutput(pFtu, (uint8_t)(1U << u8Channel));
				}

				/* enable u8Channel sync function of the ftu*/
				FTU_HWA_EnableChannelSync(pFtu, u8Channel);
				/* set FTU pwm mode */
				if (FTU_EDGE_ALIGNED_PWM == pPwmModeStruct->eAlignedMode)
				{
					FTU_HWA_ConfigChannelMode(pFtu, u8Channel, FTU_CHANNEL_MODE_EDGE_ALIGN_PWM);
				}
				FTU_HWA_ConfigChannelEdgeLevel(pFtu, u8Channel, (FTU_ChannelEdgeLevelType)pChannelCfg->ePinMode);

				if (pChannelCfg->bDeadtimeEnable)
				{
					FTU_HWA_EnableChannelDeadtime(pFtu, u8Channel);
				}
				else
				{
					FTU_HWA_DisableChannelDeadtime(pFtu, u8Channel);
				}

				/* set the period time and duty time */
				if(FTU_CENTER_ALIGNED_PWM == pPwmModeStruct->eAlignedMode)
				{
#if FTU_DEV_ERROR_REPORT == STD_ON
					if (0u != pPwmModeStruct->pPwmChannels[u32Loop].u32PhaseShift)
					{
						FTU_ReportDevError(FTU_PWM_MODE_INIT_ID, FTU_E_PARAM_PHASE_SHIFT);
					}
					else
					{
#endif
						FTU_HWA_SetChannelValue(pFtu, u8Channel, pChannelCfg->u32PwmDuty >> 1u);
#if FTU_DEV_ERROR_REPORT == STD_ON
					}
#endif
				}
				else
				{
#if FTU_DEV_ERROR_REPORT == STD_ON
					if (pPwmModeStruct->pPwmChannels[u32Loop].u32PhaseShift > FTU_GET_MAX_COUNTER(s_pFtuBasePtrs[pFtuHandle->eInstance]))
					{
						FTU_ReportDevError(FTU_PWM_MODE_INIT_ID, FTU_E_PARAM_PHASE_SHIFT);
					}
					else
					{
#endif
						if (pChannelCfg->u32PhaseShift)
						{
#if FTU_DEV_ERROR_REPORT == STD_ON
							if ((pPwmModeStruct->pPwmChannels[u32Loop].u8Channel & 1u) != 0u)
							{
								FTU_ReportDevError(FTU_PWM_MODE_INIT_ID, FTU_E_PARAM_PHASE_SHIFT);
							}
							else
							{
#endif
								pFtuHandle->tStatus.u8PhaseShiftEnable |= (uint8_t)(1u << u8Channel);
								FTU_HWA_SetChannelValue(pFtu, u8Channel, pChannelCfg->u32PhaseShift);
								if ((pChannelCfg->u32PhaseShift + pChannelCfg->u32PwmDuty) > pPwmModeStruct->u32PwmPeriod)
								{
									FTU_HWA_SetChannelValue(pFtu, (uint8_t)(u8Channel + 1),
															pChannelCfg->u32PhaseShift + pChannelCfg->u32PwmDuty - pPwmModeStruct->u32PwmPeriod - 1);
								}
								else
								{
									FTU_HWA_SetChannelValue(pFtu, (uint8_t)(u8Channel + 1),
											pChannelCfg->u32PhaseShift + pChannelCfg->u32PwmDuty);
								}
#if FTU_DEV_ERROR_REPORT == STD_ON
							}
#endif
						}
						else
						{
							FTU_HWA_SetChannelValue(pFtu, u8Channel, pChannelCfg->u32PwmDuty);
						}
#if FTU_DEV_ERROR_REPORT == STD_ON
					}
#endif
				}
				set_deadtime(pFtu, u8Channel, pChannelCfg->u32ChannelDeadtime);
#if FTU_DEV_ERROR_REPORT == STD_ON
			}
#endif
		}
#if FTU_DEV_ERROR_REPORT == STD_ON
	}
#endif
}

/**
 * @brief Update the behavior of Output compare channel
 *
 * @param pFtuHandle FTU processing handle
 * @param pOutputModeStruct the configurations of the output compare mode
 */
void FTU_OutputCompareUpdate(FTU_HandleType *pFtuHandle,
                             const FTU_OutputCompareModeType *const pOCConfig)
{
#if FTU_DEV_ERROR_REPORT == STD_ON
	if ((uint32_t)pFtuHandle->eInstance >= FTU_INSTANCE_COUNT)
	{
		FTU_ReportDevError(FTU_OC_MODE_UPDATE_ID, FTU_E_PARAM_INSTANCE);
	}
	else if (pOCConfig->u8Channel >= FTU_CHANNEL_CONTROLS_COUNT)
	{
		FTU_ReportDevError(FTU_OC_MODE_UPDATE_ID, FTU_E_PARAM_CHANNEL);
	}
	else if (pOCConfig->u32CompareValue > FTU_GET_MAX_COUNTER(s_pFtuBasePtrs[pFtuHandle->eInstance]))
	{
		FTU_ReportDevError(FTU_OC_MODE_UPDATE_ID, FTU_E_PARAM_INVALID);
	}
	else
	{
#endif
		FTU_Type * const pFtu = s_pFtuBasePtrs[pFtuHandle->eInstance];
		FTU_HWA_ConfigChannelEdgeLevel(pFtu, pOCConfig->u8Channel, (FTU_ChannelEdgeLevelType)pOCConfig->eOutputMode);
		/* set FTU CV register value*/
		FTU_HWA_SetChannelValue(pFtu, pOCConfig->u8Channel, (uint32_t)pOCConfig->u32CompareValue);
#if FTU_DEV_ERROR_REPORT == STD_ON
	}
#endif
}

/**
 * @brief Configure FTU to output compare mode
 *
 * @param pFtuHandle FTU processing handle
 * @param pOutputModeStruct the configurations of the output compare mode
 * @note This function will stop timer
 */
void FTU_OutputCompareModeInit(FTU_HandleType *pFtuHandle,
                               const FTU_OutputCompareModeType *const pOCConfig)
{
#if FTU_DEV_ERROR_REPORT == STD_ON
	if ((uint32_t)pFtuHandle->eInstance >= FTU_INSTANCE_COUNT)
	{
		FTU_ReportDevError(FTU_OC_MODE_INIT_ID, FTU_E_PARAM_INSTANCE);
	}
	else if (pOCConfig->u8Channel >= FTU_CHANNEL_CONTROLS_COUNT)
	{
		FTU_ReportDevError(FTU_OC_MODE_INIT_ID, FTU_E_PARAM_CHANNEL);
	}
	else if (pOCConfig->u32CompareValue > FTU_GET_MAX_COUNTER(s_pFtuBasePtrs[pFtuHandle->eInstance]))
	{
		FTU_ReportDevError(FTU_OC_MODE_INIT_ID, FTU_E_PARAM_INVALID);
	}
	else
	{
#endif
		FTU_Type * const pFtu = s_pFtuBasePtrs[pFtuHandle->eInstance];

		/* disable ftu timer */
		FTU_HWA_ConfigModuleClkSrc(pFtu, FTU_MODULE_NO_CLK);
		FTU_HWA_DisableChannelEnhancedPhase(pFtu, pOCConfig->u8Channel);
		FTU_HWA_DisableChannelPhase(pFtu, pOCConfig->u8Channel);
#ifdef FTU_ICM_FEATURE
		FTU_HWA_ConfigInputCaptureMeasureMode(pFtu, pOCConfig->u8Channel,
											  FTU_MEASURE_MODE_OFF);
#endif
		FTU_HWA_ConfigChannelMode(pFtu, pOCConfig->u8Channel, FTU_CHANNEL_MODE_OUTPUT_COMPARE);
		FTU_HWA_ConfigChannelEdgeLevel(pFtu, pOCConfig->u8Channel, (FTU_ChannelEdgeLevelType)pOCConfig->eOutputMode);

		/* Disable Up-Down Mode*/
		FTU_HWA_DisableModuleCpwmMode(pFtu);
		/* enable FTU output */
		FTU_HWA_EnableChannelsOutput(pFtu, (uint8_t)(1U << pOCConfig->u8Channel));
		/* set FTU CV register value*/
		FTU_HWA_SetChannelValue(pFtu, pOCConfig->u8Channel, (uint32_t)pOCConfig->u32CompareValue);
#if FTU_DEV_ERROR_REPORT == STD_ON
	}
#endif
}

/**
 * @brief Get the value of the FTU Channel
 *
 * @param pFtuHandle FTU processing handle
 * @param u32Channel FTU Channel
 * @return the value of the FTU Channel
 */
uint32_t FTU_GetChannelValue(FTU_HandleType *pFtuHandle, uint32_t u32Channel)
{
	uint32_t u32ChannelValue;
#if FTU_DEV_ERROR_REPORT == STD_ON
	if ((uint32_t)pFtuHandle->eInstance >= FTU_INSTANCE_COUNT)
	{
		u32ChannelValue = 0;
		FTU_ReportDevError(FTU_GET_CHANNEL_VALUE_ID, FTU_E_PARAM_INSTANCE);
	}
	else if (u32Channel >= FTU_CHANNEL_CONTROLS_COUNT)
	{
		u32ChannelValue = 0;
		FTU_ReportDevError(FTU_GET_CHANNEL_VALUE_ID, FTU_E_PARAM_CHANNEL);
	}
	else
	{
#endif
		FTU_Type * const pFtu = s_pFtuBasePtrs[pFtuHandle->eInstance];

		u32ChannelValue = FTU_HWA_GetChannelValue(pFtu, (uint8_t)u32Channel);
#if FTU_DEV_ERROR_REPORT == STD_ON
	}
#endif
	return u32ChannelValue;
}

/**
 * @brief Get the value of the FTU counter
 *
 * @param pFtuHandle FTU processing handle
 * @return the counter of the FTU
 */
uint32_t FTU_GetCounter(FTU_HandleType *pFtuHandle)
{
	uint32_t u32Counter;
#if FTU_DEV_ERROR_REPORT == STD_ON
	if ((uint32_t)pFtuHandle->eInstance >= FTU_INSTANCE_COUNT)
	{
		u32Counter = 0;
		FTU_ReportDevError(FTU_GET_COUNTER_ID, FTU_E_PARAM_INSTANCE);
	}
	else
	{
#endif
		FTU_Type * const pFtu = s_pFtuBasePtrs[pFtuHandle->eInstance];
		u32Counter = FTU_HWA_GetCounterValue(pFtu);
#if FTU_DEV_ERROR_REPORT == STD_ON
	}
#endif
	return u32Counter;
}

/**
 * @brief Set the value of the FTU Channel
 *
 * @param pFtuHandle FTU processing handle
 * @param u32Channel FTU Channel
 * @param u32Value the value to set
 */
void FTU_SetChannelValue(FTU_HandleType *pFtuHandle, uint32_t u32Channel, uint32_t u32Value)
{
#if FTU_DEV_ERROR_REPORT == STD_ON
	if ((uint32_t)pFtuHandle->eInstance >= FTU_INSTANCE_COUNT)
	{
		FTU_ReportDevError(FTU_SET_CHANNEL_VALUE_ID, FTU_E_PARAM_INSTANCE);
	}
	else if (u32Channel >= FTU_CHANNEL_CONTROLS_COUNT)
	{
		FTU_ReportDevError(FTU_SET_CHANNEL_VALUE_ID, FTU_E_PARAM_CHANNEL);
	}
	else if (u32Value > FTU_GET_MAX_COUNTER(s_pFtuBasePtrs[pFtuHandle->eInstance]))
	{
		FTU_ReportDevError(FTU_SET_CHANNEL_VALUE_ID, FTU_E_PARAM_COUNT);
	}
	else
	{
#endif
		FTU_Type * const pFtu = s_pFtuBasePtrs[pFtuHandle->eInstance];

		FTU_HWA_SetChannelValue(pFtu, (uint8_t)u32Channel, u32Value);
#if FTU_DEV_ERROR_REPORT == STD_ON
	}
#endif
}

/**
 * @brief Enable the output trigger of the selected FTU instance
 *
 * @param pFtuHandle FTU processing handle
 * @param u32TriggerOutputMask the output trigger mask
 */
void FTU_EnableTriggerOutput(FTU_HandleType *pFtuHandle, uint32_t u32TriggerOutputMask)
{
#if FTU_DEV_ERROR_REPORT == STD_ON
	if ((uint32_t)pFtuHandle->eInstance >= FTU_INSTANCE_COUNT)
	{
		FTU_ReportDevError(FTU_ENABLE_TRIG_OUT_ID, FTU_E_PARAM_INSTANCE);
	}
	else
	{
#endif
		FTU_Type * const pFtu = s_pFtuBasePtrs[pFtuHandle->eInstance];
		/* enable the channel match trigger */
		FTU_HWA_EnableChannelTriggerOut(pFtu, (uint8_t)(u32TriggerOutputMask & (uint32_t)FTU_TRIG_OUTPUT_MASK_ALL_CHANNEL_MATCH));
		if (0u != (u32TriggerOutputMask & (uint32_t)FTU_TRIG_OUTPUT_MASK_RELOAD))
		{
			/* enable reload trigger */
			FTU_HWA_EnableReloadTrigger(pFtu);
		}
#if FTU_DEV_ERROR_REPORT == STD_ON
	}
#endif
}

/**
 * @brief Disable the output trigger of the selected FTU instance
 *
 * @param pFtuHandle FTU processing handle
 * @param u32TriggerOutputMask the output trigger mask
 */
void FTU_DisableTriggerOutput(FTU_HandleType *pFtuHandle, uint32_t u32TriggerOutputMask)
{
#if FTU_DEV_ERROR_REPORT == STD_ON
	if ((uint32_t)pFtuHandle->eInstance >= FTU_INSTANCE_COUNT)
	{
		FTU_ReportDevError(FTU_DISABLE_TRIG_OUT_ID, FTU_E_PARAM_INSTANCE);
	}
	else
	{
#endif
		FTU_Type * const pFtu = s_pFtuBasePtrs[pFtuHandle->eInstance];
		/* disable the channel match trigger */
		FTU_HWA_DisableChannelTriggerOut(pFtu, (uint8_t)(u32TriggerOutputMask & (uint32_t)FTU_TRIG_OUTPUT_MASK_ALL_CHANNEL_MATCH));
		if (0u != (u32TriggerOutputMask & (uint32_t)FTU_TRIG_OUTPUT_MASK_RELOAD))
		{
			/* disable reload trigger */
			FTU_HWA_DisableReloadTrigger(pFtu);
		}
#if FTU_DEV_ERROR_REPORT == STD_ON
	}
#endif
}

/**
 * @brief Start the FTU instance
 *
 * @param pFtuHandle FTU processing handle
 */
void FTU_StartTimer(FTU_HandleType *pFtuHandle)
{
#if FTU_DEV_ERROR_REPORT == STD_ON
	if ((uint32_t)pFtuHandle->eInstance >= FTU_INSTANCE_COUNT)
	{
		FTU_ReportDevError(FTU_START_TIMER_ID, FTU_E_PARAM_INSTANCE);
	}
	else if (pFtuHandle->tStatus.eFtuClkSrc == FTU_NO_CLK)
	{
		FTU_ReportDevError(FTU_START_TIMER_ID, FTU_E_PARAM_INVALID);
	}
	else
	{
#endif
		FTU_Type * const pFtu = s_pFtuBasePtrs[pFtuHandle->eInstance];

		/* set FTU module clock source */
		if (pFtuHandle->tStatus.eFtuClkSrc == FTU_INTERNAL_CLK)
		{
#ifdef FTU_CNT_SEL_EXIST
			FTU_HWA_ConfigFTUCntSel(pFtu, FTU_CNT_SEL_INTERNAL_CNT);
#endif
			FTU_HWA_ConfigModuleClkSrc(pFtu, FTU_MODULE_INTERNAL_CLK);
		}
#ifdef FTU_CNT_SEL_EXIST
		else if (pFtuHandle->tStatus.eFtuClkSrc == FTU_EFTU_CNT)
		{
			FTU_HWA_ConfigFTUCntSel(pFtu, FTU_CNT_SEL_EXTERNAL_CNT);
			FTU_HWA_ConfigModuleClkSrc(pFtu, FTU_MODULE_INTERNAL_CLK);
		}
#endif
		else
		{
#ifdef FTU_CNT_SEL_EXIST
			FTU_HWA_ConfigFTUCntSel(pFtu, FTU_CNT_SEL_INTERNAL_CNT);
#endif
			FTU_HWA_ConfigModuleClkSrc(pFtu, FTU_MODULE_EXTERNAL_CLK);
		}
#if FTU_DEV_ERROR_REPORT == STD_ON
	}
#endif
}
#ifdef FTU_GTB_ADVANCED_CTRL
/**
 * @brief Stop the FTU global time base
 *
 * @param u32InstanceMask The selected FTU, each bit represents an instance
 */
void FTU_StopGlobalTimeBase(uint32_t u32InstanceMask)
{
	uint32_t u32GTB = 0u, u32Loop0;
	for (u32Loop0 = 0u; u32Loop0 < FTU_INSTANCE_COUNT; u32Loop0++)
	{
		uint32_t u32InstanceFlag = 1u << u32Loop0;
		if (0u != (u32InstanceMask & u32InstanceFlag))
		{
			u32GTB |= u32InstanceFlag;
			SCM_HWA_ClearFtuGTBMask((uint8_t)u32Loop0);
		}
	}
	SCM_HWA_ClearFtuGTBSelect(u32GTB);
}

/**
 * @brief Start the FTU global time base
 *
 * @param u32InstanceMask The selected FTU, each bit represents an instance
 * @param u32StartMask Start time, refer to FTU_GlobalTimeBaseStartType
 */
void FTU_StartGlobalTimeBase(uint32_t u32InstanceMask, uint32_t u32StartMask)
{
	uint32_t u32GTB = 0u, u32Loop0, u32Loop1;
	for (u32Loop0 = 0u; u32Loop0 < FTU_INSTANCE_COUNT; u32Loop0++)
	{
		uint32_t u32InstanceFlag = 1u << u32Loop0;
		if (0u != (u32InstanceMask & u32InstanceFlag))
		{
			if (u32StartMask & FTU_GTB_START_AT_ONCE)
			{
				u32GTB |= u32InstanceFlag;
			}
			for (u32Loop1 = 0u; u32Loop1 < 4U; u32Loop1++)
			{
				if (u32StartMask & (uint32_t)(FTU_GTB_START_AT_TSTMP1_MOD0 << u32Loop1))
				{
					SCM_HWA_ConfigFtuGTBMask((uint8_t)u32Loop0, (1u << u32Loop1));
				}
			}
		}
	}
	SCM_HWA_SetFtuGTBSelect(u32GTB);
}
#endif
/**
 * @brief Stop the FTU instance
 *
 * @param pFtuHandle FTU processing handle
 */
void FTU_StopTimer(FTU_HandleType *pFtuHandle)
{
#if FTU_DEV_ERROR_REPORT == STD_ON
	if ((uint32_t)pFtuHandle->eInstance >= FTU_INSTANCE_COUNT)
	{
		FTU_ReportDevError(FTU_STOP_TIMER_ID, FTU_E_PARAM_INSTANCE);
	}
	else
	{
#endif
		/* clear FTU module clock source */
		FTU_HWA_ConfigModuleClkSrc(s_pFtuBasePtrs[pFtuHandle->eInstance], FTU_MODULE_NO_CLK);
#if FTU_DEV_ERROR_REPORT == STD_ON
	}
#endif
}

/**
 * @brief initialize fault input of the selected Ftu instance
 *
 * @param pFtuHandle FTU processing handle
 * @param pFaultInit the fault configurations of the FTU instance
 */
void FTU_FaultInit(FTU_HandleType *pFtuHandle, const FTU_FaultInitType *const pFaultInit)
{
#if FTU_DEV_ERROR_REPORT == STD_ON
	if ((uint32_t)pFtuHandle->eInstance >= FTU_INSTANCE_COUNT)
	{
		FTU_ReportDevError(FTU_FAULT_INIT_ID, FTU_E_PARAM_INSTANCE);
	}
	else
	{
#endif
		uint32_t u32Loop, u32Temp;
		FTU_Type * const pFtu = s_pFtuBasePtrs[pFtuHandle->eInstance];

		/* configure fault mode */
		FTU_HWA_ConfigModuleFaultMode(pFtu, pFaultInit->eFaultMode);
		/* Disable all fault inputs*/
		u32Temp = FTU_HWA_GetFaultEnable(pFtu);
		FTU_HWA_DisableModuleFault(pFtu, 0xFu);
		/* configure fault filter value */
		FTU_HWA_SetModuleFaultFilterValue(pFtu, pFaultInit->u8FilterValue);
		/* recover fault inputs*/
		FTU_HWA_EnableModuleFault(pFtu, (uint8_t)u32Temp);
		/* enables the fault control in channels */
		for(u32Loop = 0u; u32Loop < FTU_FAULT_CHANNEL_COUNT; u32Loop++)
		{
			if (0u != (pFaultInit->u8FaultChannelEnable & ((uint8_t)FTU_FAULT_FOR_CHANNEL01 << u32Loop)))
			{
				FTU_HWA_EnableChannelFault(pFtu, (uint8_t)(u32Loop << 1u));
			}
			else
			{
				FTU_HWA_DisableChannelFault(pFtu, (uint8_t)(u32Loop << 1u));
			}
		}
#ifdef FTU_FAULT_DIS_DELAY_FEATURE
		/* set fault disable channel output delay value */
		FTU_HWA_SetFaultDelay0(pFtu, pFaultInit->u8FaultDisableDelay0);
		FTU_HWA_SetFaultDelay1(pFtu, pFaultInit->u8FaultDisableDelay1);
#endif
#if FTU_DEV_ERROR_REPORT == STD_ON
	}
#endif
}
#ifdef FTU_FAULT_DIS_DELAY_FEATURE
/**
 * @brief Select fault disable channel output delay value
 *
 * @param pFtuHandle FTU processing handle
 * @param u8Channel FTU channel number, range is 0-7.
 * @param eSelection Fault disable channel output delay value selection.
 */
void FTU_FaultSelectDelayValue(FTU_HandleType *pFtuHandle, uint8_t u8Channel, FTU_FaultDisableDelayType eDelaySelection)
{
#if FTU_DEV_ERROR_REPORT == STD_ON
	if ((uint32_t)pFtuHandle->eInstance >= FTU_INSTANCE_COUNT)
	{
		FTU_ReportDevError(FTU_FAULT_SEL_DELAY_ID, FTU_E_PARAM_INSTANCE);
	}
	else if (u8Channel >= FTU_CHANNEL_CONTROLS_COUNT)
	{
		FTU_ReportDevError(FTU_FAULT_SEL_DELAY_ID, FTU_E_PARAM_CHANNEL);
	}
	else
	{
#endif
		FTU_HWA_SelectFaultDelay(s_pFtuBasePtrs[pFtuHandle->eInstance], u8Channel, eDelaySelection);
#if FTU_DEV_ERROR_REPORT == STD_ON
	}
#endif
}
#endif
/**
 * @brief Enable a fault input
 *
 * @param pFtuHandle FTU processing handle
 * @param pFaultCtrl configurations of the fault input
 */
void FTU_FaultEnable(FTU_HandleType *pFtuHandle, const FTU_FaultControlType *const pFaultCtrl)
{
#if FTU_DEV_ERROR_REPORT == STD_ON
	if ((uint32_t)pFtuHandle->eInstance >= FTU_INSTANCE_COUNT)
	{
		FTU_ReportDevError(FTU_FAULT_ENABLE_ID, FTU_E_PARAM_INSTANCE);
	}
	else if (pFaultCtrl->u8FaultIndex >= FTU_FAULT_INPUT_COUNT(s_pFtuBasePtrs[pFtuHandle->eInstance]))
	{
		FTU_ReportDevError(FTU_FAULT_ENABLE_ID, FTU_E_PARAM_INVALID);
	}
	else
	{
#endif
		FTU_Type * const pFtu = s_pFtuBasePtrs[pFtuHandle->eInstance];
		/* configure fault input polarity */
		FTU_HWA_ConfigFaultPolarity(pFtu, pFaultCtrl->u8FaultIndex, (uint8_t)pFaultCtrl->eFaultPol);
		if(true == pFaultCtrl->bFaultFilterEnable)
		{
			FTU_HWA_EnableModuleFaultGlitchFilter(pFtu, (uint8_t)(1u << pFaultCtrl->u8FaultIndex));
		}
		else
		{
			FTU_HWA_DisableModuleFaultGlitchFilter(pFtu, (uint8_t)(1u << pFaultCtrl->u8FaultIndex));
		}
		/* enable fault input */
		FTU_HWA_EnableModuleFault(pFtu, (uint8_t)(1u << pFaultCtrl->u8FaultIndex));
#if FTU_DEV_ERROR_REPORT == STD_ON
	}
#endif
}

/**
 * @brief Disable a fault input
 *
 * @param pFtuHandle FTU processing handle
 * @param u32FaultIndex index of the fault input
 */
void FTU_FaultDisable(FTU_HandleType *pFtuHandle, uint32_t u32FaultIndex)
{
#if FTU_DEV_ERROR_REPORT == STD_ON
	if ((uint32_t)pFtuHandle->eInstance >= FTU_INSTANCE_COUNT)
	{
		FTU_ReportDevError(FTU_FAULT_DISABLE_ID, FTU_E_PARAM_INSTANCE);
	}
	else if (u32FaultIndex >= FTU_FAULT_INPUT_COUNT(s_pFtuBasePtrs[pFtuHandle->eInstance]))
	{
		FTU_ReportDevError(FTU_FAULT_DISABLE_ID, FTU_E_PARAM_INVALID);
	}
	else
	{
#endif
		FTU_HWA_DisableModuleFault(s_pFtuBasePtrs[pFtuHandle->eInstance], (uint8_t)(0x1u << u32FaultIndex));
#if FTU_DEV_ERROR_REPORT == STD_ON
	}
#endif
}

/**
 * @brief initialize a input capture channel of the selected Ftu instance
 *
 * @param pFtuHandle FTU processing handle
 * @param pInputChannel configurations of the input capture channel
 */
void FTU_InputCaptureChannelInit(FTU_HandleType *pFtuHandle,
                                 const FTU_InputChannelType *const pInputChannel)
{
#if FTU_DEV_ERROR_REPORT == STD_ON
	if ((uint32_t)pFtuHandle->eInstance >= FTU_INSTANCE_COUNT)
	{
		FTU_ReportDevError(FTU_IC_CHANNEL_INIT_ID, FTU_E_PARAM_INSTANCE);
	}
	else if (pInputChannel->u8Channel >= FTU_CHANNEL_CONTROLS_COUNT)
	{
		FTU_ReportDevError(FTU_IC_CHANNEL_INIT_ID, FTU_E_PARAM_CHANNEL);
	}
	else
	{
#endif
		FTU_Type * const pFtu = s_pFtuBasePtrs[pFtuHandle->eInstance];

		FTU_HWA_DisableQuadratureMode(pFtu);
		FTU_HWA_DisableChannelEnhancedPhase(pFtu, pInputChannel->u8Channel);
		FTU_HWA_DisableChannelPhase(pFtu, pInputChannel->u8Channel);
#ifdef FTU_ICM_FEATURE
		FTU_HWA_ConfigInputCaptureMeasureMode(pFtu, pInputChannel->u8Channel,
											  FTU_MEASURE_MODE_OFF);
#endif
		FTU_HWA_ConfigChannelMode(pFtu, pInputChannel->u8Channel, FTU_CHANNEL_MODE_INPUT);
		if(pInputChannel->u8Channel < FTU_INPUT_FILTER_COUNT)
		{
			/* set FTU input capture filter value */
			FTU_HWA_ConfigInputCaptureFilter(
					pFtu, pInputChannel->u8Channel,
					pInputChannel->u8FilterValue);

		}

		FTU_HWA_ConfigChannelEdgeLevel(pFtu, pInputChannel->u8Channel, (FTU_ChannelEdgeLevelType)pInputChannel->eInputMode);
#if FTU_DEV_ERROR_REPORT == STD_ON
	}
#endif
}

/**
 * @brief initialize the quadrature decoder mode
 *
 * @param pFtuHandle FTU processing handle
 * @param pQuadInit configurations of the quadrature decoder
 */
void FTU_QuadratureModeInit(FTU_HandleType *pFtuHandle,
                            const FTU_QuadratureInitType *const pQuadInit)
{
#if FTU_DEV_ERROR_REPORT == STD_ON
	if ((uint32_t)pFtuHandle->eInstance >= FTU_INSTANCE_COUNT)
	{
		FTU_ReportDevError(FTU_QD_MODE_INIT_ID, FTU_E_PARAM_INSTANCE);
	}
	else if (0U == FTU_INSTANCE_QD_SUPPORT(s_pFtuBasePtrs[pFtuHandle->eInstance]))
	{
		FTU_ReportDevError(FTU_QD_MODE_INIT_ID, FTU_E_PARAM_INSTANCE);
	}
	else
	{
#endif
		FTU_Type * const pFtu = s_pFtuBasePtrs[pFtuHandle->eInstance];

		/* set quadrature mode */
		FTU_HWA_ConfigQuadratureMode(pFtu, pQuadInit->eQuadMode);
		/* set PHA polarity*/
		if(pQuadInit->bPhaInverted)
		{
			FTU_HWA_EnablePhaInv(pFtu);
		}
		else
		{
			FTU_HWA_DisablePhaInv(pFtu);
		}
		/* set PHB polarity*/
		if(pQuadInit->bPhbInverted)
		{
			FTU_HWA_EnablePhbInv(pFtu);
		}
		else
		{
			FTU_HWA_DisablePhbInv(pFtu);
		}
		/* prescale should not be set in QD mode */
		FTU_HWA_SetModulePrescale(pFtu, FTU_DIV_1);
		/* set top value */
		FTU_HWA_SetModuleCompareValue(pFtu, pQuadInit->u16TopValue);
		/* set bottom value */
		FTU_HWA_SetCounterInitialValue(pFtu, pQuadInit->u16BottomValue);

		/* Set phase A glitch filter value */
		if (0U != pQuadInit->u8PhaFilterVal)
		{
			FTU_HWA_ConfigChannelFilterValue(pFtu, 0, pQuadInit->u8PhaFilterVal);
			FTU_HWA_EnablePhaGlitchFilter(pFtu);
		}
		else
		{
			FTU_HWA_DisablePhaGlitchFilter(pFtu);
		}
		/* Set phase B glitch filter value */
		if (0U != pQuadInit->u8PhbFilterVal)
		{
			FTU_HWA_ConfigChannelFilterValue(pFtu, 1, pQuadInit->u8PhbFilterVal);
			FTU_HWA_EnablePhbGlitchFilter(pFtu);
		}
		else
		{
			FTU_HWA_DisablePhbGlitchFilter(pFtu);
		}
		/* enable the quadrature*/
		FTU_HWA_EnableQuadratureMode(pFtu);
#if FTU_DEV_ERROR_REPORT == STD_ON
	}
#endif
}
/**
 * @brief Enable FTU interrupt
 *
 * @param pFtuHandle FTU processing handle
 * @param u32InterruptMask interrupt enable mask
 */
void FTU_EnableInterrupt(FTU_HandleType *pFtuHandle, uint32_t u32InterruptMask)
{
#if FTU_DEV_ERROR_REPORT == STD_ON
	if ((uint32_t)pFtuHandle->eInstance >= FTU_INSTANCE_COUNT)
	{
		FTU_ReportDevError(FTU_ENABLE_INTR_ID, FTU_E_PARAM_INSTANCE);
	}
	else
	{
#endif
		FTU_Type * const pFtu = s_pFtuBasePtrs[pFtuHandle->eInstance];
		uint32_t u32Loop;

		for(u32Loop = 0u; u32Loop < FTU_CHANNEL_CONTROLS_COUNT; u32Loop++)
		{
			if (0u != (u32InterruptMask & ((uint32_t)FTU_INTR_MASK_CHANNEL_0 << u32Loop)))
			{
				/* Enable Channel Interrupt */
				FTU_HWA_EnableChannelInterrupt(pFtu, (uint8_t)u32Loop);
			}
		}

		if (0u != (u32InterruptMask & (uint32_t)FTU_INTR_MASK_OVERFLOW))
		{
			/* Enable Overflow Interrupt */
			FTU_HWA_EnableOverflowInterrupt(pFtu);
		}

		if (0u != (u32InterruptMask & (uint32_t)FTU_INTR_MASK_FAULT))
		{
			/* Enable Fault Interrupt */
			FTU_HWA_EnableModuleFaultInterrupt(pFtu);
		}

		if (0u != (u32InterruptMask & (uint32_t)FTU_INTR_MASK_RELOAD_POINT))
		{
			/* Enable Reload Point Interrupt */
			FTU_HWA_EnableReloadPointInterrupt(pFtu);
		}
#if FTU_DEV_ERROR_REPORT == STD_ON
	}
#endif
}

/**
 * @brief Disable FTU interrupt
 *
 * @param pFtuHandle FTU processing handle
 * @param u32InterruptMask interrupt disable mask
 */
void FTU_DisableInterrupt(FTU_HandleType *pFtuHandle, uint32_t u32InterruptMask)
{
#if FTU_DEV_ERROR_REPORT == STD_ON
	if ((uint32_t)pFtuHandle->eInstance >= FTU_INSTANCE_COUNT)
	{
		FTU_ReportDevError(FTU_DISABLE_INTR_ID, FTU_E_PARAM_INSTANCE);
	}
	else
	{
#endif
		FTU_Type * const pFtu = s_pFtuBasePtrs[pFtuHandle->eInstance];
		uint32_t u32Loop;

		for(u32Loop = 0; u32Loop < FTU_CHANNEL_CONTROLS_COUNT; u32Loop++)
		{
			if (0u != (u32InterruptMask & ((uint32_t)FTU_INTR_MASK_CHANNEL_0 << u32Loop)))
			{
				/* Disable Channel Interrupt */
				FTU_HWA_DisableChannelInterrupt(pFtu, (uint8_t)u32Loop);
			}
		}

		if (0u != (u32InterruptMask & (uint32_t)FTU_INTR_MASK_OVERFLOW))
		{
			/* Disable Overflow Interrupt */
			FTU_HWA_DisableOverflowInterrupt(pFtu);
		}

		if (0u != (u32InterruptMask & (uint32_t)FTU_INTR_MASK_FAULT))
		{
			/* Disable Fault Interrupt */
			FTU_HWA_DisableModuleFaultInterrupt(pFtu);
		}

		if (0u != (u32InterruptMask & (uint32_t)FTU_INTR_MASK_RELOAD_POINT))
		{
			/* Disable Reload Point Interrupt */
			FTU_HWA_DisableReloadPointInterrupt(pFtu);
		}
#if FTU_DEV_ERROR_REPORT == STD_ON
	}
#endif
}

/**
 * @brief Clear the fault flag of the FTU instance
 *
 * @param pFtuHandle FTU processing handle
 * @param u32FaultFlag flag to clear
 */
void FTU_ClearFault(FTU_HandleType *pFtuHandle, uint32_t u32FaultFlag)
{
#if FTU_DEV_ERROR_REPORT == STD_ON
	if ((uint32_t)pFtuHandle->eInstance >= FTU_INSTANCE_COUNT)
	{
		FTU_ReportDevError(FTU_CLEAR_FAULT_ID, FTU_E_PARAM_INSTANCE);
	}
	else
	{
#endif
		FTU_HWA_ClearModuleFaultFlag(s_pFtuBasePtrs[pFtuHandle->eInstance], (uint8_t)u32FaultFlag);
#if FTU_DEV_ERROR_REPORT == STD_ON
	}
#endif
}

/**
 * @brief Get the fault flag of the FTU instance
 *
 * @param pFtuHandle FTU processing handle
 * @return uint32_t the fault flag of the selected Ftu instance
 */
uint32_t FTU_GetFaultFlag(FTU_HandleType *pFtuHandle)
{
	uint32_t u32FaultFlag = 0;
#if FTU_DEV_ERROR_REPORT == STD_ON
	if ((uint32_t)pFtuHandle->eInstance >= FTU_INSTANCE_COUNT)
	{
		FTU_ReportDevError(FTU_GET_FAULT_FLAG_ID, FTU_E_PARAM_INSTANCE);
	}
	else
	{
#endif
		u32FaultFlag = FTU_HWA_ReadModuleFaultFlag(s_pFtuBasePtrs[pFtuHandle->eInstance]);
#if FTU_DEV_ERROR_REPORT == STD_ON
	}
#endif
	return u32FaultFlag;
}


/**
 * @brief Enable ftu channel DMA
 *
 * @param pFtuHandle FTU processing handle
 * @param u32DmaMask The dma channel mask.
 */

void FTU_EnableChannelDma(FTU_HandleType *pFtuHandle, uint32_t u32Channel)
{
#if FTU_DEV_ERROR_REPORT == STD_ON
	if ((uint32_t)pFtuHandle->eInstance >= FTU_INSTANCE_COUNT)
	{
		FTU_ReportDevError(FTU_ENABLE_CHANNEL_DMA_ID, FTU_E_PARAM_INSTANCE);
	}
	else
	{
#endif
		FTU_HWA_EnableChannelDma(s_pFtuBasePtrs[pFtuHandle->eInstance], (uint8_t)u32Channel);
#if FTU_DEV_ERROR_REPORT == STD_ON
	}
#endif
}

#ifdef FTU_ICM_FEATURE
/**
 * @brief Initialize a Expect Edge Number Measurement channel
 *
 * @param pFtuHandle FTU processing handle
 * @param pExpectEdumMeasure measurement configuration.
 */
void FTU_ExpectEdgeNumberMeasureChannelInit(FTU_HandleType *pFtuHandle, FTU_ExpectEdgeNumberMeasureType *pExpectEdgeNumMeasure)
{
#if FTU_DEV_ERROR_REPORT == STD_ON
	if ((uint32_t)pFtuHandle->eInstance >= FTU_INSTANCE_COUNT)
	{
		FTU_ReportDevError(FTU_IC_EXPENM_INIT_ID, FTU_E_PARAM_INSTANCE);
	}
	else if (pExpectEdgeNumMeasure->u8Channel >= FTU_CHANNEL_CONTROLS_COUNT)
	{
		FTU_ReportDevError(FTU_IC_EXPENM_INIT_ID, FTU_E_PARAM_CHANNEL);
	}
	else if ((pExpectEdgeNumMeasure->u8Channel & 1u) != 0u)
	{
		FTU_ReportDevError(FTU_IC_EXPENM_INIT_ID, FTU_E_PARAM_CHANNEL);
	}
	else
	{
#endif
		FTU_Type * const pFtu = s_pFtuBasePtrs[pFtuHandle->eInstance];

		FTU_HWA_ConfigChannelMode(pFtu, pExpectEdgeNumMeasure->u8Channel,
								  FTU_CHANNEL_MODE_INPUT);
		FTU_HWA_ConfigChannelEdgeLevel(pFtu, pExpectEdgeNumMeasure->u8Channel,
						   	   	   	   (FTU_ChannelEdgeLevelType)pExpectEdgeNumMeasure->eEdgeMode);
		FTU_HWA_ConfigChannelEdgeLevel(pFtu, (uint8_t)(pExpectEdgeNumMeasure->u8Channel + 1u),
									   FTU_CHANNEL_EDGE_NOT_USED);
		FTU_HWA_ConfigEdgeNumber(pFtu, (uint8_t)(pExpectEdgeNumMeasure->u8Channel + (uint8_t)1u),
								 pExpectEdgeNumMeasure->u8ExpectEdgeNumber);
		if (FTU_MEASURE_CONTINUOUS_MODE == pExpectEdgeNumMeasure->eContinuouslyMode)
		{
			FTU_HWA_EnableMeasureContinous(pFtu, pExpectEdgeNumMeasure->u8Channel);
		}
		else
		{
			FTU_HWA_DisableMeasureContinous(pFtu, pExpectEdgeNumMeasure->u8Channel);
		}
		/* Must put the ICM_MODE setting at the end, otherwise it will not be configured correctly. */
		FTU_HWA_ConfigInputCaptureMeasureMode(	pFtu, pExpectEdgeNumMeasure->u8Channel,
												FTU_MEASURE_EXPECT_EDGE_NUMBER);
#if FTU_DEV_ERROR_REPORT == STD_ON
	}
#endif
}

/**
 * @brief Initialize a Edge Number Measurement channel
 *
 * @param pFtuHandle FTU processing handle
 * @param pEdgeNumMeasure measurement configuration.
 */
void FTU_EdgeNumberMeasureChannelInit(FTU_HandleType *pFtuHandle, FTU_EdgeNumberMeasureType *pEdgeNumMeasure)
{
#if FTU_DEV_ERROR_REPORT == STD_ON
	if ((uint32_t)pFtuHandle->eInstance >= FTU_INSTANCE_COUNT)
	{
		FTU_ReportDevError(FTU_IC_ENM_INIT_ID, FTU_E_PARAM_INSTANCE);
	}
	else if (pEdgeNumMeasure->u8Channel >= FTU_CHANNEL_CONTROLS_COUNT)
	{
		FTU_ReportDevError(FTU_IC_ENM_INIT_ID, FTU_E_PARAM_CHANNEL);
	}
	else if ((pEdgeNumMeasure->u8Channel & 1u) != 0u)
	{
		FTU_ReportDevError(FTU_IC_ENM_INIT_ID, FTU_E_PARAM_CHANNEL);
	}
	else if (pEdgeNumMeasure->u32StartWindow >= pEdgeNumMeasure->u32EndWindow)
	{
		FTU_ReportDevError(FTU_IC_ENM_INIT_ID, FTU_E_PARAM_INVALID);
	}
	else if (pEdgeNumMeasure->u32EndWindow > FTU_GET_MAX_COUNTER(s_pFtuBasePtrs[pFtuHandle->eInstance]))
	{
		FTU_ReportDevError(FTU_IC_ENM_INIT_ID, FTU_E_PARAM_COUNT);
	}
	else
	{
#endif
		FTU_Type * const pFtu = s_pFtuBasePtrs[pFtuHandle->eInstance];

		FTU_HWA_ConfigChannelMode(pFtu, pEdgeNumMeasure->u8Channel,
								  FTU_CHANNEL_MODE_INPUT);
		FTU_HWA_ConfigChannelEdgeLevel(pFtu, pEdgeNumMeasure->u8Channel,
									   (FTU_ChannelEdgeLevelType)pEdgeNumMeasure->eEdgeMode);

		FTU_HWA_ConfigChannelEdgeLevel(pFtu, (uint8_t)(pEdgeNumMeasure->u8Channel + 1u),
									   FTU_CHANNEL_EDGE_NOT_USED);
		FTU_HWA_ConfigInputCaptureMeasureMode(pFtu, pEdgeNumMeasure->u8Channel,
											  FTU_MEASURE_ICENM_WIND_WRITE);
		FTU_HWA_SetChannelValue(pFtu, pEdgeNumMeasure->u8Channel,
								pEdgeNumMeasure->u32StartWindow);
		FTU_HWA_SetChannelValue(pFtu, (uint8_t)(pEdgeNumMeasure->u8Channel + 1u),
								pEdgeNumMeasure->u32EndWindow);
		FTU_HWA_ConfigInputCaptureMeasureMode(  pFtu, pEdgeNumMeasure->u8Channel,
												FTU_MEASURE_EDGE_NUMBER);
		if (FTU_MEASURE_CONTINUOUS_MODE == pEdgeNumMeasure->eContinuouslyMode)
		{
			FTU_HWA_EnableMeasureContinous(pFtu, pEdgeNumMeasure->u8Channel);
		}
		else
		{
			FTU_HWA_DisableMeasureContinous(pFtu, pEdgeNumMeasure->u8Channel);
		}
#if FTU_DEV_ERROR_REPORT == STD_ON
	}
#endif
}

/**
 * @brief Get the expect edge number result of the channel
 *
 * @param pFtuHandle FTU processing handle
 * @param u8Channel FTU channel number, range is 0-7.
 * @param pResult point to the result buffer.
 */
void FTU_GetExpectEdgeNumberResult(FTU_HandleType *pFtuHandle, uint8_t u8Channel, FTU_ExpectEdgeNumberResultType *pResult)
{
#if FTU_DEV_ERROR_REPORT == STD_ON
	if ((uint32_t)pFtuHandle->eInstance >= FTU_INSTANCE_COUNT)
	{
		FTU_ReportDevError(FTU_IC_EXPENM_GET_ID, FTU_E_PARAM_INSTANCE);
	}
	else if (u8Channel >= FTU_CHANNEL_CONTROLS_COUNT)
	{
		FTU_ReportDevError(FTU_IC_EXPENM_GET_ID, FTU_E_PARAM_CHANNEL);
	}
	else if ((u8Channel & 1u) != 0u)
	{
		FTU_ReportDevError(FTU_IC_EXPENM_GET_ID, FTU_E_PARAM_CHANNEL);
	}
	else
	{
#endif
		FTU_Type * const pFtu = s_pFtuBasePtrs[pFtuHandle->eInstance];

		pResult->u32FirstEdgeTime = FTU_HWA_GetChannelValue(pFtu, u8Channel);
		pResult->u32LastEdgeTime = FTU_HWA_GetChannelValue(pFtu, (uint8_t)(u8Channel + 1u));
#if FTU_DEV_ERROR_REPORT == STD_ON
	}
#endif
}

/**
 * @brief Get Edge number counter
 *
 * @param pFtuHandle FTU processing handle
 * @param u8Channel FTU channel number.
 * @return uint8_t Edge number counter
 */
uint8_t FTU_GetEdgeNumberCount(FTU_HandleType *pFtuHandle, uint8_t u8Channel)
{
	uint8_t u8Count;
#if FTU_DEV_ERROR_REPORT == STD_ON
	if ((uint32_t)pFtuHandle->eInstance >= FTU_INSTANCE_COUNT)
	{
		u8Count = 0;
		FTU_ReportDevError(FTU_IC_ENM_GET_ID, FTU_E_PARAM_INSTANCE);

	}
	else if (u8Channel >= FTU_CHANNEL_CONTROLS_COUNT)
	{
		u8Count = 0;
		FTU_ReportDevError(FTU_IC_ENM_GET_ID, FTU_E_PARAM_CHANNEL);
	}
	else if ((u8Channel & 1u) != 0u)
	{
		u8Count = 0;
		FTU_ReportDevError(FTU_IC_ENM_GET_ID, FTU_E_PARAM_CHANNEL);
	}
	else
	{
#endif
		u8Count = FTU_HWA_GetEdgeNumberCount(s_pFtuBasePtrs[pFtuHandle->eInstance], u8Channel);
#if FTU_DEV_ERROR_REPORT == STD_ON
	}
#endif
	return u8Count;
}
/**
 * @brief Initialize a signal measure channel
 *
 * @param pFtuHandle FTU processing handle
 * @param pMeasure measurement configuration.
 */
void FTU_SignalMeasureChannelInit(FTU_HandleType *pFtuHandle, FTU_SignalMeasureType *pMeasure)
{
#if FTU_DEV_ERROR_REPORT == STD_ON
	if ((uint32_t)pFtuHandle->eInstance >= FTU_INSTANCE_COUNT)
	{
		FTU_ReportDevError(FTU_IC_SIG_MEAS_INIT_ID, FTU_E_PARAM_INSTANCE);
	}
	else if (pMeasure->u8Channel >= FTU_CHANNEL_CONTROLS_COUNT)
	{
		FTU_ReportDevError(FTU_IC_SIG_MEAS_INIT_ID, FTU_E_PARAM_CHANNEL);
	}
	else if ((pMeasure->u8Channel & 1u) != 0u)
	{
		FTU_ReportDevError(FTU_IC_SIG_MEAS_INIT_ID, FTU_E_PARAM_CHANNEL);
	}
	else
	{
#endif
		FTU_Type * const pFtu = s_pFtuBasePtrs[pFtuHandle->eInstance];

		FTU_HWA_ConfigInputCaptureMeasureMode(pFtu, pMeasure->u8Channel, FTU_MEASURE_MODE_OFF);
		FTU_HWA_ConfigInputCaptureMeasureMode(pFtu, (uint8_t)(pMeasure->u8Channel + 1u), FTU_MEASURE_MODE_OFF);
		FTU_HWA_DisableChannelEnhancedPhase(pFtu, pMeasure->u8Channel);
		FTU_HWA_DisableChannelPhase(pFtu, pMeasure->u8Channel);
		FTU_HWA_DisableChannelEnhancedPhase(pFtu, (uint8_t)(pMeasure->u8Channel + 1u));
		FTU_HWA_DisableChannelPhase(pFtu, (uint8_t)(pMeasure->u8Channel + 1u));
		FTU_HWA_DisableModuleCpwmMode(pFtu);

		FTU_HWA_ConfigChannelMode(pFtu, pMeasure->u8Channel, FTU_CHANNEL_MODE_INPUT);
		FTU_HWA_ConfigChannelMode(pFtu, (uint8_t)(pMeasure->u8Channel + 1u), FTU_CHANNEL_MODE_INPUT);
		if (FTU_SIGNAL_MEASURE_HIGH_TIME == pMeasure->eMeasureMode)
		{
			FTU_HWA_ConfigChannelEdgeLevel(pFtu, pMeasure->u8Channel, FTU_CHANNEL_EDGE_RISING);
			FTU_HWA_ConfigChannelEdgeLevel(pFtu, (uint8_t)(pMeasure->u8Channel + 1u), FTU_CHANNEL_EDGE_FALLING);
			FTU_HWA_ConfigInputCaptureMeasureMode(pFtu, pMeasure->u8Channel, FTU_MEASURE_MODE_DUTY_CYCLE);
			FTU_HWA_ConfigInputCaptureMeasureMode(pFtu, (uint8_t)(pMeasure->u8Channel + 1), FTU_MEASURE_MODE_DUTY_CYCLE);
			FTU_HWA_SetChannelPolarity(pFtu, (uint8_t)(1u << pMeasure->u8Channel));
		}
		else if (FTU_SIGNAL_MEASURE_LOW_TIME == pMeasure->eMeasureMode)
		{
			FTU_HWA_ConfigChannelEdgeLevel(pFtu, pMeasure->u8Channel, FTU_CHANNEL_EDGE_RISING);
			FTU_HWA_ConfigChannelEdgeLevel(pFtu, (uint8_t)(pMeasure->u8Channel + 1u), FTU_CHANNEL_EDGE_FALLING);
			FTU_HWA_ConfigInputCaptureMeasureMode(pFtu, pMeasure->u8Channel, FTU_MEASURE_MODE_DUTY_CYCLE);
			FTU_HWA_ConfigInputCaptureMeasureMode(pFtu, (uint8_t)(pMeasure->u8Channel + 1u), FTU_MEASURE_MODE_DUTY_CYCLE);
			FTU_HWA_ClearChannelPolarity(pFtu, (uint8_t)(1u << pMeasure->u8Channel));
		}
		else if (FTU_SIGNAL_MEASURE_PERIOD_RISING_EDGE == pMeasure->eMeasureMode)
		{
			FTU_HWA_ConfigChannelEdgeLevel(pFtu, pMeasure->u8Channel, FTU_CHANNEL_EDGE_RISING);
			FTU_HWA_ConfigChannelEdgeLevel(pFtu, (uint8_t)(pMeasure->u8Channel + 1u), FTU_CHANNEL_EDGE_NOT_USED);
			FTU_HWA_ConfigInputCaptureMeasureMode(pFtu, pMeasure->u8Channel, FTU_MEASURE_MODE_PERIOD);
			FTU_HWA_ConfigInputCaptureMeasureMode(pFtu, (uint8_t)(pMeasure->u8Channel + 1u), FTU_MEASURE_MODE_PERIOD);
		}
		else if (FTU_SIGNAL_MEASURE_PERIOD_FALLING_EDGE == pMeasure->eMeasureMode)
		{
			FTU_HWA_ConfigChannelEdgeLevel(pFtu, pMeasure->u8Channel, FTU_CHANNEL_EDGE_FALLING);
			FTU_HWA_ConfigChannelEdgeLevel(pFtu, (uint8_t)(pMeasure->u8Channel + 1u), FTU_CHANNEL_EDGE_NOT_USED);
			FTU_HWA_ConfigInputCaptureMeasureMode(pFtu, pMeasure->u8Channel, FTU_MEASURE_MODE_PERIOD);
			FTU_HWA_ConfigInputCaptureMeasureMode(pFtu, (uint8_t)(pMeasure->u8Channel + 1u), FTU_MEASURE_MODE_PERIOD);
		}

		if (FTU_MEASURE_CONTINUOUS_MODE == pMeasure->eContinuouslyMode)
		{
			FTU_HWA_EnableMeasureContinous(pFtu, pMeasure->u8Channel);
		}
		else
		{
			FTU_HWA_DisableMeasureContinous(pFtu, pMeasure->u8Channel);
		}

		if (FTU_MEASURE_START_IMMEDIATELY == pMeasure->eStartMode)
		{
			FTU_HWA_EnableMeasureStartImmd(pFtu, pMeasure->u8Channel);
		}
		else
		{
			FTU_HWA_DisableMeasureStartImmd(pFtu, pMeasure->u8Channel);
		}
#if FTU_DEV_ERROR_REPORT == STD_ON
	}
#endif
}
/**
 * @brief Re-start measurement when in single mode
 *
 * @param pFtuHandle FTU processing handle
 * @param u8Channel FTU channel number, range is 0-7.
 */
void FTU_SignalMeasureChannelSingle(FTU_HandleType *pFtuHandle, uint8_t u8Channel)
{
#if FTU_DEV_ERROR_REPORT == STD_ON
	if ((uint32_t)pFtuHandle->eInstance >= FTU_INSTANCE_COUNT)
	{
		FTU_ReportDevError(FTU_IC_SIG_MEAS_SINGLE_ID, FTU_E_PARAM_INSTANCE);
	}
	else if (u8Channel >= FTU_CHANNEL_CONTROLS_COUNT)
	{
		FTU_ReportDevError(FTU_IC_SIG_MEAS_SINGLE_ID, FTU_E_PARAM_CHANNEL);
	}
	else if ((u8Channel & 1u) != 0u)
	{
		FTU_ReportDevError(FTU_IC_SIG_MEAS_SINGLE_ID, FTU_E_PARAM_CHANNEL);
	}
	else
	{
#endif
		FTU_HWA_SingleMeasurement(s_pFtuBasePtrs[pFtuHandle->eInstance], u8Channel);
#if FTU_DEV_ERROR_REPORT == STD_ON
	}
#endif
}

/**
 * @brief Get the measurement result of the channel
 *
 * @param pFtuHandle FTU processing handle
 * @param u8Channel FTU channel number, range is 0-7.
 * @param pResult point to the result buffer.
 */
void FTU_GetSignalMeasureResult(FTU_HandleType *pFtuHandle, uint8_t u8Channel, FTU_SignalMeasureValueType *pResult)
{
#if FTU_DEV_ERROR_REPORT == STD_ON
	if ((uint32_t)pFtuHandle->eInstance >= FTU_INSTANCE_COUNT)
	{
		FTU_ReportDevError(FTU_IC_SIG_MEAS_GET_ID, FTU_E_PARAM_INSTANCE);
	}
	else if (u8Channel >= FTU_CHANNEL_CONTROLS_COUNT)
	{
		FTU_ReportDevError(FTU_IC_SIG_MEAS_GET_ID, FTU_E_PARAM_CHANNEL);
	}
	else if ((u8Channel & 1u) != 0u)
	{
		FTU_ReportDevError(FTU_IC_SIG_MEAS_GET_ID, FTU_E_PARAM_CHANNEL);
	}
	else
	{
#endif
		FTU_Type * const pFtu = s_pFtuBasePtrs[pFtuHandle->eInstance];

		FTU_MeasurementModeType eMeasureMode = FTU_HWA_GetMeasureMode(pFtu, u8Channel);
		if (FTU_MEASURE_MODE_DUTY_CYCLE == eMeasureMode)
		{
			if (FTU_HWA_GetChannelPolarity(pFtu, (uint8_t)(1u << u8Channel)))
			{
				pResult->u32StartTime = FTU_HWA_GetChannelValue(pFtu, u8Channel);
				pResult->u32EndTime = FTU_HWA_GetChannelValue(pFtu, (uint8_t)(u8Channel + 1u));
			}
			else
			{
				pResult->u32StartTime = FTU_HWA_GetChannelValue(pFtu, (uint8_t)(u8Channel + 1u));
				pResult->u32EndTime = FTU_HWA_GetChannelValue(pFtu, u8Channel);
			}
		}
		else if(FTU_MEASURE_MODE_PERIOD == eMeasureMode)
		{
			pResult->u32StartTime = FTU_HWA_GetChannelValue(pFtu, (uint8_t)(u8Channel + 1u));
			pResult->u32EndTime = FTU_HWA_GetChannelValue(pFtu, u8Channel);
		}
		else
		{
			pResult->u32StartTime = 0u;
			pResult->u32EndTime = 0u;
		}
#if FTU_DEV_ERROR_REPORT == STD_ON
	}
#endif
}
#endif

/**
 * @brief Interrupt IRQ handle of FTU instance
 *
 * @param eInstance the selected FTU instance
 */
void FTUn_IRQHandler(FTU_HandleType *pFtuHandle)
{
	FTU_Type *pFtu = s_pFtuBasePtrs[pFtuHandle->eInstance];
	uint32_t u32FaultFlag = 0u;
	uint8_t u8FaultEnable = FTU_HWA_ReadFaultIntrEnable(pFtu);
	uint8_t u8OverflowFlag = FTU_HWA_ReadModuleOverflowFlag(pFtu);
	uint8_t u8ReloadFlag = FTU_HWA_ReadReloadIntrEnable(pFtu);
	uint32_t u32Loop, u32ChannelIntrFlag = 0, u32TimeStamp;
    
	u8OverflowFlag = FTU_HWA_ReadModuleOverflowIntrEnable(pFtu) & u8OverflowFlag;
	u8ReloadFlag = FTU_HWA_ReadModuleReloadFlag(pFtu) & u8ReloadFlag;
	if(0u != u8FaultEnable)
	{
		u32FaultFlag = FTU_HWA_ReadModuleFaultFlag(pFtu);
	}

	/* Clear interrupt flag*/
	if (0u != u8OverflowFlag)
	{
		FTU_HWA_ClearOverflowFlag(pFtu);
	}
	if (0u != u8ReloadFlag)
	{
		FTU_HWA_ClearReloadFlag(pFtu);
	}

	for (u32Loop = 0U; u32Loop < FTU_CHANNEL_CONTROLS_COUNT; u32Loop++)
	{
		if ((0u != FTU_HWA_ReadChannelInterruptFlag(pFtu, (uint8_t)u32Loop)) &&
			(0u != FTU_HWA_ReadChannelInterruptEnableFlag(pFtu, (uint8_t)u32Loop)))
		{
			FTU_HWA_ClearChannelInterruptFlag(pFtu, (uint8_t)u32Loop);
			u32ChannelIntrFlag |= (uint8_t)(1u << u32Loop);
		}
	}

	/* call callback functions*/
	if ((0u != u8OverflowFlag) && (NULL != pFtuHandle->tStatus.pOverflowCallback))
	{
		pFtuHandle->tStatus.pOverflowCallback(pFtuHandle);
	}

	if ((0u != u8ReloadFlag) && (NULL != pFtuHandle->tStatus.pReloadPointCallback))
	{
		pFtuHandle->tStatus.pReloadPointCallback(pFtuHandle);
	}

	if ((0u != u32FaultFlag) && (NULL != pFtuHandle->tStatus.pFaultCallback))
	{
		uint32_t u32FaultInputCount = FTU_FAULT_INPUT_COUNT(s_pFtuBasePtrs[pFtuHandle->eInstance]);
		for (u32Loop = 0U; u32Loop < u32FaultInputCount; u32Loop++)
		{
			if (0u != (u32FaultFlag & ((uint32_t)1u << u32Loop)))
			{
				pFtuHandle->tStatus.pFaultCallback(pFtuHandle, u32Loop);
			}
		}
	}

	if ((0u != u32ChannelIntrFlag) && (NULL != pFtuHandle->tStatus.pChannelCallback))
	{
		for (u32Loop = 0U; u32Loop < FTU_CHANNEL_CONTROLS_COUNT; u32Loop++)
		{
			if (0u != (u32ChannelIntrFlag & ((uint32_t)1u << u32Loop)))
			{
				u32TimeStamp = FTU_HWA_GetChannelValue(pFtu, (uint8_t)u32Loop);
				pFtuHandle->tStatus.pChannelCallback(pFtuHandle, u32Loop, u32TimeStamp);
			}
		}
	}
}

#endif