1 // SPDX-License-Identifier: GPL-2.0
2 // RTC driver for ChromeOS Embedded Controller.
3 //
4 // Copyright (C) 2017 Google, Inc.
5 // Author: Stephen Barber <smbarber@chromium.org>
6
7 #include <linux/kernel.h>
8 #include <linux/mod_devicetable.h>
9 #include <linux/module.h>
10 #include <linux/platform_data/cros_ec_commands.h>
11 #include <linux/platform_data/cros_ec_proto.h>
12 #include <linux/platform_device.h>
13 #include <linux/rtc.h>
14 #include <linux/slab.h>
15
16 #define DRV_NAME "cros-ec-rtc"
17
18 #define SECS_PER_DAY (24 * 60 * 60)
19
20 /**
21 * struct cros_ec_rtc - Driver data for EC RTC
22 *
23 * @cros_ec: Pointer to EC device
24 * @rtc: Pointer to RTC device
25 * @notifier: Notifier info for responding to EC events
26 * @saved_alarm: Alarm to restore when interrupts are reenabled
27 */
28 struct cros_ec_rtc {
29 struct cros_ec_device *cros_ec;
30 struct rtc_device *rtc;
31 struct notifier_block notifier;
32 u32 saved_alarm;
33 };
34
cros_ec_rtc_get(struct cros_ec_device * cros_ec,u32 command,u32 * response)35 static int cros_ec_rtc_get(struct cros_ec_device *cros_ec, u32 command,
36 u32 *response)
37 {
38 DEFINE_RAW_FLEX(struct cros_ec_command, msg, data,
39 sizeof(struct ec_response_rtc));
40 int ret;
41
42 msg->command = command;
43 msg->insize = sizeof(struct ec_response_rtc);
44
45 ret = cros_ec_cmd_xfer_status(cros_ec, msg);
46 if (ret < 0)
47 return ret;
48
49 *response = ((struct ec_response_rtc *)msg->data)->time;
50
51 return 0;
52 }
53
cros_ec_rtc_set(struct cros_ec_device * cros_ec,u32 command,u32 param)54 static int cros_ec_rtc_set(struct cros_ec_device *cros_ec, u32 command,
55 u32 param)
56 {
57 DEFINE_RAW_FLEX(struct cros_ec_command, msg, data,
58 sizeof(struct ec_response_rtc));
59 int ret;
60
61 msg->command = command;
62 msg->outsize = sizeof(struct ec_response_rtc);
63 ((struct ec_response_rtc *)msg->data)->time = param;
64
65 ret = cros_ec_cmd_xfer_status(cros_ec, msg);
66 if (ret < 0)
67 return ret;
68 return 0;
69 }
70
71 /* Read the current time from the EC. */
cros_ec_rtc_read_time(struct device * dev,struct rtc_time * tm)72 static int cros_ec_rtc_read_time(struct device *dev, struct rtc_time *tm)
73 {
74 struct cros_ec_rtc *cros_ec_rtc = dev_get_drvdata(dev);
75 struct cros_ec_device *cros_ec = cros_ec_rtc->cros_ec;
76 int ret;
77 u32 time;
78
79 ret = cros_ec_rtc_get(cros_ec, EC_CMD_RTC_GET_VALUE, &time);
80 if (ret) {
81 dev_err(dev, "error getting time: %d\n", ret);
82 return ret;
83 }
84
85 rtc_time64_to_tm(time, tm);
86
87 return 0;
88 }
89
90 /* Set the current EC time. */
cros_ec_rtc_set_time(struct device * dev,struct rtc_time * tm)91 static int cros_ec_rtc_set_time(struct device *dev, struct rtc_time *tm)
92 {
93 struct cros_ec_rtc *cros_ec_rtc = dev_get_drvdata(dev);
94 struct cros_ec_device *cros_ec = cros_ec_rtc->cros_ec;
95 int ret;
96 time64_t time = rtc_tm_to_time64(tm);
97
98 ret = cros_ec_rtc_set(cros_ec, EC_CMD_RTC_SET_VALUE, (u32)time);
99 if (ret < 0) {
100 dev_err(dev, "error setting time: %d\n", ret);
101 return ret;
102 }
103
104 return 0;
105 }
106
107 /* Read alarm time from RTC. */
cros_ec_rtc_read_alarm(struct device * dev,struct rtc_wkalrm * alrm)108 static int cros_ec_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
109 {
110 struct cros_ec_rtc *cros_ec_rtc = dev_get_drvdata(dev);
111 struct cros_ec_device *cros_ec = cros_ec_rtc->cros_ec;
112 int ret;
113 u32 current_time, alarm_offset;
114
115 /*
116 * The EC host command for getting the alarm is relative (i.e. 5
117 * seconds from now) whereas rtc_wkalrm is absolute. Get the current
118 * RTC time first so we can calculate the relative time.
119 */
120 ret = cros_ec_rtc_get(cros_ec, EC_CMD_RTC_GET_VALUE, ¤t_time);
121 if (ret < 0) {
122 dev_err(dev, "error getting time: %d\n", ret);
123 return ret;
124 }
125
126 ret = cros_ec_rtc_get(cros_ec, EC_CMD_RTC_GET_ALARM, &alarm_offset);
127 if (ret < 0) {
128 dev_err(dev, "error getting alarm: %d\n", ret);
129 return ret;
130 }
131
132 rtc_time64_to_tm(current_time + alarm_offset, &alrm->time);
133
134 return 0;
135 }
136
137 /* Set the EC's RTC alarm. */
cros_ec_rtc_set_alarm(struct device * dev,struct rtc_wkalrm * alrm)138 static int cros_ec_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
139 {
140 struct cros_ec_rtc *cros_ec_rtc = dev_get_drvdata(dev);
141 struct cros_ec_device *cros_ec = cros_ec_rtc->cros_ec;
142 int ret;
143 time64_t alarm_time;
144 u32 current_time, alarm_offset;
145
146 /*
147 * The EC host command for setting the alarm is relative
148 * (i.e. 5 seconds from now) whereas rtc_wkalrm is absolute.
149 * Get the current RTC time first so we can calculate the
150 * relative time.
151 */
152 ret = cros_ec_rtc_get(cros_ec, EC_CMD_RTC_GET_VALUE, ¤t_time);
153 if (ret < 0) {
154 dev_err(dev, "error getting time: %d\n", ret);
155 return ret;
156 }
157
158 alarm_time = rtc_tm_to_time64(&alrm->time);
159
160 if (alarm_time < 0 || alarm_time > U32_MAX)
161 return -EINVAL;
162
163 if (!alrm->enabled) {
164 /*
165 * If the alarm is being disabled, send an alarm
166 * clear command.
167 */
168 alarm_offset = EC_RTC_ALARM_CLEAR;
169 cros_ec_rtc->saved_alarm = (u32)alarm_time;
170 } else {
171 /* Don't set an alarm in the past. */
172 if ((u32)alarm_time <= current_time)
173 return -ETIME;
174
175 alarm_offset = (u32)alarm_time - current_time;
176 }
177
178 ret = cros_ec_rtc_set(cros_ec, EC_CMD_RTC_SET_ALARM, alarm_offset);
179 if (ret < 0) {
180 dev_err(dev, "error setting alarm in %u seconds: %d\n",
181 alarm_offset, ret);
182 /*
183 * The EC code returns -EINVAL if the alarm time is too
184 * far in the future. Convert it to the expected error code.
185 */
186 if (ret == -EINVAL)
187 ret = -ERANGE;
188 return ret;
189 }
190
191 return 0;
192 }
193
cros_ec_rtc_alarm_irq_enable(struct device * dev,unsigned int enabled)194 static int cros_ec_rtc_alarm_irq_enable(struct device *dev,
195 unsigned int enabled)
196 {
197 struct cros_ec_rtc *cros_ec_rtc = dev_get_drvdata(dev);
198 struct cros_ec_device *cros_ec = cros_ec_rtc->cros_ec;
199 int ret;
200 u32 current_time, alarm_offset, alarm_value;
201
202 ret = cros_ec_rtc_get(cros_ec, EC_CMD_RTC_GET_VALUE, ¤t_time);
203 if (ret < 0) {
204 dev_err(dev, "error getting time: %d\n", ret);
205 return ret;
206 }
207
208 if (enabled) {
209 /* Restore saved alarm if it's still in the future. */
210 if (cros_ec_rtc->saved_alarm < current_time)
211 alarm_offset = EC_RTC_ALARM_CLEAR;
212 else
213 alarm_offset = cros_ec_rtc->saved_alarm - current_time;
214
215 ret = cros_ec_rtc_set(cros_ec, EC_CMD_RTC_SET_ALARM,
216 alarm_offset);
217 if (ret < 0) {
218 dev_err(dev, "error restoring alarm: %d\n", ret);
219 return ret;
220 }
221 } else {
222 /* Disable alarm, saving the old alarm value. */
223 ret = cros_ec_rtc_get(cros_ec, EC_CMD_RTC_GET_ALARM,
224 &alarm_offset);
225 if (ret < 0) {
226 dev_err(dev, "error saving alarm: %d\n", ret);
227 return ret;
228 }
229
230 alarm_value = current_time + alarm_offset;
231
232 /*
233 * If the current EC alarm is already past, we don't want
234 * to set an alarm when we go through the alarm irq enable
235 * path.
236 */
237 if (alarm_value < current_time)
238 cros_ec_rtc->saved_alarm = EC_RTC_ALARM_CLEAR;
239 else
240 cros_ec_rtc->saved_alarm = alarm_value;
241
242 alarm_offset = EC_RTC_ALARM_CLEAR;
243 ret = cros_ec_rtc_set(cros_ec, EC_CMD_RTC_SET_ALARM,
244 alarm_offset);
245 if (ret < 0) {
246 dev_err(dev, "error disabling alarm: %d\n", ret);
247 return ret;
248 }
249 }
250
251 return 0;
252 }
253
cros_ec_rtc_event(struct notifier_block * nb,unsigned long queued_during_suspend,void * _notify)254 static int cros_ec_rtc_event(struct notifier_block *nb,
255 unsigned long queued_during_suspend,
256 void *_notify)
257 {
258 struct cros_ec_rtc *cros_ec_rtc;
259 struct rtc_device *rtc;
260 struct cros_ec_device *cros_ec;
261 u32 host_event;
262
263 cros_ec_rtc = container_of(nb, struct cros_ec_rtc, notifier);
264 rtc = cros_ec_rtc->rtc;
265 cros_ec = cros_ec_rtc->cros_ec;
266
267 host_event = cros_ec_get_host_event(cros_ec);
268 if (host_event & EC_HOST_EVENT_MASK(EC_HOST_EVENT_RTC)) {
269 rtc_update_irq(rtc, 1, RTC_IRQF | RTC_AF);
270 return NOTIFY_OK;
271 } else {
272 return NOTIFY_DONE;
273 }
274 }
275
276 static const struct rtc_class_ops cros_ec_rtc_ops = {
277 .read_time = cros_ec_rtc_read_time,
278 .set_time = cros_ec_rtc_set_time,
279 .read_alarm = cros_ec_rtc_read_alarm,
280 .set_alarm = cros_ec_rtc_set_alarm,
281 .alarm_irq_enable = cros_ec_rtc_alarm_irq_enable,
282 };
283
284 #ifdef CONFIG_PM_SLEEP
cros_ec_rtc_suspend(struct device * dev)285 static int cros_ec_rtc_suspend(struct device *dev)
286 {
287 struct platform_device *pdev = to_platform_device(dev);
288 struct cros_ec_rtc *cros_ec_rtc = dev_get_drvdata(&pdev->dev);
289
290 if (device_may_wakeup(dev))
291 return enable_irq_wake(cros_ec_rtc->cros_ec->irq);
292
293 return 0;
294 }
295
cros_ec_rtc_resume(struct device * dev)296 static int cros_ec_rtc_resume(struct device *dev)
297 {
298 struct platform_device *pdev = to_platform_device(dev);
299 struct cros_ec_rtc *cros_ec_rtc = dev_get_drvdata(&pdev->dev);
300
301 if (device_may_wakeup(dev))
302 return disable_irq_wake(cros_ec_rtc->cros_ec->irq);
303
304 return 0;
305 }
306 #endif
307
308 static SIMPLE_DEV_PM_OPS(cros_ec_rtc_pm_ops, cros_ec_rtc_suspend,
309 cros_ec_rtc_resume);
310
cros_ec_rtc_probe(struct platform_device * pdev)311 static int cros_ec_rtc_probe(struct platform_device *pdev)
312 {
313 struct cros_ec_dev *ec_dev = dev_get_drvdata(pdev->dev.parent);
314 struct cros_ec_device *cros_ec = ec_dev->ec_dev;
315 struct cros_ec_rtc *cros_ec_rtc;
316 struct rtc_time tm;
317 int ret;
318
319 cros_ec_rtc = devm_kzalloc(&pdev->dev, sizeof(*cros_ec_rtc),
320 GFP_KERNEL);
321 if (!cros_ec_rtc)
322 return -ENOMEM;
323
324 platform_set_drvdata(pdev, cros_ec_rtc);
325 cros_ec_rtc->cros_ec = cros_ec;
326
327 /* Get initial time */
328 ret = cros_ec_rtc_read_time(&pdev->dev, &tm);
329 if (ret) {
330 dev_err(&pdev->dev, "failed to read RTC time\n");
331 return ret;
332 }
333
334 ret = device_init_wakeup(&pdev->dev, true);
335 if (ret) {
336 dev_err(&pdev->dev, "failed to initialize wakeup\n");
337 return ret;
338 }
339
340 cros_ec_rtc->rtc = devm_rtc_allocate_device(&pdev->dev);
341 if (IS_ERR(cros_ec_rtc->rtc))
342 return PTR_ERR(cros_ec_rtc->rtc);
343
344 cros_ec_rtc->rtc->ops = &cros_ec_rtc_ops;
345 cros_ec_rtc->rtc->range_max = U32_MAX;
346
347 /*
348 * The RTC on some older Chromebooks can only handle alarms less than
349 * 24 hours in the future. The only way to find out is to try to set an
350 * alarm further in the future. If that fails, assume that the RTC
351 * connected to the EC can only handle less than 24 hours of alarm
352 * window.
353 */
354 ret = cros_ec_rtc_set(cros_ec, EC_CMD_RTC_SET_ALARM, SECS_PER_DAY * 2);
355 if (ret == -EINVAL)
356 cros_ec_rtc->rtc->alarm_offset_max = SECS_PER_DAY - 1;
357
358 (void)cros_ec_rtc_set(cros_ec, EC_CMD_RTC_SET_ALARM,
359 EC_RTC_ALARM_CLEAR);
360
361 ret = devm_rtc_register_device(cros_ec_rtc->rtc);
362 if (ret)
363 return ret;
364
365 /* Get RTC events from the EC. */
366 cros_ec_rtc->notifier.notifier_call = cros_ec_rtc_event;
367 ret = blocking_notifier_chain_register(&cros_ec->event_notifier,
368 &cros_ec_rtc->notifier);
369 if (ret) {
370 dev_err(&pdev->dev, "failed to register notifier\n");
371 return ret;
372 }
373
374 return 0;
375 }
376
cros_ec_rtc_remove(struct platform_device * pdev)377 static void cros_ec_rtc_remove(struct platform_device *pdev)
378 {
379 struct cros_ec_rtc *cros_ec_rtc = platform_get_drvdata(pdev);
380 struct device *dev = &pdev->dev;
381 int ret;
382
383 ret = blocking_notifier_chain_unregister(
384 &cros_ec_rtc->cros_ec->event_notifier,
385 &cros_ec_rtc->notifier);
386 if (ret)
387 dev_err(dev, "failed to unregister notifier\n");
388 }
389
390 static const struct platform_device_id cros_ec_rtc_id[] = {
391 { DRV_NAME, 0 },
392 {}
393 };
394 MODULE_DEVICE_TABLE(platform, cros_ec_rtc_id);
395
396 static struct platform_driver cros_ec_rtc_driver = {
397 .probe = cros_ec_rtc_probe,
398 .remove = cros_ec_rtc_remove,
399 .driver = {
400 .name = DRV_NAME,
401 .pm = &cros_ec_rtc_pm_ops,
402 },
403 .id_table = cros_ec_rtc_id,
404 };
405
406 module_platform_driver(cros_ec_rtc_driver);
407
408 MODULE_DESCRIPTION("RTC driver for Chrome OS ECs");
409 MODULE_AUTHOR("Stephen Barber <smbarber@chromium.org>");
410 MODULE_LICENSE("GPL v2");
411