test/dm/rtc.c

   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 <dm.h>
   9 #include <i2c.h>
  10 #include <log.h>
  11 #include <rtc.h>
  12 #include <asm/io.h>
  13 #include <asm/test.h>
  14 #include <dm/test.h>
  15 #include <test/ut.h>
  16
  17 /* Simple RTC sanity check */
  18 static int dm_test_rtc_base(struct unit_test_state *uts)
  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 */
  56 static int dm_test_rtc_set_get(struct unit_test_state *uts)
  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
  65         ut_assertok(i2c_emul_find(dev, &emul));
  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));
  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;
  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 */
 134 static int dm_test_rtc_reset(struct unit_test_state *uts)
 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
 143         ut_assertok(i2c_emul_find(dev, &emul));
 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 */
 160 static int dm_test_rtc_dual(struct unit_test_state *uts)
 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
 172         ut_assertok(i2c_emul_find(dev1, &emul1));
 173         ut_assert(emul1 != NULL);
 174         ut_assertok(i2c_emul_find(dev2, &emul2));
 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);