tasks_startup_private.c

Go to the documentation of this file.

 
// Framework Includes
#include <define_error_flags.h>
#include <define_error_ids.h>
#include <define_tasks_config.h>
#include <error_handler.h>
#include <error_handler_config.h>
#include <midware_clock_manager.h>
#include <midware_clock_manager_diag.h>
#include <midware_error_manager.h>
#include <midware_error_manager_diag.h>
#include <midware_interrupt_manager.h>
#include <midware_memory_manager.h>
#include <midware_memory_manager_diag.h>
#include <midware_power_manager.h>
#include <midware_watchdog_manager.h>
#include <tasks_config.h>
#include <tasks_startup_private.h>
 
// Private function prototypes
static void DetermineErrChConfigs(errChConfigs_t* configs);
static errChConfig_t GetErrChConfig(errId_t id);
 
errFlag_t InitWatchdogs(void)
{
    const uint8_t noErrorFlagVal = (uint8_t)NO_ERROR;
    uint8_t combinedFlags        = noErrorFlagVal; // Default to NO_ERROR
 
    const wdtTimeout_t closedWindow = WDT_TIMEOUT_OFF;
 
    const uint32_t initialResetVal = INIT_SWDT_DURATION + SWDT_OPEN_WINDOW;
    const bool useRegProtect       = true;  // Avoid accidental register modification
    const bool useRegLock          = false; // SWDT intended to be updated run-time
    const bool useInstrMode        = false; // Only clock mode supported by default
 
    // Use bitwise 'OR' to combine return flags (assumes ERROR and NO_ERROR are nonzero complements)
    combinedFlags |= (uint8_t)MW_SetWdtTimeout(closedWindow, INIT_WDT_DURATION);
    combinedFlags |= (uint8_t)MW_SetSwdtResetValue(initialResetVal);
    combinedFlags |= (uint8_t)MW_SetSwdtWindowValue(SWDT_OPEN_WINDOW);
    MW_EnableSwdt(useRegProtect, useRegLock, useInstrMode);
 
    // Check if any middleware functions returned ERROR
    errFlag_t retFlag = NO_ERROR;
    if (combinedFlags != noErrorFlagVal)
    {
        retFlag = ERROR;
    }
    return retFlag;
}
 
errFlag_t InitClocks(void)
{
    const uint8_t noErrorFlagVal = (uint8_t)NO_ERROR;
    uint8_t combinedFlags        = noErrorFlagVal; // Default to NO_ERROR
 
    const cfdSource_t cfdSource = CFD_SRC_MAINCLK; // Ensure that the main clock source is monitored
    const cfdReference_t cfdRef = CFD_REF_OSC32K;  // Use internal reference (initially)
 
    const cfmSource_t cfmSource = CFM_SRC_MAINCLK; // Ensure that the main clock source is monitored
    cfmReference_t cfmRef       = CFM_REF_OSC32K;  // Use internal reference (initially)
    const cfmWindow_t cfmWindow = { .windowHigh = INIT_CFM0_WIN_HIGH,
                                    .windowLow  = INIT_CFM0_WIN_LOW,
                                    .refCount   = INIT_CFM0_WIN_REF };
    const bool useContinuousMode = true; // Monitor source continuously
 
    // Use bitwise 'OR' to combine return flags (assumes ERROR and NO_ERROR are nonzero complements)
    combinedFlags |= (uint8_t)MW_SetMainClockFrequency(INIT_CLOCK_FRQ, INIT_CLOCK_DIV);
    combinedFlags |= (uint8_t)MW_StartCfd0(cfdSource, cfdRef);
    combinedFlags |= (uint8_t)MW_StartCfm0(cfmSource, cfmRef, cfmWindow, useContinuousMode);
 
    /* Intentional misra-c2012-2.2/14.3 deviation */
    if (INIT_REDUNDANT_CFD == ENABLED)
    {
        combinedFlags |= (uint8_t)MW_StartCfd1(cfdSource, cfdRef);
    }
    /* Intentional misra-c2012-2.2/14.3 deviation */
    if (INIT_REDUNDANT_CFM == ENABLED)
    {
        combinedFlags |= (uint8_t)MW_StartCfm1(cfmSource, cfmRef, cfmWindow, useContinuousMode);
    }
 
    // Check if any middleware functions returned ERROR
    errFlag_t retFlag = NO_ERROR;
    if (combinedFlags != noErrorFlagVal)
    {
        retFlag = ERROR;
    }
    return retFlag;
}
 
