midware_error_manager_diag.c

Go to the documentation of this file.

 
// Standard Library Includes
#include <stdbool.h>
#include <stdint.h>
 
// Framework Includes
#include <driver_cpuctrl.h>
#include <driver_errctrl.h>
#include <midware_error_manager_diag.h>
#include <midware_shared_diag_private.h>
 
// Device-specific Includes
#include <xc.h>
 
// Error channel masks
static const uint32_t splimMask  = 1UL << ERRCTRL_ESF_5_bp;
static const uint32_t cfd0Mask   = 1UL << ERRCTRL_ESF_9_bp;
static const uint32_t cfd1Mask   = 1UL << ERRCTRL_ESF_10_bp;
static const uint32_t cfm0Mask   = 1UL << ERRCTRL_ESF_11_bp;
static const uint32_t cfm1Mask   = 1UL << ERRCTRL_ESF_12_bp;
static const uint32_t eepromMask = 1UL << ERRCTRL_ESF_14_bp;
static const uint32_t evsys0Mask = 1UL << ERRCTRL_ESF_15_bp;
static const uint32_t evsys1Mask = 1UL << ERRCTRL_ESF_16_bp;
 
// Private function prototypes
static bool VerifyDiagnosticResult(uint32_t channelMask);
 
static bool InjectSplimError(void);
static uint8_t DisableSplimChannel(void);
static void RestoreSplimChannelConfig(uint8_t splimChBackup);
 
static bool InjectCfd0Error(void);
static uint8_t DisableCfd0Channel(void);
static void RestoreCfd0ChannelConfig(uint8_t cfd0ChBackup);
 
static bool InjectCfd1Error(void);
static uint8_t DisableCfd1Channel(void);
static void RestoreCfd1ChannelConfig(uint8_t cfd1ChBackup);
 
static bool InjectCfm0Error(void);
static uint8_t DisableCfm0Channel(void);
static void RestoreCfm0ChannelConfig(uint8_t cfm0ChBackup);
 
static bool InjectCfm1Error(void);
static uint8_t DisableCfm1Channel(void);
static void RestoreCfm1ChannelConfig(uint8_t cfm1ChBackup);
 
static bool InjectEepromError(void);
static uint8_t DisableEepromChannel(void);
static void RestoreEepromChannelConfig(uint8_t eepromChBackup);
 
static bool InjectEvsys0Error(void);
static uint8_t DisableEvsys0Channel(void);
static void RestoreEvsys0ChannelConfig(uint8_t evsys0ChBackup);
 
static bool InjectEvsys1Error(void);
static uint8_t DisableEvsys1Channel(void);
static void RestoreEvsys1ChannelConfig(uint8_t evsys1ChBackup);
 
errFlag_t MW_DiagErrorChannelSplim(void)
{
    const bool isConfigurable = IsErrChConfigurable(splimMask);
    if (!isConfigurable)
    {
        /* cppcheck-suppress misra-c2012-15.5 */
        return ERROR;
    }
 
    // Disable and backup global interrupts configuration to avoid timeout while in CONFIG state
    AtomicSectionStart();
 
    const bool isChannelSet = InjectSplimError();
 
    // Restore global interrupts configuration
    AtomicSectionEnd();
 
    errFlag_t flag = ERROR;
    if (isChannelSet)
    {
        flag = NO_ERROR;
    }
 
    return flag;
}
 
errFlag_t MW_DiagErrorChannelCfd0(void)
{
    const bool isConfigurable = IsErrChConfigurable(cfd0Mask);
    if (!isConfigurable)
    {
        /* cppcheck-suppress misra-c2012-15.5 */
        return ERROR;
    }
 
    // Disable and backup global interrupts configuration to avoid timeout while in CONFIG state
    AtomicSectionStart();
 
    const bool isChannelSet = InjectCfd0Error();
 
    // Restore global interrupts configuration
    AtomicSectionEnd();
 
    errFlag_t flag = ERROR;
    if (isChannelSet)
    {
        flag = NO_ERROR;
    }
 
    return flag;
}
 
