drivers/rtc/i2c_rtc_emul.c

   1 /*
   2  * Simulate an I2C real time clock
   3  *
   4  * Copyright (c) 2015 Google, Inc
   5  * Written by Simon Glass <sjg@chromium.org>
   6  *
   7  * SPDX-License-Identifier:     GPL-2.0+
   8  */
   9
  10 /*
  11  * This is a test driver. It starts off with the current time of the machine,
  12  * but also supports setting the time, using an offset from the current
  13  * clock. This driver is only intended for testing, not accurate
  14  * time-keeping. It does not change the system time.
  15  */
  16
  17 #include <common.h>
  18 #include <dm.h>
  19 #include <fdtdec.h>
  20 #include <i2c.h>
  21 #include <os.h>
  22 #include <rtc.h>
  23 #include <asm/rtc.h>
  24 #include <asm/test.h>
  25
  26 #ifdef DEBUG
  27 #define debug_buffer print_buffer
  28 #else
  29 #define debug_buffer(x, ...)
  30 #endif
  31
  32 DECLARE_GLOBAL_DATA_PTR;
  33
  34 /**
  35  * struct sandbox_i2c_rtc_plat_data - platform data for the RTC
  36  *
  37  * @base_time:          Base system time when RTC device was bound
  38  * @offset:             RTC offset from current system time
  39  * @use_system_time:    true to use system time, false to use @base_time
  40  * @reg:                Register values
  41  */
  42 struct sandbox_i2c_rtc_plat_data {
  43         long base_time;
  44         long offset;
  45         bool use_system_time;
  46         u8 reg[REG_COUNT];
  47 };
  48
  49 struct sandbox_i2c_rtc {
  50         unsigned int offset_secs;
  51 };
  52
  53 long sandbox_i2c_rtc_set_offset(struct udevice *dev, bool use_system_time,
  54                                 int offset)
  55 {
  56         struct sandbox_i2c_rtc_plat_data *plat = dev_get_platdata(dev);
  57         long old_offset;
  58
  59         old_offset = plat->offset;
  60         plat->use_system_time = use_system_time;
  61         if (offset != -1)
  62                 plat->offset = offset;
  63
  64         return old_offset;
  65 }
  66
  67 long sandbox_i2c_rtc_get_set_base_time(struct udevice *dev, long base_time)
  68 {
  69         struct sandbox_i2c_rtc_plat_data *plat = dev_get_platdata(dev);
  70         long old_base_time;
  71
  72         old_base_time = plat->base_time;
  73         if (base_time != -1)
  74                 plat->base_time = base_time;
  75
  76         return old_base_time;
  77 }
  78
  79 static void reset_time(struct udevice *dev)
  80 {
  81         struct sandbox_i2c_rtc_plat_data *plat = dev_get_platdata(dev);
  82         struct rtc_time now;
  83
  84         os_localtime(&now);
  85         plat->base_time = rtc_mktime(&now);
  86         plat->offset = 0;
  87         plat->use_system_time = true;
  88 }
  89
  90 static int sandbox_i2c_rtc_get(struct udevice *dev, struct rtc_time *time)
  91 {
  92         struct sandbox_i2c_rtc_plat_data *plat = dev_get_platdata(dev);
  93         struct rtc_time tm_now;
  94         long now;
  95
  96         if (plat->use_system_time) {
  97                 os_localtime(&tm_now);
  98                 now = rtc_mktime(&tm_now);
  99         } else {
 100                 now = plat->base_time;
 101         }
 102
 103         return rtc_to_tm(now + plat->offset, time);
 104 }
 105
 106 static int sandbox_i2c_rtc_set(struct udevice *dev, const struct rtc_time *time)
 107 {
 108         struct sandbox_i2c_rtc_plat_data *plat = dev_get_platdata(dev);
 109         struct rtc_time tm_now;
 110         long now;
 111
 112         if (plat->use_system_time) {
 113                 os_localtime(&tm_now);
 114                 now = rtc_mktime(&tm_now);
 115         } else {
 116                 now = plat->base_time;
 117         }
 118         plat->offset = rtc_mktime(time) - now;
 119
 120         return 0;
 121 }
 122
 123 /* Update the current time in the registers */
 124 static int sandbox_i2c_rtc_prepare_read(struct udevice *emul)
 125 {
 126         struct sandbox_i2c_rtc_plat_data *plat = dev_get_platdata(emul);
 127         struct rtc_time time;
 128         int ret;
 129
 130         ret = sandbox_i2c_rtc_get(emul, &time);
 131         if (ret)
 132                 return ret;
 133
 134         plat->reg[REG_SEC] = time.tm_sec;
 135         plat->reg[REG_MIN] = time.tm_min;
 136         plat->reg[REG_HOUR] = time.tm_hour;
 137         plat->reg[REG_MDAY] = time.tm_mday;
 138         plat->reg[REG_MON] = time.tm_mon;
 139         plat->reg[REG_YEAR] = time.tm_year - 1900;
 140         plat->reg[REG_WDAY] = time.tm_wday;
 141
 142         return 0;
 143 }
 144
 145 static int sandbox_i2c_rtc_complete_write(struct udevice *emul)
 146 {
 147         struct sandbox_i2c_rtc_plat_data *plat = dev_get_platdata(emul);
 148         struct rtc_time time;
 149         int ret;
 150
 151         time.tm_sec = plat->reg[REG_SEC];
 152         time.tm_min = plat->reg[REG_MIN];
 153         time.tm_hour = plat->reg[REG_HOUR];
 154         time.tm_mday = plat->reg[REG_MDAY];
 155         time.tm_mon = plat->reg[REG_MON];
 156         time.tm_year = plat->reg[REG_YEAR] + 1900;
 157         time.tm_wday = plat->reg[REG_WDAY];
 158
 159         ret = sandbox_i2c_rtc_set(emul, &time);
 160         if (ret)
 161                 return ret;
 162
 163         return 0;
 164 }
 165
 166 static int sandbox_i2c_rtc_xfer(struct udevice *emul, struct i2c_msg *msg,
 167                                 int nmsgs)
 168 {
 169         struct sandbox_i2c_rtc_plat_data *plat = dev_get_platdata(emul);
 170         uint offset = 0;
 171         int ret;
 172
 173         debug("\n%s\n", __func__);
 174         ret = sandbox_i2c_rtc_prepare_read(emul);
 175         if (ret)
 176                 return ret;
 177         for (; nmsgs > 0; nmsgs--, msg++) {
 178                 int len;
 179                 u8 *ptr;
 180
 181                 len = msg->len;
 182                 debug("   %s: msg->len=%d",
 183                       msg->flags & I2C_M_RD ? "read" : "write",
 184                       msg->len);
 185                 if (msg->flags & I2C_M_RD) {
 186                         debug(", offset %x, len %x: ", offset, len);
 187
 188                         /* Read the register */
 189                         memcpy(msg->buf, plat->reg + offset, len);
 190                         memset(msg->buf + len, '\xff', msg->len - len);
 191                         debug_buffer(0, msg->buf, 1, msg->len, 0);
 192                 } else if (len >= 1) {
 193                         ptr = msg->buf;
 194                         offset = *ptr++ & (REG_COUNT - 1);
 195                         len--;
 196                         debug(", set offset %x: ", offset);
 197                         debug_buffer(0, msg->buf, 1, msg->len, 0);
 198
 199                         /* Write the register */
 200                         memcpy(plat->reg + offset, ptr, len);
 201                         if (offset == REG_RESET)
 202                                 reset_time(emul);
 203                 }
 204         }
 205         ret = sandbox_i2c_rtc_complete_write(emul);
 206         if (ret)
 207                 return ret;
 208
 209         return 0;
 210 }
 211
 212 struct dm_i2c_ops sandbox_i2c_rtc_emul_ops = {
 213         .xfer = sandbox_i2c_rtc_xfer,
 214 };
 215
 216 static int sandbox_i2c_rtc_bind(struct udevice *dev)
 217 {
 218         reset_time(dev);
 219
 220         return 0;
 221 }
 222
 223 static const struct udevice_id sandbox_i2c_rtc_ids[] = {
 224         { .compatible = "sandbox,i2c-rtc" },
 225         { }
 226 };
 227
 228 U_BOOT_DRIVER(sandbox_i2c_rtc_emul) = {
 229         .name           = "sandbox_i2c_rtc_emul",
 230         .id             = UCLASS_I2C_EMUL,
 231         .of_match       = sandbox_i2c_rtc_ids,
 232         .bind           = sandbox_i2c_rtc_bind,
 233         .priv_auto_alloc_size = sizeof(struct sandbox_i2c_rtc),
 234         .platdata_auto_alloc_size = sizeof(struct sandbox_i2c_rtc_plat_data),
 235         .ops            = &sandbox_i2c_rtc_emul_ops,
 236 };