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