errFlag_t MW_DiagErrorChannelCfd1(void)
{
    const bool isConfigurable = IsErrChConfigurable(cfd1Mask);
    if (!isConfigurable)
    {
        /* cppcheck-suppress misra-c2012-15.5 */
        return ERROR;
    }
 
    // Disable and backup global interrupts configuration to avoid timeout while in CONFIG state
    AtomicSectionStart();
 
    const bool isChannelSet = InjectCfd1Error();
 
    // Restore global interrupts configuration
    AtomicSectionEnd();
 
    errFlag_t flag = ERROR;
    if (isChannelSet)
    {
        flag = NO_ERROR;
    }
 
    return flag;
}
 
errFlag_t MW_DiagErrorChannelCfm0(void)
{
    const bool isConfigurable = IsErrChConfigurable(cfm0Mask);
    if (!isConfigurable)
    {
        /* cppcheck-suppress misra-c2012-15.5 */
        return ERROR;
    }
 
    // Disable and backup global interrupts configuration to avoid timeout while in CONFIG state
    AtomicSectionStart();
 
    const bool isChannelSet = InjectCfm0Error();
 
    // Restore global interrupts configuration
    AtomicSectionEnd();
 
    errFlag_t flag = ERROR;
    if (isChannelSet)
    {
        flag = NO_ERROR;
    }
 
    return flag;
}
 
errFlag_t MW_DiagErrorChannelCfm1(void)
{
    const bool isConfigurable = IsErrChConfigurable(cfm1Mask);
    if (!isConfigurable)
    {
        /* cppcheck-suppress misra-c2012-15.5 */
        return ERROR;
    }
 
    // Disable and backup global interrupts configuration to avoid timeout while in CONFIG state
    AtomicSectionStart();
 
    const bool isChannelSet = InjectCfm1Error();
 
    // Restore global interrupts configuration
    AtomicSectionEnd();
 
    errFlag_t flag = ERROR;
    if (isChannelSet)
    {
        flag = NO_ERROR;
    }
 
    return flag;
}
 
errFlag_t MW_DiagErrorChannelEeprom(void)
{
    const bool isConfigurable = IsErrChConfigurable(eepromMask);
    if (!isConfigurable)
    {
        /* cppcheck-suppress misra-c2012-15.5 */
        return ERROR;
    }
 
    // Disable and backup global interrupts configuration to avoid timeout while in CONFIG state
    AtomicSectionStart();
 
    const bool isChannelSet = InjectEepromError();
 
    // Restore global interrupts configuration
    AtomicSectionEnd();
 
    errFlag_t flag = ERROR;
    if (isChannelSet)
    {
        flag = NO_ERROR;
    }
 
    return flag;
}
 
errFlag_t MW_DiagErrorChannelEvsys0(void)
{
    const bool isConfigurable = IsErrChConfigurable(evsys0Mask);
    if (!isConfigurable)
    {
        /* cppcheck-suppress misra-c2012-15.5 */
        return ERROR;
    }
 
    // Disable and backup global interrupts configuration to avoid timeout while in CONFIG state
    AtomicSectionStart();
 
    const bool isChannelSet = InjectEvsys0Error();
 
    // Restore global interrupts configuration
    AtomicSectionEnd();
 
    errFlag_t flag = ERROR;
    if (isChannelSet)
    {
        flag = NO_ERROR;
    }
 
    return flag;
}
 
errFlag_t MW_DiagErrorChannelEvsys1(void)
{
    const bool isConfigurable = IsErrChConfigurable(evsys1Mask);
    if (!isConfigurable)
    {
        /* cppcheck-suppress misra-c2012-15.5 */
        return ERROR;
    }
 
    // Disable and backup global interrupts configuration to avoid timeout while in CONFIG state
    AtomicSectionStart();
 
    const bool isChannelSet = InjectEvsys1Error();
 
    // Restore global interrupts configuration
    AtomicSectionEnd();
 
    errFlag_t flag = ERROR;
    if (isChannelSet)
    {
        flag = NO_ERROR;
    }
 
    return flag;
}
 
// Verifies that the expected flags are set and clears them, returns true if channel is set
static bool VerifyDiagnosticResult(uint32_t channelMask)
{
    // Diagnostic is successful if flag is raised on the Error Channel
    const uint32_t chStatus = ERRCTRL_ReadChannelStatus();
    const bool isChannelSet = ((chStatus & channelMask) == channelMask);
    ERRCTRL_WriteChannelStatus(channelMask); // Clear status flag
 
    return isChannelSet;
}
 
