midware_error_manager.c

Go to the documentation of this file.

 
// Standard Library Includes
#include <stddef.h>
 
// Framework Includes
#include <driver_cpuctrl.h>
#include <driver_errctrl.h>
#include <midware_error_manager.h>
 
// Device-specific Includes
#include <xc.h>
 
// Private function prototypes
static errFlag_t ConfigAllChannels(const errChConfigs_t* configs);
static uint8_t DetermineChannelConfig(errChConfig_t config);
static errFlag_t ConfigVregfail(errChConfig_t config);
static errFlag_t ConfigBuserr(errChConfig_t config);
static errFlag_t ConfigRam2(errChConfig_t config);
static errFlag_t ConfigFlash2(errChConfig_t config);
static errFlag_t ConfigOpc(errChConfig_t config);
static errFlag_t ConfigSplim(errChConfig_t config);
static errFlag_t ConfigRam1(errChConfig_t config);
static errFlag_t ConfigFlash1(errChConfig_t config);
static errFlag_t ConfigVregwarn(errChConfig_t config);
static errFlag_t ConfigCfd0(errChConfig_t config);
static errFlag_t ConfigCfd1(errChConfig_t config);
static errFlag_t ConfigCfm0(errChConfig_t config);
static errFlag_t ConfigCfm1(errChConfig_t config);
static errFlag_t ConfigSwdt(errChConfig_t config);
static errFlag_t ConfigEeprom(errChConfig_t config);
static errFlag_t ConfigEvsys0(errChConfig_t config);
static errFlag_t ConfigEvsys1(errChConfig_t config);
 
errFlag_t MW_GetErrorChannel(errCh_t ch)
{
    if (ch >= ERRCH_MAX)
    {
        /* cppcheck-suppress misra-c2012-15.5 */
        return ERROR;
    }
 
    // Assumes channel number corresponds to bit position
    const uint32_t channelMask = 1UL << (uint8_t)ch;
    const uint32_t regVal      = ERRCTRL_ReadChannelStatus();
 
    const bool isChannelSet = ((regVal & channelMask) == channelMask);
 
    errFlag_t flag = NO_ERROR;
    if (isChannelSet)
    {
        flag = ERROR;
    }
 
    return flag;
}
 
errFlag_t MW_ClearErrorChannel(errCh_t ch)
{
    if (ch >= ERRCH_MAX)
    {
        /* cppcheck-suppress misra-c2012-15.5 */
        return ERROR;
    }
 
    // Assumes channel number corresponds to bit position
    const uint32_t channelMask = 1UL << (uint8_t)ch;
 
    // Channel is cleared by writing the channel bitmask
    ERRCTRL_WriteChannelStatus(channelMask);
 
    // Check if clear was successful
    const uint32_t regVal   = ERRCTRL_ReadChannelStatus();
    const bool isNotCleared = ((regVal & channelMask) == channelMask);
 
    errFlag_t flag = NO_ERROR;
    if (isNotCleared)
    {
        flag = ERROR;
    }
 
    return flag;
}
 
errFlag_t MW_CheckIoSafe(void)
{
    const uint8_t regVal     = ERRCTRL_ReadStatusA();
    const uint8_t ioSafeMask = (uint8_t)ERRCTRL_IOSAFE_bm;
    const bool isIoSafe      = ((regVal & ioSafeMask) == ioSafeMask);
 
    errFlag_t flag = ERROR;
    if (isIoSafe)
    {
        flag = NO_ERROR;
    }
 
    return flag;
}
 
void MW_EnableForceFloat(void)
{
    ERRCTRL_SetControlA((uint8_t)ERRCTRL_FORCEFLOAT_bm);
}
 
errFlag_t MW_DisableForceFloat(void)
{
    ERRCTRL_ClearControlA((uint8_t)ERRCTRL_FORCEFLOAT_bm);
 
    // Check if clear was successful
    uint8_t regVal               = ERRCTRL_ReadControlA();
    const uint8_t forcefloatMask = (uint8_t)ERRCTRL_FORCEFLOAT_bm;
    const bool isNotCleared      = ((regVal & forcefloatMask) == forcefloatMask);
 
    errFlag_t flag = NO_ERROR;
    if (isNotCleared)
    {
        flag = ERROR;
    }
 
    return flag;
}
 
