midware_power_manager_diag.c

 
// Standard Library Includes
#include <stdbool.h>
#include <stdint.h>
 
// Framework Includes
#include <driver_cpuctrl.h>
#include <driver_errctrl.h>
#include <driver_slpctrl.h>
#include <midware_power_manager_diag.h>
#include <midware_shared_diag_private.h>
 
// Device-specific Includes
#include <xc.h>

#define CRITICAL_CH_CONFIG ((uint8_t)ERRCTRL_FLOAT_bm | (uint8_t)ERRCTRL_ERRLVL_CRITICAL_gc)
 
/*
 * Variables used for tracking internal state and restoring error channel configs after diagnostics
 * are complete. Must be written to atomically to avoid any race conditions.
 */
static volatile bool isDiagOngoing       = false;
static volatile uint8_t vregfailChBackup = CRITICAL_CH_CONFIG;
static volatile uint8_t vregwarnChBackup = CRITICAL_CH_CONFIG;
 
// Error Controller masks
static const uint32_t vregfailChMask = 1UL << ERRCTRL_ESF_0_bp;
static const uint32_t vregwarnChMask = 1UL << ERRCTRL_ESF_8_bp;
 
// Private function prototypes
static errFlag_t DiagVmonBegin(bool isOver);
static bool IsDiagVmonDone(bool isOver);
static errFlag_t DiagVmonEnd(bool isOver);
static errFlag_t VerifyDiagStartFlags(void);
static errFlag_t VerifyDiagEndFlags(bool isOver);
static void BackupVregChConfigs(void);
static void DisableVregChannels(void);
static void RestoreVregChConfigs(void);
 
errFlag_t MW_DiagVmonOverBegin(void)
{
    const bool isOver    = true;
    const errFlag_t flag = DiagVmonBegin(isOver);
    return flag;
}
 
bool MW_IsDiagVmonOverDone(void)
{
    const bool isOver = true;
    const bool isDone = IsDiagVmonDone(isOver);
    return isDone;
}
 
errFlag_t MW_DiagVmonOverEnd(void)
{
    const bool isOver    = true;
    const errFlag_t flag = DiagVmonEnd(isOver);
    return flag;
}
 
errFlag_t MW_DiagVmonUnderBegin(void)
{
    const bool isOver    = false;
    const errFlag_t flag = DiagVmonBegin(isOver);
    return flag;
}
 
bool MW_IsDiagVmonUnderDone(void)
{
    const bool isOver = false;
    const bool isDone = IsDiagVmonDone(isOver);
    return isDone;
}
 
errFlag_t MW_DiagVmonUnderEnd(void)
{
    const bool isOver    = false;
    const errFlag_t flag = DiagVmonEnd(isOver);
    return flag;
}
 
static errFlag_t DiagVmonBegin(bool isOver)
{
    const uint32_t errorChMask = vregwarnChMask | vregfailChMask;
    const bool isConfigurable  = IsErrChConfigurable(errorChMask);
    if (isDiagOngoing || !isConfigurable)
    {
        /* cppcheck-suppress misra-c2012-15.5 */
        return ERROR;
    }
 
    // Disable and backup global interrupts configuration
    AtomicSectionStart();
 
    // Prevent error injection from triggering a real error response
    BackupVregChConfigs();
    DisableVregChannels();
 
    uint8_t dmodeVal = (uint8_t)SLPCTRL_DMODE_UNDER_gc; // Starts undervoltage diagnostic by default
    if (isOver)
    {
        dmodeVal = (uint8_t)SLPCTRL_DMODE_OVER_gc;
    }
    SLPCTRL_WriteControlB(dmodeVal); // Start error injection
 
    const errFlag_t flag = VerifyDiagStartFlags();
 
    isDiagOngoing = true;
 
    // Restore global interrupts configuration
    AtomicSectionEnd();
 
    return flag;
}
 
static bool IsDiagVmonDone(bool isOver)
{
    bool isErrInjectionDone = false;
 
    if (isDiagOngoing)
    {
        const uint8_t intFlagVal     = SLPCTRL_ReadIntFlags();
        const uint8_t vdexitFlagMask = (uint8_t)SLPCTRL_VDEXIT_bm;
 
        uint8_t flagMask = (uint8_t)SLPCTRL_VUV_bm;
        if (isOver)
        {
            flagMask = (uint8_t)SLPCTRL_VOV_bm;
        }
 
        bool isFlagSet       = (intFlagVal & flagMask) == flagMask;
        bool isVdexitFlagSet = (intFlagVal & vdexitFlagMask) == vdexitFlagMask;
        if (isFlagSet || isVdexitFlagSet)
        {
            isErrInjectionDone = true;
        }
    }
 
    return isErrInjectionDone;
}
 
