1 /*
2 * Copyright (c) 2022-2023 Huawei Device Co., Ltd.
3 *
4 * HDF is dual licensed: you can use it either under the terms of
5 * the GPL, or the BSD license, at your option.
6 * See the LICENSE file in the root of this repository for complete details.
7 */
8
9 #include "rtc_test.h"
10 #include "hdf_base.h"
11 #include "hdf_io_service_if.h"
12 #include "hdf_log.h"
13 #include "osal_mem.h"
14 #include "osal_time.h"
15 #include "rtc_base.h"
16 #include "rtc_if.h"
17 #include "securec.h"
18
19 #define HDF_LOG_TAG rtc_test_c
20
21 #define RTC_TEST_TIME_ZONE 8
22
RtcTestGetConfig(struct RtcTestConfig * config)23 static int32_t RtcTestGetConfig(struct RtcTestConfig *config)
24 {
25 int32_t ret;
26 struct HdfSBuf *reply = NULL;
27 struct HdfIoService *service = NULL;
28 const void *buf = NULL;
29 uint32_t len;
30
31 service = HdfIoServiceBind("RTC_TEST");
32 if (service == NULL) {
33 HDF_LOGE("RtcTestGetConfig: service RTC_TEST bind fail!");
34 return HDF_ERR_NOT_SUPPORT;
35 }
36
37 reply = HdfSbufObtainDefaultSize();
38 if (reply == NULL) {
39 HDF_LOGE("RtcTestGetConfig: fail to obtain reply!");
40 HdfIoServiceRecycle(service);
41 return HDF_ERR_MALLOC_FAIL;
42 }
43
44 ret = service->dispatcher->Dispatch(&service->object, 0, NULL, reply);
45 if (ret != HDF_SUCCESS) {
46 HDF_LOGE("RtcTestGetConfig: remote dispatch fail, ret: %d!", ret);
47 HdfIoServiceRecycle(service);
48 HdfSbufRecycle(reply);
49 return ret;
50 }
51
52 if (!HdfSbufReadBuffer(reply, &buf, &len)) {
53 HDF_LOGE("RtcTestGetConfig: read buf fail!");
54 HdfIoServiceRecycle(service);
55 HdfSbufRecycle(reply);
56 return HDF_ERR_IO;
57 }
58
59 if (len != sizeof(*config)) {
60 HDF_LOGE("RtcTestGetConfig: config size:%zu, read size:%u!", sizeof(*config), len);
61 HdfIoServiceRecycle(service);
62 HdfSbufRecycle(reply);
63 return HDF_ERR_IO;
64 }
65
66 if (memcpy_s(config, sizeof(*config), buf, sizeof(*config)) != EOK) {
67 HDF_LOGE("RtcTestGetConfig: memcpy buf fail!");
68 HdfIoServiceRecycle(service);
69 HdfSbufRecycle(reply);
70 return HDF_ERR_IO;
71 }
72
73 HdfSbufRecycle(reply);
74 HdfIoServiceRecycle(service);
75 return HDF_SUCCESS;
76 }
77
RtcTesterGet(void)78 static struct RtcTester *RtcTesterGet(void)
79 {
80 int32_t ret;
81 static struct RtcTester tester;
82
83 ret = RtcTestGetConfig(&tester.config);
84 if (ret != HDF_SUCCESS) {
85 HDF_LOGE("RtcTesterGet: read config fail, ret: %d!", ret);
86 return NULL;
87 }
88
89 tester.handle = RtcOpen();
90 if (tester.handle == NULL) {
91 HDF_LOGE("RtcTesterGet: open Rtc fail!");
92 return NULL;
93 }
94
95 return &tester;
96 }
97
RtcTesterPut(struct RtcTester * tester)98 static void RtcTesterPut(struct RtcTester *tester)
99 {
100 if (tester == NULL || tester->handle == NULL) {
101 HDF_LOGE("RtcTesterPut: tester or handle is null!");
102 return;
103 }
104
105 RtcClose(tester->handle);
106 tester->handle = NULL;
107 }
108
109 static int8_t g_rtcIrqCallback = HDF_FAILURE;
110
RtcAlarmACallback(enum RtcAlarmIndex alarmIndex)111 static int32_t RtcAlarmACallback(enum RtcAlarmIndex alarmIndex)
112 {
113 if (alarmIndex == RTC_ALARM_INDEX_A) {
114 HDF_LOGI("RtcAlarmACallback: alarm a callback success!");
115 g_rtcIrqCallback = HDF_SUCCESS;
116 } else {
117 g_rtcIrqCallback = HDF_FAILURE;
118 }
119 return 0;
120 }
121
IsSameRtcTestTime(const struct RtcTime * readTime,const struct RtcTime * writeTime)122 static int32_t IsSameRtcTestTime(const struct RtcTime *readTime, const struct RtcTime *writeTime)
123 {
124 if ((readTime->year != writeTime->year) || (readTime->month != writeTime->month) ||
125 (readTime->day != writeTime->day) || (readTime->weekday != writeTime->weekday) ||
126 (readTime->hour != writeTime->hour) || (readTime->minute != writeTime->minute) ||
127 (readTime->second < writeTime->second)) {
128 return HDF_FAILURE;
129 }
130 return HDF_SUCCESS;
131 }
132
TestReadWriteTime(struct RtcTester * tester)133 static int32_t TestReadWriteTime(struct RtcTester *tester)
134 {
135 int32_t ret;
136 struct RtcTime readTime = {0};
137
138 ret = RtcWriteTime(tester->handle, &tester->time);
139 if (ret != HDF_SUCCESS) {
140 HDF_LOGE("TestReadWriteTime: write time fail, ret: %d!", ret);
141 return ret;
142 }
143
144 OsalMSleep(tester->config.writeWaitMillisecond);
145
146 ret = RtcReadTime(tester->handle, &readTime);
147 if (ret != HDF_SUCCESS) {
148 HDF_LOGE("TestReadWriteTime: read time fail, ret: %d!", ret);
149 return ret;
150 }
151
152 ret = IsSameRtcTestTime(&readTime, &tester->time);
153 if (ret != HDF_SUCCESS) {
154 HDF_LOGE("TestReadWriteTime: different time, ret: %d!", ret);
155 return ret;
156 }
157
158 return HDF_SUCCESS;
159 }
RtcReadWriteTimeTest(struct RtcTester * tester)160 static int32_t RtcReadWriteTimeTest(struct RtcTester *tester)
161 {
162 int32_t ret;
163
164 /* 2020-08-08 Saturday 09:08:08 .000 */
165 tester->time.year = tester->config.year;
166 tester->time.month = tester->config.month;
167 tester->time.day = tester->config.day;
168 tester->time.hour = tester->config.hour;
169 tester->time.minute = tester->config.minute;
170 tester->time.second = tester->config.second;
171 tester->time.millisecond = 0;
172 tester->time.weekday = RtcGetWeekDay(&tester->time);
173
174 ret = TestReadWriteTime(tester);
175 if (ret != HDF_SUCCESS) {
176 HDF_LOGE("RtcReadWriteTimeTest: test ReadWriteTime fail, ret: %d!", ret);
177 return ret;
178 }
179
180 return HDF_SUCCESS;
181 }
182
RtcReadWriteMaxTimeTest(struct RtcTester * tester)183 static int32_t RtcReadWriteMaxTimeTest(struct RtcTester *tester)
184 {
185 int32_t ret;
186
187 tester->time.year = tester->config.year;
188 tester->time.month = tester->config.month + 1;
189 tester->time.day = RTC_GREAT_MONTH_DAY + 1;
190 tester->time.hour = RTC_DAY_HOURS;
191 tester->time.minute = RTC_MAX_MINUTE;
192 tester->time.second = RTC_MAX_SECOND;
193 tester->time.millisecond = RTC_MAX_MS;
194 tester->time.weekday = RtcGetWeekDay(&tester->time);
195
196 ret = TestReadWriteTime(tester);
197 if (ret == HDF_SUCCESS) {
198 HDF_LOGE("RtcReadWriteMaxTimeTest: test fail!");
199 return HDF_FAILURE;
200 }
201
202 return HDF_SUCCESS;
203 }
204
RtcReadWriteMinTimeTest(struct RtcTester * tester)205 static int32_t RtcReadWriteMinTimeTest(struct RtcTester *tester)
206 {
207 int32_t ret;
208
209 tester->time.year = RTC_BEGIN_YEAR - 1;
210 tester->time.month = 0;
211 tester->time.day = 0;
212 tester->time.hour = 0;
213 tester->time.minute = 0;
214 tester->time.second = 0;
215 tester->time.millisecond = 0;
216 tester->time.weekday = RtcGetWeekDay(&tester->time);
217
218 ret = TestReadWriteTime(tester);
219 if (ret == HDF_SUCCESS) {
220 HDF_LOGE("RtcReadWriteMinTimeTest: test fail!");
221 return HDF_FAILURE;
222 }
223
224 return HDF_SUCCESS;
225 }
226
TestReadWriteAlarm(struct RtcTester * tester)227 static int32_t TestReadWriteAlarm(struct RtcTester *tester)
228 {
229 int32_t ret;
230 struct RtcTime readTime = {0};
231
232 ret = RtcWriteAlarm(tester->handle, RTC_ALARM_INDEX_A, &tester->time);
233 if (ret != HDF_SUCCESS) {
234 HDF_LOGE("TestReadWriteAlarm: write alarm fail, ret: %d!", ret);
235 return ret;
236 }
237
238 OsalMSleep(tester->config.writeWaitMillisecond);
239
240 ret = RtcReadAlarm(tester->handle, RTC_ALARM_INDEX_A, &readTime);
241 if (ret != HDF_SUCCESS) {
242 HDF_LOGE("TestReadWriteAlarm: read alarm fail, ret: %d!", ret);
243 return ret;
244 }
245
246 ret = IsSameRtcTestTime(&readTime, &tester->time);
247 if (ret != HDF_SUCCESS) {
248 HDF_LOGE("TestReadWriteAlarm: different time, ret: %d!", ret);
249 return ret;
250 }
251
252 return HDF_SUCCESS;
253 }
RtcReadWriteAlarmTimeTest(struct RtcTester * tester)254 static int32_t RtcReadWriteAlarmTimeTest(struct RtcTester *tester)
255 {
256 int32_t ret;
257
258 tester->time.year = tester->config.year;
259 tester->time.month = tester->config.month;
260 tester->time.day = tester->config.day;
261 tester->time.hour = tester->config.hour + RTC_UNIT_DIFF;
262 tester->time.minute = tester->config.minute;
263 tester->time.second = tester->config.second;
264 tester->time.millisecond = 0;
265 tester->time.weekday = RtcGetWeekDay(&tester->time);
266
267 ret = TestReadWriteAlarm(tester);
268 if (ret != HDF_SUCCESS) {
269 HDF_LOGE("RtcReadWriteAlarmTimeTest: test fail, ret: %d!", ret);
270 return ret;
271 }
272
273 return HDF_SUCCESS;
274 }
275
RtcReadWriteAlarmMaxTimeTest(struct RtcTester * tester)276 static int32_t RtcReadWriteAlarmMaxTimeTest(struct RtcTester *tester)
277 {
278 int32_t ret;
279
280 tester->time.year = tester->config.maxYear;
281 tester->time.month = RTC_MAX_MONTH + 1;
282 tester->time.day = RTC_GREAT_MONTH_DAY + 1;
283 tester->time.hour = RTC_DAY_HOURS;
284 tester->time.minute = RTC_MAX_MINUTE;
285 tester->time.second = RTC_MAX_SECOND;
286 tester->time.millisecond = RTC_MAX_MS;
287 tester->time.weekday = RtcGetWeekDay(&tester->time);
288
289 ret = TestReadWriteAlarm(tester);
290 if (ret == HDF_SUCCESS) {
291 HDF_LOGE("RtcReadWriteAlarmMaxTimeTest: test fail!");
292 return HDF_FAILURE;
293 }
294
295 return HDF_SUCCESS;
296 }
297
RtcReadWriteAlarmMinTimeTest(struct RtcTester * tester)298 static int32_t RtcReadWriteAlarmMinTimeTest(struct RtcTester *tester)
299 {
300 int32_t ret;
301
302 tester->time.year = RTC_BEGIN_YEAR - 1;
303 tester->time.month = 0;
304 tester->time.day = 0;
305 tester->time.hour = 0;
306 tester->time.minute = 0;
307 tester->time.second = 0;
308 tester->time.millisecond = 0;
309 tester->time.weekday = RtcGetWeekDay(&tester->time);
310
311 ret = TestReadWriteAlarm(tester);
312 if (ret == HDF_SUCCESS) {
313 HDF_LOGE("RtcReadWriteAlarmMinTimeTest: test fail!");
314 return HDF_FAILURE;
315 }
316
317 return HDF_SUCCESS;
318 }
319
RtcAlarmEnableTest(struct RtcTester * tester)320 static int32_t RtcAlarmEnableTest(struct RtcTester *tester)
321 {
322 int32_t ret;
323
324 /* 2020-08-08 Saturday 08:09:08 .000 */
325 tester->time.year = tester->config.year;
326 tester->time.month = tester->config.month;
327 tester->time.day = tester->config.day;
328 tester->time.hour = tester->config.hour;
329 tester->time.minute = tester->config.minute + RTC_UNIT_DIFF;
330 tester->time.second = tester->config.second;
331 tester->time.millisecond = 0;
332 tester->time.weekday = RtcGetWeekDay(&tester->time);
333
334 ret = TestReadWriteAlarm(tester);
335 if (ret != HDF_SUCCESS) {
336 HDF_LOGE("RtcAlarmEnableTest: read write alarm fail, ret: %d!", ret);
337 return ret;
338 }
339
340 ret = RtcAlarmInterruptEnable(tester->handle, RTC_ALARM_INDEX_A, 1);
341 if (ret != HDF_SUCCESS) {
342 HDF_LOGE("RtcAlarmEnableTest: alarm interrupt enable fail, ret: %d!", ret);
343 return ret;
344 }
345
346 return HDF_SUCCESS;
347 }
348
RtcAlarmIrqAttachConfig(struct RtcTester * tester)349 static int32_t RtcAlarmIrqAttachConfig(struct RtcTester *tester)
350 {
351 int32_t ret;
352 uint32_t freq;
353
354 ret = RtcRegisterAlarmCallback(tester->handle, RTC_ALARM_INDEX_A, RtcAlarmACallback);
355 if (ret != HDF_SUCCESS) {
356 HDF_LOGE("RtcAlarmIrqAttachConfig: register alarm callback fail, ret: %d!", ret);
357 return ret;
358 }
359
360 freq = tester->config.frequency;
361 ret = RtcSetFreq(tester->handle, freq);
362 if (ret != HDF_SUCCESS) {
363 HDF_LOGE("RtcAlarmIrqAttachConfig: set freq fail, ret: %d!", ret);
364 return ret;
365 }
366
367 ret = RtcAlarmInterruptEnable(tester->handle, RTC_ALARM_INDEX_A, 1);
368 if (ret != HDF_SUCCESS) {
369 HDF_LOGE("RtcAlarmIrqAttachConfig: alarm interrupt enable fail, ret: %d!", ret);
370 return ret;
371 }
372
373 return HDF_SUCCESS;
374 }
375
RtcAlarmIrqTest(struct RtcTester * tester)376 static int32_t RtcAlarmIrqTest(struct RtcTester *tester)
377 {
378 int32_t ret;
379
380 /* set time 2020-08-08 Saturday 08:08:08 .000 */
381 tester->time.year = tester->config.year;
382 tester->time.month = tester->config.month;
383 tester->time.day = tester->config.day;
384 tester->time.hour = tester->config.hour;
385 tester->time.minute = tester->config.minute;
386 tester->time.second = tester->config.second;
387 tester->time.millisecond = 0;
388 tester->time.weekday = RtcGetWeekDay(&tester->time);
389
390 ret = RtcAlarmIrqAttachConfig(tester);
391 if (ret != HDF_SUCCESS) {
392 HDF_LOGE("RtcAlarmIrqTest: alarm irq attach config fail, ret: %d!", ret);
393 return ret;
394 }
395
396 ret = RtcWriteTime(tester->handle, &tester->time);
397 if (ret != HDF_SUCCESS) {
398 HDF_LOGE("RtcAlarmIrqTest: write time fail, ret: %d!", ret);
399 return ret;
400 }
401
402 /* set alarm time 2020-08-08 Saturday 08:08:09 .000 */
403 tester->time.second = tester->config.second + 1;
404 ret = RtcWriteAlarm(tester->handle, RTC_ALARM_INDEX_A, &tester->time);
405 if (ret != HDF_SUCCESS) {
406 HDF_LOGE("RtcAlarmIrqTest: write alarm fail, ret: %d!", ret);
407 return ret;
408 }
409
410 OsalSleep(tester->config.writeWaitMillisecond);
411 if (g_rtcIrqCallback == HDF_FAILURE) {
412 HDF_LOGE("RtcAlarmIrqTest: rtc irq call back fail!");
413 return HDF_FAILURE;
414 }
415 g_rtcIrqCallback = HDF_FAILURE;
416 return HDF_SUCCESS;
417 }
418
RtcRegisterCallbackTest(struct RtcTester * tester)419 static int32_t RtcRegisterCallbackTest(struct RtcTester *tester)
420 {
421 int32_t ret;
422
423 ret = RtcRegisterAlarmCallback(tester->handle, RTC_ALARM_INDEX_A, RtcAlarmACallback);
424 if (ret != HDF_SUCCESS) {
425 HDF_LOGE("RtcRegisterCallbackTest: register alarm callback fail, ret: %d!", ret);
426 return ret;
427 }
428
429 return HDF_SUCCESS;
430 }
431
RtcRegisterNullCallbackTest(struct RtcTester * tester)432 static int32_t RtcRegisterNullCallbackTest(struct RtcTester *tester)
433 {
434 int32_t ret;
435
436 ret = RtcRegisterAlarmCallback(tester->handle, RTC_ALARM_INDEX_A, NULL);
437 if (ret == HDF_SUCCESS) {
438 HDF_LOGE("RtcRegisterNullCallbackTest: register alarm callback fail!");
439 return HDF_FAILURE;
440 }
441
442 return HDF_SUCCESS;
443 }
444
RtcSetNormalFreqTest(struct RtcTester * tester)445 static int32_t RtcSetNormalFreqTest(struct RtcTester *tester)
446 {
447 int32_t ret;
448
449 ret = RtcSetFreq(tester->handle, tester->config.frequency);
450 if (ret != HDF_SUCCESS) {
451 HDF_LOGE("RtcSetNormalFreqTest: set normal frequency fail, ret: %d!", ret);
452 return ret;
453 }
454
455 return HDF_SUCCESS;
456 }
457
RtcSetMaxFreqTest(struct RtcTester * tester)458 static int32_t RtcSetMaxFreqTest(struct RtcTester *tester)
459 {
460 int32_t ret;
461
462 ret = RtcSetFreq(tester->handle, tester->config.frequency * RTC_TIME_UNIT);
463 if (ret == HDF_SUCCESS) {
464 HDF_LOGE("RtcSetMaxFreqTest: set max frequency test fail!");
465 return HDF_FAILURE;
466 }
467
468 return HDF_SUCCESS;
469 }
470
RtcSetMinFreqTest(struct RtcTester * tester)471 static int32_t RtcSetMinFreqTest(struct RtcTester *tester)
472 {
473 int32_t ret;
474
475 ret = RtcSetFreq(tester->handle, 0);
476 if (ret == HDF_SUCCESS) {
477 HDF_LOGE("RtcSetMinFreqTest: set min frequency test fail!");
478 return HDF_FAILURE;
479 }
480
481 ret = RtcSetFreq(tester->handle, tester->config.frequency);
482
483 return ret;
484 }
485
RtcReadWriteUserRegTest(struct RtcTester * tester)486 static int32_t RtcReadWriteUserRegTest(struct RtcTester *tester)
487 {
488 int32_t ret;
489 uint8_t value;
490
491 value = tester->config.userValue;
492 ret = RtcWriteReg(tester->handle, 0, value);
493 if (ret != HDF_SUCCESS) {
494 HDF_LOGE("RtcReadWriteUserRegTest: write reg fail, ret: %d!", ret);
495 return ret;
496 }
497
498 ret = RtcReadReg(tester->handle, 0, &value);
499 if (ret != HDF_SUCCESS) {
500 HDF_LOGE("RtcReadWriteUserRegTest: read reg fail, ret :%d!", ret);
501 return ret;
502 }
503
504 if (value != tester->config.userValue) {
505 HDF_LOGE("RtcReadWriteUserRegTest: value is not same. value :%hhu, userValue :%u!", value,
506 tester->config.userValue);
507 return HDF_FAILURE;
508 }
509
510 return HDF_SUCCESS;
511 }
512
RtcReadWriteMaxUserIndexTest(struct RtcTester * tester)513 static int32_t RtcReadWriteMaxUserIndexTest(struct RtcTester *tester)
514 {
515 int32_t ret;
516 uint8_t value;
517
518 value = tester->config.userValue;
519 ret = RtcWriteReg(tester->handle, tester->config.userMaxIndex, value);
520 if (ret != HDF_SUCCESS) {
521 HDF_LOGI("RtcReadWriteMaxUserIndexTest: write reg max index test success!");
522 return HDF_SUCCESS;
523 }
524
525 ret = RtcReadReg(tester->handle, tester->config.userMaxIndex, &value);
526 if (ret != HDF_SUCCESS) {
527 HDF_LOGI("RtcReadWriteMaxUserIndexTest: read reg max index test success!");
528 return HDF_SUCCESS;
529 }
530
531 HDF_LOGE("RtcReadWriteMaxUserIndexTest: read write reg max index test fail!");
532 return HDF_FAILURE;
533 }
534
RtcTestSample(struct RtcTester * tester)535 static int32_t RtcTestSample(struct RtcTester *tester)
536 {
537 int32_t ret;
538 uint32_t freq;
539 struct RtcTime readTime = {0};
540
541 ret = RtcRegisterAlarmCallback(tester->handle, RTC_ALARM_INDEX_A, RtcAlarmACallback);
542 if (ret != HDF_SUCCESS) {
543 HDF_LOGE("RtcTestSample: register alarm callback fail, ret: %d!", ret);
544 return ret;
545 }
546
547 freq = tester->config.frequency;
548 ret = RtcSetFreq(tester->handle, freq);
549 if (ret != HDF_SUCCESS) {
550 HDF_LOGE("RtcTestSample: set frequency fail, ret: %d!", ret);
551 return ret;
552 }
553
554 ret = RtcAlarmInterruptEnable(tester->handle, RTC_ALARM_INDEX_A, 1);
555 if (ret != HDF_SUCCESS) {
556 HDF_LOGE("RtcTestSample: alarm interrupt enable fail, ret: %d!", ret);
557 return ret;
558 }
559
560 tester->time.year = tester->config.year;
561 tester->time.month = RTC_JANUARY;
562 tester->time.day = tester->config.day;
563 tester->time.hour = 0;
564 tester->time.minute = 0;
565 tester->time.second = 0;
566 tester->time.millisecond = 0;
567
568 ret = RtcWriteTime(tester->handle, &tester->time);
569 if (ret != HDF_SUCCESS) {
570 HDF_LOGE("RtcTestSample: write time fail, ret: %d!", ret);
571 return ret;
572 }
573
574 tester->time.second = tester->config.second;
575 ret = RtcWriteAlarm(tester->handle, RTC_ALARM_INDEX_A, &tester->time);
576 if (ret != HDF_SUCCESS) {
577 HDF_LOGE("RtcTestSample: write alarm fail, ret: %d!", ret);
578 return ret;
579 }
580
581 OsalMSleep(tester->config.writeWaitMillisecond);
582
583 ret = RtcReadAlarm(tester->handle, RTC_ALARM_INDEX_A, &readTime);
584 if (ret != HDF_SUCCESS) {
585 HDF_LOGE("RtcTestSample: read alarm fail, ret: %d!", ret);
586 return ret;
587 }
588
589 ret = RtcReadTime(tester->handle, &tester->time);
590 if (ret != HDF_SUCCESS) {
591 HDF_LOGE("RtcTestSample: read time fail, ret: %d!", ret);
592 return ret;
593 }
594
595 return HDF_SUCCESS;
596 }
597
RtcReadWriteReliability(struct RtcTester * tester)598 static int32_t RtcReadWriteReliability(struct RtcTester *tester)
599 {
600 uint32_t i;
601
602 for (i = 0; i < tester->config.time; i++) {
603 (void)RtcReadWriteTimeTest(tester);
604 (void)RtcReadWriteAlarmTimeTest(tester);
605 #ifdef __LITEOS__
606 (void)RtcSetNormalFreqTest(tester);
607 #endif
608 }
609
610 return HDF_SUCCESS;
611 }
612
RtcMiniSetGetTimeZoneTest(struct RtcTester * tester)613 static int32_t RtcMiniSetGetTimeZoneTest(struct RtcTester *tester)
614 {
615 #ifdef __KERNEL__
616 int32_t timeZone = RTC_TEST_TIME_ZONE;
617 int32_t ret;
618
619 (void)tester;
620 ret = RtcSetTimeZone(timeZone);
621 if (ret != HDF_SUCCESS) {
622 HDF_LOGE("RtcMiniSetGetTimeZoneTest: rtc set time zone fail, ret: %d!", ret);
623 return ret;
624 }
625
626 HDF_LOGI("RtcMiniSetGetTimeZoneTest: rtc set time zone test done, then test rtc get time zone!");
627
628 ret = RtcGetTimeZone(&timeZone);
629 if (ret != HDF_SUCCESS) {
630 HDF_LOGE("RtcMiniSetGetTimeZoneTest: rtc get time zone fail, ret: %d!", ret);
631 return ret;
632 }
633 #else
634 (void)tester;
635 #endif
636 HDF_LOGI("RtcMiniSetGetTimeZoneTest: all test done!");
637 return HDF_SUCCESS;
638 }
639
640 struct RtcTestEntry {
641 int cmd;
642 int32_t (*func)(struct RtcTester *tester);
643 const char *name;
644 };
645
646 // add test case entry
647 static struct RtcTestEntry g_entry[] = {
648 {RTC_TEST_CMD_WR_TIME, RtcReadWriteTimeTest, "RtcReadWriteTimeTest" },
649 {RTC_TEST_CMD_WR_MAX_TIME, RtcReadWriteMaxTimeTest, "RtcReadWriteMaxTimeTest" },
650 {RTC_TEST_CMD_WR_MIN_TIME, RtcReadWriteMinTimeTest, "RtcReadWriteMinTimeTest" },
651 {RTC_TEST_CMD_WR_ALARM_TIME, RtcReadWriteAlarmTimeTest, "RtcReadWriteAlarmTimeTest" },
652 {RTC_TEST_CMD_WR_ALARM_MAX_TIME, RtcReadWriteAlarmMaxTimeTest, "RtcReadWriteAlarmMaxTimeTest"},
653 {RTC_TEST_CMD_WR_ALARM_MIN_TIME, RtcReadWriteAlarmMinTimeTest, "RtcReadWriteAlarmMinTimeTest"},
654 {RTC_TEST_CMD_RTC_ALARM_ENABLE, RtcAlarmEnableTest, "RtcAlarmEnableTest" },
655 {RTC_TEST_CMD_RTC_ALARM_IRQ, RtcAlarmIrqTest, "RtcAlarmIrqTest" },
656 {RTC_TEST_CMD_RTC_REGISTER_CALLBACK, RtcRegisterCallbackTest, "RtcRegisterCallbackTest" },
657 {RTC_TEST_CMD_RTC_REGISTER_CALLBACK_NULL, RtcRegisterNullCallbackTest, "RtcRegisterNullCallbackTest" },
658 {RTC_TEST_CMD_RTC_WR_FREQ, RtcSetNormalFreqTest, "RtcSetNormalFreqTest" },
659 {RTC_TEST_CMD_RTC_WR_MAX_FREQ, RtcSetMaxFreqTest, "RtcSetMaxFreqTest" },
660 {RTC_TEST_CMD_RTC_WR_MIN_FREQ, RtcSetMinFreqTest, "RtcSetMinFreqTest" },
661 {RTC_TEST_CMD_RTC_WR_USER_REG, RtcReadWriteUserRegTest, "RtcReadWriteUserRegTest" },
662 {RTC_TEST_CMD_RTC_WR_USER_REG_MAX_INDEX, RtcReadWriteMaxUserIndexTest, "RtcReadWriteMaxUserIndexTest"},
663 {RTC_TEST_CMD_RTC_FUNCTION_TEST, RtcTestSample, "RtcTestSample" },
664 {RTC_TEST_CMD_RTC_WR_RELIABILITY, RtcReadWriteReliability, "RtcReadWriteReliability" },
665 {RTC_MINI_SET_GET_TIME_ZONE_TEST, RtcMiniSetGetTimeZoneTest, "RtcMiniSetGetTimeZoneTest" },
666 };
667
RtcTestExecute(int cmd)668 int32_t RtcTestExecute(int cmd)
669 {
670 uint32_t i;
671 struct RtcTester *tester = NULL;
672 int32_t ret = HDF_ERR_NOT_SUPPORT;
673
674 tester = RtcTesterGet();
675 if (tester == NULL) {
676 HDF_LOGE("RtcTestExecute: tester is null!");
677 return HDF_ERR_INVALID_OBJECT;
678 }
679
680 if (cmd > RTC_TEST_CMD_MAX) {
681 HDF_LOGE("RtcTestExecute: invalid cmd: %d!", cmd);
682 ret = HDF_ERR_NOT_SUPPORT;
683 goto EXIT;
684 }
685
686 for (i = 0; i < sizeof(g_entry) / sizeof(g_entry[0]); i++) {
687 if (g_entry[i].cmd != cmd || g_entry[i].func == NULL) {
688 continue;
689 }
690 ret = g_entry[i].func(tester);
691 break;
692 }
693
694 EXIT:
695 HDF_LOGE("[RtcTestExecute][======cmd:%d====ret:%d======]", cmd, ret);
696 RtcTesterPut(tester);
697 return ret;
698 }
699