watchdog.h

Go to the documentation of this file.

 
#ifndef INFUSE_SDK_DRIVERS_WATCHDOG_H_
#define INFUSE_SDK_DRIVERS_WATCHDOG_H_
 
#include <zephyr/kernel.h>
#include <zephyr/device.h>
#include <zephyr/toolchain.h>
 
#include <zephyr/drivers/watchdog.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
#define INFUSE_WATCHDOG_DEV DEVICE_DT_GET(DT_ALIAS(watchdog0))
 
#define INFUSE_WATCHDOG_FEED_PERIOD                                                                \
        K_MSEC(CONFIG_INFUSE_WATCHDOG_PERIOD_MS - CONFIG_INFUSE_WATCHDOG_FEED_EARLY_MS)
 
#define _INFUSE_WATCHDOG_CB                                                                        \
        COND_CODE_1(CONFIG_HAS_WDT_NO_CALLBACKS, (NULL), (infuse_watchdog_expired))
 
#define INFUSE_WATCHDOG_DEFAULT_TIMEOUT_CFG                                                        \
        (struct wdt_timeout_cfg)                                                                   \
        {                                                                                          \
                .window =                                                                          \
                        {                                                                          \
                                .min = 0,                                                          \
                                .max = CONFIG_INFUSE_WATCHDOG_PERIOD_MS,                           \
                        },                                                                         \
                .flags = WDT_FLAG_RESET_SOC, .callback = _INFUSE_WATCHDOG_CB,                      \
        }
 
#if defined(CONFIG_INFUSE_WATCHDOG) || defined(__DOXYGEN__)
 
#define INFUSE_WATCHDOG_REGISTER_SYS_INIT(name, dependency, chan_name, period_name)                \
        static k_timeout_t period_name = K_FOREVER;                                                \
        static int chan_name;                                                                      \
        static int name##_register(void)                                                           \
        {                                                                                          \
                (void)period_name;                                                                 \
                chan_name =                                                                        \
                        IS_ENABLED(dependency) ? infuse_watchdog_install(&period_name) : -ENODEV;  \
                return 0;                                                                          \
        }                                                                                          \
        SYS_INIT(name##_register, POST_KERNEL, 0);
 
void infuse_watchdog_warning(const struct device *dev, int channel_id);
 
void infuse_watchdog_expired(const struct device *dev, int channel_id);
 
int infuse_watchdog_install(k_timeout_t *feed_period);
 
void infuse_watchdog_thread_register(int wdog_channel, k_tid_t thread);
 
int infuse_watchdog_thread_state_lookup(int wdog_channel, uint32_t *info1, uint32_t *info2);
 
int infuse_watchdog_start(void);
 
void infuse_watchdog_feed(int wdog_channel);
 
void infuse_watchdog_feed_all(void);
 
#else
 
#define INFUSE_WATCHDOG_REGISTER_SYS_INIT(name, dependency, chan_name, period_name)                \
        static k_timeout_t period_name = K_FOREVER;                                                \
        static int chan_name = 0
 
static inline int infuse_watchdog_install(k_timeout_t *feed_period)
{
        ARG_UNUSED(feed_period);
 
        return 0;
}
 
static inline void infuse_watchdog_thread_register(int wdog_channel, k_tid_t thread)
{
}
 
static inline int infuse_watchdog_thread_state_lookup(int wdog_channel, uint32_t *info1,
                                                      uint32_t *info2)
{
        ARG_UNUSED(wdog_channel);
        ARG_UNUSED(info1);
        ARG_UNUSED(info2);
 
        return -EINVAL;
}
 
static inline int infuse_watchdog_start(void)
{
        return 0;
}
 
static inline void infuse_watchdog_feed(int wdog_channel)
{
        ARG_UNUSED(wdog_channel);
}
 
static inline void infuse_watchdog_feed_all(void)
{
}
 
#endif /* defined(CONFIG_INFUSE_WATCHDOG) || defined(__DOXYGEN__) */
 
#ifdef __cplusplus
}
#endif
 
#endif /* INFUSE_SDK_DRIVERS_WATCHDOG_H_ */