tasks_shared_private.c

Go to the documentation of this file.

 
// Framework Includes
#include <define_error_flags.h>
#include <define_error_ids.h>
#include <error_handler.h>
#include <error_handler_config.h>
#include <midware_clock_manager.h>
#include <midware_error_manager.h>
#include <midware_memory_manager.h>
#include <midware_power_manager.h>
#include <midware_watchdog_manager.h>
#include <tasks_shared_private.h>
 
void ReportClearVregfailChannelError(void)
{
    if (MW_GetErrorChannel(ERRCH_VREGFAIL) != NO_ERROR)
    {
        errFlag_t flag = MW_GetClearVmonOverError();
        EH_HandleError(flag, ERRID_VREGFAIL_VOV);
 
        flag = MW_GetClearVmonUnderError();
        EH_HandleError(flag, ERRID_VREGFAIL_VUV);
 
        // The channel can only be cleared after all error sources are cleared
        flag = MW_ClearErrorChannel(ERRCH_VREGFAIL);
        EH_HandleError(flag, ERRID_VREGFAIL_CH); // In case the channel was not cleared
    }
}
 
void ReportClearBuserrChannelError(void)
{
    if (MW_GetErrorChannel(ERRCH_BUSERR) != NO_ERROR)
    {
        errFlag_t flag = MW_GetClearBusError();
        EH_HandleError(flag, ERRID_BUSERR_BUSERR);
 
        // Check and report if bus error was due to bus parity error (ECC errors are reported and
        // cleared separately)
        if (flag == ERROR)
        {
            flag = MW_GetClearRamParityError();
            EH_HandleError(flag, ERRID_RAM_PARITY);
 
            flag = MW_GetClearNvmParityError();
            EH_HandleError(flag, ERRID_NVM_PARITY);
        }
 
        flag = MW_GetClearCpuDataParityError();
        EH_HandleError(flag, ERRID_BUSERR_PARITYD);
 
        // The channel can only be cleared after all error sources are cleared
        flag = MW_ClearErrorChannel(ERRCH_BUSERR);
        EH_HandleError(flag, ERRID_BUSERR_CH); // In case the channel was not cleared
    }
}
 
void ReportClearRam2ChannelError(void)
{
    if (MW_GetErrorChannel(ERRCH_RAM2) != NO_ERROR)
    {
        errFlag_t flag = MW_GetClearRamEcc2Error();
        EH_HandleError(flag, ERRID_RAM2_ECC2);
 
        flag = MW_GetClearRamEccCompError();
        EH_HandleError(flag, ERRID_RAM2_COMP);
 
        // The channel can only be cleared after all error sources are cleared
        flag = MW_ClearErrorChannel(ERRCH_RAM2);
        EH_HandleError(flag, ERRID_RAM2_CH); // In case the channel was not cleared
    }
}
 
void ReportClearFlash2ChannelError(void)
{
    if (MW_GetErrorChannel(ERRCH_FLASH2) != NO_ERROR)
    {
        errFlag_t flag = MW_GetClearNvmFlashEcc2Error();
        EH_HandleError(flag, ERRID_FLASH2_ECC2);
 
        flag = MW_GetClearNvmEccCompError();
        EH_HandleError(flag, ERRID_FLASH2_COMP);
 
        // The channel can only be cleared after all error sources are cleared
        flag = MW_ClearErrorChannel(ERRCH_FLASH2);
        EH_HandleError(flag, ERRID_FLASH2_CH); // In case the channel was not cleared
    }
}
 
void ReportClearOpcChannelError(void)
{
    if (MW_GetErrorChannel(ERRCH_OPC) != NO_ERROR)
    {
        errFlag_t flag = MW_GetClearCpuOpcodeError();
        EH_HandleError(flag, ERRID_OPC_OPC);
 
        flag = MW_GetClearCpuInstrParityError();
        EH_HandleError(flag, ERRID_OPC_PARITYI);
 
        // The channel can only be cleared after all error sources are cleared
        flag = MW_ClearErrorChannel(ERRCH_OPC);
        EH_HandleError(flag, ERRID_OPC_CH); // In case the channel was not cleared
    }
}
 