// Configures SPLIM error channel for error injection and restores it after injection is complete
static bool InjectSplimError(void)
{
    // Prevent error injection from triggering a real error response
    const uint8_t splimChBackup = DisableSplimChannel();
 
    // Start error injection
    ERRCTRL_WriteChannelTest(splimMask);
 
    const bool isChannelSet = VerifyDiagnosticResult(splimMask);
 
    RestoreSplimChannelConfig(splimChBackup);
 
    return isChannelSet;
}
 
// Sets SPLIM channel with NOTIFICATION severity and I/O float disabled, returns original config
static uint8_t DisableSplimChannel(void)
{
    const uint8_t stateMask       = (uint8_t)ERRCTRL_STATE_gm;
    const uint8_t floatConfig     = 0U << ERRCTRL_FLOAT_bp; // Disable I/O float
    const uint8_t severityConfig  = (uint8_t)ERRCTRL_ERRLVL_NOTIFICATION_gc;
    const uint8_t disableChConfig = (floatConfig | severityConfig);
 
    const uint8_t splimChBackup = ERRCTRL_ReadConfigSplim();
 
    ERRCTRL_ModifyControlA(stateMask, (uint8_t)ERRCTRL_STATE_CONFIG_gc);
    ERRCTRL_WriteConfigSplim(disableChConfig);
    ERRCTRL_ModifyControlA(stateMask, (uint8_t)ERRCTRL_STATE_NORMAL_gc);
 
    return splimChBackup;
}
 
static void RestoreSplimChannelConfig(uint8_t splimChBackup)
{
    const uint8_t stateMask = (uint8_t)ERRCTRL_STATE_gm;
    ERRCTRL_ModifyControlA(stateMask, (uint8_t)ERRCTRL_STATE_CONFIG_gc);
    ERRCTRL_WriteConfigSplim(splimChBackup);
    ERRCTRL_ModifyControlA(stateMask, (uint8_t)ERRCTRL_STATE_NORMAL_gc);
}
 
// Configures CFD0 error channel for error injection and restores it after injection is complete
static bool InjectCfd0Error(void)
{
    // Prevent error injection from triggering a real error response
    const uint8_t cfd0ChBackup = DisableCfd0Channel();
 
    // Start error injection
    ERRCTRL_WriteChannelTest(cfd0Mask);
 
    const bool isChannelSet = VerifyDiagnosticResult(cfd0Mask);
 
    RestoreCfd0ChannelConfig(cfd0ChBackup);
 
    return isChannelSet;
}
 
// Sets CFD0 channel with NOTIFICATION severity and I/O float disabled, returns original config
static uint8_t DisableCfd0Channel(void)
{
    const uint8_t stateMask       = (uint8_t)ERRCTRL_STATE_gm;
    const uint8_t floatConfig     = 0U << ERRCTRL_FLOAT_bp; // Disable I/O float
    const uint8_t severityConfig  = (uint8_t)ERRCTRL_ERRLVL_NOTIFICATION_gc;
    const uint8_t disableChConfig = (floatConfig | severityConfig);
 
    const uint8_t cfd0ChBackup = ERRCTRL_ReadConfigCfd0();
 
    ERRCTRL_ModifyControlA(stateMask, (uint8_t)ERRCTRL_STATE_CONFIG_gc);
    ERRCTRL_WriteConfigCfd0(disableChConfig);
    ERRCTRL_ModifyControlA(stateMask, (uint8_t)ERRCTRL_STATE_NORMAL_gc);
 
    return cfd0ChBackup;
}
 
static void RestoreCfd0ChannelConfig(uint8_t cfd0ChBackup)
{
    const uint8_t stateMask = (uint8_t)ERRCTRL_STATE_gm;
    ERRCTRL_ModifyControlA(stateMask, (uint8_t)ERRCTRL_STATE_CONFIG_gc);
    ERRCTRL_WriteConfigCfd0(cfd0ChBackup);
    ERRCTRL_ModifyControlA(stateMask, (uint8_t)ERRCTRL_STATE_NORMAL_gc);
}
 