void MW_StartHeartbeat(void)
{
    ERRCTRL_SetControlA((uint8_t)ERRCTRL_HEART_bm);
}
 
void MW_StopHeartbeat(void)
{
    ERRCTRL_ClearControlA((uint8_t)ERRCTRL_HEART_bm);
}
 
errFlag_t MW_ConfigErrorChannels(const errChConfigs_t* configs, uint8_t timeout)
{
    const bool isTimeoutDisabled = (timeout == 0U); // Timeout mechanism should not be disabled
    const bool isConfigsNull     = (configs == NULL);
 
    // Cannot go into CONFIG state if error controller is not in NORMAL state
    const uint8_t regVal            = ERRCTRL_ReadControlA();
    const uint8_t stateMask         = (uint8_t)ERRCTRL_STATE_gm;
    const uint8_t normalStateConfig = (uint8_t)ERRCTRL_STATE_NORMAL_gc;
    const bool isStateNormal        = ((regVal & stateMask) == normalStateConfig);
 
    if (isTimeoutDisabled || isConfigsNull || !isStateNormal)
    {
        /* cppcheck-suppress misra-c2012-15.5 */
        return ERROR;
    }
 
    // Disable global interrupts to avoid timeout while the error controller is in CONFIG state
    const uint8_t cpuStatusRegVal   = CPUCTRL_ReadStatusRegister();
    const uint8_t gieMask           = (uint8_t)CPU_I_bm; // Global Interrupt Enable status bit
    const bool wasInterruptsEnabled = ((cpuStatusRegVal & gieMask) == gieMask);
    CPUCTRL_ClearStatusRegister(gieMask);
 
    // Error Controller must be in CONFIG state to be able to configure error channels and timeout
    ERRCTRL_ModifyControlA(stateMask, (uint8_t)ERRCTRL_STATE_CONFIG_gc);
 
    errFlag_t configErrorFlag = ConfigAllChannels(configs);
 
    ERRCTRL_WriteTimeoutValue(timeout);
 
    ERRCTRL_ModifyControlA(stateMask, normalStateConfig);
 
    // Restore global interrupt configuration
    if (wasInterruptsEnabled)
    {
        CPUCTRL_SetStatusRegister(gieMask);
    }
 
    return configErrorFlag;
}
 
static errFlag_t ConfigAllChannels(const errChConfigs_t* configs)
{
    const uint8_t noErrorFlagVal = (uint8_t)NO_ERROR;
    uint8_t combinedFlags        = noErrorFlagVal; // Default to NO_ERROR
 
    // Use bitwise 'OR' to combine return flags (assumes ERROR and NO_ERROR are nonzero complements)
    combinedFlags |= (uint8_t)ConfigVregfail(configs->vregfail);
    combinedFlags |= (uint8_t)ConfigBuserr(configs->buserr);
    combinedFlags |= (uint8_t)ConfigRam2(configs->ram2);
    combinedFlags |= (uint8_t)ConfigFlash2(configs->flash2);
    combinedFlags |= (uint8_t)ConfigOpc(configs->opc);
    combinedFlags |= (uint8_t)ConfigSplim(configs->splim);
    combinedFlags |= (uint8_t)ConfigRam1(configs->ram1);
    combinedFlags |= (uint8_t)ConfigFlash1(configs->flash1);
    combinedFlags |= (uint8_t)ConfigVregwarn(configs->vregwarn);
    combinedFlags |= (uint8_t)ConfigCfd0(configs->cfd0);
    combinedFlags |= (uint8_t)ConfigCfd1(configs->cfd1);
    combinedFlags |= (uint8_t)ConfigCfm0(configs->cfm0);
    combinedFlags |= (uint8_t)ConfigCfm1(configs->cfm1);
    combinedFlags |= (uint8_t)ConfigSwdt(configs->swdt);
    combinedFlags |= (uint8_t)ConfigEeprom(configs->eeprom);
    combinedFlags |= (uint8_t)ConfigEvsys0(configs->evsys0);
    combinedFlags |= (uint8_t)ConfigEvsys1(configs->evsys1);
 
    // Check if any channel configs returned ERROR
    errFlag_t retFlag = NO_ERROR;
    if (combinedFlags != noErrorFlagVal)
    {
        retFlag = ERROR;
    }
    return retFlag;
}
 
