1 // SPDX-License-Identifier: GPL-2.0+
3 * Copyright (C) 2015 Google, Inc
4 * Written by Simon Glass <sjg@chromium.org>
17 #include <test/test.h>
20 /* Simple RTC sanity check */
21 static int dm_test_rtc_base(struct unit_test_state *uts)
25 ut_asserteq(-ENODEV, uclass_get_device_by_seq(UCLASS_RTC, 2, &dev));
26 ut_assertok(uclass_get_device(UCLASS_RTC, 0, &dev));
27 ut_assertok(uclass_get_device(UCLASS_RTC, 1, &dev));
31 DM_TEST(dm_test_rtc_base, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
33 static void show_time(const char *msg, struct rtc_time *time)
35 printf("%s: %02d/%02d/%04d %02d:%02d:%02d\n", msg,
36 time->tm_mday, time->tm_mon, time->tm_year,
37 time->tm_hour, time->tm_min, time->tm_sec);
40 static int cmp_times(struct rtc_time *expect, struct rtc_time *time, bool show)
44 same = expect->tm_sec == time->tm_sec;
45 same &= expect->tm_min == time->tm_min;
46 same &= expect->tm_hour == time->tm_hour;
47 same &= expect->tm_mday == time->tm_mday;
48 same &= expect->tm_mon == time->tm_mon;
49 same &= expect->tm_year == time->tm_year;
51 show_time("expected", expect);
52 show_time("actual", time);
55 return same ? 0 : -EINVAL;
58 /* Set and get the time */
59 static int dm_test_rtc_set_get(struct unit_test_state *uts)
61 struct rtc_time now, time, cmp;
62 struct udevice *dev, *emul;
63 long offset, old_offset, old_base_time;
65 ut_assertok(uclass_get_device(UCLASS_RTC, 0, &dev));
66 ut_assertok(dm_rtc_get(dev, &now));
68 ut_assertok(i2c_emul_find(dev, &emul));
69 ut_assert(emul != NULL);
71 /* Tell the RTC to go into manual mode */
72 old_offset = sandbox_i2c_rtc_set_offset(emul, false, 0);
73 old_base_time = sandbox_i2c_rtc_get_set_base_time(emul, -1);
75 memset(&time, '\0', sizeof(time));
82 ut_assertok(dm_rtc_set(dev, &time));
84 memset(&cmp, '\0', sizeof(cmp));
85 ut_assertok(dm_rtc_get(dev, &cmp));
86 ut_assertok(cmp_times(&time, &cmp, true));
88 memset(&time, '\0', sizeof(time));
95 ut_assertok(dm_rtc_set(dev, &time));
97 memset(&cmp, '\0', sizeof(cmp));
98 ut_assertok(dm_rtc_get(dev, &cmp));
99 ut_assertok(cmp_times(&time, &cmp, true));
101 /* Increment by 1 second */
102 offset = sandbox_i2c_rtc_set_offset(emul, false, 0);
103 sandbox_i2c_rtc_set_offset(emul, false, offset + 1);
105 memset(&cmp, '\0', sizeof(cmp));
106 ut_assertok(dm_rtc_get(dev, &cmp));
107 ut_asserteq(1, cmp.tm_sec);
109 /* Check against original offset */
110 sandbox_i2c_rtc_set_offset(emul, false, old_offset);
111 ut_assertok(dm_rtc_get(dev, &cmp));
112 ut_assertok(cmp_times(&now, &cmp, true));
114 /* Back to the original offset */
115 sandbox_i2c_rtc_set_offset(emul, false, 0);
116 memset(&cmp, '\0', sizeof(cmp));
117 ut_assertok(dm_rtc_get(dev, &cmp));
118 ut_assertok(cmp_times(&now, &cmp, true));
120 /* Increment the base time by 1 emul */
121 sandbox_i2c_rtc_get_set_base_time(emul, old_base_time + 1);
122 memset(&cmp, '\0', sizeof(cmp));
123 ut_assertok(dm_rtc_get(dev, &cmp));
124 if (now.tm_sec == 59) {
125 ut_asserteq(0, cmp.tm_sec);
127 ut_asserteq(now.tm_sec + 1, cmp.tm_sec);
130 old_offset = sandbox_i2c_rtc_set_offset(emul, true, 0);
134 DM_TEST(dm_test_rtc_set_get, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
136 static int dm_test_rtc_read_write(struct unit_test_state *uts)
138 struct rtc_time time;
139 struct udevice *dev, *emul;
143 ut_assertok(uclass_get_device(UCLASS_RTC, 0, &dev));
145 memcpy(buf, "car", 4);
146 ut_assertok(dm_rtc_write(dev, REG_AUX0, buf, 4));
147 memset(buf, '\0', sizeof(buf));
148 ut_assertok(dm_rtc_read(dev, REG_AUX0, buf, 4));
149 ut_asserteq(memcmp(buf, "car", 4), 0);
152 ut_assertok(dm_rtc_write(dev, REG_AUX0, ®, 1));
153 memset(buf, '\0', sizeof(buf));
154 ut_assertok(dm_rtc_read(dev, REG_AUX0, buf, 4));
155 ut_asserteq(memcmp(buf, "bar", 4), 0);
158 ut_assertok(dm_rtc_write(dev, REG_AUX2, ®, 1));
159 memset(buf, '\0', sizeof(buf));
160 ut_assertok(dm_rtc_read(dev, REG_AUX1, buf, 3));
161 ut_asserteq(memcmp(buf, "at", 3), 0);
163 ut_assertok(i2c_emul_find(dev, &emul));
164 ut_assert(emul != NULL);
166 old_offset = sandbox_i2c_rtc_set_offset(emul, false, 0);
167 ut_assertok(dm_rtc_get(dev, &time));
169 ut_assertok(dm_rtc_read(dev, REG_SEC, ®, 1));
170 ut_asserteq(time.tm_sec, reg);
171 ut_assertok(dm_rtc_read(dev, REG_MDAY, ®, 1));
172 ut_asserteq(time.tm_mday, reg);
174 sandbox_i2c_rtc_set_offset(emul, true, old_offset);
178 DM_TEST(dm_test_rtc_read_write, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
180 /* Test 'rtc list' command */
181 static int dm_test_rtc_cmd_list(struct unit_test_state *uts)
183 console_record_reset();
185 run_command("rtc list", 0);
186 ut_assert_nextline("RTC #0 - rtc@43");
187 ut_assert_nextline("RTC #1 - rtc@61");
188 ut_assert_console_end();
192 DM_TEST(dm_test_rtc_cmd_list, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
194 /* Test 'rtc read' and 'rtc write' commands */
195 static int dm_test_rtc_cmd_rw(struct unit_test_state *uts)
197 console_record_reset();
199 run_command("rtc dev 0", 0);
200 ut_assert_nextline("RTC #0 - rtc@43");
201 ut_assert_console_end();
203 run_command("rtc write 0x30 aabb", 0);
204 ut_assert_console_end();
206 run_command("rtc read 0x30 2", 0);
207 ut_assert_nextline("00000030: aa bb ..");
208 ut_assert_console_end();
210 run_command("rtc dev 1", 0);
211 ut_assert_nextline("RTC #1 - rtc@61");
212 ut_assert_console_end();
214 run_command("rtc write 0x30 ccdd", 0);
215 ut_assert_console_end();
217 run_command("rtc read 0x30 2", 0);
218 ut_assert_nextline("00000030: cc dd ..");
219 ut_assert_console_end();
222 * Switch back to device #0, check that its aux registers
223 * still have the same values.
225 run_command("rtc dev 0", 0);
226 ut_assert_nextline("RTC #0 - rtc@43");
227 ut_assert_console_end();
229 run_command("rtc read 0x30 2", 0);
230 ut_assert_nextline("00000030: aa bb ..");
231 ut_assert_console_end();
235 DM_TEST(dm_test_rtc_cmd_rw, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
238 static int dm_test_rtc_reset(struct unit_test_state *uts)
241 struct udevice *dev, *emul;
242 long old_base_time, base_time;
244 ut_assertok(uclass_get_device(UCLASS_RTC, 0, &dev));
245 ut_assertok(dm_rtc_get(dev, &now));
247 ut_assertok(i2c_emul_find(dev, &emul));
248 ut_assert(emul != NULL);
250 old_base_time = sandbox_i2c_rtc_get_set_base_time(emul, 0);
252 ut_asserteq(0, sandbox_i2c_rtc_get_set_base_time(emul, -1));
254 /* Resetting the RTC should put he base time back to normal */
255 ut_assertok(dm_rtc_reset(dev));
256 base_time = sandbox_i2c_rtc_get_set_base_time(emul, -1);
257 ut_asserteq(old_base_time, base_time);
261 DM_TEST(dm_test_rtc_reset, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
263 /* Check that two RTC devices can be used independently */
264 static int dm_test_rtc_dual(struct unit_test_state *uts)
266 struct rtc_time now1, now2, cmp;
267 struct udevice *dev1, *dev2;
268 struct udevice *emul1, *emul2;
271 ut_assertok(uclass_get_device(UCLASS_RTC, 0, &dev1));
272 ut_assertok(dm_rtc_get(dev1, &now1));
273 ut_assertok(uclass_get_device(UCLASS_RTC, 1, &dev2));
274 ut_assertok(dm_rtc_get(dev2, &now2));
276 ut_assertok(i2c_emul_find(dev1, &emul1));
277 ut_assert(emul1 != NULL);
278 ut_assertok(i2c_emul_find(dev2, &emul2));
279 ut_assert(emul2 != NULL);
281 offset = sandbox_i2c_rtc_set_offset(emul1, false, -1);
282 sandbox_i2c_rtc_set_offset(emul2, false, offset + 1);
283 memset(&cmp, '\0', sizeof(cmp));
284 ut_assertok(dm_rtc_get(dev2, &cmp));
285 ut_asserteq(-EINVAL, cmp_times(&now1, &cmp, false));
287 memset(&cmp, '\0', sizeof(cmp));
288 ut_assertok(dm_rtc_get(dev1, &cmp));
289 ut_assertok(cmp_times(&now1, &cmp, true));
293 DM_TEST(dm_test_rtc_dual, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);