// Configures CFD1 error channel for error injection and restores it after injection is complete
static bool InjectCfd1Error(void)
{
    // Prevent error injection from triggering a real error response
    const uint8_t cfd1ChBackup = DisableCfd1Channel();
 
    // Start error injection
    ERRCTRL_WriteChannelTest(cfd1Mask);
 
    const bool isChannelSet = VerifyDiagnosticResult(cfd1Mask);
 
    RestoreCfd1ChannelConfig(cfd1ChBackup);
 
    return isChannelSet;
}
 
// Sets CFD1 channel with NOTIFICATION severity and I/O float disabled, returns original config
static uint8_t DisableCfd1Channel(void)
{
    const uint8_t stateMask       = (uint8_t)ERRCTRL_STATE_gm;
    const uint8_t floatConfig     = 0U << ERRCTRL_FLOAT_bp; // Disable I/O float
    const uint8_t severityConfig  = (uint8_t)ERRCTRL_ERRLVL_NOTIFICATION_gc;
    const uint8_t disableChConfig = (floatConfig | severityConfig);
 
    const uint8_t cfd1ChBackup = ERRCTRL_ReadConfigCfd1();
 
    ERRCTRL_ModifyControlA(stateMask, (uint8_t)ERRCTRL_STATE_CONFIG_gc);
    ERRCTRL_WriteConfigCfd1(disableChConfig);
    ERRCTRL_ModifyControlA(stateMask, (uint8_t)ERRCTRL_STATE_NORMAL_gc);
 
    return cfd1ChBackup;
}
 
static void RestoreCfd1ChannelConfig(uint8_t cfd1ChBackup)
{
    const uint8_t stateMask = (uint8_t)ERRCTRL_STATE_gm;
    ERRCTRL_ModifyControlA(stateMask, (uint8_t)ERRCTRL_STATE_CONFIG_gc);
    ERRCTRL_WriteConfigCfd1(cfd1ChBackup);
    ERRCTRL_ModifyControlA(stateMask, (uint8_t)ERRCTRL_STATE_NORMAL_gc);
}
 
// Configures CFM0 error channel for error injection and restores it after injection is complete
static bool InjectCfm0Error(void)
{
    // Prevent error injection from triggering a real error response
    const uint8_t cfm0ChBackup = DisableCfm0Channel();
 
    // Start error injection
    ERRCTRL_WriteChannelTest(cfm0Mask);
 
    const bool isChannelSet = VerifyDiagnosticResult(cfm0Mask);
 
    RestoreCfm0ChannelConfig(cfm0ChBackup);
 
    return isChannelSet;
}
 
// Sets CFM0 channel with NOTIFICATION severity and I/O float disabled, returns original config
static uint8_t DisableCfm0Channel(void)
{
    const uint8_t stateMask       = (uint8_t)ERRCTRL_STATE_gm;
    const uint8_t floatConfig     = 0U << ERRCTRL_FLOAT_bp; // Disable I/O float
    const uint8_t severityConfig  = (uint8_t)ERRCTRL_ERRLVL_NOTIFICATION_gc;
    const uint8_t disableChConfig = (floatConfig | severityConfig);
 
    const uint8_t cfm0ChBackup = ERRCTRL_ReadConfigCfm0();
 
    ERRCTRL_ModifyControlA(stateMask, (uint8_t)ERRCTRL_STATE_CONFIG_gc);
    ERRCTRL_WriteConfigCfm0(disableChConfig);
    ERRCTRL_ModifyControlA(stateMask, (uint8_t)ERRCTRL_STATE_NORMAL_gc);
 
    return cfm0ChBackup;
}
 
static void RestoreCfm0ChannelConfig(uint8_t cfm0ChBackup)
{
    const uint8_t stateMask = (uint8_t)ERRCTRL_STATE_gm;
    ERRCTRL_ModifyControlA(stateMask, (uint8_t)ERRCTRL_STATE_CONFIG_gc);
    ERRCTRL_WriteConfigCfm0(cfm0ChBackup);
    ERRCTRL_ModifyControlA(stateMask, (uint8_t)ERRCTRL_STATE_NORMAL_gc);
}
 