static uint8_t DetermineChannelConfig(errChConfig_t config)
{
    uint8_t floatIoConfig = 0U; // Float disabled
 
    if (config.floatIo)
    {
        floatIoConfig = (uint8_t)ERRCTRL_FLOAT_bm;
    }
 
    uint8_t severityConfig = (uint8_t)config.severity << ERRCTRL_ERRLVL_gp;
 
    return floatIoConfig | severityConfig;
}
 
static errFlag_t ConfigVregfail(errChConfig_t config)
{
    // Ensure severity is valid
    if (config.severity >= ERRCH_SEVERITY_MAX)
    {
        /* cppcheck-suppress misra-c2012-15.5 */
        return ERROR;
    }
 
    uint8_t channelConfig = DetermineChannelConfig(config);
 
    ERRCTRL_WriteConfigVregfail(channelConfig);
 
    return NO_ERROR;
}
 
static errFlag_t ConfigBuserr(errChConfig_t config)
{
    // Ensure severity is valid
    if (config.severity >= ERRCH_SEVERITY_MAX)
    {
        /* cppcheck-suppress misra-c2012-15.5 */
        return ERROR;
    }
 
    uint8_t channelConfig = DetermineChannelConfig(config);
 
    ERRCTRL_WriteConfigBuserr(channelConfig);
 
    return NO_ERROR;
}
 
static errFlag_t ConfigRam2(errChConfig_t config)
{
    // Ensure severity is valid
    if (config.severity >= ERRCH_SEVERITY_MAX)
    {
        /* cppcheck-suppress misra-c2012-15.5 */
        return ERROR;
    }
 
    uint8_t channelConfig = DetermineChannelConfig(config);
 
    ERRCTRL_WriteConfigRam2(channelConfig);
 
    return NO_ERROR;
}
 
static errFlag_t ConfigFlash2(errChConfig_t config)
{
    // Ensure severity is valid
    if (config.severity >= ERRCH_SEVERITY_MAX)
    {
        /* cppcheck-suppress misra-c2012-15.5 */
        return ERROR;
    }
 
    uint8_t channelConfig = DetermineChannelConfig(config);
 
    ERRCTRL_WriteConfigFlash2(channelConfig);
 
    return NO_ERROR;
}
 
static errFlag_t ConfigOpc(errChConfig_t config)
{
    // Ensure severity is valid
    if (config.severity >= ERRCH_SEVERITY_MAX)
    {
        /* cppcheck-suppress misra-c2012-15.5 */
        return ERROR;
    }
 
    uint8_t channelConfig = DetermineChannelConfig(config);
 
    ERRCTRL_WriteConfigOpc(channelConfig);
 
    return NO_ERROR;
}
 
static errFlag_t ConfigSplim(errChConfig_t config)
{
    // Ensure severity is valid
    if (config.severity >= ERRCH_SEVERITY_MAX)
    {
        /* cppcheck-suppress misra-c2012-15.5 */
        return ERROR;
    }
 
    uint8_t channelConfig = DetermineChannelConfig(config);
 
    ERRCTRL_WriteConfigSplim(channelConfig);
 
    return NO_ERROR;
}
 
static errFlag_t ConfigRam1(errChConfig_t config)
{
    // Ensure severity is valid
    if (config.severity >= ERRCH_SEVERITY_MAX)
    {
        /* cppcheck-suppress misra-c2012-15.5 */
        return ERROR;
    }
 
    uint8_t channelConfig = DetermineChannelConfig(config);
 
    ERRCTRL_WriteConfigRam1(channelConfig);
 
    return NO_ERROR;
}
 
static errFlag_t ConfigFlash1(errChConfig_t config)
{
    // Ensure severity is valid
    if (config.severity >= ERRCH_SEVERITY_MAX)
    {
        /* cppcheck-suppress misra-c2012-15.5 */
        return ERROR;
    }
 
    uint8_t channelConfig = DetermineChannelConfig(config);
 
    ERRCTRL_WriteConfigFlash1(channelConfig);
 
    return NO_ERROR;
}
 
