1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Real Time Clock Driver Test Program
4  *
5  * Copyright (c) 2018 Alexandre Belloni <alexandre.belloni@bootlin.com>
6  */
7 
8 #include <errno.h>
9 #include <fcntl.h>
10 #include <linux/rtc.h>
11 #include <stdio.h>
12 #include <stdlib.h>
13 #include <sys/ioctl.h>
14 #include <sys/time.h>
15 #include <sys/types.h>
16 #include <time.h>
17 #include <unistd.h>
18 
19 #include "../kselftest_harness.h"
20 
21 #define NUM_UIE 3
22 #define ALARM_DELTA 3
23 #define READ_LOOP_DURATION_SEC 30
24 #define READ_LOOP_SLEEP_MS 11
25 
26 static char *rtc_file = "/dev/rtc0";
27 
28 FIXTURE(rtc) {
29 	int fd;
30 };
31 
32 FIXTURE_SETUP(rtc) {
33 	self->fd = open(rtc_file, O_RDONLY);
34 	ASSERT_NE(-1, self->fd);
35 }
36 
37 FIXTURE_TEARDOWN(rtc) {
38 	close(self->fd);
39 }
40 
41 TEST_F(rtc, date_read) {
42 	int rc;
43 	struct rtc_time rtc_tm;
44 
45 	/* Read the RTC time/date */
46 	rc = ioctl(self->fd, RTC_RD_TIME, &rtc_tm);
47 	ASSERT_NE(-1, rc);
48 
49 	TH_LOG("Current RTC date/time is %02d/%02d/%02d %02d:%02d:%02d.",
50 	       rtc_tm.tm_mday, rtc_tm.tm_mon + 1, rtc_tm.tm_year + 1900,
51 	       rtc_tm.tm_hour, rtc_tm.tm_min, rtc_tm.tm_sec);
52 }
53 
54 static time_t rtc_time_to_timestamp(struct rtc_time *rtc_time)
55 {
56 	struct tm tm_time = {
57 	       .tm_sec = rtc_time->tm_sec,
58 	       .tm_min = rtc_time->tm_min,
59 	       .tm_hour = rtc_time->tm_hour,
60 	       .tm_mday = rtc_time->tm_mday,
61 	       .tm_mon = rtc_time->tm_mon,
62 	       .tm_year = rtc_time->tm_year,
63 	};
64 
65 	return mktime(&tm_time);
66 }
67 
68 static void nanosleep_with_retries(long ns)
69 {
70 	struct timespec req = {
71 		.tv_sec = 0,
72 		.tv_nsec = ns,
73 	};
74 	struct timespec rem;
75 
76 	while (nanosleep(&req, &rem) != 0) {
77 		req.tv_sec = rem.tv_sec;
78 		req.tv_nsec = rem.tv_nsec;
79 	}
80 }
81 
82 TEST_F_TIMEOUT(rtc, date_read_loop, READ_LOOP_DURATION_SEC + 2) {
83 	int rc;
84 	long iter_count = 0;
85 	struct rtc_time rtc_tm;
86 	time_t start_rtc_read, prev_rtc_read;
87 
88 	TH_LOG("Continuously reading RTC time for %ds (with %dms breaks after every read).",
89 	       READ_LOOP_DURATION_SEC, READ_LOOP_SLEEP_MS);
90 
91 	rc = ioctl(self->fd, RTC_RD_TIME, &rtc_tm);
92 	ASSERT_NE(-1, rc);
93 	start_rtc_read = rtc_time_to_timestamp(&rtc_tm);
94 	prev_rtc_read = start_rtc_read;
95 
96 	do  {
97 		time_t rtc_read;
98 
99 		rc = ioctl(self->fd, RTC_RD_TIME, &rtc_tm);
100 		ASSERT_NE(-1, rc);
101 
102 		rtc_read = rtc_time_to_timestamp(&rtc_tm);
103 		/* Time should not go backwards */
104 		ASSERT_LE(prev_rtc_read, rtc_read);
105 		/* Time should not increase more then 1s at a time */
106 		ASSERT_GE(prev_rtc_read + 1, rtc_read);
107 
108 		/* Sleep 11ms to avoid killing / overheating the RTC */
109 		nanosleep_with_retries(READ_LOOP_SLEEP_MS * 1000000);
110 
111 		prev_rtc_read = rtc_read;
112 		iter_count++;
113 	} while (prev_rtc_read <= start_rtc_read + READ_LOOP_DURATION_SEC);
114 
115 	TH_LOG("Performed %ld RTC time reads.", iter_count);
116 }
117 
118 TEST_F_TIMEOUT(rtc, uie_read, NUM_UIE + 2) {
119 	int i, rc, irq = 0;
120 	unsigned long data;
121 
122 	/* Turn on update interrupts */
123 	rc = ioctl(self->fd, RTC_UIE_ON, 0);
124 	if (rc == -1) {
125 		ASSERT_EQ(EINVAL, errno);
126 		TH_LOG("skip update IRQs not supported.");
127 		return;
128 	}
129 
130 	for (i = 0; i < NUM_UIE; i++) {
131 		/* This read will block */
132 		rc = read(self->fd, &data, sizeof(data));
133 		ASSERT_NE(-1, rc);
134 		irq++;
135 	}
136 
137 	EXPECT_EQ(NUM_UIE, irq);
138 
139 	rc = ioctl(self->fd, RTC_UIE_OFF, 0);
140 	ASSERT_NE(-1, rc);
141 }
142 
143 TEST_F(rtc, uie_select) {
144 	int i, rc, irq = 0;
145 	unsigned long data;
146 
147 	/* Turn on update interrupts */
148 	rc = ioctl(self->fd, RTC_UIE_ON, 0);
149 	if (rc == -1) {
150 		ASSERT_EQ(EINVAL, errno);
151 		TH_LOG("skip update IRQs not supported.");
152 		return;
153 	}
154 
155 	for (i = 0; i < NUM_UIE; i++) {
156 		struct timeval tv = { .tv_sec = 2 };
157 		fd_set readfds;
158 
159 		FD_ZERO(&readfds);
160 		FD_SET(self->fd, &readfds);
161 		/* The select will wait until an RTC interrupt happens. */
162 		rc = select(self->fd + 1, &readfds, NULL, NULL, &tv);
163 		ASSERT_NE(-1, rc);
164 		ASSERT_NE(0, rc);
165 
166 		/* This read won't block */
167 		rc = read(self->fd, &data, sizeof(unsigned long));
168 		ASSERT_NE(-1, rc);
169 		irq++;
170 	}
171 
172 	EXPECT_EQ(NUM_UIE, irq);
173 
174 	rc = ioctl(self->fd, RTC_UIE_OFF, 0);
175 	ASSERT_NE(-1, rc);
176 }
177 
178 TEST_F(rtc, alarm_alm_set) {
179 	struct timeval tv = { .tv_sec = ALARM_DELTA + 2 };
180 	unsigned long data;
181 	struct rtc_time tm;
182 	fd_set readfds;
183 	time_t secs, new;
184 	int rc;
185 
186 	rc = ioctl(self->fd, RTC_RD_TIME, &tm);
187 	ASSERT_NE(-1, rc);
188 
189 	secs = timegm((struct tm *)&tm) + ALARM_DELTA;
190 	gmtime_r(&secs, (struct tm *)&tm);
191 
192 	rc = ioctl(self->fd, RTC_ALM_SET, &tm);
193 	if (rc == -1) {
194 		ASSERT_EQ(EINVAL, errno);
195 		TH_LOG("skip alarms are not supported.");
196 		return;
197 	}
198 
199 	rc = ioctl(self->fd, RTC_ALM_READ, &tm);
200 	ASSERT_NE(-1, rc);
201 
202 	TH_LOG("Alarm time now set to %02d:%02d:%02d.",
203 	       tm.tm_hour, tm.tm_min, tm.tm_sec);
204 
205 	/* Enable alarm interrupts */
206 	rc = ioctl(self->fd, RTC_AIE_ON, 0);
207 	ASSERT_NE(-1, rc);
208 
209 	FD_ZERO(&readfds);
210 	FD_SET(self->fd, &readfds);
211 
212 	rc = select(self->fd + 1, &readfds, NULL, NULL, &tv);
213 	ASSERT_NE(-1, rc);
214 	ASSERT_NE(0, rc);
215 
216 	/* Disable alarm interrupts */
217 	rc = ioctl(self->fd, RTC_AIE_OFF, 0);
218 	ASSERT_NE(-1, rc);
219 
220 	rc = read(self->fd, &data, sizeof(unsigned long));
221 	ASSERT_NE(-1, rc);
222 	TH_LOG("data: %lx", data);
223 
224 	rc = ioctl(self->fd, RTC_RD_TIME, &tm);
225 	ASSERT_NE(-1, rc);
226 
227 	new = timegm((struct tm *)&tm);
228 	ASSERT_EQ(new, secs);
229 }
230 
231 TEST_F(rtc, alarm_wkalm_set) {
232 	struct timeval tv = { .tv_sec = ALARM_DELTA + 2 };
233 	struct rtc_wkalrm alarm = { 0 };
234 	struct rtc_time tm;
235 	unsigned long data;
236 	fd_set readfds;
237 	time_t secs, new;
238 	int rc;
239 
240 	rc = ioctl(self->fd, RTC_RD_TIME, &alarm.time);
241 	ASSERT_NE(-1, rc);
242 
243 	secs = timegm((struct tm *)&alarm.time) + ALARM_DELTA;
244 	gmtime_r(&secs, (struct tm *)&alarm.time);
245 
246 	alarm.enabled = 1;
247 
248 	rc = ioctl(self->fd, RTC_WKALM_SET, &alarm);
249 	if (rc == -1) {
250 		ASSERT_EQ(EINVAL, errno);
251 		TH_LOG("skip alarms are not supported.");
252 		return;
253 	}
254 
255 	rc = ioctl(self->fd, RTC_WKALM_RD, &alarm);
256 	ASSERT_NE(-1, rc);
257 
258 	TH_LOG("Alarm time now set to %02d/%02d/%02d %02d:%02d:%02d.",
259 	       alarm.time.tm_mday, alarm.time.tm_mon + 1,
260 	       alarm.time.tm_year + 1900, alarm.time.tm_hour,
261 	       alarm.time.tm_min, alarm.time.tm_sec);
262 
263 	FD_ZERO(&readfds);
264 	FD_SET(self->fd, &readfds);
265 
266 	rc = select(self->fd + 1, &readfds, NULL, NULL, &tv);
267 	ASSERT_NE(-1, rc);
268 	ASSERT_NE(0, rc);
269 
270 	rc = read(self->fd, &data, sizeof(unsigned long));
271 	ASSERT_NE(-1, rc);
272 
273 	rc = ioctl(self->fd, RTC_RD_TIME, &tm);
274 	ASSERT_NE(-1, rc);
275 
276 	new = timegm((struct tm *)&tm);
277 	ASSERT_EQ(new, secs);
278 }
279 
280 TEST_F_TIMEOUT(rtc, alarm_alm_set_minute, 65) {
281 	struct timeval tv = { .tv_sec = 62 };
282 	unsigned long data;
283 	struct rtc_time tm;
284 	fd_set readfds;
285 	time_t secs, new;
286 	int rc;
287 
288 	rc = ioctl(self->fd, RTC_RD_TIME, &tm);
289 	ASSERT_NE(-1, rc);
290 
291 	secs = timegm((struct tm *)&tm) + 60 - tm.tm_sec;
292 	gmtime_r(&secs, (struct tm *)&tm);
293 
294 	rc = ioctl(self->fd, RTC_ALM_SET, &tm);
295 	if (rc == -1) {
296 		ASSERT_EQ(EINVAL, errno);
297 		TH_LOG("skip alarms are not supported.");
298 		return;
299 	}
300 
301 	rc = ioctl(self->fd, RTC_ALM_READ, &tm);
302 	ASSERT_NE(-1, rc);
303 
304 	TH_LOG("Alarm time now set to %02d:%02d:%02d.",
305 	       tm.tm_hour, tm.tm_min, tm.tm_sec);
306 
307 	/* Enable alarm interrupts */
308 	rc = ioctl(self->fd, RTC_AIE_ON, 0);
309 	ASSERT_NE(-1, rc);
310 
311 	FD_ZERO(&readfds);
312 	FD_SET(self->fd, &readfds);
313 
314 	rc = select(self->fd + 1, &readfds, NULL, NULL, &tv);
315 	ASSERT_NE(-1, rc);
316 	ASSERT_NE(0, rc);
317 
318 	/* Disable alarm interrupts */
319 	rc = ioctl(self->fd, RTC_AIE_OFF, 0);
320 	ASSERT_NE(-1, rc);
321 
322 	rc = read(self->fd, &data, sizeof(unsigned long));
323 	ASSERT_NE(-1, rc);
324 	TH_LOG("data: %lx", data);
325 
326 	rc = ioctl(self->fd, RTC_RD_TIME, &tm);
327 	ASSERT_NE(-1, rc);
328 
329 	new = timegm((struct tm *)&tm);
330 	ASSERT_EQ(new, secs);
331 }
332 
333 TEST_F_TIMEOUT(rtc, alarm_wkalm_set_minute, 65) {
334 	struct timeval tv = { .tv_sec = 62 };
335 	struct rtc_wkalrm alarm = { 0 };
336 	struct rtc_time tm;
337 	unsigned long data;
338 	fd_set readfds;
339 	time_t secs, new;
340 	int rc;
341 
342 	rc = ioctl(self->fd, RTC_RD_TIME, &alarm.time);
343 	ASSERT_NE(-1, rc);
344 
345 	secs = timegm((struct tm *)&alarm.time) + 60 - alarm.time.tm_sec;
346 	gmtime_r(&secs, (struct tm *)&alarm.time);
347 
348 	alarm.enabled = 1;
349 
350 	rc = ioctl(self->fd, RTC_WKALM_SET, &alarm);
351 	if (rc == -1) {
352 		ASSERT_EQ(EINVAL, errno);
353 		TH_LOG("skip alarms are not supported.");
354 		return;
355 	}
356 
357 	rc = ioctl(self->fd, RTC_WKALM_RD, &alarm);
358 	ASSERT_NE(-1, rc);
359 
360 	TH_LOG("Alarm time now set to %02d/%02d/%02d %02d:%02d:%02d.",
361 	       alarm.time.tm_mday, alarm.time.tm_mon + 1,
362 	       alarm.time.tm_year + 1900, alarm.time.tm_hour,
363 	       alarm.time.tm_min, alarm.time.tm_sec);
364 
365 	FD_ZERO(&readfds);
366 	FD_SET(self->fd, &readfds);
367 
368 	rc = select(self->fd + 1, &readfds, NULL, NULL, &tv);
369 	ASSERT_NE(-1, rc);
370 	ASSERT_NE(0, rc);
371 
372 	rc = read(self->fd, &data, sizeof(unsigned long));
373 	ASSERT_NE(-1, rc);
374 
375 	rc = ioctl(self->fd, RTC_RD_TIME, &tm);
376 	ASSERT_NE(-1, rc);
377 
378 	new = timegm((struct tm *)&tm);
379 	ASSERT_EQ(new, secs);
380 }
381 
382 static void __attribute__((constructor))
383 __constructor_order_last(void)
384 {
385 	if (!__constructor_order)
386 		__constructor_order = _CONSTRUCTOR_ORDER_BACKWARD;
387 }
388 
389 int main(int argc, char **argv)
390 {
391 	switch (argc) {
392 	case 2:
393 		rtc_file = argv[1];
394 		/* FALLTHROUGH */
395 	case 1:
396 		break;
397 	default:
398 		fprintf(stderr, "usage: %s [rtcdev]\n", argv[0]);
399 		return 1;
400 	}
401 
402 	return test_harness_run(argc, argv);
403 }
404