// Configures CFM1 error channel for error injection and restores it after injection is complete
static bool InjectCfm1Error(void)
{
    // Prevent error injection from triggering a real error response
    const uint8_t cfm1ChBackup = DisableCfm1Channel();
 
    // Start error injection
    ERRCTRL_WriteChannelTest(cfm1Mask);
 
    const bool isChannelSet = VerifyDiagnosticResult(cfm1Mask);
 
    RestoreCfm1ChannelConfig(cfm1ChBackup);
 
    return isChannelSet;
}
 
// Sets CFM1 channel with NOTIFICATION severity and I/O float disabled, returns original config
static uint8_t DisableCfm1Channel(void)
{
    const uint8_t stateMask       = (uint8_t)ERRCTRL_STATE_gm;
    const uint8_t floatConfig     = 0U << ERRCTRL_FLOAT_bp; // Disable I/O float
    const uint8_t severityConfig  = (uint8_t)ERRCTRL_ERRLVL_NOTIFICATION_gc;
    const uint8_t disableChConfig = (floatConfig | severityConfig);
 
    const uint8_t cfm1ChBackup = ERRCTRL_ReadConfigCfm1();
 
    ERRCTRL_ModifyControlA(stateMask, (uint8_t)ERRCTRL_STATE_CONFIG_gc);
    ERRCTRL_WriteConfigCfm1(disableChConfig);
    ERRCTRL_ModifyControlA(stateMask, (uint8_t)ERRCTRL_STATE_NORMAL_gc);
 
    return cfm1ChBackup;
}
 
static void RestoreCfm1ChannelConfig(uint8_t cfm1ChBackup)
{
    const uint8_t stateMask = (uint8_t)ERRCTRL_STATE_gm;
    ERRCTRL_ModifyControlA(stateMask, (uint8_t)ERRCTRL_STATE_CONFIG_gc);
    ERRCTRL_WriteConfigCfm1(cfm1ChBackup);
    ERRCTRL_ModifyControlA(stateMask, (uint8_t)ERRCTRL_STATE_NORMAL_gc);
}
 
// Configures EEPROM error channel for error injection and restores it after injection is complete
static bool InjectEepromError(void)
{
    // Prevent error injection from triggering a real error response
    const uint8_t eepromChBackup = DisableEepromChannel();
 
    // Start error injection
    ERRCTRL_WriteChannelTest(eepromMask);
 
    const bool isChannelSet = VerifyDiagnosticResult(eepromMask);
 
    RestoreEepromChannelConfig(eepromChBackup);
 
    return isChannelSet;
}
 
// Sets EEPROM channel with NOTIFICATION severity and I/O float disabled, returns original config
static uint8_t DisableEepromChannel(void)
{
    const uint8_t stateMask       = (uint8_t)ERRCTRL_STATE_gm;
    const uint8_t floatConfig     = 0U << ERRCTRL_FLOAT_bp; // Disable I/O float
    const uint8_t severityConfig  = (uint8_t)ERRCTRL_ERRLVL_NOTIFICATION_gc;
    const uint8_t disableChConfig = (floatConfig | severityConfig);
 
    const uint8_t eepromChBackup = ERRCTRL_ReadConfigEeprom();
 
    ERRCTRL_ModifyControlA(stateMask, (uint8_t)ERRCTRL_STATE_CONFIG_gc);
    ERRCTRL_WriteConfigEeprom(disableChConfig);
    ERRCTRL_ModifyControlA(stateMask, (uint8_t)ERRCTRL_STATE_NORMAL_gc);
 
    return eepromChBackup;
}
 
static void RestoreEepromChannelConfig(uint8_t eepromChBackup)
{
    const uint8_t stateMask = (uint8_t)ERRCTRL_STATE_gm;
    ERRCTRL_ModifyControlA(stateMask, (uint8_t)ERRCTRL_STATE_CONFIG_gc);
    ERRCTRL_WriteConfigEeprom(eepromChBackup);
    ERRCTRL_ModifyControlA(stateMask, (uint8_t)ERRCTRL_STATE_NORMAL_gc);
}
 