static errFlag_t DiagVmonEnd(bool isOver)
{
    if (isDiagOngoing == false)
    {
        /* cppcheck-suppress misra-c2012-15.5 */
        return ERROR;
    }
 
    // Disable and backup global interrupts configuration
    AtomicSectionStart();
 
    // Take VMON out of diagnostic mode
    SLPCTRL_WriteControlB((uint8_t)SLPCTRL_DMODE_NO_gc); // If already timed out, this has no effect
 
    const errFlag_t diagResult = VerifyDiagEndFlags(isOver);
 
    RestoreVregChConfigs();
 
    isDiagOngoing = false;
 
    // Restore global interrupts configuration
    AtomicSectionEnd();
 
    return diagResult;
}
 
// Verifies that the expected flags are set after starting a diagnostic and clears them
static errFlag_t VerifyDiagStartFlags(void)
{
    errFlag_t flag = ERROR;
 
    /*
     * When entering diagnostic mode, the VDENTER flag should be set, indicating that the error
     * injection has successfully started. This flag will also set the VREGWARN Error Channel. Both
     * of these are cleared here since they are not symptoms of errors in this case.
     */
    const uint8_t intFlagVal      = SLPCTRL_ReadIntFlags();
    const uint8_t vdenterFlagMask = (uint8_t)SLPCTRL_VDENTER_bm;
    bool isVdenterSet             = (intFlagVal & vdenterFlagMask) == vdenterFlagMask;
    if (isVdenterSet)
    {
        SLPCTRL_WriteIntFlags(vdenterFlagMask);     // Clear VDENTER interrupt flag
        ERRCTRL_WriteChannelStatus(vregwarnChMask); // Clear VREGWARN channel flag
        flag = NO_ERROR; // If VDENTER is set, the diagnostic was successfully initiated
    }
 
    return flag;
}
 
// Verifies that the expected flags are set when ending a diagnostic and clears them
static errFlag_t VerifyDiagEndFlags(bool isOver)
{
    errFlag_t diagResultFlag = ERROR;
    uint8_t flagMask         = (uint8_t)SLPCTRL_VUV_bm; // Checks undervoltage flag by default
    if (isOver)
    {
        flagMask = (uint8_t)SLPCTRL_VOV_bm;
    }
 
    const uint8_t intFlagVal = SLPCTRL_ReadIntFlags();
    const bool isFlagSet     = (intFlagVal & flagMask) == flagMask;
 
    const uint32_t chStatus    = ERRCTRL_ReadChannelStatus();
    const bool isVregwarnChSet = ((chStatus & vregwarnChMask) == vregwarnChMask);
    const bool isVregfailChSet = ((chStatus & vregfailChMask) == vregfailChMask);
 
    if ((isFlagSet && isVregfailChSet && isVregwarnChSet))
    {
        /*
         * If the VOV/VUV interrupt flag was set, that means that the VMON successfully detected and
         * reported the injected error. In addition, the VREGFAIL channel should have been set by
         * the VOV/VUV flag. The VREGWARN channel should also have been set once the VMON goes out
         * of diagnostic mode and sets VDEXIT, either through a timeout or manually exiting
         * diagnostic mode. All of these conditions need to be met for the diagnostic to be
         * considered successful.
         */
        diagResultFlag = NO_ERROR;
    }
 
    const uint8_t vdexitFlagMask = (uint8_t)SLPCTRL_VDEXIT_bm;
    SLPCTRL_WriteIntFlags(flagMask | vdexitFlagMask);            // Clear diagnostic interrupt flags
    ERRCTRL_WriteChannelStatus(vregfailChMask | vregwarnChMask); // Clear diagnosed Error Channels
 
    return diagResultFlag;
}
 
// Saves the VREG Error Channel configurations so they can be restored after the diagnostic is done
static void BackupVregChConfigs(void)
{
    vregfailChBackup = ERRCTRL_ReadConfigVregfail();
    vregwarnChBackup = ERRCTRL_ReadConfigVregwarn();
}
 
// Sets the VREG Error Channels to NOTIFICATION severity and disables I/O float
static void DisableVregChannels(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 disabledChConfig = (floatConfig | severityConfig);
 
    ERRCTRL_ModifyControlA(stateMask, (uint8_t)ERRCTRL_STATE_CONFIG_gc);
    ERRCTRL_WriteConfigVregfail(disabledChConfig);
    ERRCTRL_WriteConfigVregwarn(disabledChConfig);
    ERRCTRL_ModifyControlA(stateMask, (uint8_t)ERRCTRL_STATE_NORMAL_gc);
}
 
// Restores the VREG Error Channel configs to their backed up configurations
static void RestoreVregChConfigs(void)
{
    const uint8_t stateMask = (uint8_t)ERRCTRL_STATE_gm;
    ERRCTRL_ModifyControlA(stateMask, (uint8_t)ERRCTRL_STATE_CONFIG_gc);
    ERRCTRL_WriteConfigVregfail(vregfailChBackup);
    ERRCTRL_WriteConfigVregwarn(vregwarnChBackup);
    ERRCTRL_ModifyControlA(stateMask, (uint8_t)ERRCTRL_STATE_NORMAL_gc);
}