watchdog_app.c

Go to the documentation of this file.

/**
 * \file watchdog_app.c
 *
 * \brief Watchdog application wrapper for initializing, starting, and feeding the
 * watchdog timer using Zephyr watchdog APIs.
 *
 * \copyright 2021 Nordic Semiconductor ASA
 * \note SPDX-License-Identifier: LicenseRef-Nordic-5-Clause
 *
 */
 
#include "../jfet_files/jfet_common.h"
#include <zephyr/device.h>
#include <zephyr/drivers/watchdog.h>
#include <zephyr/kernel.h>
 
#include "watchdog_app.h"
 
#include <zephyr/logging/log.h>
// If a specific logging level is configured for the watchdog module, enable it here.
// LOG_MODULE_REGISTER(watchdog_app, CONFIG_WATCHDOG_LOG_LEVEL);
LOG_MODULE_REGISTER(watchdog_app);
 
#define WDT_FEED_WORKER_DELAY_MS ((CONFIG_WATCHDOG_APPLICATION_TIMEOUT_SEC * 1000) / 2)
#define WATCHDOG_TIMEOUT_MSEC (CONFIG_WATCHDOG_APPLICATION_TIMEOUT_SEC * 1000)
 
/**
 * \brief Watchdog configuration storage.
 *
 * This structure holds the watchdog device pointer used for
 * initialization and operation of the watchdog timer.
 */
struct wdt_config_storage {
  const struct device *wdt; /*!< Pointer to the watchdog device instance. */
};
 
/**
 * \brief Watchdog runtime data storage.
 *
 * This structure holds the installed watchdog channel ID and the delayed work
 * item used to periodically feed the watchdog.
 */
struct wdt_data_storage {
  int wdt_channel_id;                            /*!< Watchdog channel ID installed with the driver. */
  struct k_work_delayable system_workqueue_work; /*!< Delayed work used to feed the watchdog periodically. */
};
 
static watchdog_evt_handler_t app_evt_handler; //!< Registered application event handler.
 
static bool init_and_start; //!< Flag set when the library has been initialized and started. */
 
/**
 * \fn static void watchdog_notify_event(const struct watchdog_evt *evt)
 *
 * \brief Notify the registered watchdog event handler of an event.
 *
 * \param evt Pointer to the watchdog event data.
 */
static void watchdog_notify_event(const struct watchdog_evt *evt) {
  __ASSERT(evt != NULL, "Library event not found");
 
  if (app_evt_handler != NULL) {
    app_evt_handler(evt);
  }
}
 
/** \brief Watchdog device configuration storage. */
static const struct wdt_config_storage wdt_config = {
    .wdt = DEVICE_DT_GET(DT_NODELABEL(wdt)),
};
 
static struct wdt_data_storage wdt_data;
 
/** \fn static void primary_feed_worker(struct k_work *work_desc)
 *
 * \brief Primary watchdog feeding work handler.
 *
 * This work handler feeds the watchdog timer periodically unless
 * the stopWDTFeed flag is set. If feeding succeeds, the work is
 * rescheduled after WDT_FEED_WORKER_DELAY_MS. If the flag is set,
 * the function returns early to allow the watchdog to timeout.
 *
 * \param work_desc Pointer to the work item descriptor.
 */
static void primary_feed_worker(struct k_work *work_desc) {
  if (stopWDTFeed)
    return; /* force a WDT timeout */
  struct watchdog_evt evt = {
      .type = WATCHDOG_EVT_FEED,
  };
 
  int err = wdt_feed(wdt_config.wdt, wdt_data.wdt_channel_id);
 
  //    myPrintkI("Feeding watchdog\n");
  LOG_DBG("Feeding watchdog");
 
  if (err) {
    myPrintkE("Cannot feed watchdog. Error code: %d\n", err);
    LOG_ERR("Cannot feed watchdog. Error code: %d", err);
  } else {
    k_work_reschedule(&wdt_data.system_workqueue_work, K_MSEC(WDT_FEED_WORKER_DELAY_MS));
  }
 
  watchdog_notify_event(&evt);
}
 