// Configures EVSYS0 error channel for error injection and restores it after injection is complete
static bool InjectEvsys0Error(void)
{
    // Prevent error injection from triggering a real error response
    const uint8_t evsys0ChBackup = DisableEvsys0Channel();
 
    // Start error injection
    ERRCTRL_WriteChannelTest(evsys0Mask);
 
    const bool isChannelSet = VerifyDiagnosticResult(evsys0Mask);
 
    RestoreEvsys0ChannelConfig(evsys0ChBackup);
 
    return isChannelSet;
}
 
// Sets EVSYS0 channel with NOTIFICATION severity and I/O float disabled, returns original config
static uint8_t DisableEvsys0Channel(void)
{
    const uint8_t stateMask       = (uint8_t)ERRCTRL_STATE_gm;
    const uint8_t floatConfig     = 0U << ERRCTRL_FLOAT_bp; // Disable I/O float
    const uint8_t severityConfig  = (uint8_t)ERRCTRL_ERRLVL_NOTIFICATION_gc;
    const uint8_t disableChConfig = (floatConfig | severityConfig);
 
    const uint8_t evsys0ChBackup = ERRCTRL_ReadConfigEvsys0();
 
    ERRCTRL_ModifyControlA(stateMask, (uint8_t)ERRCTRL_STATE_CONFIG_gc);
    ERRCTRL_WriteConfigEvsys0(disableChConfig);
    ERRCTRL_ModifyControlA(stateMask, (uint8_t)ERRCTRL_STATE_NORMAL_gc);
 
    return evsys0ChBackup;
}
 
static void RestoreEvsys0ChannelConfig(uint8_t evsys0ChBackup)
{
    const uint8_t stateMask = (uint8_t)ERRCTRL_STATE_gm;
    ERRCTRL_ModifyControlA(stateMask, (uint8_t)ERRCTRL_STATE_CONFIG_gc);
    ERRCTRL_WriteConfigEvsys0(evsys0ChBackup);
    ERRCTRL_ModifyControlA(stateMask, (uint8_t)ERRCTRL_STATE_NORMAL_gc);
}
 
// Configures EVSYS1 error channel for error injection and restores it after injection is complete
static bool InjectEvsys1Error(void)
{
    // Prevent error injection from triggering a real error response
    const uint8_t evsys1ChBackup = DisableEvsys1Channel();
 
    // Start error injection
    ERRCTRL_WriteChannelTest(evsys1Mask);
 
    const bool isChannelSet = VerifyDiagnosticResult(evsys1Mask);
 
    RestoreEvsys1ChannelConfig(evsys1ChBackup);
 
    return isChannelSet;
}
 
// Sets EVSYS1 channel with NOTIFICATION severity and I/O float disabled, returns original config
static uint8_t DisableEvsys1Channel(void)
{
    const uint8_t stateMask       = (uint8_t)ERRCTRL_STATE_gm;
    const uint8_t floatConfig     = 0U << ERRCTRL_FLOAT_bp; // Disable I/O float
    const uint8_t severityConfig  = (uint8_t)ERRCTRL_ERRLVL_NOTIFICATION_gc;
    const uint8_t disableChConfig = (floatConfig | severityConfig);
 
    const uint8_t evsys1ChBackup = ERRCTRL_ReadConfigEvsys1();
 
    ERRCTRL_ModifyControlA(stateMask, (uint8_t)ERRCTRL_STATE_CONFIG_gc);
    ERRCTRL_WriteConfigEvsys1(disableChConfig);
    ERRCTRL_ModifyControlA(stateMask, (uint8_t)ERRCTRL_STATE_NORMAL_gc);
 
    return evsys1ChBackup;
}
 
static void RestoreEvsys1ChannelConfig(uint8_t evsys1ChBackup)
{
    const uint8_t stateMask = (uint8_t)ERRCTRL_STATE_gm;
    ERRCTRL_ModifyControlA(stateMask, (uint8_t)ERRCTRL_STATE_CONFIG_gc);
    ERRCTRL_WriteConfigEvsys1(evsys1ChBackup);
    ERRCTRL_ModifyControlA(stateMask, (uint8_t)ERRCTRL_STATE_NORMAL_gc);
}