static errFlag_t ConfigVregwarn(errChConfig_t config)
{
    // Ensure severity is valid
    if (config.severity >= ERRCH_SEVERITY_MAX)
    {
        /* cppcheck-suppress misra-c2012-15.5 */
        return ERROR;
    }
 
    uint8_t channelConfig = DetermineChannelConfig(config);
 
    ERRCTRL_WriteConfigVregwarn(channelConfig);
 
    return NO_ERROR;
}
 
static errFlag_t ConfigCfd0(errChConfig_t config)
{
    // Ensure severity is valid
    if (config.severity >= ERRCH_SEVERITY_MAX)
    {
        /* cppcheck-suppress misra-c2012-15.5 */
        return ERROR;
    }
 
    uint8_t channelConfig = DetermineChannelConfig(config);
 
    ERRCTRL_WriteConfigCfd0(channelConfig);
 
    return NO_ERROR;
}
 
static errFlag_t ConfigCfd1(errChConfig_t config)
{
    // Ensure severity is valid
    if (config.severity >= ERRCH_SEVERITY_MAX)
    {
        /* cppcheck-suppress misra-c2012-15.5 */
        return ERROR;
    }
 
    uint8_t channelConfig = DetermineChannelConfig(config);
 
    ERRCTRL_WriteConfigCfd1(channelConfig);
 
    return NO_ERROR;
}
 
static errFlag_t ConfigCfm0(errChConfig_t config)
{
    // Ensure severity is valid
    if (config.severity >= ERRCH_SEVERITY_MAX)
    {
        /* cppcheck-suppress misra-c2012-15.5 */
        return ERROR;
    }
 
    uint8_t channelConfig = DetermineChannelConfig(config);
 
    ERRCTRL_WriteConfigCfm0(channelConfig);
 
    return NO_ERROR;
}
 
static errFlag_t ConfigCfm1(errChConfig_t config)
{
    // Ensure severity is valid
    if (config.severity >= ERRCH_SEVERITY_MAX)
    {
        /* cppcheck-suppress misra-c2012-15.5 */
        return ERROR;
    }
 
    uint8_t channelConfig = DetermineChannelConfig(config);
 
    ERRCTRL_WriteConfigCfm1(channelConfig);
 
    return NO_ERROR;
}
 
static errFlag_t ConfigSwdt(errChConfig_t config)
{
    // Ensure severity is valid
    if (config.severity >= ERRCH_SEVERITY_MAX)
    {
        /* cppcheck-suppress misra-c2012-15.5 */
        return ERROR;
    }
 
    uint8_t channelConfig = DetermineChannelConfig(config);
 
    ERRCTRL_WriteConfigSwdt(channelConfig);
 
    return NO_ERROR;
}
 
static errFlag_t ConfigEeprom(errChConfig_t config)
{
    // Ensure severity is valid
    if (config.severity >= ERRCH_SEVERITY_MAX)
    {
        /* cppcheck-suppress misra-c2012-15.5 */
        return ERROR;
    }
 
    uint8_t channelConfig = DetermineChannelConfig(config);
 
    ERRCTRL_WriteConfigEeprom(channelConfig);
 
    return NO_ERROR;
}
 
static errFlag_t ConfigEvsys0(errChConfig_t config)
{
    // Ensure severity is valid
    if (config.severity >= ERRCH_SEVERITY_MAX)
    {
        /* cppcheck-suppress misra-c2012-15.5 */
        return ERROR;
    }
 
    uint8_t channelConfig = DetermineChannelConfig(config);
 
    ERRCTRL_WriteConfigEvsys0(channelConfig);
 
    return NO_ERROR;
}
 
static errFlag_t ConfigEvsys1(errChConfig_t config)
{
    // Ensure severity is valid
    if (config.severity >= ERRCH_SEVERITY_MAX)
    {
        /* cppcheck-suppress misra-c2012-15.5 */
        return ERROR;
    }
 
    uint8_t channelConfig = DetermineChannelConfig(config);
 
    ERRCTRL_WriteConfigEvsys1(channelConfig);
 
    return NO_ERROR;
}