]> git.dujemihanovic.xyz Git - u-boot.git/commitdiff
sandbox: add test of wdt-uclass' watchdog_reset()
authorRasmus Villemoes <rasmus.villemoes@prevas.dk>
Thu, 19 Aug 2021 09:57:06 +0000 (11:57 +0200)
committerStefan Roese <sr@denx.de>
Tue, 31 Aug 2021 10:04:03 +0000 (12:04 +0200)
Check that the watchdog_reset() implementation in wdt-uclass behaves
as expected:

- resets all activated watchdog devices
- leaves unactivated/stopped devices alone
- that the rate-limiting works, with a per-device threshold

Reviewed-by: Simon Glass <sjg@chromium.org>
Reviewed-by: Stefan Roese <sr@denx.de>
Signed-off-by: Rasmus Villemoes <rasmus.villemoes@prevas.dk>
arch/sandbox/dts/test.dts
test/dm/wdt.c

index e91387a81f889c8e0d4935a158a7c38c6f877d36..1399a14929b15e308422f5c0b58ea6e624a2769a 100644 (file)
        gpio-wdt {
                gpios = <&gpio_a 7 0>;
                compatible = "linux,wdt-gpio";
+               hw_margin_ms = <100>;
                always-running;
        };
 
 
        wdt0: wdt@0 {
                compatible = "sandbox,wdt";
+               hw_margin_ms = <200>;
        };
 
        axi: axi@0 {
index abff853a023d9a756fb9242e88292b03a3f642c5..ee615f0e1487b86098313c0483ed288e7a85a0c7 100644 (file)
@@ -12,6 +12,8 @@
 #include <dm/test.h>
 #include <test/test.h>
 #include <test/ut.h>
+#include <linux/delay.h>
+#include <watchdog.h>
 
 /* Test that watchdog driver functions are called */
 static int dm_test_wdt_base(struct unit_test_state *uts)
@@ -73,3 +75,55 @@ static int dm_test_wdt_gpio(struct unit_test_state *uts)
        return 0;
 }
 DM_TEST(dm_test_wdt_gpio, UT_TESTF_SCAN_FDT);
+
+static int dm_test_wdt_watchdog_reset(struct unit_test_state *uts)
+{
+       struct sandbox_state *state = state_get_current();
+       struct udevice *gpio_wdt, *sandbox_wdt;
+       struct udevice *gpio;
+       const u64 timeout = 42;
+       const int offset = 7;
+       uint reset_count;
+       int val;
+
+       ut_assertok(uclass_get_device_by_driver(UCLASS_WDT,
+                                               DM_DRIVER_GET(wdt_gpio), &gpio_wdt));
+       ut_assertnonnull(gpio_wdt);
+       ut_assertok(uclass_get_device_by_driver(UCLASS_WDT,
+                                               DM_DRIVER_GET(wdt_sandbox), &sandbox_wdt));
+       ut_assertnonnull(sandbox_wdt);
+       ut_assertok(uclass_get_device_by_name(UCLASS_GPIO, "base-gpios", &gpio));
+       ut_assertnonnull(gpio);
+
+       /* Neither device should be "started", so watchdog_reset() should be a no-op. */
+       reset_count = state->wdt.reset_count;
+       val = sandbox_gpio_get_value(gpio, offset);
+       watchdog_reset();
+       ut_asserteq(reset_count, state->wdt.reset_count);
+       ut_asserteq(val, sandbox_gpio_get_value(gpio, offset));
+
+       /* Start both devices. */
+       ut_assertok(wdt_start(gpio_wdt, timeout, 0));
+       ut_assertok(wdt_start(sandbox_wdt, timeout, 0));
+
+       /* Make sure both devices have just been pinged. */
+       timer_test_add_offset(100);
+       watchdog_reset();
+       reset_count = state->wdt.reset_count;
+       val = sandbox_gpio_get_value(gpio, offset);
+
+       /* The gpio watchdog should be pinged, the sandbox one not. */
+       timer_test_add_offset(30);
+       watchdog_reset();
+       ut_asserteq(reset_count, state->wdt.reset_count);
+       ut_asserteq(!val, sandbox_gpio_get_value(gpio, offset));
+
+       /* After another ~30ms, both devices should get pinged. */
+       timer_test_add_offset(30);
+       watchdog_reset();
+       ut_asserteq(reset_count + 1, state->wdt.reset_count);
+       ut_asserteq(val, sandbox_gpio_get_value(gpio, offset));
+
+       return 0;
+}
+DM_TEST(dm_test_wdt_watchdog_reset, UT_TESTF_SCAN_FDT);