HVAC_M7
/
PeripheralDriver_Flagchip_FC7240_V2
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
PeripheralDriver_Flagchip_F.../Src/module_driver_sddf.c

875 lines
32 KiB
C
Raw Blame History

/**
* @file module_driver_sddf.c
* @author Flagchip
* @brief Sigma Delta Digital Filter (SDDF) driver source code
* @version 2.0.0
* @date 2024-08-20
*
* SDK Version: 2.6.0
*
* @copyright Copyright (c) 2020-2024 Flagchip Semiconductors Co., Ltd.
*
*/
/* ********************************************************************************
* Revision History:
*
* Version Date Initials CR# Descriptions
* --------- ---------- ------------ ---------- ---------------
* 0.2.0 2023-02-07 Flagchip030 N/A First version for FC7300
******************************************************************************** */
#include "module_driver_sddf.h"
#include "HwA_scm.h"
#if SDDF_INSTANCE_COUNT > 0u
#ifndef SDDF_DEV_ERROR_REPORT
#define SDDF_DEV_ERROR_REPORT STD_OFF
#endif
#if SDDF_DEV_ERROR_REPORT == STD_ON
#define SDDF_ReportDevError(func, error) ReportDevError(SDDF_MODULE_ID, func, error)
#endif
static SDDF_Type *const s_apSddfBase[SDDF_INSTANCE_COUNT] = SDDF_BASE_PTRS;
static uint32_t *s_apSddfChannelBuffer[SDDF_INSTANCE_COUNT][SDDF_CH_CNT] = {NULL};
void SDDFn_IRQHandler(SDDF_HandleType *pHandle)
{
SDDF_InstanceType eInstance =pHandle->eInstance;
SDDF_Type *const pSddf = s_apSddfBase[eInstance];
uint8_t u8Channel = 0U;
while ((u8Channel < SDDF_CH_CNT) && (SDDF_HWA_GetNormalInterruptStatus(pSddf) != 0U))
{
if (SDDF_HWA_GetChannelZeroCrossDetectStatus(pSddf, u8Channel) == true)
{
SDDF_HWA_ClearChannelZeroCrossDetectStatus(pSddf, u8Channel);
if (pHandle->tSettings.Notifications[u8Channel].pZeroCrossDetectNotify != NULL)
{
pHandle->tSettings.Notifications[u8Channel].pZeroCrossDetectNotify(SDDF_ZERO_CROSS_EVENT);
}
}
if (SDDF_HWA_GetChannelFIFODataReadyStatus(pSddf, u8Channel) == true)
{
if (s_apSddfChannelBuffer[eInstance][u8Channel] != NULL)
{
uint8_t u8FIFODepth = (uint8_t)(SDDF_HWA_GetChannelFIFOWatermark(pSddf, u8Channel) + 1U);
uint8_t u8FIFOIdx = 0U;
for (u8FIFOIdx = 0U; u8FIFOIdx < u8FIFODepth; u8FIFOIdx++)
{
s_apSddfChannelBuffer[eInstance][u8Channel][u8FIFOIdx] = SDDF_HWA_GetChannelData(pSddf, u8Channel);
}
SDDF_HWA_ClearChannelFIFODataReadyStatus(pSddf, u8Channel);
if (pHandle->tSettings.Notifications[u8Channel].pFIFOReadyNotify != NULL)
{
pHandle->tSettings.Notifications[u8Channel].pFIFOReadyNotify(s_apSddfChannelBuffer[eInstance][u8Channel]);
}
}
}
if (SDDF_HWA_GetChannelConvCompleteStatus(pSddf, u8Channel) == true)
{
SDDF_HWA_ClearChannelConvCompleteStatus(pSddf, u8Channel);
if (pHandle->tSettings.Notifications[u8Channel].pConvCompleteNotify != NULL)
{
pHandle->tSettings.Notifications[u8Channel].pConvCompleteNotify();
}
}
u8Channel++;
}
u8Channel = 0U;
while ((u8Channel < SDDF_CH_CNT) && (SDDF_HWA_GetAbnormalInterruptStatus0(pSddf) != 0U))
{
if (SDDF_HWA_GetChannelLowLimitStatus(pSddf, u8Channel) == true)
{
SDDF_HWA_ClearChannelLowLimitStatus(pSddf, u8Channel);
if (pHandle->tSettings.Notifications[u8Channel].pLimitCheckNotify != NULL)
{
pHandle->tSettings.Notifications[u8Channel].pLimitCheckNotify(SDDF_LOW_LIMIT_EVENT);
}
}
if (SDDF_HWA_GetChannelHighLimitStatus(pSddf, u8Channel) == true)
{
SDDF_HWA_ClearChannelHighLimitStatus(pSddf, u8Channel);
if (pHandle->tSettings.Notifications[u8Channel].pLimitCheckNotify != NULL)
{
pHandle->tSettings.Notifications[u8Channel].pLimitCheckNotify(SDDF_HIGH_LIMIT_EVENT);
}
}
if (SDDF_HWA_GetChannelWindowLimitStatus(pSddf, u8Channel) == true)
{
SDDF_HWA_ClearChannelWindowLimitStatus(pSddf, u8Channel);
if (pHandle->tSettings.Notifications[u8Channel].pLimitCheckNotify != NULL)
{
pHandle->tSettings.Notifications[u8Channel].pLimitCheckNotify(SDDF_WINDOW_LIMIT_EVENT);
}
}
if (SDDF_HWA_GetChannelShortCircuitDetectStatus(pSddf, u8Channel) == true)
{
SDDF_HWA_ClearChannelShortCircuitDetectStatus(pSddf, u8Channel);
if (pHandle->tSettings.Notifications[u8Channel].pShortCircuitDetectNotify != NULL)
{
pHandle->tSettings.Notifications[u8Channel].pShortCircuitDetectNotify(SDDF_SHORT_CIRCUIT_EVENT);
}
}
u8Channel++;
}
u8Channel = 0U;
while ((u8Channel < SDDF_CH_CNT) && (SDDF_HWA_GetAbnormalInterruptStatus1(pSddf) != 0U))
{
if (SDDF_HWA_GetChannelClockAbsenceStatus(pSddf, u8Channel) == true)
{
SDDF_HWA_ClearChannelClockAbsenceStatus(pSddf, u8Channel);
if (pHandle->tSettings.Notifications[u8Channel].pClockAbsenceDetectNotify != NULL)
{
pHandle->tSettings.Notifications[u8Channel].pClockAbsenceDetectNotify(SDDF_CLOCK_ABSENCE_EVENT);
}
}
if (SDDF_HWA_GetChannelSaturationStatus(pSddf, u8Channel) == true)
{
SDDF_HWA_ClearChannelSaturationStatus(pSddf, u8Channel);
if (pHandle->tSettings.Notifications[u8Channel].pDataSaturationNotify != NULL)
{
pHandle->tSettings.Notifications[u8Channel].pDataSaturationNotify();
}
}
if (SDDF_HWA_GetChannelFIFOUnderflowStatus(pSddf, u8Channel) == true)
{
SDDF_HWA_ClearChannelFIFOUnderflowStatus(pSddf, u8Channel);
if (pHandle->tSettings.Notifications[u8Channel].pUnderflowNotify != NULL)
{
pHandle->tSettings.Notifications[u8Channel].pUnderflowNotify();
}
}
if (SDDF_HWA_GetChannelFIFOOverflowStatus(pSddf, u8Channel) == true)
{
SDDF_HWA_ClearChannelFIFOOverflowStatus(pSddf, u8Channel);
if (pHandle->tSettings.Notifications[u8Channel].pOverflowNotify != NULL)
{
pHandle->tSettings.Notifications[u8Channel].pOverflowNotify();
}
}
u8Channel++;
}
}
void SDDFn_CHnDMAHandler(SDDF_HandleType *pHandle, uint8_t u8Channel)
{
SDDF_InstanceType eInstance =pHandle->eInstance;
SDDF_Type *const pSddf = s_apSddfBase[eInstance];
if (SDDF_HWA_GetChannelFIFODataReadyStatus(pSddf, u8Channel) == true)
{
SDDF_HWA_ClearChannelFIFODataReadyStatus(pSddf, u8Channel);
}
if (pHandle->tSettings.Notifications[u8Channel].pDMAReadyNotify != NULL)
{
pHandle->tSettings.Notifications[u8Channel].pDMAReadyNotify(s_apSddfChannelBuffer[eInstance][u8Channel]);
}
}
void SDDF_DeInit(SDDF_HandleType *pHandle)
{
#if SDDF_DEV_ERROR_REPORT == STD_ON
if (pHandle == NULL)
{
SDDF_ReportDevError(SDDF_DEINIT_ID, SDDF_E_PARAM_POINTER);
}
else if(pHandle->eInstance >= SDDF_INSTANCE_COUNT)
{
SDDF_ReportDevError(SDDF_DEINIT_ID, SDDF_E_PARAM_INSTANCE);
}
else
{
#endif
SDDF_InstanceType eInstance =pHandle->eInstance;
SDDF_Type *const pSddf = s_apSddfBase[eInstance];
SDDF_HWA_MainDisable(pSddf);
SDDF_HWA_Reset(pSddf);
SDDF_HWA_ClearNormalInterruptStatus(pSddf);
SDDF_HWA_ClearAbnormalInterruptStatus0(pSddf);
SDDF_HWA_ClearAbnormalInterruptStatus1(pSddf);
SDDF_HWA_SetCtrl(pSddf, 0U);
#if SDDF_DEV_ERROR_REPORT == STD_ON
}
#endif
}
void SDDF_Init(SDDF_HandleType *pHandle, const SDDF_InitConfigType *pInitCfg)
{
#if SDDF_DEV_ERROR_REPORT == STD_ON
if (pHandle == NULL)
{
SDDF_ReportDevError(SDDF_INIT_ID, SDDF_E_PARAM_POINTER);
}
else if(pHandle->eInstance >= SDDF_INSTANCE_COUNT)
{
SDDF_ReportDevError(SDDF_INIT_ID, SDDF_E_PARAM_INSTANCE);
}
else if(pInitCfg == NULL)
{
SDDF_ReportDevError(SDDF_INIT_ID, SDDF_E_PARAM_POINTER);
}
else
{
#endif
SDDF_InstanceType eInstance =pHandle->eInstance;
SDDF_Type *const pSddf = s_apSddfBase[eInstance];
uint32_t u32Ctrl;
SDDF_DeInit(pHandle);
u32Ctrl = SDDF_CTRL_PRESCALE(pInitCfg->ePreDiv) | SDDF_CTRL_MCLK_DIV(pInitCfg->u16Div);
SDDF_HWA_SetCtrl(pSddf, u32Ctrl);
#if SDDF_DEV_ERROR_REPORT == STD_ON
}
#endif
}
void SDDF_ConfigClockOut(SDDF_HandleType *pHandle, const SDDF_ClockOutConfigType *pClockOutCfg)
{
#if SDDF_DEV_ERROR_REPORT == STD_ON
if (pHandle == NULL)
{
SDDF_ReportDevError(SDDF_CFG_CLK_OUT_ID, SDDF_E_PARAM_POINTER);
}
else if(pHandle->eInstance >= SDDF_INSTANCE_COUNT)
{
SDDF_ReportDevError(SDDF_CFG_CLK_OUT_ID, SDDF_E_PARAM_INSTANCE);
}
else if(pClockOutCfg == NULL)
{
SDDF_ReportDevError(SDDF_CFG_CLK_OUT_ID, SDDF_E_PARAM_POINTER);
}
else
{
#endif
SDDF_InstanceType eInstance =pHandle->eInstance;
SDDF_Type *const pSddf = s_apSddfBase[eInstance];
uint32_t u32Ctrl = (SDDF_HWA_GetCtrl(pSddf) & ~(SDDF_CTRL_CLKO0_DIS_MASK | SDDF_CTRL_CLKO1_DIS_MASK | SDDF_CTRL_CLKO2_DIS_MASK)) |
SDDF_CTRL_CLKO0_DIS(!pClockOutCfg->bClockOut0Enable) | SDDF_CTRL_CLKO1_DIS(!pClockOutCfg->bClockOut1Enable) |
SDDF_CTRL_CLKO2_DIS(!pClockOutCfg->bClockOut2Enable);
SDDF_HWA_SetCtrl(pSddf, u32Ctrl);
// SCM_HWA_SetClkOutSel_SDDF_CH0((SCM_SDDF_ClkOutSelType)pClockOutCfg->eClk0Src);
// SCM_HWA_SetClkOutSel_SDDF_CH1((SCM_SDDF_ClkOutSelType)pClockOutCfg->eClk1Src);
// SCM_HWA_SetClkOutSel_SDDF_CH2((SCM_SDDF_ClkOutSelType)pClockOutCfg->eClk2Src);
// SCM_HWA_SetClkOutSel_SDDF_CH3((SCM_SDDF_ClkOutSelType)pClockOutCfg->eClk3Src);
#if SDDF_DEV_ERROR_REPORT == STD_ON
}
#endif
}
void SDDF_Enable(SDDF_HandleType *pHandle)
{
#if SDDF_DEV_ERROR_REPORT == STD_ON
if (pHandle == NULL)
{
SDDF_ReportDevError(SDDF_ENABLE_ID, SDDF_E_PARAM_POINTER);
}
else if(pHandle->eInstance >= SDDF_INSTANCE_COUNT)
{
SDDF_ReportDevError(SDDF_ENABLE_ID, SDDF_E_PARAM_INSTANCE);
}
else
{
#endif
SDDF_InstanceType eInstance =pHandle->eInstance;
SDDF_Type *const pSddf = s_apSddfBase[eInstance];
SDDF_HWA_MainEnable(pSddf);
#if SDDF_DEV_ERROR_REPORT == STD_ON
}
#endif
}
void SDDF_Disable(SDDF_HandleType *pHandle)
{
#if SDDF_DEV_ERROR_REPORT == STD_ON
if (pHandle == NULL)
{
SDDF_ReportDevError(SDDF_DISABLE_ID, SDDF_E_PARAM_POINTER);
}
else if(pHandle->eInstance >= SDDF_INSTANCE_COUNT)
{
SDDF_ReportDevError(SDDF_DISABLE_ID, SDDF_E_PARAM_INSTANCE);
}
else
{
#endif
SDDF_InstanceType eInstance =pHandle->eInstance;
SDDF_Type *const pSddf = s_apSddfBase[eInstance];
SDDF_HWA_MainDisable(pSddf);
#if SDDF_DEV_ERROR_REPORT == STD_ON
}
#endif
}
void SDDF_EnableDebugMode(SDDF_HandleType *pHandle, SDDF_DebugModuleEnableType eModuleEnable)
{
#if SDDF_DEV_ERROR_REPORT == STD_ON
if (pHandle == NULL)
{
SDDF_ReportDevError(SDDF_EN_DBG_MODE_ID, SDDF_E_PARAM_POINTER);
}
else if(pHandle->eInstance >= SDDF_INSTANCE_COUNT)
{
SDDF_ReportDevError(SDDF_EN_DBG_MODE_ID, SDDF_E_PARAM_INSTANCE);
}
else
{
#endif
SDDF_InstanceType eInstance =pHandle->eInstance;
SDDF_Type *const pSddf = s_apSddfBase[eInstance];
uint32_t u32Ctrl = (SDDF_HWA_GetCtrl(pSddf) & ~(SDDF_CTRL_DBG_MODE_MASK | SDDF_CTRL_DBG_EN_MASK)) | SDDF_CTRL_DBG_MODE(true) | SDDF_CTRL_DBG_EN(eModuleEnable);
SDDF_HWA_SetCtrl(pSddf, u32Ctrl);
#if SDDF_DEV_ERROR_REPORT == STD_ON
}
#endif
}
void SDDF_DisableDebugMode(SDDF_HandleType *pHandle)
{
#if SDDF_DEV_ERROR_REPORT == STD_ON
if (pHandle == NULL)
{
SDDF_ReportDevError(SDDF_DIS_DBG_MODE_ID, SDDF_E_PARAM_POINTER);
}
else if(pHandle->eInstance >= SDDF_INSTANCE_COUNT)
{
SDDF_ReportDevError(SDDF_DIS_DBG_MODE_ID, SDDF_E_PARAM_INSTANCE);
}
else
{
#endif
SDDF_InstanceType eInstance =pHandle->eInstance;
SDDF_Type *const pSddf = s_apSddfBase[eInstance];
uint32_t u32Ctrl = SDDF_HWA_GetCtrl(pSddf) & ~(SDDF_CTRL_DBG_MODE_MASK | SDDF_CTRL_DBG_EN_MASK);
SDDF_HWA_SetCtrl(pSddf, u32Ctrl);
#if SDDF_DEV_ERROR_REPORT == STD_ON
}
#endif
}
void SDDF_InitChannel(SDDF_HandleType *pHandle, uint8_t u8Channel, const SDDF_ChannelConfigType *pChannelCfg)
{
#if SDDF_DEV_ERROR_REPORT == STD_ON
if (pHandle == NULL)
{
SDDF_ReportDevError(SDDF_INIT_CH_ID, SDDF_E_PARAM_POINTER);
}
else if(pHandle->eInstance >= SDDF_INSTANCE_COUNT)
{
SDDF_ReportDevError(SDDF_INIT_CH_ID, SDDF_E_PARAM_INSTANCE);
}
else if(u8Channel >= SDDF_CH_CNT)
{
SDDF_ReportDevError(SDDF_INIT_CH_ID, SDDF_E_PARAM_CHANNEL);
}
else if(pChannelCfg == NULL)
{
SDDF_ReportDevError(SDDF_INIT_CH_ID, SDDF_E_PARAM_POINTER);
}
else if(pChannelCfg->bMainFilterEnable && pChannelCfg->pMainFilterConfig==NULL)
{
SDDF_ReportDevError(SDDF_INIT_CH_ID, SDDF_E_PARAM_MAIN_FILTER);
}
else if(pChannelCfg->bAuxiliaryFilterEnable && pChannelCfg->pAuxiliaryFilterConfig == NULL)
{
SDDF_ReportDevError(SDDF_INIT_CH_ID, SDDF_E_PARAM_AUX_FILTER);
}
else
{
#endif
SDDF_InstanceType eInstance =pHandle->eInstance;
SDDF_Type *const pSddf = s_apSddfBase[eInstance];
uint32_t u32ChannelConfig;
uint32_t u32ChannelDataRate;
u32ChannelConfig = SDDF_CFR_TRGLVL(pChannelCfg->eTriggerEvent) | SDDF_CFR_TRGSEL(pChannelCfg->eTriggerSrc) | SDDF_CFR_CLKEDG(pChannelCfg->eInputClockEdge) |
SDDF_CFR_CLKSEL(SDDF_CLOCK_SRC_EXTERNAL_MODULATOR_CLOCK) | SDDF_CFR_IBFMT(pChannelCfg->eBitFormat) | SDDF_CFR_RDFMT(pChannelCfg->eResultFormat) |
SDDF_CFR_FWMK(pChannelCfg->u8FIFOWatermark - 1U);
SDDF_HWA_SetChannelConfig(pSddf, u8Channel, u32ChannelConfig);
switch (u8Channel)
{
case 0U:
{
// SCM_HWA_SetClkInSel_SDDF_CH0((SCM_SDDF_ClkInSelType)pChannelCfg->eInputClockSrc);
break;
}
case 1U:
{
// SCM_HWA_SetClkInSel_SDDF_CH1((SCM_SDDF_ClkInSelType)pChannelCfg->eInputClockSrc);
break;
}
case 2U:
{
// SCM_HWA_SetClkInSel_SDDF_CH2((SCM_SDDF_ClkInSelType)pChannelCfg->eInputClockSrc);
break;
}
case 3U:
{
// SCM_HWA_SetClkInSel_SDDF_CH3((SCM_SDDF_ClkInSelType)pChannelCfg->eInputClockSrc);
break;
}
default:
break;
}
SDDF_HWA_SetChannelFIFOEnableFlag(pSddf, u8Channel, pChannelCfg->bFIFOEnable);
if (pChannelCfg->bMainFilterEnable == true)
{
const SDDF_MainFilterConfigType *pMainCfg = pChannelCfg->pMainFilterConfig;
u32ChannelDataRate = (SDDF_HWA_GetChannelDataRate(pSddf, u8Channel) & ~(SDDF_CDR_MFOSR_MASK | SDDF_CDR_MFORD_MASK | SDDF_CDR_MFCM_MASK)) |
SDDF_CDR_MFOSR(pMainCfg->u16OverSamplingRate) | SDDF_CDR_MFORD(pMainCfg->eFilterOrder) | SDDF_CDR_MFCM(pMainCfg->eConvMode);
SDDF_HWA_SetChannelDataRate(pSddf, u8Channel, u32ChannelDataRate);
SDDF_HWA_SetChannelMainFilterShift(pSddf, u8Channel, pMainCfg->eShift);
SDDF_HWA_SetChannelBias(pSddf, u8Channel, pMainCfg->s32Bias);
SDDF_HWA_SetChannelMainFilterEnableFlag(pSddf, u8Channel, true);
}
else
{
SDDF_HWA_SetChannelMainFilterEnableFlag(pSddf, u8Channel, false);
}
if (pChannelCfg->bAuxiliaryFilterEnable == true)
{
const SDDF_AuxFilterConfigType *pAuxCfg = pChannelCfg->pAuxiliaryFilterConfig;
u32ChannelDataRate = (SDDF_HWA_GetChannelDataRate(pSddf, u8Channel) & ~(SDDF_CDR_AFOSR_MASK | SDDF_CDR_AFORD_MASK | SDDF_CDR_AFCM_MASK)) |
SDDF_CDR_AFOSR(pAuxCfg->u16OverSamplingRate) | SDDF_CDR_AFORD(pAuxCfg->eFilterOrder) | SDDF_CDR_AFCM(pAuxCfg->eConvMode);
SDDF_HWA_SetChannelDataRate(pSddf, u8Channel, u32ChannelDataRate);
SDDF_HWA_SetChannelAuxiliaryFilterEnableFlag(pSddf, u8Channel, true);
}
else
{
SDDF_HWA_SetChannelAuxiliaryFilterEnableFlag(pSddf, u8Channel, false);
}
#if SDDF_DEV_ERROR_REPORT == STD_ON
}
#endif
}
void SDDF_ChannelEnable(SDDF_HandleType *pHandle, uint8_t u8Channel)
{
#if SDDF_DEV_ERROR_REPORT == STD_ON
if (pHandle == NULL)
{
SDDF_ReportDevError(SDDF_CH_ENABLE_ID, SDDF_E_PARAM_POINTER);
}
else if(pHandle->eInstance >= SDDF_INSTANCE_COUNT)
{
SDDF_ReportDevError(SDDF_CH_ENABLE_ID, SDDF_E_PARAM_INSTANCE);
}
else if(u8Channel >= SDDF_CH_CNT)
{
SDDF_ReportDevError(SDDF_CH_ENABLE_ID, SDDF_E_PARAM_CHANNEL);
}
else
{
#endif
SDDF_InstanceType eInstance =pHandle->eInstance;
SDDF_Type *const pSddf = s_apSddfBase[eInstance];
SDDF_HWA_SetChannelEnableFlag(pSddf, u8Channel, true);
#if SDDF_DEV_ERROR_REPORT == STD_ON
}
#endif
}
void SDDF_ChannelDisable(SDDF_HandleType *pHandle, uint8_t u8Channel)
{
#if SDDF_DEV_ERROR_REPORT == STD_ON
if (pHandle == NULL)
{
SDDF_ReportDevError(SDDF_CH_DISABLE_ID, SDDF_E_PARAM_POINTER);
}
else if(pHandle->eInstance >= SDDF_INSTANCE_COUNT)
{
SDDF_ReportDevError(SDDF_CH_DISABLE_ID, SDDF_E_PARAM_INSTANCE);
}
else if(u8Channel >= SDDF_CH_CNT)
{
SDDF_ReportDevError(SDDF_CH_DISABLE_ID, SDDF_E_PARAM_CHANNEL);
}
else
{
#endif
SDDF_InstanceType eInstance =pHandle->eInstance;
SDDF_Type *const pSddf = s_apSddfBase[eInstance];
SDDF_HWA_SetChannelEnableFlag(pSddf, u8Channel, false);
#if SDDF_DEV_ERROR_REPORT == STD_ON
}
#endif
}
void SDDF_ConfigChannelInterrupt(SDDF_HandleType *pHandle, uint8_t u8Channel, const SDDF_ChannelInterruptConfigType *pIntCfg)
{
#if SDDF_DEV_ERROR_REPORT == STD_ON
if (pHandle == NULL)
{
SDDF_ReportDevError(SDDF_CFG_CH_INT_ID, SDDF_E_PARAM_POINTER);
}
else if(pHandle->eInstance >= SDDF_INSTANCE_COUNT)
{
SDDF_ReportDevError(SDDF_CFG_CH_INT_ID, SDDF_E_PARAM_INSTANCE);
}
else if(u8Channel >= SDDF_CH_CNT)
{
SDDF_ReportDevError(SDDF_CFG_CH_INT_ID, SDDF_E_PARAM_CHANNEL);
}
else if(pIntCfg == NULL)
{
SDDF_ReportDevError(SDDF_CFG_CH_INT_ID, SDDF_E_PARAM_POINTER);
}
else
{
#endif
SDDF_InstanceType eInstance =pHandle->eInstance;
SDDF_Type *const pSddf = s_apSddfBase[eInstance];
if (pIntCfg->bConversionCompleteIntEnable == true)
{
SDDF_HWA_SetChannelConvCompleteIntEnableFlag(pSddf, u8Channel, true);
pHandle->tSettings.Notifications[u8Channel].pConvCompleteNotify = pIntCfg->pConvCompleteNotify;
}
else
{
SDDF_HWA_SetChannelConvCompleteIntEnableFlag(pSddf, u8Channel, false);
pHandle->tSettings.Notifications[u8Channel].pConvCompleteNotify = NULL;
}
if (pIntCfg->bFIFOReadyIntEnable == true)
{
SDDF_HWA_SetChannelFIFODataReadyIntEnableFlag(pSddf, u8Channel, true);
pHandle->tSettings.Notifications[u8Channel].pFIFOReadyNotify = pIntCfg->pFIFOReadyNotify;
s_apSddfChannelBuffer[eInstance][u8Channel] = pIntCfg->pResultBuffer;
}
else
{
SDDF_HWA_SetChannelFIFODataReadyIntEnableFlag(pSddf, u8Channel, true);
pHandle->tSettings.Notifications[u8Channel].pFIFOReadyNotify = NULL;
s_apSddfChannelBuffer[eInstance][u8Channel] = NULL;
}
#if SDDF_DEV_ERROR_REPORT == STD_ON
}
#endif
}
void SDDF_ConfigChannelDMA(SDDF_HandleType *pHandle, uint8_t u8Channel, const SDDF_ChannelDMAConfigType *pDMACfg, DMA_TransferCompleteCallbackType pDmaCallback)
{
#if SDDF_DEV_ERROR_REPORT == STD_ON
if (pHandle == NULL)
{
SDDF_ReportDevError(SDDF_CFG_CH_DMA_ID, SDDF_E_PARAM_POINTER);
}
else if(pHandle->eInstance >= SDDF_INSTANCE_COUNT)
{
SDDF_ReportDevError(SDDF_CFG_CH_DMA_ID, SDDF_E_PARAM_INSTANCE);
}
else if(u8Channel >= SDDF_CH_CNT)
{
SDDF_ReportDevError(SDDF_CFG_CH_DMA_ID, SDDF_E_PARAM_CHANNEL);
}
else if(pDMACfg == NULL)
{
SDDF_ReportDevError(SDDF_CFG_CH_DMA_ID, SDDF_E_PARAM_POINTER);
}
else
{
#endif
SDDF_InstanceType eInstance =pHandle->eInstance;
SDDF_Type *const pSddf = s_apSddfBase[eInstance];
if (pDMACfg->bDMAEnable == true)
{
DMA_ChannelCfgType tDmaCfg;
uint8_t u8FIFODepth = (uint8_t)(SDDF_HWA_GetChannelFIFOWatermark(pSddf, u8Channel) + 1U);
s_apSddfChannelBuffer[eInstance][u8Channel] = pDMACfg->pResultBuffer;
pHandle->tSettings.Notifications[u8Channel].pDMAReadyNotify = pDMACfg->pDMAReadyNotify;
tDmaCfg.pSrcBuffer = &pSddf->CH[u8Channel].CRDATA;
tDmaCfg.pDestBuffer = pDMACfg->pResultBuffer;
tDmaCfg.u32BlockSize = 4U * u8FIFODepth;
tDmaCfg.u16BlockCount = 1U;
tDmaCfg.eSrcIncMode = DMA_INCREMENT_DISABLE;
tDmaCfg.eDestIncMode = DMA_INCREMENT_DATA_SIZE;
tDmaCfg.eSrcDataSize = DMA_TRANSFER_SIZE_4B;
tDmaCfg.eDestDataSize = DMA_TRANSFER_SIZE_4B;
tDmaCfg.u8ChannelPriority = pDMACfg->u8ChannelPriority;
tDmaCfg.bSrcBlockOffsetEn = false;
tDmaCfg.bDestBlockOffsetEn = false;
tDmaCfg.s32BlockOffset = 0;
tDmaCfg.bSrcAddrLoopbackEn = true;
tDmaCfg.bDestAddrLoopbackEn = true;
tDmaCfg.bAutoStop = false;
tDmaCfg.bSrcCircularBufferEn = false;
tDmaCfg.u32SrcCircBufferSize = DMA_CIRCULAR_BUFFER_SIZE_1B;
tDmaCfg.bDestCircularBufferEn = false;
tDmaCfg.u32DestCircBufferSize = DMA_CIRCULAR_BUFFER_SIZE_1B;
if (u8Channel == 0U)
{
tDmaCfg.eTriggerSrc = DMA_REQ_SDDF_CH0;
}
else if (u8Channel == 1U)
{
tDmaCfg.eTriggerSrc = DMA_REQ_SDDF_CH1;
}
else if (u8Channel == 2U)
{
tDmaCfg.eTriggerSrc = DMA_REQ_SDDF_CH2;
}
else if (u8Channel == 3U)
{
tDmaCfg.eTriggerSrc = DMA_REQ_SDDF_CH3;
}
else {}
tDmaCfg.bTransferCompleteIntEn = true;
tDmaCfg.pTransferCompleteNotify = pDmaCallback;
// tDmaCfg.bTransferErrorIntEn[0] = false;
// tDmaCfg.pTransferErrorNotify[0] = NULL;
SDDF_HWA_SetChannelDMAEnableFlag(pSddf, u8Channel, true);
DMA_InitChannel(pDMACfg->pDmahandle, &tDmaCfg);
DMA_InitChannelInterrupt(pDMACfg->pDmahandle, &tDmaCfg);
}
else
{
SDDF_HWA_SetChannelDMAEnableFlag(pSddf, u8Channel, false);
}
#if SDDF_DEV_ERROR_REPORT == STD_ON
}
#endif
}
void SDDF_ConfigChannelClockAbsenceDetect(SDDF_HandleType *pHandle, uint8_t u8Channel, SDDF_ClockAbsenceDetectConfigType *pConfig)
{
#if SDDF_DEV_ERROR_REPORT == STD_ON
if (pHandle == NULL)
{
SDDF_ReportDevError(SDDF_CFG_CH_CLK_ABS_DET_ID, SDDF_E_PARAM_POINTER);
}
else if(pHandle->eInstance >= SDDF_INSTANCE_COUNT)
{
SDDF_ReportDevError(SDDF_CFG_CH_CLK_ABS_DET_ID, SDDF_E_PARAM_INSTANCE);
}
else if(u8Channel >= SDDF_CH_CNT)
{
SDDF_ReportDevError(SDDF_CFG_CH_CLK_ABS_DET_ID, SDDF_E_PARAM_CHANNEL);
}
else if(pConfig == NULL)
{
SDDF_ReportDevError(SDDF_CFG_CH_CLK_ABS_DET_ID, SDDF_E_PARAM_POINTER);
}
else
{
#endif
SDDF_InstanceType eInstance =pHandle->eInstance;
SDDF_Type *const pSddf = s_apSddfBase[eInstance];
uint32_t u32ChannelProtection = (SDDF_HWA_GetChannelProtectionConfig(pSddf, u8Channel) & ~(SDDF_CPR_CADLMT_MASK | SDDF_CPR_CAD_BKEN_MASK)) |
SDDF_CPR_CADLMT(pConfig->u8ClockAbsenceDetectThreshold) | SDDF_CPR_CAD_BKEN(pConfig->bClockAbsenceDetectBreakEnable);
SDDF_HWA_SetChannelProtectionConfig(pSddf, u8Channel, u32ChannelProtection);
if (pConfig->bClockAbsenceDetectIntEnable == true)
{
SDDF_HWA_SetChannelClockAbsenceIntEnableFlag(pSddf, u8Channel, true);
pHandle->tSettings.Notifications[u8Channel].pClockAbsenceDetectNotify = pConfig->pClockAbsenceDetectNotify;
}
else
{
SDDF_HWA_SetChannelClockAbsenceIntEnableFlag(pSddf, u8Channel, false);
pHandle->tSettings.Notifications[u8Channel].pClockAbsenceDetectNotify = NULL;
}
SDDF_HWA_SetChannelClockAbsenceDetectEnableFlag(pSddf, u8Channel, pConfig->bClockAbsenceDetectEnable);
#if SDDF_DEV_ERROR_REPORT == STD_ON
}
#endif
}
void SDDF_ConfigChannelShortCircuitDetect(SDDF_HandleType *pHandle, uint8_t u8Channel, SDDF_ShortCircuitDetectConfigType *pConfig)
{
#if SDDF_DEV_ERROR_REPORT == STD_ON
if (pHandle == NULL)
{
SDDF_ReportDevError(SDDF_CFG_CH_SHORT_CIR_DET_ID, SDDF_E_PARAM_POINTER);
}
else if(pHandle->eInstance >= SDDF_INSTANCE_COUNT)
{
SDDF_ReportDevError(SDDF_CFG_CH_SHORT_CIR_DET_ID, SDDF_E_PARAM_INSTANCE);
}
else if(u8Channel >= SDDF_CH_CNT)
{
SDDF_ReportDevError(SDDF_CFG_CH_SHORT_CIR_DET_ID, SDDF_E_PARAM_CHANNEL);
}
else if(pConfig == NULL)
{
SDDF_ReportDevError(SDDF_CFG_CH_SHORT_CIR_DET_ID, SDDF_E_PARAM_POINTER);
}
else
{
#endif
SDDF_InstanceType eInstance =pHandle->eInstance;
SDDF_Type *const pSddf = s_apSddfBase[eInstance];
uint32_t u32ChannelProtection =
(SDDF_HWA_GetChannelProtectionConfig(pSddf, u8Channel) & ~(SDDF_CPR_SCDOPT_MASK | SDDF_CPR_SCDCM_MASK | SDDF_CPR_SCDLMT_MASK | SDDF_CPR_SCD_BKEN_MASK)) |
SDDF_CPR_SCDOPT(pConfig->eShortCircuitDetectOption) | SDDF_CPR_SCDCM(pConfig->eShortCircuitDetectMode) | SDDF_CPR_SCDLMT(pConfig->u8ShortCircuitDetectThreshold) |
SDDF_CPR_SCD_BKEN(pConfig->bShortCircuitDetectBreakEnable);
SDDF_HWA_SetChannelProtectionConfig(pSddf, u8Channel, u32ChannelProtection);
if (pConfig->bShortCircuitDetectIntEnable == true)
{
SDDF_HWA_SetChannelShortCircuitDetectIntEnableFlag(pSddf, u8Channel, true);
pHandle->tSettings.Notifications[u8Channel].pShortCircuitDetectNotify = pConfig->pShortCircuitDetectNotify;
}
else
{
SDDF_HWA_SetChannelShortCircuitDetectIntEnableFlag(pSddf, u8Channel, false);
pHandle->tSettings.Notifications[u8Channel].pShortCircuitDetectNotify = NULL;
}
SDDF_HWA_SetChannelShortCircuitDetectEnableFlag(pSddf, u8Channel, pConfig->bShortCircuitDetectEnable);
#if SDDF_DEV_ERROR_REPORT == STD_ON
}
#endif
}
void SDDF_ConfigChannelLimitCheck(SDDF_HandleType *pHandle, uint8_t u8Channel, SDDF_LimitCheckConfigType *pConfig)
{
#if SDDF_DEV_ERROR_REPORT == STD_ON
if (pHandle == NULL)
{
SDDF_ReportDevError(SDDF_CFG_CH_LIM_CHK_ID, SDDF_E_PARAM_POINTER);
}
else if(pHandle->eInstance >= SDDF_INSTANCE_COUNT)
{
SDDF_ReportDevError(SDDF_CFG_CH_LIM_CHK_ID, SDDF_E_PARAM_INSTANCE);
}
else if(u8Channel >= SDDF_CH_CNT)
{
SDDF_ReportDevError(SDDF_CFG_CH_LIM_CHK_ID, SDDF_E_PARAM_CHANNEL);
}
else if(pConfig == NULL)
{
SDDF_ReportDevError(SDDF_CFG_CH_LIM_CHK_ID, SDDF_E_PARAM_POINTER);
}
else
{
#endif
SDDF_InstanceType eInstance =pHandle->eInstance;
SDDF_Type *const pSddf = s_apSddfBase[eInstance];
uint32_t u32ChannelProtection =
(SDDF_HWA_GetChannelProtectionConfig(pSddf, u8Channel) & ~(SDDF_CPR_LMTOPT_MASK | SDDF_CPR_LLMT_BKEN_MASK | SDDF_CPR_HLMT_BKEN_MASK | SDDF_CPR_WLMT_BKEN_MASK)) |
SDDF_CPR_LMTOPT(pConfig->eLimitCheckOption) | SDDF_CPR_LLMT_BKEN(pConfig->bLowLimitBreakEnable) | SDDF_CPR_HLMT_BKEN(pConfig->bHighLimitBreakEnable) |
SDDF_CPR_WLMT_BKEN(pConfig->bWindowLimitBreakEnable);
SDDF_HWA_SetChannelProtectionConfig(pSddf, u8Channel, u32ChannelProtection);
SDDF_HWA_SetChannelLimitCheckInputSrc(pSddf, u8Channel, pConfig->eLimitCheckInputSrc);
SDDF_HWA_SetChannelLowLimit(pSddf, u8Channel, pConfig->u32LowLimit);
SDDF_HWA_SetChannelHighLimit(pSddf, u8Channel, pConfig->u32HighLimit);
if ((pConfig->bLowLimitIntEnable == true) || (pConfig->bHighLimitIntEnable == true) || (pConfig->bWindowLimitBreakEnable == true))
{
uint32_t u32AbnormalIntEn0 = (SDDF_HWA_GetAbnormalInterruptEnable0(pSddf) &
~((SDDF_ABNIER0_LLMTIE0_MASK << u8Channel) | (SDDF_ABNIER0_HLMTIE0_MASK << u8Channel) | (SDDF_ABNIER0_WLMTIE0_MASK << u8Channel))) |
(SDDF_ABNIER0_LLMTIE0(pConfig->bLowLimitIntEnable) << u8Channel) | (SDDF_ABNIER0_HLMTIE0(pConfig->bHighLimitIntEnable) << u8Channel) |
(SDDF_ABNIER0_WLMTIE0(pConfig->bWindowLimitIntEnable) << u8Channel);
SDDF_HWA_SetAbnormalInterruptEnable0(pSddf, u32AbnormalIntEn0);
pHandle->tSettings.Notifications[u8Channel].pLimitCheckNotify = pConfig->pLimitCheckNotify;
}
else
{
uint32_t u32AbnormalIntEn0 = (SDDF_HWA_GetAbnormalInterruptEnable0(pSddf) &
~((SDDF_ABNIER0_LLMTIE0_MASK << u8Channel) | (SDDF_ABNIER0_HLMTIE0_MASK << u8Channel) | (SDDF_ABNIER0_WLMTIE0_MASK << u8Channel))) |
(SDDF_ABNIER0_LLMTIE0(pConfig->bLowLimitIntEnable) << u8Channel) | (SDDF_ABNIER0_HLMTIE0(pConfig->bHighLimitIntEnable) << u8Channel) |
(SDDF_ABNIER0_WLMTIE0(pConfig->bWindowLimitIntEnable) << u8Channel);
SDDF_HWA_SetAbnormalInterruptEnable0(pSddf, u32AbnormalIntEn0);
pHandle->tSettings.Notifications[u8Channel].pLimitCheckNotify = NULL;
}
SDDF_HWA_SetChannelLimitCheckEnableFlag(pSddf, u8Channel, pConfig->bLimitCheckEnable);
#if SDDF_DEV_ERROR_REPORT == STD_ON
}
#endif
}
void SDDF_ConfigChannelZeroCrossDetect(SDDF_HandleType *pHandle, uint8_t u8Channel, SDDF_ZeroCrossDetectConfigType *pConfig)
{
#if SDDF_DEV_ERROR_REPORT == STD_ON
if (pHandle == NULL)
{
SDDF_ReportDevError(SDDF_CFG_CH_ZERO_CROSS_DET_ID, SDDF_E_PARAM_POINTER);
}
else if(pHandle->eInstance >= SDDF_INSTANCE_COUNT)
{
SDDF_ReportDevError(SDDF_CFG_CH_ZERO_CROSS_DET_ID, SDDF_E_PARAM_INSTANCE);
}
else if(u8Channel >= SDDF_CH_CNT)
{
SDDF_ReportDevError(SDDF_CFG_CH_ZERO_CROSS_DET_ID, SDDF_E_PARAM_CHANNEL);
}
else if(pConfig == NULL)
{
SDDF_ReportDevError(SDDF_CFG_CH_ZERO_CROSS_DET_ID, SDDF_E_PARAM_POINTER);
}
else
{
#endif
SDDF_InstanceType eInstance =pHandle->eInstance;
SDDF_Type *const pSddf = s_apSddfBase[eInstance];
SDDF_HWA_SetChannelZeroCrossCheckInputSrc(pSddf, u8Channel, pConfig->eZeroCrossDetectInputSrc);
if (pConfig->bZeroCrossDetectIntEnable == true)
{
SDDF_HWA_SetChannelZeroCrossDetectIntEnableFlag(pSddf, u8Channel, true);
pHandle->tSettings.Notifications[u8Channel].pZeroCrossDetectNotify = pConfig->pZeroCrossDetectNotify;
}
else
{
SDDF_HWA_SetChannelZeroCrossDetectIntEnableFlag(pSddf, u8Channel, false);
pHandle->tSettings.Notifications[u8Channel].pZeroCrossDetectNotify = NULL;
}
SDDF_HWA_SetChannelZeroCrossDetectEnableFlag(pSddf, u8Channel, pConfig->bZeroCrossDetectEnable);
#if SDDF_DEV_ERROR_REPORT == STD_ON
}
#endif
}
void SDDF_GenerateChannelSwTrigger(SDDF_HandleType *pHandle, uint8_t u8Channel)
{
#if SDDF_DEV_ERROR_REPORT == STD_ON
if (pHandle == NULL)
{
SDDF_ReportDevError(SDDF_GEN_CH_SW_TRIG_ID, SDDF_E_PARAM_POINTER);
}
else if(pHandle->eInstance >= SDDF_INSTANCE_COUNT)
{
SDDF_ReportDevError(SDDF_GEN_CH_SW_TRIG_ID, SDDF_E_PARAM_INSTANCE);
}
else if(u8Channel >= SDDF_CH_CNT)
{
SDDF_ReportDevError(SDDF_GEN_CH_SW_TRIG_ID, SDDF_E_PARAM_CHANNEL);
}
else
{
#endif
SDDF_InstanceType eInstance =pHandle->eInstance;
SDDF_Type *const pSddf = s_apSddfBase[eInstance];
SDDF_HWA_GenerateChannelSwTrigger(pSddf, u8Channel);
#if SDDF_DEV_ERROR_REPORT == STD_ON
}
#endif
}
uint32_t SDDF_GetChannelFIFOData(SDDF_HandleType *pHandle, uint8_t u8Channel)
{
uint32_t ret = 0U;
#if SDDF_DEV_ERROR_REPORT == STD_ON
if (pHandle == NULL)
{
SDDF_ReportDevError(SDDF_GET_CH_FIFO_DATA_ID, SDDF_E_PARAM_POINTER);
}
else if(pHandle->eInstance >= SDDF_INSTANCE_COUNT)
{
SDDF_ReportDevError(SDDF_GET_CH_FIFO_DATA_ID, SDDF_E_PARAM_INSTANCE);
}
else if(u8Channel >= SDDF_CH_CNT)
{
SDDF_ReportDevError(SDDF_GET_CH_FIFO_DATA_ID, SDDF_E_PARAM_CHANNEL);
}
else
{
#endif
SDDF_InstanceType eInstance =pHandle->eInstance;
SDDF_Type *const pSddf = s_apSddfBase[eInstance];
ret = SDDF_HWA_GetChannelData(pSddf, u8Channel);
#if SDDF_DEV_ERROR_REPORT == STD_ON
}
#endif
return ret;
}
#endif
Reference in New Issue View Git Blame Copy Permalink