errFlag_t InitErrorController(void)
{
    errChConfigs_t configs; // Used to configure all error channels
 
    // Use configured Error ID criticality and float macro config to populate struct
    DetermineErrChConfigs(&configs);
 
    errFlag_t flag = MW_ConfigErrorChannels(&configs, INIT_ERRCTRL_TIMEOUT);
 
    return flag;
}
 
errFlag_t InitInterrupts(void)
{
    const bool enableRoundRobin  = (INIT_INT_ROUND_ROBIN == ENABLED);
    const bool expectAltLocation = (INIT_INT_ALT_VECTOR_LOC == ENABLED);
 
    // Enable all error interrupts. Memory, ERRCTRL and CPU error flag interrupts are always on.
    MW_EnableSwdtInterrupts();
    MW_EnableClockInterrupts(); // All CFM and CFD interrupts.
    MW_EnablePowerInterrupts(); // VMON and VLM interrupts.
 
    MW_SetIntVectorLocation(expectAltLocation);
 
    errFlag_t flag = MW_SetIntPriority(enableRoundRobin, INIT_INT_LVL0_START, INIT_INT_LVL1);
 
    return flag;
}
 
errFlag_t InitPower(void)
{
    const uint8_t noErrorFlagVal = (uint8_t)NO_ERROR;
    uint8_t combinedFlags        = noErrorFlagVal; // Default to NO_ERROR
 
    const sleepMode_t sleepMode = SLP_MODE_IDLE;
    const bool useVmonSleep     = (INIT_VMON_ALWAYS_ON == ENABLED);
    const bool useFullMode      = (INIT_VMON_FULL_POWER_MODE == ENABLED);
 
    // Use bitwise 'OR' to combine return flags (assumes ERROR and NO_ERROR are nonzero complements)
    combinedFlags |= (uint8_t)MW_SetSleepMode(sleepMode);
    // Assumes BOD is already enabled through fuses for config to take effect
    combinedFlags |= (uint8_t)MW_ConfigVlm(INIT_VLM_THRESHOLD, INIT_VLM_TRIGGER);
 
    MW_SetVmonSleep(useVmonSleep, useFullMode);
 
    // Check if any middleware functions returned ERROR
    errFlag_t retFlag = NO_ERROR;
    if (combinedFlags != noErrorFlagVal)
    {
        retFlag = ERROR;
    }
    return retFlag;
}
 
errFlag_t InitMemories(void)
{
    const uint8_t noErrorFlagVal = (uint8_t)NO_ERROR;
    uint8_t combinedFlags        = noErrorFlagVal; // Default to NO_ERROR
 
    const bool lockStackLimit = (INIT_STACK_LIMIT_LOCK == ENABLED);
 
    // Use bitwise 'OR' to combine return flags (assumes ERROR and NO_ERROR are nonzero complements)
    combinedFlags |= (uint8_t)MW_SetNvmEccAllOnes(INIT_NVM_ECC_ALL_ONES);
    combinedFlags |= (uint8_t)MW_SetRamStackLimit(INIT_STACK_LIMIT, lockStackLimit);
 
    // Check if any middleware functions returned ERROR
    errFlag_t retFlag = NO_ERROR;
    if (combinedFlags != noErrorFlagVal)
    {
        retFlag = ERROR;
    }
    return retFlag;
}
 
