hw_watchdog.h

Go to the documentation of this file.

 
#ifndef HW_WATCHDOG_H_
#define HW_WATCHDOG_H_
 
 
#include <stdbool.h>
#include <stdint.h>
#include <sdk_defs.h>
 
#define NMI_MAGIC_NUMBER                0xDEADBEEF
 
extern volatile uint32_t nmi_event_data[9];
 
typedef enum {
        HW_WDG_RESET_NMI = 0,     
        HW_WDG_RESET_RST = 1      
} HW_WDG_RESET;
 
typedef void (*hw_watchdog_interrupt_cb)(unsigned long *exception_args);
 
 
__ALWAYS_RETAINED_CODE bool hw_watchdog_freeze(void);
 
__RETAINED_CODE bool hw_watchdog_unfreeze(void);
 
__STATIC_FORCEINLINE bool hw_watchdog_check_write_busy(void)
{
        return (!!(REG_GETF(SYS_WDOG, WATCHDOG_CTRL_REG, WRITE_BUSY)));
}
 
__STATIC_INLINE void hw_watchdog_write_value_ctrl(bool enable)
{
        while (hw_watchdog_check_write_busy());
        if (enable) {
                REG_SETF(SYS_WDOG, WATCHDOG_REG, WDOG_WEN, 0x0);
        }
        else {
                REG_SETF(SYS_WDOG, WATCHDOG_REG, WDOG_WEN, 0xff);
        }
}
 
__STATIC_FORCEINLINE void hw_watchdog_set_pos_val(uint16_t value)
{
        uint32_t tmp;
 
        ASSERT_WARNING(SYS_WDOG_WATCHDOG_REG_WDOG_VAL_Msk >= value); // check if reload value is greater than max allowed value
        ASSERT_WARNING(!REG_GETF(SYS_WDOG, WATCHDOG_REG, WDOG_WEN)); // can not write register if WDOG_WEN is not zero
        tmp = SYS_WDOG->WATCHDOG_REG;
        REG_SET_FIELD(SYS_WDOG, WATCHDOG_REG, WDOG_VAL_NEG, tmp, 0);
        REG_SET_FIELD(SYS_WDOG, WATCHDOG_REG, WDOG_VAL, tmp, value);
 
        /* Wait until a new WDOG_VAL can be written in the Watchdog timer */
        while (hw_watchdog_check_write_busy());
 
        /* Write a new WDOG_VAL in the Watchdog timer */
        SYS_WDOG->WATCHDOG_REG = tmp;
 
}
 
__STATIC_INLINE void hw_watchdog_set_neg_val(uint16_t value)
{
        uint32_t tmp;
 
        ASSERT_WARNING(SYS_WDOG_WATCHDOG_REG_WDOG_VAL_Msk >= value); // check if reload value is greater than max allowed value
        ASSERT_WARNING(!REG_GETF(SYS_WDOG, WATCHDOG_REG, WDOG_WEN)); // can not write register if WDOG_WEN is not zero
        tmp = SYS_WDOG->WATCHDOG_REG;
        REG_SET_FIELD(SYS_WDOG, WATCHDOG_REG, WDOG_VAL_NEG, tmp, 1);
        REG_SET_FIELD(SYS_WDOG, WATCHDOG_REG, WDOG_VAL, tmp, value);
 
        /* Wait until a new WDOG_VAL can be written in the Watchdog timer */
        while (hw_watchdog_check_write_busy());
 
        /* Write a new WDOG_VAL in the Watchdog timer */
        SYS_WDOG->WATCHDOG_REG = tmp;
 
}
 
__STATIC_INLINE uint16_t hw_watchdog_get_val(void)
{
        // The watchdog value cannot be read while watchdog is busy writing a new value
        while (hw_watchdog_check_write_busy());
 
        return REG_GETF(SYS_WDOG, WATCHDOG_REG, WDOG_VAL);
}
 
__STATIC_FORCEINLINE void hw_watchdog_gen_RST(void)
{
        REG_SET_BIT(SYS_WDOG, WATCHDOG_CTRL_REG, NMI_RST);
}
 
__STATIC_FORCEINLINE void hw_watchdog_gen_NMI(void)
{
        REG_CLR_BIT(SYS_WDOG, WATCHDOG_CTRL_REG, NMI_RST);
}
 
__STATIC_INLINE void hw_watchdog_freeze_ctrl(bool enable)
{
        if (enable) {
                REG_SET_BIT(SYS_WDOG, WATCHDOG_CTRL_REG, WDOG_FREEZE_EN);
        }
        else {
                REG_CLR_BIT(SYS_WDOG, WATCHDOG_CTRL_REG, WDOG_FREEZE_EN);
        }
}
 
void hw_watchdog_register_int(hw_watchdog_interrupt_cb handler);
 
__RETAINED_CODE void hw_watchdog_unregister_int(void);
 
__RETAINED_CODE void hw_watchdog_handle_int(unsigned long *hardfault_args);
 
HW_WDG_RESET hw_watchdog_is_irq_or_rst_gen(void);
 
 
#endif /* HW_WATCHDOG_H_ */