1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3 * Copyright (C) 2015 Google, Inc
4 * Written by Simon Glass <sjg@chromium.org>
5 */
6
7 #include <common.h>
8 #include <console.h>
9 #include <dm.h>
10 #include <i2c.h>
11 #include <log.h>
12 #include <rtc.h>
13 #include <asm/io.h>
14 #include <asm/rtc.h>
15 #include <asm/test.h>
16 #include <dm/test.h>
17 #include <test/test.h>
18 #include <test/ut.h>
19
20 /* Simple RTC sanity check */
dm_test_rtc_base(struct unit_test_state * uts)21 static int dm_test_rtc_base(struct unit_test_state *uts)
22 {
23 struct udevice *dev;
24
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));
28
29 return 0;
30 }
31 DM_TEST(dm_test_rtc_base, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
32
show_time(const char * msg,struct rtc_time * time)33 static void show_time(const char *msg, struct rtc_time *time)
34 {
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);
38 }
39
cmp_times(struct rtc_time * expect,struct rtc_time * time,bool show)40 static int cmp_times(struct rtc_time *expect, struct rtc_time *time, bool show)
41 {
42 bool same;
43
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;
50 if (!same && show) {
51 show_time("expected", expect);
52 show_time("actual", time);
53 }
54
55 return same ? 0 : -EINVAL;
56 }
57
58 /* Set and get the time */
dm_test_rtc_set_get(struct unit_test_state * uts)59 static int dm_test_rtc_set_get(struct unit_test_state *uts)
60 {
61 struct rtc_time now, time, cmp;
62 struct udevice *dev, *emul;
63 long offset, old_offset, old_base_time;
64
65 ut_assertok(uclass_get_device(UCLASS_RTC, 0, &dev));
66 ut_assertok(dm_rtc_get(dev, &now));
67
68 ut_assertok(i2c_emul_find(dev, &emul));
69 ut_assert(emul != NULL);
70
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);
74
75 memset(&time, '\0', sizeof(time));
76 time.tm_mday = 3;
77 time.tm_mon = 6;
78 time.tm_year = 2004;
79 time.tm_sec = 0;
80 time.tm_min = 18;
81 time.tm_hour = 18;
82 ut_assertok(dm_rtc_set(dev, &time));
83
84 memset(&cmp, '\0', sizeof(cmp));
85 ut_assertok(dm_rtc_get(dev, &cmp));
86 ut_assertok(cmp_times(&time, &cmp, true));
87
88 memset(&time, '\0', sizeof(time));
89 time.tm_mday = 31;
90 time.tm_mon = 8;
91 time.tm_year = 2004;
92 time.tm_sec = 0;
93 time.tm_min = 18;
94 time.tm_hour = 18;
95 ut_assertok(dm_rtc_set(dev, &time));
96
97 memset(&cmp, '\0', sizeof(cmp));
98 ut_assertok(dm_rtc_get(dev, &cmp));
99 ut_assertok(cmp_times(&time, &cmp, true));
100
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);
104
105 memset(&cmp, '\0', sizeof(cmp));
106 ut_assertok(dm_rtc_get(dev, &cmp));
107 ut_asserteq(1, cmp.tm_sec);
108
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));
113
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));
119
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);
126 } else {
127 ut_asserteq(now.tm_sec + 1, cmp.tm_sec);
128 }
129
130 old_offset = sandbox_i2c_rtc_set_offset(emul, true, 0);
131
132 return 0;
133 }
134 DM_TEST(dm_test_rtc_set_get, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
135
dm_test_rtc_read_write(struct unit_test_state * uts)136 static int dm_test_rtc_read_write(struct unit_test_state *uts)
137 {
138 struct rtc_time time;
139 struct udevice *dev, *emul;
140 long old_offset;
141 u8 buf[4], reg;
142
143 ut_assertok(uclass_get_device(UCLASS_RTC, 0, &dev));
144
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);
150
151 reg = 'b';
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);
156
157 reg = 't';
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);
162
163 ut_assertok(i2c_emul_find(dev, &emul));
164 ut_assert(emul != NULL);
165
166 old_offset = sandbox_i2c_rtc_set_offset(emul, false, 0);
167 ut_assertok(dm_rtc_get(dev, &time));
168
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);
173
174 sandbox_i2c_rtc_set_offset(emul, true, old_offset);
175
176 return 0;
177 }
178 DM_TEST(dm_test_rtc_read_write, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
179
180 /* Test 'rtc list' command */
dm_test_rtc_cmd_list(struct unit_test_state * uts)181 static int dm_test_rtc_cmd_list(struct unit_test_state *uts)
182 {
183 console_record_reset();
184
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();
189
190 return 0;
191 }
192 DM_TEST(dm_test_rtc_cmd_list, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
193
194 /* Test 'rtc read' and 'rtc write' commands */
dm_test_rtc_cmd_rw(struct unit_test_state * uts)195 static int dm_test_rtc_cmd_rw(struct unit_test_state *uts)
196 {
197 console_record_reset();
198
199 run_command("rtc dev 0", 0);
200 ut_assert_nextline("RTC #0 - rtc@43");
201 ut_assert_console_end();
202
203 run_command("rtc write 0x30 aabb", 0);
204 ut_assert_console_end();
205
206 run_command("rtc read 0x30 2", 0);
207 ut_assert_nextline("00000030: aa bb ..");
208 ut_assert_console_end();
209
210 run_command("rtc dev 1", 0);
211 ut_assert_nextline("RTC #1 - rtc@61");
212 ut_assert_console_end();
213
214 run_command("rtc write 0x30 ccdd", 0);
215 ut_assert_console_end();
216
217 run_command("rtc read 0x30 2", 0);
218 ut_assert_nextline("00000030: cc dd ..");
219 ut_assert_console_end();
220
221 /*
222 * Switch back to device #0, check that its aux registers
223 * still have the same values.
224 */
225 run_command("rtc dev 0", 0);
226 ut_assert_nextline("RTC #0 - rtc@43");
227 ut_assert_console_end();
228
229 run_command("rtc read 0x30 2", 0);
230 ut_assert_nextline("00000030: aa bb ..");
231 ut_assert_console_end();
232
233 return 0;
234 }
235 DM_TEST(dm_test_rtc_cmd_rw, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
236
237 /* Reset the time */
dm_test_rtc_reset(struct unit_test_state * uts)238 static int dm_test_rtc_reset(struct unit_test_state *uts)
239 {
240 struct rtc_time now;
241 struct udevice *dev, *emul;
242 long old_base_time, base_time;
243
244 ut_assertok(uclass_get_device(UCLASS_RTC, 0, &dev));
245 ut_assertok(dm_rtc_get(dev, &now));
246
247 ut_assertok(i2c_emul_find(dev, &emul));
248 ut_assert(emul != NULL);
249
250 old_base_time = sandbox_i2c_rtc_get_set_base_time(emul, 0);
251
252 ut_asserteq(0, sandbox_i2c_rtc_get_set_base_time(emul, -1));
253
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);
258
259 return 0;
260 }
261 DM_TEST(dm_test_rtc_reset, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
262
263 /* Check that two RTC devices can be used independently */
dm_test_rtc_dual(struct unit_test_state * uts)264 static int dm_test_rtc_dual(struct unit_test_state *uts)
265 {
266 struct rtc_time now1, now2, cmp;
267 struct udevice *dev1, *dev2;
268 struct udevice *emul1, *emul2;
269 long offset;
270
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));
275
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);
280
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));
286
287 memset(&cmp, '\0', sizeof(cmp));
288 ut_assertok(dm_rtc_get(dev1, &cmp));
289 ut_assertok(cmp_times(&now1, &cmp, true));
290
291 return 0;
292 }
293 DM_TEST(dm_test_rtc_dual, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
294