void RunStartupDiagClock(void)
{
    /* Intentional misra-c2012-2.2/14.3 deviation */
    if (DIAG_STARTUP_CFM0 == ENABLED)
    {
        errFlag_t flag = MW_DiagClockCfm0();
        EH_HandleError(flag, ERRID_DIAG_CFM0);
    }
 
    /* Intentional misra-c2012-2.2/14.3 deviation */
    if (DIAG_STARTUP_CFM1 == ENABLED)
    {
        errFlag_t flag = MW_DiagClockCfm1();
        EH_HandleError(flag, ERRID_DIAG_CFM1);
    }
 
    /* Intentional misra-c2012-2.2/14.3 deviation */
    if (DIAG_STARTUP_CFD0 == ENABLED)
    {
        errFlag_t flag = MW_DiagClockCfd0Begin();
        EH_HandleError(flag, ERRID_DIAG_CFD0);
    }
 
    /* Intentional misra-c2012-2.2/14.3 deviation */
    if (DIAG_STARTUP_CFD1 == ENABLED)
    {
        errFlag_t flag = MW_DiagClockCfd1Begin();
        EH_HandleError(flag, ERRID_DIAG_CFD1);
    }
 
    return; // Avoid empty function warning if all diagnostics are DISABLED
}
 
void RunStartupDiagParity(void)
{
    errFlag_t flag = NO_ERROR;
 
    flag = MW_DiagRamParity();
    EH_HandleError(flag, ERRID_DIAG_PARITY_RAM);
 
    flag = MW_DiagNvmParity();
    EH_HandleError(flag, ERRID_DIAG_PARITY_NVM);
}
 
void RunStartupDiagEcc(void)
{
    errFlag_t flag = NO_ERROR;
 
    flag = MW_DiagRamEcc();
    EH_HandleError(flag, ERRID_DIAG_ECC_RAM);
 
    flag = MW_DiagNvmFlashEcc();
    EH_HandleError(flag, ERRID_DIAG_ECC_FLASH);
 
    /* Intentional misra-c2012-2.2/14.3 deviation */
    if (DIAG_STARTUP_ECC_EEPROM == ENABLED)
    {
        flag = MW_DiagNvmEepromEcc();
        EH_HandleError(flag, ERRID_DIAG_ECC_EEPROM);
    }
}
 
void RunStartupDiagErrorCh(void)
{
    /* Intentional misra-c2012-2.2/14.3 deviation */
    if (DIAG_STARTUP_ERRCH_SPLIM == ENABLED)
    {
        errFlag_t flag = MW_DiagErrorChannelSplim();
        EH_HandleError(flag, ERRID_DIAG_ERRCH_SPLIM);
    }
 
    /* Intentional misra-c2012-2.2/14.3 deviation */
    if (DIAG_STARTUP_ERRCH_CFD0 == ENABLED)
    {
        errFlag_t flag = MW_DiagErrorChannelCfd0();
        EH_HandleError(flag, ERRID_DIAG_ERRCH_CFD0);
    }
 
    /* Intentional misra-c2012-2.2/14.3 deviation */
    if (DIAG_STARTUP_ERRCH_CFD1 == ENABLED)
    {
        errFlag_t flag = MW_DiagErrorChannelCfd1();
        EH_HandleError(flag, ERRID_DIAG_ERRCH_CFD1);
    }
 
    /* Intentional misra-c2012-2.2/14.3 deviation */
    if (DIAG_STARTUP_ERRCH_CFM0 == ENABLED)
    {
        errFlag_t flag = MW_DiagErrorChannelCfm0();
        EH_HandleError(flag, ERRID_DIAG_ERRCH_CFM0);
    }
 
    /* Intentional misra-c2012-2.2/14.3 deviation */
    if (DIAG_STARTUP_ERRCH_CFM1 == ENABLED)
    {
        errFlag_t flag = MW_DiagErrorChannelCfm1();
        EH_HandleError(flag, ERRID_DIAG_ERRCH_CFM1);
    }
 
    /* Intentional misra-c2012-2.2/14.3 deviation */
    if (DIAG_STARTUP_ERRCH_EEPROM == ENABLED)
    {
        errFlag_t flag = MW_DiagErrorChannelEeprom();
        EH_HandleError(flag, ERRID_DIAG_ERRCH_EEPROM);
    }
 
    /* Intentional misra-c2012-2.2/14.3 deviation */
    if (DIAG_STARTUP_ERRCH_EVSYS0 == ENABLED)
    {
        errFlag_t flag = MW_DiagErrorChannelEvsys0();
        EH_HandleError(flag, ERRID_DIAG_ERRCH_EVSYS0);
    }
 
    /* Intentional misra-c2012-2.2/14.3 deviation */
    if (DIAG_STARTUP_ERRCH_EVSYS1 == ENABLED)
    {
        errFlag_t flag = MW_DiagErrorChannelEvsys1();
        EH_HandleError(flag, ERRID_DIAG_ERRCH_EVSYS1);
    }
 
    return; // Avoid empty function warning if all diagnostics are DISABLED
}
 