void ReportClearSplimChannelError(void)
{
    if (MW_GetErrorChannel(ERRCH_SPLIM) != NO_ERROR)
    {
        errFlag_t flag = MW_GetClearRamStackError();
        /* For Error Channels with only one error source,
        the Channel Error ID is reported to the Error Handler. */
        EH_HandleError(flag, ERRID_SPLIM_CH);
 
        // The channel can only be cleared after all error sources are cleared
        flag = MW_ClearErrorChannel(ERRCH_SPLIM);
        EH_HandleError(flag, ERRID_SPLIM_CH); // In case the channel was not cleared
    }
}
 
void ReportClearRam1ChannelError(void)
{
    if (MW_GetErrorChannel(ERRCH_RAM1) != NO_ERROR)
    {
        errFlag_t flag = MW_GetClearRamEcc1Error();
        EH_HandleError(flag, ERRID_RAM1_CH);
 
        // The channel can only be cleared after all error sources are cleared
        flag = MW_ClearErrorChannel(ERRCH_RAM1);
        EH_HandleError(flag, ERRID_RAM1_CH); // In case the channel was not cleared
    }
}
 
void ReportClearFlash1ChannelError(void)
{
    if (MW_GetErrorChannel(ERRCH_FLASH1) != NO_ERROR)
    {
        errFlag_t flag = MW_GetClearNvmFlashEcc1Error();
        EH_HandleError(flag, ERRID_FLASH1_CH);
 
        // The channel can only be cleared after all error sources are cleared
        flag = MW_ClearErrorChannel(ERRCH_FLASH1);
        EH_HandleError(flag, ERRID_FLASH1_CH); // In case the channel was not cleared
    }
}
 
void ReportClearVregwarnChannelError(void)
{
    if (MW_GetErrorChannel(ERRCH_VREGWARN) != NO_ERROR)
    {
        errFlag_t flag = MW_GetClearVmonDiagEntryError();
        EH_HandleError(flag, ERRID_VREGWARN_VDENTER);
 
        flag = MW_GetClearVmonDiagExitError();
        EH_HandleError(flag, ERRID_VREGWARN_VDEXIT);
 
        flag = MW_GetClearVmonInternalError();
        EH_HandleError(flag, ERRID_VREGWARN_VERR);
 
        flag = MW_GetClearVmonSleepEntryError();
        EH_HandleError(flag, ERRID_VREGWARN_VSLP);
 
        flag = MW_GetClearVmonDisabledError();
        EH_HandleError(flag, ERRID_VREGWARN_VDIS);
 
        flag = MW_GetClearSleepError();
        EH_HandleError(flag, ERRID_VREGWARN_SERR);
 
        // The channel can only be cleared after all error sources are cleared
        flag = MW_ClearErrorChannel(ERRCH_VREGWARN);
        EH_HandleError(flag, ERRID_VREGWARN_CH); // In case the channel was not cleared
    }
}
 
void ReportClearCfd0ChannelError(void)
{
    if (MW_GetErrorChannel(ERRCH_CFD0) != NO_ERROR)
    {
        errFlag_t flag = MW_GetClearClockCfd0Error();
        EH_HandleError(flag, ERRID_CFD0_CH);
 
        // The channel can only be cleared after all error sources are cleared
        flag = MW_ClearErrorChannel(ERRCH_CFD0);
        EH_HandleError(flag, ERRID_CFD0_CH); // In case the channel was not cleared
    }
}
 
void ReportClearCfd1ChannelError(void)
{
    if (MW_GetErrorChannel(ERRCH_CFD1) != NO_ERROR)
    {
        errFlag_t flag = MW_GetClearClockCfd1Error();
        EH_HandleError(flag, ERRID_CFD1_CH);
 
        // The channel can only be cleared after all error sources are cleared
        flag = MW_ClearErrorChannel(ERRCH_CFD1);
        EH_HandleError(flag, ERRID_CFD1_CH); // In case the channel was not cleared
    }
}
 