/** \fn watchdog_timeout_install(const struct wdt_config_storage *config, struct wdt_data_storage *data)
 *
 * \brief Installs a watchdog timeout configuration and registers it with the WDT device.
 *
 * \param config Pointer to the watchdog configuration storage containing the WDT device.
 * \param data Pointer to the watchdog data storage where the channel ID will be stored.
 *
 * \return 0 on success, -EFAULT if timeout installation fails.
 */
static int watchdog_timeout_install(const struct wdt_config_storage *config, struct wdt_data_storage *data) {
  static const struct wdt_timeout_cfg wdt_settings = {.window =
                                                          {
                                                              .min = 0,
                                                              .max = WATCHDOG_TIMEOUT_MSEC,
                                                          },
                                                      .callback = NULL,
                                                      .flags = WDT_FLAG_RESET_SOC};
  struct watchdog_evt evt = {.type = WATCHDOG_EVT_TIMEOUT_INSTALLED, .timeout = WATCHDOG_TIMEOUT_MSEC};
 
  __ASSERT_NO_MSG(config != NULL);
  __ASSERT_NO_MSG(data != NULL);
 
  data->wdt_channel_id = wdt_install_timeout(config->wdt, &wdt_settings);
  if (data->wdt_channel_id < 0) {
    myPrintkE("Cannot install watchdog timer! Error code: %d\n", data->wdt_channel_id);
    LOG_ERR("Cannot install watchdog timer! Error code: %d", data->wdt_channel_id);
    return -EFAULT;
  }
 
  watchdog_notify_event(&evt);
 
  myPrintkI("Watchdog timeout installed. Timeout: %d Seconds\n", CONFIG_WATCHDOG_APPLICATION_TIMEOUT_SEC);
  LOG_DBG("Watchdog timeout installed. Timeout: %d", CONFIG_WATCHDOG_APPLICATION_TIMEOUT_SEC);
  return 0;
}
 
/** \fn watchdog_start(const struct wdt_config_storage *config)
 *
 * \brief Starts the watchdog timer hardware instance.
 *
 * \param config Pointer to watchdog configuration storage.
 *
 * \return 0 on success, or a negative errno on failure.
 */
static int watchdog_start(const struct wdt_config_storage *config) {
  __ASSERT_NO_MSG(config != NULL);
 
  int err = wdt_setup(config->wdt, WDT_OPT_PAUSE_HALTED_BY_DBG);
 
  if (err) {
    myPrintkE("Cannot start watchdog! Error code: %d\n", err);
    LOG_ERR("Cannot start watchdog! Error code: %d", err);
  } else {
    myPrintkI("Watchdog started\n");
    LOG_DBG("Watchdog started");
  }
  return err;
}
 
/**
 * \fn static int watchdog_feed_enable(const struct wdt_config_storage *config, struct wdt_data_storage *data)
 *
 * \brief Enable periodic feeding of the hardware watchdog.
 *
 * \param config: Pointer to the stored watchdog configuration (must not be NULL).
 * \param data:   Pointer to runtime watchdog data (must not be NULL).
 *
 * This function initializes a delayed work item which will periodically
 * call primary_feed_worker to feed the watchdog and schedules the first
 * invocation. It also performs an immediate feed to ensure the watchdog
 * does not expire while setup completes and notifies interested subsystems
 * about the feed event.
 *
 * \return 0 on success, or a negative errno on failure.
 */
static int watchdog_feed_enable(const struct wdt_config_storage *config, struct wdt_data_storage *data) {
  __ASSERT_NO_MSG(config != NULL);
  __ASSERT_NO_MSG(data != NULL);
 
  /* Prepare a feed event to notify subscribers after a successful feed */
  struct watchdog_evt evt = {
      .type = WATCHDOG_EVT_FEED,
  };
 
  /* Initialize the delayed work that will perform periodic feeds */
  k_work_init_delayable(&data->system_workqueue_work, primary_feed_worker);
 
  /* Perform an immediate feed on the configured channel */
  int err = wdt_feed(config->wdt, data->wdt_channel_id);
 
  if (err) {
    LOG_ERR("Cannot feed watchdog. Error code: %d", err);
    return err;
  }
 
  /* Notify listeners that a feed occurred */
  watchdog_notify_event(&evt);
 
  /* Schedule periodic feed worker (delay defined by WDT_FEED_WORKER_DELAY_MS) */
  k_work_schedule(&data->system_workqueue_work, K_MSEC(WDT_FEED_WORKER_DELAY_MS));
  myPrintkI("Watchdog feed enabled. Timeout: %d Seconds\n", WDT_FEED_WORKER_DELAY_MS / 1000);
  LOG_DBG("Watchdog feed enabled. Timeout: %d", WDT_FEED_WORKER_DELAY_MS / 1000);
 
  return err;
}
 
