1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3 * Copyright 2017 Google, Inc
4 */
5
6 #include <dm.h>
7 #include <time.h>
8 #include <wdt.h>
9 #include <asm/gpio.h>
10 #include <asm/state.h>
11 #include <asm/test.h>
12 #include <dm/test.h>
13 #include <test/test.h>
14 #include <test/ut.h>
15 #include <linux/delay.h>
16 #include <u-boot/schedule.h>
17 #include <watchdog.h>
18
19 /* Test that watchdog driver functions are called */
dm_test_wdt_base(struct unit_test_state * uts)20 static int dm_test_wdt_base(struct unit_test_state *uts)
21 {
22 struct sandbox_state *state = state_get_current();
23 struct udevice *dev;
24 const u64 timeout = 42;
25
26 ut_assertok(uclass_get_device_by_driver(UCLASS_WDT,
27 DM_DRIVER_GET(wdt_sandbox), &dev));
28 ut_assertnonnull(dev);
29 ut_asserteq(0, state->wdt.counter);
30 ut_asserteq(false, state->wdt.running);
31
32 ut_assertok(wdt_start(dev, timeout, 0));
33 ut_asserteq(timeout, state->wdt.counter);
34 ut_asserteq(true, state->wdt.running);
35
36 uint reset_count = state->wdt.reset_count;
37 ut_assertok(wdt_reset(dev));
38 ut_asserteq(reset_count + 1, state->wdt.reset_count);
39 ut_asserteq(true, state->wdt.running);
40
41 ut_assertok(wdt_stop(dev));
42 ut_asserteq(false, state->wdt.running);
43
44 return 0;
45 }
46 DM_TEST(dm_test_wdt_base, UTF_SCAN_PDATA | UTF_SCAN_FDT);
47
dm_test_wdt_gpio_toggle(struct unit_test_state * uts)48 static int dm_test_wdt_gpio_toggle(struct unit_test_state *uts)
49 {
50 /*
51 * The sandbox wdt gpio is "connected" to gpio bank a, offset
52 * 7. Use the sandbox back door to verify that the gpio-wdt
53 * driver behaves as expected when using the 'toggle' algorithm.
54 */
55 struct udevice *wdt, *gpio;
56 const u64 timeout = 42;
57 const int offset = 8;
58 int val;
59
60 ut_assertok(uclass_get_device_by_name(UCLASS_WDT,
61 "wdt-gpio-toggle", &wdt));
62 ut_assertnonnull(wdt);
63
64 ut_assertok(uclass_get_device_by_name(UCLASS_GPIO, "base-gpios", &gpio));
65 ut_assertnonnull(gpio);
66 ut_assertok(wdt_start(wdt, timeout, 0));
67
68 val = sandbox_gpio_get_value(gpio, offset);
69 ut_assertok(wdt_reset(wdt));
70 ut_asserteq(!val, sandbox_gpio_get_value(gpio, offset));
71 ut_assertok(wdt_reset(wdt));
72 ut_asserteq(val, sandbox_gpio_get_value(gpio, offset));
73
74 ut_asserteq(-EOPNOTSUPP, wdt_stop(wdt));
75
76 return 0;
77 }
78 DM_TEST(dm_test_wdt_gpio_toggle, UTF_SCAN_FDT);
79
dm_test_wdt_gpio_level(struct unit_test_state * uts)80 static int dm_test_wdt_gpio_level(struct unit_test_state *uts)
81 {
82 /*
83 * The sandbox wdt gpio is "connected" to gpio bank a, offset
84 * 7. Use the sandbox back door to verify that the gpio-wdt
85 * driver behaves as expected when using the 'level' algorithm.
86 */
87 struct udevice *wdt, *gpio;
88 const u64 timeout = 42;
89 const int offset = 7;
90 int val;
91
92 ut_assertok(uclass_get_device_by_name(UCLASS_WDT,
93 "wdt-gpio-level", &wdt));
94 ut_assertnonnull(wdt);
95
96 ut_assertok(uclass_get_device_by_name(UCLASS_GPIO, "base-gpios", &gpio));
97 ut_assertnonnull(gpio);
98 ut_assertok(wdt_start(wdt, timeout, 0));
99
100 val = sandbox_gpio_get_value(gpio, offset);
101 ut_assertok(wdt_reset(wdt));
102 ut_asserteq(val, sandbox_gpio_get_value(gpio, offset));
103 ut_assertok(wdt_reset(wdt));
104 ut_asserteq(val, sandbox_gpio_get_value(gpio, offset));
105
106 ut_asserteq(-EOPNOTSUPP, wdt_stop(wdt));
107
108 return 0;
109 }
110 DM_TEST(dm_test_wdt_gpio_level, UTF_SCAN_FDT);
111
dm_test_wdt_watchdog_reset(struct unit_test_state * uts)112 static int dm_test_wdt_watchdog_reset(struct unit_test_state *uts)
113 {
114 struct sandbox_state *state = state_get_current();
115 struct udevice *gpio_wdt, *sandbox_wdt;
116 struct udevice *gpio;
117 const u64 timeout = 42;
118 const int offset = 8;
119 uint reset_count;
120 int val;
121
122 ut_assertok(uclass_get_device_by_name(UCLASS_WDT,
123 "wdt-gpio-toggle", &gpio_wdt));
124 ut_assertnonnull(gpio_wdt);
125 ut_assertok(uclass_get_device_by_driver(UCLASS_WDT,
126 DM_DRIVER_GET(wdt_sandbox), &sandbox_wdt));
127 ut_assertnonnull(sandbox_wdt);
128 ut_assertok(uclass_get_device_by_name(UCLASS_GPIO, "base-gpios", &gpio));
129 ut_assertnonnull(gpio);
130
131 /* Neither device should be "started", so watchdog_reset() should be a no-op. */
132 reset_count = state->wdt.reset_count;
133 val = sandbox_gpio_get_value(gpio, offset);
134 schedule();
135 ut_asserteq(reset_count, state->wdt.reset_count);
136 ut_asserteq(val, sandbox_gpio_get_value(gpio, offset));
137
138 /* Start both devices. */
139 ut_assertok(wdt_start(gpio_wdt, timeout, 0));
140 ut_assertok(wdt_start(sandbox_wdt, timeout, 0));
141
142 /* Make sure both devices have just been pinged. */
143 timer_test_add_offset(100);
144 schedule();
145 reset_count = state->wdt.reset_count;
146 val = sandbox_gpio_get_value(gpio, offset);
147
148 /* The gpio watchdog should be pinged, the sandbox one not. */
149 timer_test_add_offset(30);
150 schedule();
151 ut_asserteq(reset_count, state->wdt.reset_count);
152 ut_asserteq(!val, sandbox_gpio_get_value(gpio, offset));
153
154 /* After another ~30ms, both devices should get pinged. */
155 timer_test_add_offset(30);
156 schedule();
157 ut_asserteq(reset_count + 1, state->wdt.reset_count);
158 ut_asserteq(val, sandbox_gpio_get_value(gpio, offset));
159
160 return 0;
161 }
162 DM_TEST(dm_test_wdt_watchdog_reset, UTF_SCAN_FDT);
163