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