// Translates Error ID criticality to Error Channel severity and sets I/O float based on config
static void DetermineErrChConfigs(errChConfigs_t* configs)
{
    configs->vregfail = GetErrChConfig(ERRID_VREGFAIL_CH);
    configs->buserr   = GetErrChConfig(ERRID_BUSERR_CH);
    configs->ram2     = GetErrChConfig(ERRID_RAM2_CH);
    configs->flash2   = GetErrChConfig(ERRID_FLASH2_CH);
    configs->opc      = GetErrChConfig(ERRID_OPC_CH);
    configs->splim    = GetErrChConfig(ERRID_SPLIM_CH);
    configs->ram1     = GetErrChConfig(ERRID_RAM1_CH);
    configs->flash1   = GetErrChConfig(ERRID_FLASH1_CH);
    configs->vregwarn = GetErrChConfig(ERRID_VREGWARN_CH);
    configs->cfd0     = GetErrChConfig(ERRID_CFD0_CH);
    configs->cfd1     = GetErrChConfig(ERRID_CFD1_CH);
    configs->cfm0     = GetErrChConfig(ERRID_CFM0_CH);
    configs->cfm1     = GetErrChConfig(ERRID_CFM1_CH);
    configs->swdt     = GetErrChConfig(ERRID_SWDT_CH);
    configs->eeprom   = GetErrChConfig(ERRID_EEPROM_CH);
    configs->evsys0   = GetErrChConfig(ERRID_EVSYS0_CH);
    configs->evsys1   = GetErrChConfig(ERRID_EVSYS1_CH);
}
 
// Converts criticality to severity and sets I/O float based on that severity for a given Error ID
static errChConfig_t GetErrChConfig(errId_t id)
{
    // Assume CRITICAL criticality by default
    errChConfig_t channel = { .severity = ERRCH_SEVERITY_CRITICAL, .floatIo = true };
 
    // Read error handler config to translate the Error ID criticality to an error channel severity
    const errCrit_t errorIdCrit = errorIdCritLut[id];
 
    // IGNORE is not a valid channel severity, use default register value
    if ((errorIdCrit == NON_CRITICAL) || (errorIdCrit == IGNORE))
    {
        channel.severity = ERRCH_SEVERITY_NONCRITICAL;
        channel.floatIo  = (INIT_FLOAT_NONCRITICAL == ENABLED);
    }
    else if (errorIdCrit == NOTIFICATION)
    {
        channel.severity = ERRCH_SEVERITY_NOTIFICATION;
        channel.floatIo  = (INIT_FLOAT_NOTIFICATION == ENABLED);
    }
    else
    {
        // Channel already set to CRITICAL where I/O float is always enabled
    }
 
    return channel;
}