/** \fn static int watchdog_enable(const struct wdt_config_storage *config, struct wdt_data_storage *data)
 *
 * \brief Enable and initialize the watchdog: verify device readiness, install the
 * timeout, start the watchdog hardware, and enable periodic feeding.
 *
 * \param config: pointer to watchdog configuration storage (wdt device and params)
 * \param data: pointer to watchdog runtime data storage (channel id, workqueue, etc.)
 *
 * \return 0 on success or a negative errno on failure.
 */
static int watchdog_enable(const struct wdt_config_storage *config, struct wdt_data_storage *data) {
  int err;
 
  __ASSERT_NO_MSG(data != NULL);
 
  if (!device_is_ready(config->wdt)) {
    myPrintkI("Watchdog device not ready\n");
    LOG_ERR("Watchdog device not ready");
    return -ENODEV;
  }
 
  err = watchdog_timeout_install(config, data);
  if (err) {
    return err;
  }
 
  err = watchdog_start(config);
  if (err) {
    return err;
  }
 
  err = watchdog_feed_enable(config, data);
  if (err) {
    return err;
  }
 
  return 0;
}
 
/** \fn int watchdog_init_and_start(void)
 *
 * \brief Initialize and start the watchdog timer.
 *
 * \return 0 on success, or a negative error code on failure.
 */
int watchdog_init_and_start(void) {
  int err;
  struct watchdog_evt evt = {.type = WATCHDOG_EVT_START};
 
  myPrintkI("start watchdog\n");
  LOG_INF("start watchdog\n");
  LOG_WRN("start watchdog\n");
  LOG_DBG("start watchdog\n");
  LOG_INF("start watchdog\n");
 
  err = watchdog_enable(&wdt_config, &wdt_data);
  if (err) {
    myPrintkE("Failed to enable watchdog, error: %d\n", err);
    LOG_ERR("Failed to enable watchdog, error: %d", err);
    return err;
  }
 
  watchdog_notify_event(&evt);
 
  init_and_start = true;
  return 0;
}
 
/** \fn void watchdog_register_handler(watchdog_evt_handler_t evt_handler)
 *
 * @brief Register handler to receive watchdog callback events.
 *
 *  @note The library only allows for one event handler to be registered
 *           at a time. A passed in event handler in this function will
 *           overwrite the previously set event handler.
 *
 *  @param evt_handler Event handler. Handler is de-registered if parameter is NULL.
 */
void watchdog_register_handler(watchdog_evt_handler_t evt_handler) {
  if (evt_handler == NULL) {
    app_evt_handler = NULL;
 
    myPrintkI("Previously registered handler %p de-registered\n", app_evt_handler);
    LOG_DBG("Previously registered handler %p de-registered", app_evt_handler);
 
    return;
  }
 
  myPrintkI("Registering handler %p\n", evt_handler);
  LOG_DBG("Registering handler %p", evt_handler);
 
  app_evt_handler = evt_handler;
 
  /* If the application watchdog already has been initialized and started prior to an
   * external module registering a handler, the newly registered handler is notified that
   * the library has been started and that a watchdog timeout has been installed.
   */
  if (init_and_start) {
    struct watchdog_evt evt = {
        .type = WATCHDOG_EVT_START,
    };
 
    watchdog_notify_event(&evt);
 
    evt.type = WATCHDOG_EVT_TIMEOUT_INSTALLED;
    evt.timeout = WATCHDOG_TIMEOUT_MSEC;
 
    watchdog_notify_event(&evt);
  }
}