midware_watchdog_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_swdt.h>
#include <driver_wdt.h>
#include <midware_watchdog_manager.h>
#include <midware_watchdog_manager_asm.h>
 
// Device-specific Includes
#include <xc.h>

#define UINT24_MAX 0x00FFFFFFUL
 
errFlag_t MW_GetSwdtPreclearError(void)
{
    const uint8_t regVal       = SWDT_ReadIntFlags();
    const uint8_t badpcMask    = (uint8_t)SWDT_BADPC_bm;
    const bool isPreclearError = ((regVal & badpcMask) == badpcMask);
 
    errFlag_t flag = NO_ERROR;
    if (isPreclearError)
    {
        flag = ERROR;
    }
 
    return flag;
}
 
errFlag_t MW_GetSwdtClearError(void)
{
    const uint8_t regVal    = SWDT_ReadIntFlags();
    const uint8_t badcMask  = (uint8_t)SWDT_BADC_bm;
    const bool isClearError = ((regVal & badcMask) == badcMask);
 
    errFlag_t flag = NO_ERROR;
    if (isClearError)
    {
        flag = ERROR;
    }
 
    return flag;
}
 
errFlag_t MW_GetSwdtUnexpectedCmdError(void)
{
    const uint8_t regVal            = SWDT_ReadIntFlags();
    const uint8_t unexpectedCmdMask = (uint8_t)SWDT_UC_bm;
    const bool isUnexpectedCmdError = ((regVal & unexpectedCmdMask) == unexpectedCmdMask);
 
    errFlag_t flag = NO_ERROR;
    if (isUnexpectedCmdError)
    {
        flag = ERROR;
    }
 
    return flag;
}
 
errFlag_t MW_GetSwdtCounterExpiredError(void)
{
    const uint8_t regVal      = SWDT_ReadIntFlags();
    const uint8_t expiredMask = (uint8_t)SWDT_EXP_bm;
    const bool isExpiredError = ((regVal & expiredMask) == expiredMask);
 
    errFlag_t flag = NO_ERROR;
    if (isExpiredError)
    {
        flag = ERROR;
    }
 
    return flag;
}
 
void MW_ClearSwdtErrors(void)
{
    // All error flags are cleared by writing the ERROR bit
    SWDT_WriteIntFlags((uint8_t)SWDT_ERROR_bm);
}
 
void MW_PreClearSwdt(void)
{
    /*
     * Assumes preclear can be received (PRECLEAR bit is set in INTFLAGS register).
     * If not, an error is reported in hardware, which is the desired behavior.
     */
    SWDT_WriteCommand((uint8_t)SWDT_COMMAND_PRECLEAR_gc);
}
 
void MW_ClearSwdt(void)
{
    bool isClosedWindow = true;
 
    while (isClosedWindow)
    {
        const uint8_t clearReadyMask = (uint8_t)(SWDT_CLEAR_bm);
 
        uint8_t regVal = SWDT_ReadIntFlags();
 
        isClosedWindow = ((regVal & clearReadyMask) != clearReadyMask);
    }
 
    SWDT_WriteCommand((uint8_t)SWDT_COMMAND_CLEAR_gc);
}
 
errFlag_t MW_SetSwdtResetValue(uint32_t resetVal)
{
    const uint32_t maxResetVal = UINT24_MAX;
    if (resetVal > maxResetVal)
    {
        /* cppcheck-suppress misra-c2012-15.5 */
        return ERROR;
    }
 
    if (resetVal == 0U)
    {
        /* cppcheck-suppress misra-c2012-15.5 */
        return ERROR;
    }
 
    SWDT_WriteResetValue(resetVal);
 
    return NO_ERROR;
}
 
errFlag_t MW_SetSwdtWindowValue(uint16_t window)
{
    if (window == 0U)
    {
        /* cppcheck-suppress misra-c2012-15.5 */
        return ERROR;
    }
 
    SWDT_WriteWindowValue(window);
 
    return NO_ERROR;
}
 
void MW_EnableSwdtInterrupts(void)
{
    SWDT_WriteIntControl((uint8_t)SWDT_ERROR_bm);
}
 
void MW_EnableSwdt(bool useCcp, bool useLock, bool useInstrMode)
{
    uint8_t registerConfig = (uint8_t)SWDT_ENABLE_bm;
 
    if (useCcp)
    {
        registerConfig |= (uint8_t)SWDT_CCP_bm;
    }
 
    if (useLock)
    {
        registerConfig |= (uint8_t)SWDT_LOCK_bm;
    }
 
    if (useInstrMode)
    {
        registerConfig |= (uint8_t)SWDT_MODE_bm;
    }
 
    SWDT_WriteControlA(registerConfig);
}
 
void MW_ClearWdt(void)
{
    // Watchdog cleared by issuing WDR instruction in assembly
    ASM_IssueWdrInstruction();
}
 
errFlag_t MW_SetWdtTimeout(wdtTimeout_t window, wdtTimeout_t period)
{
    if (window >= WDT_TIMEOUT_MAX)
    {
        /* cppcheck-suppress misra-c2012-15.5 */
        return ERROR;
    }
 
    if (period >= WDT_TIMEOUT_MAX)
    {
        /* cppcheck-suppress misra-c2012-15.5 */
        return ERROR;
    }
 
    const uint8_t windowConfig = (uint8_t)window << WDT_WINDOW_gp;
    const uint8_t periodConfig = (uint8_t)period << WDT_PERIOD_gp;
    WDT_WriteControlA(windowConfig | periodConfig);
 
    return NO_ERROR;
}