mirrors/u-boot
0
0
Fork 0
mirror of https://github.com/u-boot/u-boot.git synced 2024-11-27 22:56:49 +08:00
Code Issues Packages Projects Releases Wiki Activity

sandbox: add test of wdt-uclass' watchdog_reset()

Browse Source 
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>
This commit is contained in:
Rasmus Villemoes 2021-08-19 11:57:06 +02:00 committed by Stefan Roese
parent a9346b93b4
commit 4171c57472
2 changed files with 56 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
arch/sandbox/dts/test.dts
View File

@ -796,6 +796,7 @@
gpio-wdt {
gpios = <&gpio_a 7 0>;
compatible = "linux,wdt-gpio";
hw_margin_ms = <100>;
always-running;
};
@ -1278,6 +1279,7 @@
wdt0: wdt@0 {
compatible = "sandbox,wdt";
hw_margin_ms = <200>;
};
axi: axi@0 {

54
test/dm/wdt.c
View 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);