drivers: watchdog: Support Renesas RX independent watchdog timer driver

sangtranjc · quytranpzz · commit c7e5fcb5b3a1 · 2025-09-15T16:34:28.000Z
Add initial support for independent watchdog driver for Renesas RX
with r_iwdt_rx RDP HAL

Signed-off-by: Sang Tran &lt;sang.tran.jc@renesas.com&gt;
diff --git a/drivers/watchdog/CMakeLists.txt b/drivers/watchdog/CMakeLists.txt
@@ -62,6 +62,7 @@ zephyr_library_sources_ifdef(CONFIG_WDT_ANDES_ATCWDT200 wdt_andes_atcwdt200.c)
 zephyr_library_sources_ifdef(CONFIG_WDT_NXP_FS26 wdt_nxp_fs26.c)
 zephyr_library_sources_ifdef(CONFIG_WDT_SHELL wdt_shell.c)
 zephyr_library_sources_ifdef(CONFIG_WDT_RENESAS_RA wdt_renesas_ra.c)
+zephyr_library_sources_ifdef(CONFIG_WDT_RENESAS_RX_IWDT wdt_renesas_rx_iwdt.c)
 zephyr_library_sources_ifdef(CONFIG_WDT_NXP_EWM wdt_nxp_ewm.c)
 
 zephyr_library_sources_ifdef(CONFIG_WDT_TI_RTI wdt_ti_rti.c)
diff --git a/drivers/watchdog/Kconfig b/drivers/watchdog/Kconfig
@@ -153,6 +153,8 @@ source "drivers/watchdog/Kconfig.rts5912"
 
 source "drivers/watchdog/Kconfig.renesas_ra"
 
+source "drivers/watchdog/Kconfig.renesas_rx"
+
 source "drivers/watchdog/Kconfig.wch"
 
 source "drivers/watchdog/Kconfig.nxp_ewm"
