1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 * virtio_rtc RTC class driver
4 *
5 * Copyright (C) 2023 OpenSynergy GmbH
6 * Copyright (c) 2024 Qualcomm Innovation Center, Inc. All rights reserved.
7 */
8
9#include <linux/math64.h>
10#include <linux/overflow.h>
11#include <linux/rtc.h>
12#include <linux/time64.h>
13
14#include <uapi/linux/virtio_rtc.h>
15
16#include "virtio_rtc_internal.h"
17
18/**
19 * struct viortc_class - RTC class wrapper
20 * @viortc: virtio_rtc device data
21 * @rtc: RTC device
22 * @vio_clk_id: virtio_rtc clock id
23 * @stopped: Whether RTC ops are disallowed. Access protected by rtc_lock().
24 */
25struct viortc_class {
26 struct viortc_dev *viortc;
27 struct rtc_device *rtc;
28 u16 vio_clk_id;
29 bool stopped;
30};
31
32/**
33 * viortc_class_get_locked() - get RTC class wrapper, if ops allowed
34 * @dev: virtio device
35 *
36 * Gets the RTC class wrapper from the virtio device, if it is available and
37 * ops are allowed.
38 *
39 * Context: Caller must hold rtc_lock().
40 * Return: RTC class wrapper if available and ops allowed, ERR_PTR otherwise.
41 */
42static struct viortc_class *viortc_class_get_locked(struct device *dev)
43{
44 struct viortc_class *viortc_class;
45
46 viortc_class = viortc_class_from_dev(dev);
47 if (IS_ERR(ptr: viortc_class))
48 return viortc_class;
49
50 if (viortc_class->stopped)
51 return ERR_PTR(error: -EBUSY);
52
53 return viortc_class;
54}
55
56/**
57 * viortc_class_read_time() - RTC class op read_time
58 * @dev: virtio device
59 * @tm: read time
60 *
61 * Context: Process context.
62 * Return: Zero on success, negative error code otherwise.
63 */
64static int viortc_class_read_time(struct device *dev, struct rtc_time *tm)
65{
66 struct viortc_class *viortc_class;
67 time64_t sec;
68 int ret;
69 u64 ns;
70
71 viortc_class = viortc_class_get_locked(dev);
72 if (IS_ERR(ptr: viortc_class))
73 return PTR_ERR(ptr: viortc_class);
74
75 ret = viortc_read(viortc: viortc_class->viortc, vio_clk_id: viortc_class->vio_clk_id, reading: &ns);
76 if (ret)
77 return ret;
78
79 sec = div_u64(dividend: ns, NSEC_PER_SEC);
80
81 rtc_time64_to_tm(time: sec, tm);
82
83 return 0;
84}
85
86/**
87 * viortc_class_read_alarm() - RTC class op read_alarm
88 * @dev: virtio device
89 * @alrm: alarm read out
90 *
91 * Context: Process context.
92 * Return: Zero on success, negative error code otherwise.
93 */
94static int viortc_class_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
95{
96 struct viortc_class *viortc_class;
97 time64_t alarm_time_sec;
98 u64 alarm_time_ns;
99 bool enabled;
100 int ret;
101
102 viortc_class = viortc_class_get_locked(dev);
103 if (IS_ERR(ptr: viortc_class))
104 return PTR_ERR(ptr: viortc_class);
105
106 ret = viortc_read_alarm(viortc: viortc_class->viortc, vio_clk_id: viortc_class->vio_clk_id,
107 alarm_time: &alarm_time_ns, enabled: &enabled);
108 if (ret)
109 return ret;
110
111 alarm_time_sec = div_u64(dividend: alarm_time_ns, NSEC_PER_SEC);
112 rtc_time64_to_tm(time: alarm_time_sec, tm: &alrm->time);
113
114 alrm->enabled = enabled;
115
116 return 0;
117}
118
119/**
120 * viortc_class_set_alarm() - RTC class op set_alarm
121 * @dev: virtio device
122 * @alrm: alarm to set
123 *
124 * Context: Process context.
125 * Return: Zero on success, negative error code otherwise.
126 */
127static int viortc_class_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
128{
129 struct viortc_class *viortc_class;
130 time64_t alarm_time_sec;
131 u64 alarm_time_ns;
132
133 viortc_class = viortc_class_get_locked(dev);
134 if (IS_ERR(ptr: viortc_class))
135 return PTR_ERR(ptr: viortc_class);
136
137 alarm_time_sec = rtc_tm_to_time64(tm: &alrm->time);
138
139 if (alarm_time_sec < 0)
140 return -EINVAL;
141
142 if (check_mul_overflow((u64)alarm_time_sec, (u64)NSEC_PER_SEC,
143 &alarm_time_ns))
144 return -EINVAL;
145
146 return viortc_set_alarm(viortc: viortc_class->viortc, vio_clk_id: viortc_class->vio_clk_id,
147 alarm_time: alarm_time_ns, alarm_enable: alrm->enabled);
148}
149
150/**
151 * viortc_class_alarm_irq_enable() - RTC class op alarm_irq_enable
152 * @dev: virtio device
153 * @enabled: enable or disable alarm IRQ
154 *
155 * Context: Process context.
156 * Return: Zero on success, negative error code otherwise.
157 */
158static int viortc_class_alarm_irq_enable(struct device *dev,
159 unsigned int enabled)
160{
161 struct viortc_class *viortc_class;
162
163 viortc_class = viortc_class_get_locked(dev);
164 if (IS_ERR(ptr: viortc_class))
165 return PTR_ERR(ptr: viortc_class);
166
167 return viortc_set_alarm_enabled(viortc: viortc_class->viortc,
168 vio_clk_id: viortc_class->vio_clk_id, alarm_enable: enabled);
169}
170
171static const struct rtc_class_ops viortc_class_ops = {
172 .read_time = viortc_class_read_time,
173 .read_alarm = viortc_class_read_alarm,
174 .set_alarm = viortc_class_set_alarm,
175 .alarm_irq_enable = viortc_class_alarm_irq_enable,
176};
177
178/**
179 * viortc_class_alarm() - propagate alarm notification as alarm interrupt
180 * @viortc_class: RTC class wrapper
181 * @vio_clk_id: virtio_rtc clock id
182 *
183 * Context: Any context.
184 */
185void viortc_class_alarm(struct viortc_class *viortc_class, u16 vio_clk_id)
186{
187 if (vio_clk_id != viortc_class->vio_clk_id) {
188 dev_warn_ratelimited(&viortc_class->rtc->dev,
189 "ignoring alarm for clock id %d, expected id %d\n",
190 vio_clk_id, viortc_class->vio_clk_id);
191 return;
192 }
193
194 rtc_update_irq(rtc: viortc_class->rtc, num: 1, RTC_AF | RTC_IRQF);
195}
196
197/**
198 * viortc_class_stop() - disallow RTC class ops
199 * @viortc_class: RTC class wrapper
200 *
201 * Context: Process context. Caller must NOT hold rtc_lock().
202 */
203void viortc_class_stop(struct viortc_class *viortc_class)
204{
205 rtc_lock(viortc_class->rtc);
206
207 viortc_class->stopped = true;
208
209 rtc_unlock(viortc_class->rtc);
210}
211
212/**
213 * viortc_class_register() - register RTC class device
214 * @viortc_class: RTC class wrapper
215 *
216 * Context: Process context.
217 * Return: Zero on success, negative error code otherwise.
218 */
219int viortc_class_register(struct viortc_class *viortc_class)
220{
221 return devm_rtc_register_device(viortc_class->rtc);
222}
223
224/**
225 * viortc_class_init() - init RTC class wrapper and device
226 * @viortc: device data
227 * @vio_clk_id: virtio_rtc clock id
228 * @have_alarm: have alarm feature
229 * @parent_dev: virtio device
230 *
231 * Context: Process context.
232 * Return: RTC class wrapper on success, ERR_PTR otherwise.
233 */
234struct viortc_class *viortc_class_init(struct viortc_dev *viortc,
235 u16 vio_clk_id, bool have_alarm,
236 struct device *parent_dev)
237{
238 struct viortc_class *viortc_class;
239 struct rtc_device *rtc;
240
241 viortc_class =
242 devm_kzalloc(dev: parent_dev, size: sizeof(*viortc_class), GFP_KERNEL);
243 if (!viortc_class)
244 return ERR_PTR(error: -ENOMEM);
245
246 rtc = devm_rtc_allocate_device(dev: parent_dev);
247 if (IS_ERR(ptr: rtc))
248 return ERR_CAST(ptr: rtc);
249
250 viortc_class->viortc = viortc;
251 viortc_class->rtc = rtc;
252 viortc_class->vio_clk_id = vio_clk_id;
253
254 if (!have_alarm)
255 clear_bit(RTC_FEATURE_ALARM, addr: rtc->features);
256 clear_bit(RTC_FEATURE_UPDATE_INTERRUPT, addr: rtc->features);
257
258 rtc->ops = &viortc_class_ops;
259 rtc->range_max = div_u64(U64_MAX, NSEC_PER_SEC);
260
261 return viortc_class;
262}
263

source code of linux/drivers/virtio/virtio_rtc_class.c