void ReportClearCfm0ChannelError(void)
{
    if (MW_GetErrorChannel(ERRCH_CFM0) != NO_ERROR)
    {
        errFlag_t flag = MW_GetClearClockCfm0Error();
        EH_HandleError(flag, ERRID_CFM0_CH);
 
        // The channel can only be cleared after all error sources are cleared
        flag = MW_ClearErrorChannel(ERRCH_CFM0);
        EH_HandleError(flag, ERRID_CFM0_CH); // In case the channel was not cleared
    }
}
 
void ReportClearCfm1ChannelError(void)
{
    if (MW_GetErrorChannel(ERRCH_CFM1) != NO_ERROR)
    {
        errFlag_t flag = MW_GetClearClockCfm1Error();
        EH_HandleError(flag, ERRID_CFM1_CH);
 
        // The channel can only be cleared after all error sources are cleared
        flag = MW_ClearErrorChannel(ERRCH_CFM1);
        EH_HandleError(flag, ERRID_CFM1_CH); // In case the channel was not cleared
    }
}
 
void ReportClearSwdtChannelError(void)
{
    if (MW_GetErrorChannel(ERRCH_SWDT) != NO_ERROR)
    {
        errFlag_t flag = MW_GetSwdtPreclearError();
        EH_HandleError(flag, ERRID_SWDT_BADPC);
 
        flag = MW_GetSwdtClearError();
        EH_HandleError(flag, ERRID_SWDT_BADC);
 
        flag = MW_GetSwdtUnexpectedCmdError();
        EH_HandleError(flag, ERRID_SWDT_UC);
 
        flag = MW_GetSwdtCounterExpiredError();
        EH_HandleError(flag, ERRID_SWDT_EXP);
 
        MW_ClearSwdtErrors(); // The error flags cannot be cleared individually in hardware
 
        // The channel can only be cleared after all error sources are cleared
        flag = MW_ClearErrorChannel(ERRCH_SWDT);
        EH_HandleError(flag, ERRID_SWDT_CH); // In case the channel was not cleared
    }
}
 
void ReportClearEepromChannelError(void)
{
    if (MW_GetErrorChannel(ERRCH_EEPROM) != NO_ERROR)
    {
        errFlag_t flag = MW_GetClearNvmEepromEcc1Error();
        EH_HandleError(flag, ERRID_EEPROM_ECC1);
 
        flag = MW_GetClearNvmEepromEcc2Error();
        EH_HandleError(flag, ERRID_EEPROM_ECC2);
 
        // The channel can only be cleared after all error sources are cleared
        flag = MW_ClearErrorChannel(ERRCH_EEPROM);
        EH_HandleError(flag, ERRID_EEPROM_CH); // In case the channel was not cleared
    }
}
 
void ReportClearEvsys0ChannelError(void)
{
    if (MW_GetErrorChannel(ERRCH_EVSYS0) != NO_ERROR)
    {
        /*
         * Clear and report the error channel directly, without attempting to clear the source,
         * as it is unknown. When the event type is a "pulse", the source will be automatically
         * cleared unless there is an error. For a "level" event type, it is assumed that the
         * channel and the source is cleared in the error handler callback.
         */
        EH_HandleError(ERROR, ERRID_EVSYS0_CH);
        errFlag_t flag = MW_ClearErrorChannel(ERRCH_EVSYS0);
        EH_HandleError(flag, ERRID_EVSYS0_CLEAR); // In case the channel was not cleared
    }
}
 
void ReportClearEvsys1ChannelError(void)
{
    if (MW_GetErrorChannel(ERRCH_EVSYS1) != NO_ERROR)
    {
        /*
         * Clear and report the error channel directly, without attempting to clear the source,
         * as it is unknown. When the event type is a "pulse", the source will be automatically
         * cleared unless there is an error. For a "level" event type, it is assumed that the
         * channel and the source is cleared in the error handler callback.
         */
        EH_HandleError(ERROR, ERRID_EVSYS1_CH);
        errFlag_t flag = MW_ClearErrorChannel(ERRCH_EVSYS1);
        EH_HandleError(flag, ERRID_EVSYS1_CLEAR); // In case the channel was not cleared
    }
}