diff --git a/drivers/watchdog/Kconfig.renesas_rx b/drivers/watchdog/Kconfig.renesas_rx
@@ -0,0 +1,41 @@
+# Renesas RX Watchdog configuration
+
+# Copyright (c) 2025 Renesas Electronics Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+config WDT_RENESAS_RX_IWDT
+	bool "Renesas RX Series Independent Watchdog Driver"
+	default y
+	depends on DT_HAS_RENESAS_RX_IWDT_ENABLED
+	select HAS_WDT_DISABLE_AT_BOOT
+	select USE_RX_RDP_IWDT
+	help
+	  Enable Renesas RX series watchdog driver.
+
+if WDT_RENESAS_RX_IWDT
+
+config WDT_RENESAS_RX_IWDT_USE_NMI
+	bool "Non-maskable interrupt for IWDT"
+	default y
+	help
+	  Enable NMI for IWDT.
+
+choice
+	prompt "IWDT Start Mode"
+	default WDT_RENESAS_RX_IWDT_REGISTER_START_MODE
+	help
+	  Select the IWDT start mode.
+	  - WDT_RENESAS_RX_IWDT_AUTO_START_MODE: Counting automatically starts after a reset
+	  (auto-start mode), controlled by option function select register 0 (OFS0).
+	  - WDT_RENESAS_RX_IWDT_REGISTER_START_MODE: Counting is started by refreshing the counter.
+	  (controlled by the IWDT registers)
+
+config WDT_RENESAS_RX_IWDT_AUTO_START_MODE
+	bool "Start IWDT automatically on reset"
+
+config WDT_RENESAS_RX_IWDT_REGISTER_START_MODE
+	bool "IWDT Start Mode Select"
+
+endchoice
+
+endif # WDT_RENESAS_RX_IWDT
diff --git a/drivers/watchdog/wdt_renesas_rx_iwdt.c b/drivers/watchdog/wdt_renesas_rx_iwdt.c
@@ -0,0 +1,251 @@
+/*
+ * Copyright (c) 2025 Renesas Electronics Corporation and/or its affiliates
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @brief Independent Watchdog (IWDT) Driver for Renesas RX
+ */
+
+#define DT_DRV_COMPAT renesas_rx_iwdt
+
+#include <zephyr/drivers/watchdog.h>
+#include <soc.h>
+#include <zephyr/kernel.h>
+#include <stdlib.h>
+#include <zephyr/arch/rx/sw_nmi_table.h>
+
+#include "r_iwdt_rx_if.h"
+
+#include <platform.h>
+
+#define LOG_LEVEL CONFIG_WDT_LOG_LEVEL
+#include <zephyr/logging/log.h>
+LOG_MODULE_REGISTER(wdt_iwdt_rx);
+
+#define IWDT_NODELABEL    DT_NODELABEL(iwdt)
+#define IWDT_NMI_VECTOR   2
+
+#ifdef CONFIG_WDT_RENESAS_RX_IWDT_REGISTER_START_MODE
+#define IWDT_WINDOW_START DT_PROP(IWDT_NODELABEL, window_start)
+#define IWDT_WINDOW_END   DT_PROP(IWDT_NODELABEL, window_end)
+#endif /* CONFIG_WDT_RENESAS_RX_IWDT_REGISTER_START_MODE */
+
+#define WDT_RENESAS_RX_SUPPORTED_FLAGS (WDT_FLAG_RESET_NONE | WDT_FLAG_RESET_SOC)
+struct wdt_iwdt_rx_config {
+	struct st_iwdt *const regs;
+	const struct device *clock_dev;
+};
+
+struct wdt_iwdt_rx_data {
+	wdt_callback_t callback;
+	iwdt_config_t iwdt_config;
+	bool timeout_installed;
+};
+
+#if CONFIG_WDT_RENESAS_RX_IWDT_USE_NMI
+static void wdt_iwdt_isr(const struct device *dev)
+{
+	struct wdt_iwdt_rx_data *data = dev->data;
+
+	if (data->callback) {
+		data->callback(dev, 0);
+	}
+}
+#endif /* CONFIG_WDT_RENESAS_RX_IWDT_USE_NMI */
+
+static int wdt_iwdt_rx_disable(const struct device *dev)
+{
+	ARG_UNUSED(dev);
+
+	/* watchdog cannot be stopped once started */
+	LOG_ERR("Independent Watchdog cannot be stopped once started");
+
+	return -EPERM;
+}
+
+static int wdt_iwdt_rx_feed(const struct device *dev, int channel_id)
+{
+	ARG_UNUSED(dev);
+	ARG_UNUSED(channel_id);
+	iwdt_err_t err;
+
+	/* Reset counter */
+	err = R_IWDT_Control(IWDT_CMD_REFRESH_COUNTING, NULL);
+	if (err != IWDT_SUCCESS) {
+		return -EIO;
+	}
+
+	return 0;
+}
+
+static int wdt_iwdt_rx_install_timeout(const struct device *dev, const struct wdt_timeout_cfg *cfg)
+{
+	struct wdt_iwdt_rx_data *data = dev->data;
+
+	if (cfg->window.min > cfg->window.max || cfg->window.max == 0) {
+		return -EINVAL;
+	}
+
+	if ((cfg->flags & ~WDT_RENESAS_RX_SUPPORTED_FLAGS) != 0) {
+		return -ENOTSUP;
+	}
+
+	if (cfg->callback != NULL && (cfg->flags & WDT_FLAG_RESET_MASK) != 0) {
+		LOG_ERR("WDT_FLAG_RESET_NONE should be chosen in case of interrupt response");
+		return -ENOTSUP;
+	}
+
+#ifdef CONFIG_WDT_RENESAS_RX_IWDT_AUTO_START_MODE
+	/* In auto-start mode, IWDT is started by OFS setting when the chip is reset.
+	 * So timeout and other parameters must be configured via Kconfig.
+	 * Runtime configuration is ignored.
+	 */
+	if (CONFIG_WDT_RENESAS_RX_OFS0_IWDTRSTIRQS == 0) {
+		if ((cfg->flags & WDT_FLAG_RESET_MASK) != WDT_FLAG_RESET_NONE) {
+			LOG_ERR("Reset flag is not consistent with OFS setting");
+			return -EINVAL;
+		}
+	} else if (CONFIG_WDT_RENESAS_RX_OFS0_IWDTRSTIRQS == 1) {
+		if ((cfg->flags & WDT_FLAG_RESET_MASK) == WDT_FLAG_RESET_NONE) {
+			LOG_ERR("Reset flag is not consistent with OFS setting");
+			return -EINVAL;
+		}
+	} else {
+		LOG_ERR("Invalid OFS setting");
+		return -EINVAL;
+	}
+
+	LOG_WRN("IWDT is auto-started by OFS. Timeout and other parameters must be configured via "
+		"Kconfig, runtime configuration is ignored.");
+#ifdef CONFIG_WDT_RENESAS_RX_IWDT_USE_NMI
+	data->callback = cfg->callback;
+#endif
+	data->timeout_installed = true;
+	return 0;
+#else /* CONFIG_WDT_RENESAS_RX_IWDT_AUTO_START_MODE */
+	const struct wdt_iwdt_rx_config *iwdt_cfg = dev->config;
+	uint32_t clock_rate;
+	int ret;
+
+	/* Get the iwdt clock rate in hz */
+	ret = clock_control_get_rate(iwdt_cfg->clock_dev, NULL, &clock_rate);
+	if (ret != 0) {
+		return ret;
+	}
+
+	uint32_t clock_rate_khz = clock_rate / 1000;
+
+	const uint16_t timeout_period[4] = {128, 512, 1024, 2048};
+	const uint16_t clock_divide[6][2] = {{IWDT_CLOCK_DIV_1, 1},     {IWDT_CLOCK_DIV_16, 16},
+					     {IWDT_CLOCK_DIV_32, 32},   {IWDT_CLOCK_DIV_64, 64},
+					     {IWDT_CLOCK_DIV_128, 128}, {IWDT_CLOCK_DIV_256, 256}};
+	int16_t last_error = INT16_MAX;
+	int32_t error;
+	uint16_t iwdt_tops = 0;
+	uint16_t iwdt_clock_div = 0;
+	uint16_t iwdt_timeout = ((uint32_t)timeout_period[0] * clock_divide[0][1]) / clock_rate_khz;
+
+	for (int idx_p = 0; idx_p < 4; idx_p++) {
+		for (int idx_d = 0; idx_d < 6; idx_d++) {
+			iwdt_timeout = ((uint32_t)timeout_period[idx_p] * clock_divide[idx_d][1]) /
+				       clock_rate_khz;
+			error = cfg->window.max - iwdt_timeout;
+
+			if (error < 0) {
+				break;
+			}
+
+			if (error < last_error) {
+				last_error = error;
+				iwdt_tops = idx_p;
+				iwdt_clock_div = clock_divide[idx_d][0];
+			}
+		}
+	}
+
+	data->iwdt_config.timeout = iwdt_tops;
+	data->iwdt_config.iwdtclk_div = iwdt_clock_div;
+	data->iwdt_config.window_start = IWDT_WINDOW_START;
+	data->iwdt_config.window_end = IWDT_WINDOW_END;
+	data->iwdt_config.timeout_control =
+		(cfg->flags & WDT_FLAG_RESET_MASK) != 0 ? IWDT_TIMEOUT_RESET : IWDT_TIMEOUT_NMI;
+	data->iwdt_config.count_stop_enable = IWDT_COUNT_STOP_DISABLE;
+
+	data->timeout_installed = true;
+
+#if CONFIG_WDT_RENESAS_RX_IWDT_USE_NMI
+	data->callback = cfg->callback;
+#endif
+	return 0;
+
+#endif /* CONFIG_WDT_RENESAS_RX_IWDT_AUTO_START_MODE */
+}
+
+static int wdt_iwdt_rx_setup(const struct device *dev, uint8_t options)
+{
+	struct wdt_iwdt_rx_data *data = dev->data;
+
+	if (!data->timeout_installed) {
+		return -EINVAL;
+	}
+
+#ifdef CONFIG_WDT_RENESAS_RX_IWDT_USE_NMI
+	nmi_enable(IWDT_NMI_VECTOR, (nmi_callback_t)wdt_iwdt_isr, (void *)dev);
+#endif /* CONFIG_WDT_RENESAS_RX_IWDT_USE_NMI */
+
+#if CONFIG_WDT_RENESAS_RX_IWDT_AUTO_START_MODE
+	LOG_WRN("WDT is configured in auto-start mode, setup via API is not supported");
+	return 0;
+#else /* CONFIG_WDT_RENESAS_RX_IWDT_AUTO_START_MODE */
+
+	iwdt_err_t err;
+	int ret;
+
+	if (options & WDT_OPT_PAUSE_HALTED_BY_DBG) {
+		return -ENOTSUP;
+	}
+
+	if (options & WDT_OPT_PAUSE_IN_SLEEP) {
+		data->iwdt_config.count_stop_enable = IWDT_COUNT_STOP_ENABLE;
+	} else {
+		data->iwdt_config.count_stop_enable = IWDT_COUNT_STOP_DISABLE;
+	}
+
+	err = R_IWDT_Open(&data->iwdt_config);
+	if (err != IWDT_SUCCESS) {
+		return -EINVAL;
+	}
+
+	ret = wdt_iwdt_rx_feed(dev, 0);
+	if (ret != 0) {
+		return ret;
+	}
+
+	return 0;
+#endif /* CONFIG_WDT_RENESAS_RX_IWDT_AUTO_START_MODE */
+}
+
+static DEVICE_API(wdt, wdt_iwdt_rx_api) = {
+	.disable = wdt_iwdt_rx_disable,
+	.feed = wdt_iwdt_rx_feed,
+	.install_timeout = wdt_iwdt_rx_install_timeout,
+	.setup = wdt_iwdt_rx_setup,
+};
+
+#define IWDT_RENESAS_RX_DEFINE(idx)                                                                \
+	static struct wdt_iwdt_rx_config iwdt_rx_cfg##idx = {                                      \
+		.regs = (struct st_iwdt *)DT_REG_ADDR(IWDT_NODELABEL),                             \
+		.clock_dev = DEVICE_DT_GET(DT_CLOCKS_CTLR(idx)),                                   \
+	};                                                                                         \
+	static struct wdt_iwdt_rx_data iwdt_rx_data##idx = {                                       \
+		.timeout_installed = false,                                                        \
+		.iwdt_config = {.count_stop_enable = IWDT_COUNT_STOP_DISABLE,                      \
+				.timeout_control = IWDT_TIMEOUT_RESET},                            \
+	};                                                                                         \
+                                                                                                   \
+	DEVICE_DT_DEFINE(idx, NULL, NULL, &iwdt_rx_data##idx, &iwdt_rx_cfg##idx, POST_KERNEL,      \
+			 CONFIG_KERNEL_INIT_PRIORITY_DEVICE, &wdt_iwdt_rx_api);
+
+DT_FOREACH_STATUS_OKAY(renesas_rx_iwdt, IWDT_RENESAS_RX_DEFINE);
diff --git a/dts/bindings/watchdog/renesas,rx-iwdt.yaml b/dts/bindings/watchdog/renesas,rx-iwdt.yaml
@@ -0,0 +1,39 @@
+# Copyright (c) 2025 Renesas Electronics Corporation and/or its affiliates
+# SPDX-License-Identifier: Apache-2.0
+
+description: Renesas RX Independent Watchdog
+
+compatible: "renesas,rx-iwdt"
+
+include: base.yaml
+
+properties:
+  reg:
+    required: true
+
+  clocks:
+    required: true
+
+  window-start:
+    required: true
+    type: int
+    enum: [0, 0x1000, 0x2000, 0x3000]
+    description: |
+      The start of the window in clock cycles. The watchdog will reset the system
+      if the watchdog is not refreshed within the window.
+      - 0: 25%
+      - 0x1000: 50%
+      - 0x2000: 75%
+      - 0x3000: 100% (window end position is not specified.)
+
+  window-end:
+    required: true
+    type: int
+    enum: [0, 0x100, 0x200, 0x300]
+    description: |
+      The end of the window in clock cycles. The watchdog will reset the system
+      if the watchdog is not refreshed within the window.
+      - 0: 75%
+      - 0x200: 50%
+      - 0x200: 25%
+      - 0x300: 0% (window start position is not specified.)
diff --git a/modules/Kconfig.renesas b/modules/Kconfig.renesas
@@ -356,4 +356,9 @@ config USE_RX_RDP_ADC
 	help
 	  Enable RX RDP ADC driver
 
+config USE_RX_RDP_IWDT
+	bool
+	help
+	  Enable RX RDP IWDT driver
+
 endif # HAS_RENESAS_RX_RDP
