midware_power_manager.c

Go to the documentation of this file.

 
// Standard Library Includes
#include <stdbool.h>
#include <stdint.h>
 
// Framework Includes
#include <define_error_flags.h>
#include <driver_bodctrl.h>
#include <driver_slpctrl.h>
#include <midware_power_manager.h>
 
// Device-specific Includes
#include <xc.h>
 
errFlag_t MW_GetClearVlmError(void)
{
    const uint8_t regVal  = BODCTRL_ReadIntFlags();
    const uint8_t vlmMask = (uint8_t)BOD_VLMIF_bm;
    const bool isVlmError = ((regVal & vlmMask) == vlmMask);
 
    errFlag_t flag = NO_ERROR;
    if (isVlmError)
    {
        flag = ERROR;
        BODCTRL_WriteIntFlags(vlmMask); // The flag is cleared by writing the flag bitmask
    }
 
    return flag;
}
 
errFlag_t MW_GetClearVmonOverError(void)
{
    const uint8_t regVal  = SLPCTRL_ReadIntFlags();
    const uint8_t vovMask = (uint8_t)SLPCTRL_VOV_bm;
    const bool isVovError = ((regVal & vovMask) == vovMask);
 
    errFlag_t flag = NO_ERROR;
    if (isVovError)
    {
        flag = ERROR;
        SLPCTRL_WriteIntFlags(vovMask); // The flag is cleared by writing the flag bitmask
    }
 
    return flag;
}
 
errFlag_t MW_GetClearVmonUnderError(void)
{
    const uint8_t regVal  = SLPCTRL_ReadIntFlags();
    const uint8_t vuvMask = (uint8_t)SLPCTRL_VUV_bm;
    const bool isVuvError = ((regVal & vuvMask) == vuvMask);
 
    errFlag_t flag = NO_ERROR;
    if (isVuvError)
    {
        flag = ERROR;
        SLPCTRL_WriteIntFlags(vuvMask); // The flag is cleared by writing the flag bitmask
    }
 
    return flag;
}
 
errFlag_t MW_GetClearVmonDiagEntryError(void)
{
    const uint8_t regVal      = SLPCTRL_ReadIntFlags();
    const uint8_t vdenterMask = (uint8_t)SLPCTRL_VDENTER_bm;
    const bool isVdenterError = ((regVal & vdenterMask) == vdenterMask);
 
    errFlag_t flag = NO_ERROR;
    if (isVdenterError)
    {
        flag = ERROR;
        SLPCTRL_WriteIntFlags(vdenterMask); // The flag is cleared by writing the flag bitmask
    }
 
    return flag;
}
 
errFlag_t MW_GetClearVmonDiagExitError(void)
{
    const uint8_t regVal     = SLPCTRL_ReadIntFlags();
    const uint8_t vdexitMask = (uint8_t)SLPCTRL_VDEXIT_bm;
    const bool isVdexitError = ((regVal & vdexitMask) == vdexitMask);
 
    errFlag_t flag = NO_ERROR;
    if (isVdexitError)
    {
        flag = ERROR;
        SLPCTRL_WriteIntFlags(vdexitMask); // The flag is cleared by writing the flag bitmask
    }
 
    return flag;
}
 
errFlag_t MW_GetClearVmonInternalError(void)
{
    const uint8_t regVal   = SLPCTRL_ReadIntFlags();
    const uint8_t verrMask = (uint8_t)SLPCTRL_VERR_bm;
    const bool isVerrError = ((regVal & verrMask) == verrMask);
 
    errFlag_t flag = NO_ERROR;
    if (isVerrError)
    {
        flag = ERROR;
        SLPCTRL_WriteIntFlags(verrMask); // The flag is cleared by writing the flag bitmask
    }
 
    return flag;
}
 
errFlag_t MW_GetClearVmonSleepEntryError(void)
{
    const uint8_t regVal   = SLPCTRL_ReadIntFlags();
    const uint8_t vslpMask = (uint8_t)SLPCTRL_VSLP_bm;
    const bool isVslpError = ((regVal & vslpMask) == vslpMask);
 
    errFlag_t flag = NO_ERROR;
    if (isVslpError)
    {
        flag = ERROR;
        SLPCTRL_WriteIntFlags(vslpMask); // The flag is cleared by writing the flag bitmask
    }
 
    return flag;
}
 
