Tom Rini | 83d290c | 2018-05-06 17:58:06 -0400 | [diff] [blame] | 1 | // SPDX-License-Identifier: GPL-2.0+ |
Simon Glass | 4772511 | 2015-04-20 12:37:31 -0600 | [diff] [blame] | 2 | /* |
| 3 | * Copyright (C) 2015 Google, Inc |
Simon Glass | 4772511 | 2015-04-20 12:37:31 -0600 | [diff] [blame] | 4 | * Written by Simon Glass <sjg@chromium.org> |
| 5 | */ |
| 6 | |
| 7 | #include <common.h> |
| 8 | #include <dm.h> |
Simon Glass | 031a650 | 2018-11-18 08:14:34 -0700 | [diff] [blame] | 9 | #include <i2c.h> |
Simon Glass | f7ae49f | 2020-05-10 11:40:05 -0600 | [diff] [blame] | 10 | #include <log.h> |
Simon Glass | 4772511 | 2015-04-20 12:37:31 -0600 | [diff] [blame] | 11 | #include <rtc.h> |
| 12 | #include <asm/io.h> |
Simon Glass | 4772511 | 2015-04-20 12:37:31 -0600 | [diff] [blame] | 13 | #include <asm/test.h> |
Joe Hershberger | e721b88 | 2015-05-20 14:27:27 -0500 | [diff] [blame] | 14 | #include <dm/test.h> |
| 15 | #include <test/ut.h> |
Simon Glass | 4772511 | 2015-04-20 12:37:31 -0600 | [diff] [blame] | 16 | |
| 17 | /* Simple RTC sanity check */ |
Joe Hershberger | e721b88 | 2015-05-20 14:27:27 -0500 | [diff] [blame] | 18 | static int dm_test_rtc_base(struct unit_test_state *uts) |
Simon Glass | 4772511 | 2015-04-20 12:37:31 -0600 | [diff] [blame] | 19 | { |
| 20 | struct udevice *dev; |
| 21 | |
| 22 | ut_asserteq(-ENODEV, uclass_get_device_by_seq(UCLASS_RTC, 2, &dev)); |
| 23 | ut_assertok(uclass_get_device(UCLASS_RTC, 0, &dev)); |
| 24 | ut_assertok(uclass_get_device(UCLASS_RTC, 1, &dev)); |
| 25 | |
| 26 | return 0; |
| 27 | } |
| 28 | DM_TEST(dm_test_rtc_base, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT); |
| 29 | |
| 30 | static void show_time(const char *msg, struct rtc_time *time) |
| 31 | { |
| 32 | printf("%s: %02d/%02d/%04d %02d:%02d:%02d\n", msg, |
| 33 | time->tm_mday, time->tm_mon, time->tm_year, |
| 34 | time->tm_hour, time->tm_min, time->tm_sec); |
| 35 | } |
| 36 | |
| 37 | static int cmp_times(struct rtc_time *expect, struct rtc_time *time, bool show) |
| 38 | { |
| 39 | bool same; |
| 40 | |
| 41 | same = expect->tm_sec == time->tm_sec; |
| 42 | same &= expect->tm_min == time->tm_min; |
| 43 | same &= expect->tm_hour == time->tm_hour; |
| 44 | same &= expect->tm_mday == time->tm_mday; |
| 45 | same &= expect->tm_mon == time->tm_mon; |
| 46 | same &= expect->tm_year == time->tm_year; |
| 47 | if (!same && show) { |
| 48 | show_time("expected", expect); |
| 49 | show_time("actual", time); |
| 50 | } |
| 51 | |
| 52 | return same ? 0 : -EINVAL; |
| 53 | } |
| 54 | |
| 55 | /* Set and get the time */ |
Joe Hershberger | e721b88 | 2015-05-20 14:27:27 -0500 | [diff] [blame] | 56 | static int dm_test_rtc_set_get(struct unit_test_state *uts) |
Simon Glass | 4772511 | 2015-04-20 12:37:31 -0600 | [diff] [blame] | 57 | { |
| 58 | struct rtc_time now, time, cmp; |
| 59 | struct udevice *dev, *emul; |
| 60 | long offset, old_offset, old_base_time; |
| 61 | |
| 62 | ut_assertok(uclass_get_device(UCLASS_RTC, 0, &dev)); |
| 63 | ut_assertok(dm_rtc_get(dev, &now)); |
| 64 | |
Simon Glass | 031a650 | 2018-11-18 08:14:34 -0700 | [diff] [blame] | 65 | ut_assertok(i2c_emul_find(dev, &emul)); |
Simon Glass | 4772511 | 2015-04-20 12:37:31 -0600 | [diff] [blame] | 66 | ut_assert(emul != NULL); |
| 67 | |
| 68 | /* Tell the RTC to go into manual mode */ |
| 69 | old_offset = sandbox_i2c_rtc_set_offset(emul, false, 0); |
| 70 | old_base_time = sandbox_i2c_rtc_get_set_base_time(emul, -1); |
| 71 | |
| 72 | memset(&time, '\0', sizeof(time)); |
Rasmus Villemoes | 9fb6a41 | 2020-07-06 22:01:16 +0200 | [diff] [blame^] | 73 | time.tm_mday = 3; |
| 74 | time.tm_mon = 6; |
| 75 | time.tm_year = 2004; |
| 76 | time.tm_sec = 0; |
| 77 | time.tm_min = 18; |
| 78 | time.tm_hour = 18; |
| 79 | ut_assertok(dm_rtc_set(dev, &time)); |
| 80 | |
| 81 | memset(&cmp, '\0', sizeof(cmp)); |
| 82 | ut_assertok(dm_rtc_get(dev, &cmp)); |
| 83 | ut_assertok(cmp_times(&time, &cmp, true)); |
| 84 | |
| 85 | memset(&time, '\0', sizeof(time)); |
| 86 | time.tm_mday = 31; |
Simon Glass | 4772511 | 2015-04-20 12:37:31 -0600 | [diff] [blame] | 87 | time.tm_mon = 8; |
| 88 | time.tm_year = 2004; |
| 89 | time.tm_sec = 0; |
| 90 | time.tm_min = 18; |
| 91 | time.tm_hour = 18; |
| 92 | ut_assertok(dm_rtc_set(dev, &time)); |
| 93 | |
| 94 | memset(&cmp, '\0', sizeof(cmp)); |
| 95 | ut_assertok(dm_rtc_get(dev, &cmp)); |
| 96 | ut_assertok(cmp_times(&time, &cmp, true)); |
| 97 | |
| 98 | /* Increment by 1 second */ |
| 99 | offset = sandbox_i2c_rtc_set_offset(emul, false, 0); |
| 100 | sandbox_i2c_rtc_set_offset(emul, false, offset + 1); |
| 101 | |
| 102 | memset(&cmp, '\0', sizeof(cmp)); |
| 103 | ut_assertok(dm_rtc_get(dev, &cmp)); |
| 104 | ut_asserteq(1, cmp.tm_sec); |
| 105 | |
| 106 | /* Check against original offset */ |
| 107 | sandbox_i2c_rtc_set_offset(emul, false, old_offset); |
| 108 | ut_assertok(dm_rtc_get(dev, &cmp)); |
| 109 | ut_assertok(cmp_times(&now, &cmp, true)); |
| 110 | |
| 111 | /* Back to the original offset */ |
| 112 | sandbox_i2c_rtc_set_offset(emul, false, 0); |
| 113 | memset(&cmp, '\0', sizeof(cmp)); |
| 114 | ut_assertok(dm_rtc_get(dev, &cmp)); |
| 115 | ut_assertok(cmp_times(&now, &cmp, true)); |
| 116 | |
| 117 | /* Increment the base time by 1 emul */ |
| 118 | sandbox_i2c_rtc_get_set_base_time(emul, old_base_time + 1); |
| 119 | memset(&cmp, '\0', sizeof(cmp)); |
| 120 | ut_assertok(dm_rtc_get(dev, &cmp)); |
| 121 | if (now.tm_sec == 59) { |
| 122 | ut_asserteq(0, cmp.tm_sec); |
| 123 | } else { |
| 124 | ut_asserteq(now.tm_sec + 1, cmp.tm_sec); |
| 125 | } |
| 126 | |
| 127 | old_offset = sandbox_i2c_rtc_set_offset(emul, true, 0); |
| 128 | |
| 129 | return 0; |
| 130 | } |
| 131 | DM_TEST(dm_test_rtc_set_get, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT); |
| 132 | |
| 133 | /* Reset the time */ |
Joe Hershberger | e721b88 | 2015-05-20 14:27:27 -0500 | [diff] [blame] | 134 | static int dm_test_rtc_reset(struct unit_test_state *uts) |
Simon Glass | 4772511 | 2015-04-20 12:37:31 -0600 | [diff] [blame] | 135 | { |
| 136 | struct rtc_time now; |
| 137 | struct udevice *dev, *emul; |
| 138 | long old_base_time, base_time; |
| 139 | |
| 140 | ut_assertok(uclass_get_device(UCLASS_RTC, 0, &dev)); |
| 141 | ut_assertok(dm_rtc_get(dev, &now)); |
| 142 | |
Simon Glass | 031a650 | 2018-11-18 08:14:34 -0700 | [diff] [blame] | 143 | ut_assertok(i2c_emul_find(dev, &emul)); |
Simon Glass | 4772511 | 2015-04-20 12:37:31 -0600 | [diff] [blame] | 144 | ut_assert(emul != NULL); |
| 145 | |
| 146 | old_base_time = sandbox_i2c_rtc_get_set_base_time(emul, 0); |
| 147 | |
| 148 | ut_asserteq(0, sandbox_i2c_rtc_get_set_base_time(emul, -1)); |
| 149 | |
| 150 | /* Resetting the RTC should put he base time back to normal */ |
| 151 | ut_assertok(dm_rtc_reset(dev)); |
| 152 | base_time = sandbox_i2c_rtc_get_set_base_time(emul, -1); |
| 153 | ut_asserteq(old_base_time, base_time); |
| 154 | |
| 155 | return 0; |
| 156 | } |
| 157 | DM_TEST(dm_test_rtc_reset, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT); |
| 158 | |
| 159 | /* Check that two RTC devices can be used independently */ |
Joe Hershberger | e721b88 | 2015-05-20 14:27:27 -0500 | [diff] [blame] | 160 | static int dm_test_rtc_dual(struct unit_test_state *uts) |
Simon Glass | 4772511 | 2015-04-20 12:37:31 -0600 | [diff] [blame] | 161 | { |
| 162 | struct rtc_time now1, now2, cmp; |
| 163 | struct udevice *dev1, *dev2; |
| 164 | struct udevice *emul1, *emul2; |
| 165 | long offset; |
| 166 | |
| 167 | ut_assertok(uclass_get_device(UCLASS_RTC, 0, &dev1)); |
| 168 | ut_assertok(dm_rtc_get(dev1, &now1)); |
| 169 | ut_assertok(uclass_get_device(UCLASS_RTC, 1, &dev2)); |
| 170 | ut_assertok(dm_rtc_get(dev2, &now2)); |
| 171 | |
Simon Glass | 031a650 | 2018-11-18 08:14:34 -0700 | [diff] [blame] | 172 | ut_assertok(i2c_emul_find(dev1, &emul1)); |
Simon Glass | 4772511 | 2015-04-20 12:37:31 -0600 | [diff] [blame] | 173 | ut_assert(emul1 != NULL); |
Simon Glass | 031a650 | 2018-11-18 08:14:34 -0700 | [diff] [blame] | 174 | ut_assertok(i2c_emul_find(dev2, &emul2)); |
Simon Glass | 4772511 | 2015-04-20 12:37:31 -0600 | [diff] [blame] | 175 | ut_assert(emul2 != NULL); |
| 176 | |
| 177 | offset = sandbox_i2c_rtc_set_offset(emul1, false, -1); |
| 178 | sandbox_i2c_rtc_set_offset(emul2, false, offset + 1); |
| 179 | memset(&cmp, '\0', sizeof(cmp)); |
| 180 | ut_assertok(dm_rtc_get(dev2, &cmp)); |
| 181 | ut_asserteq(-EINVAL, cmp_times(&now1, &cmp, false)); |
| 182 | |
| 183 | memset(&cmp, '\0', sizeof(cmp)); |
| 184 | ut_assertok(dm_rtc_get(dev1, &cmp)); |
| 185 | ut_assertok(cmp_times(&now1, &cmp, true)); |
| 186 | |
| 187 | return 0; |
| 188 | } |
| 189 | DM_TEST(dm_test_rtc_dual, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT); |