midware_reset_manager.c

Go to the documentation of this file.

 
// Standard Library Includes
#include <stdbool.h>
 
// Framework includes
#include <driver_errctrl.h>
#include <driver_rstctrl.h>
#include <driver_wdt.h>
#include <midware_reset_manager.h>
 
// Device-specific Includes
#include <xc.h>
 
// Private function prototypes
static uint8_t GetClearResetFlagPosition(void);
static resetReason_t GetClearMachineCheckReason(void);
static uint8_t GetClearMachineCheckMask(void);
static resetReason_t GetErrorControllerReason(void);
static resetReason_t GetWatchdogReason(void);
 
void MW_ResetDevice(void)
{
    RSTCTRL_WriteSoftwareResetRegister((uint8_t)RSTCTRL_SWRST_bm);
}
 
resetReason_t MW_GetClearResetReason(void)
{
    const uint8_t flagPos            = GetClearResetFlagPosition();
    const uint8_t machineCheckPos    = (uint8_t)RSTCTRL_MCRF_bp;
    const uint8_t errorControllerPos = (uint8_t)RSTCTRL_ECRF_bp;
    const uint8_t watchdogPos        = (uint8_t)RSTCTRL_WDRF_bp;
 
    resetReason_t resetReason = RSTRSN_UNKNOWN;
    if (flagPos == machineCheckPos) // Check if machine check reset
    {
        resetReason = GetClearMachineCheckReason();
    }
    else if (flagPos == errorControllerPos) // Check if error controller reset
    {
        resetReason = GetErrorControllerReason();
    }
    else if (flagPos == watchdogPos) // Check if watchdog reset
    {
        resetReason = GetWatchdogReason();
    }
    else
    {
        const uint8_t msb = 7U;
        if (flagPos <= msb) // Ensure the flag position is within the valid range
        {
            // Calculate the reset reason enum value based on the flag position
            const uint8_t flagOffset = (uint8_t)RSTRSN_POWER_ON;
            const uint8_t reasonVal  = flagOffset + flagPos;
 
            /* Intentional misra-c2012-10.5 deviation */
            resetReason = (resetReason_t)(reasonVal);
        }
    }
 
    return resetReason;
}
 
// Locates first set bit and returns its corresponding bit position
static uint8_t GetClearResetFlagPosition(void)
{
    const uint8_t allFlagsMask = 0xFFU;
    const uint8_t resetFlags   = RSTCTRL_ReadResetFlagRegister();
    RSTCTRL_WriteResetFlagRegister(allFlagsMask); // Clear all flags
    uint8_t flagPosition = 0xFFU; // Default to invalid position in case none are set
 
    // Check from most significant bit (MSb) to least significant bit (LSb)
    const int8_t msb = 7;
    for (int8_t bitPos = msb; bitPos >= 0; bitPos--)
    {
        // Check if bit is set
        uint8_t flagMask = ((uint8_t)1 << (uint8_t)bitPos);
        if ((resetFlags & flagMask) == flagMask)
        {
            // Store flag position, exit loop
            flagPosition = (uint8_t)bitPos;
            break;
        }
    }
    return flagPosition;
}
 
static resetReason_t GetClearMachineCheckReason(void)
{
    resetReason_t resetReason    = RSTRSN_MCHK_UNKNOWN;
    uint8_t machineCheckPosition = GetClearMachineCheckMask();
 
    const uint8_t msb = 9U;
    if (machineCheckPosition <= msb) // Check if the flag position is within valid range
    {
        // Calculate the reset reason based on the flag position
        const uint8_t machineCheckOffset = (uint8_t)RSTRSN_MCHK_OCD;
        const uint8_t reasonVal          = machineCheckOffset + machineCheckPosition;
 
        /* Intentional misra-c2012-10.5 deviation */
        resetReason = (resetReason_t)(reasonVal);
    }
 
    return resetReason;
}
 
static uint8_t GetClearMachineCheckMask(void)
{
    const uint8_t allFlagsMask = 0xFFU;
    uint16_t resetFlags        = (uint16_t)RSTCTRL_ReadMachineCheckFlagsA();
    resetFlags |= (uint16_t)RSTCTRL_ReadMachineCheckFlagsB() << 8;
    RSTCTRL_WriteMachineCheckFlagsA(allFlagsMask);
    RSTCTRL_WriteMachineCheckFlagsB((uint8_t)RSTCTRL_UPDI_bm | (uint8_t)RSTCTRL_CFD_bm);
    uint8_t machineCheckPosition = 0xFFU; // Default to invalid position in case none are set
 
    // Check from most significant bit (msb) to least significant bit (lsb)
    const int8_t msb = 9;
    for (int8_t bitPos = msb; bitPos >= 0; bitPos--)
    {
        // Check if bit is set
        const uint16_t flagMask = (uint16_t)1U << (uint8_t)bitPos;
        if ((resetFlags & flagMask) == flagMask)
        {
            // Store flag position, exit loop
            machineCheckPosition = (uint8_t)bitPos;
            break;
        }
    }
    return machineCheckPosition;
}
 
static resetReason_t GetErrorControllerReason(void)
{
    resetReason_t resetReason = RSTRSN_ERRCH_UNKNOWN;
    const uint8_t cause       = ERRCTRL_ReadResetCause();
    const uint8_t maxCause    = (uint8_t)ERRCTRL_CAUSE_EVSYS1_gc;
    if (cause <= maxCause) // Check if the identified cause is within valid range
    {
        // Calculate the reset reason enum value based on the cause value
        const uint8_t errorChannelOffset = (uint8_t)RSTRSN_ERRCH_VREGFAIL;
        const uint8_t reasonVal          = errorChannelOffset + cause;
 
        /* Intentional misra-c2012-10.5 deviation */
        resetReason = (resetReason_t)(reasonVal);
    }
    return resetReason;
}
 
static resetReason_t GetWatchdogReason(void)
{
    const uint8_t status      = WDT_ReadStatus();
    const uint8_t causeMask   = (uint8_t)WDT_CAUSE_bm;
    const bool isTimeoutCause = ((status & causeMask) == causeMask);
 
    resetReason_t resetReason = RSTRSN_WDT_OUTSIDE;
    if (isTimeoutCause)
    {
        resetReason = RSTRSN_WDT_TIMEOUT;
    }
 
    return resetReason;
}