errFlag_t MW_GetClearVmonDisabledError(void)
{
    const uint8_t regVal   = SLPCTRL_ReadIntFlags();
    const uint8_t vdisMask = (uint8_t)SLPCTRL_VDIS_bm;
    const bool isVdisError = ((regVal & vdisMask) == vdisMask);
 
    errFlag_t flag = NO_ERROR;
    if (isVdisError)
    {
        flag = ERROR;
        SLPCTRL_WriteIntFlags(vdisMask); // The flag is cleared by writing the flag bitmask
    }
 
    return flag;
}
 
errFlag_t MW_GetClearSleepError(void)
{
    const uint8_t regVal   = SLPCTRL_ReadIntFlags();
    const uint8_t serrMask = (uint8_t)SLPCTRL_SERR_bm;
    const bool isSerrError = ((regVal & serrMask) == serrMask);
 
    errFlag_t flag = NO_ERROR;
    if (isSerrError)
    {
        flag = ERROR;
        SLPCTRL_WriteIntFlags(serrMask); // The flag is cleared by writing the flag bitmask
    }
 
    return flag;
}
 
void MW_EnablePowerInterrupts(void)
{
    const uint8_t bodctrlIntMask   = (uint8_t)BOD_VLMIE_bm;
    const uint8_t slpctrlIntConfig = (uint8_t)SLPCTRL_VOV_bm | (uint8_t)SLPCTRL_VUV_bm
                                     | (uint8_t)SLPCTRL_VDENTER_bm | (uint8_t)SLPCTRL_VDEXIT_bm
                                     | (uint8_t)SLPCTRL_VERR_bm | (uint8_t)SLPCTRL_VSLP_bm
                                     | (uint8_t)SLPCTRL_VDIS_bm | (uint8_t)SLPCTRL_SERR_bm;
 
    BODCTRL_SetIntControl(bodctrlIntMask);
    SLPCTRL_WriteIntControl(slpctrlIntConfig);
}
 
errFlag_t MW_ConfigVlm(vlmThreshold_t threshold, vlmTrigger_t trigger)
{
    const bool outOfRange = (threshold >= VLM_THRESHOLD_MAX) || (trigger >= VLM_TRIGGER_MAX);
 
    if (outOfRange)
    {
        /* cppcheck-suppress misra-c2012-15.5 */
        return ERROR;
    }
 
    const uint8_t regVal = (uint8_t)threshold << BOD_VLMLVL_gp;
    BODCTRL_WriteVlmControlA(regVal);
 
    const uint8_t groupConfig = (uint8_t)trigger << BOD_VLMCFG_gp;
    BODCTRL_ModifyIntControl((uint8_t)BOD_VLMCFG_gm, groupConfig);
 
    return NO_ERROR;
}
 
errFlag_t MW_SetSleepMode(sleepMode_t sleepMode)
{
    if (sleepMode >= SLP_MODE_MAX)
    {
        /* cppcheck-suppress misra-c2012-15.5 */
        return ERROR;
    }
 
    const uint8_t groupConfig = (uint8_t)sleepMode << SLPCTRL_SMODE_gp;
    SLPCTRL_ModifyControlA((uint8_t)SLPCTRL_SMODE_gm, groupConfig);
 
    return NO_ERROR;
}
 
void MW_SetVmonSleep(bool enableInSleep, bool useFullPowerMode)
{
    uint8_t registerConfig = (uint8_t)SLPCTRL_PMODE_AUTO_gc;
 
    if (useFullPowerMode)
    {
        registerConfig = (uint8_t)SLPCTRL_PMODE_FULL_gc;
    }
 
    if (enableInSleep)
    {
        registerConfig |= (uint8_t)SLPCTRL_VMONSEN_bm;
    }
 
    SLPCTRL_WriteVregControl(registerConfig);
}