projects/linux·blob master · refs

1419 lines · 35.1 KiB

1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 * virtio_rtc driver core
4 *
5 * Copyright (C) 2022-2024 OpenSynergy GmbH
6 * Copyright (c) 2024 Qualcomm Innovation Center, Inc. All rights reserved.
7 */
8
9#include <linux/completion.h>
10#include <linux/device.h>
11#include <linux/module.h>
12#include <linux/pm.h>
13#include <linux/virtio.h>
14#include <linux/virtio_config.h>
15#include <linux/virtio_ids.h>
16
17#include <uapi/linux/virtio_rtc.h>
18
19#include "virtio_rtc_internal.h"
20
21#define VIORTC_ALARMQ_BUF_CAP sizeof(union virtio_rtc_notif_alarmq)
22
23/* virtqueue order */
24enum {
25 VIORTC_REQUESTQ,
26 VIORTC_ALARMQ,
27 VIORTC_MAX_NR_QUEUES,
28};
29
30/**
31 * struct viortc_vq - virtqueue abstraction
32 * @vq: virtqueue
33 * @lock: protects access to vq
34 */
35struct viortc_vq {
36 struct virtqueue *vq;
37 spinlock_t lock;
38};
39
40/**
41 * struct viortc_dev - virtio_rtc device data
42 * @vdev: virtio device
43 * @viortc_class: RTC class wrapper for UTC-like clock, NULL if not available
44 * @vqs: virtqueues
45 * @clocks_to_unregister: Clock references, which are only used during device
46 * removal.
47 * For other uses, there would be a race between device
48 * creation and setting the pointers here.
49 * @alarmq_bufs: alarmq buffers list
50 * @num_alarmq_bufs: # of alarmq buffers
51 * @num_clocks: # of virtio_rtc clocks
52 */
53struct viortc_dev {
54 struct virtio_device *vdev;
55 struct viortc_class *viortc_class;
56 struct viortc_vq vqs[VIORTC_MAX_NR_QUEUES];
57 struct viortc_ptp_clock **clocks_to_unregister;
58 void **alarmq_bufs;
59 unsigned int num_alarmq_bufs;
60 u16 num_clocks;
61};
62
63/**
64 * struct viortc_msg - Message requested by driver, responded by device.
65 * @viortc: device data
66 * @req: request buffer
67 * @resp: response buffer
68 * @responded: vqueue callback signals response reception
69 * @refcnt: Message reference count, message and buffers will be deallocated
70 * once 0. refcnt is decremented in the vqueue callback and in the
71 * thread waiting on the responded completion.
72 * If a message response wait function times out, the message will be
73 * freed upon late reception (refcnt will reach 0 in the callback), or
74 * device removal.
75 * @req_size: size of request in bytes
76 * @resp_cap: maximum size of response in bytes
77 * @resp_actual_size: actual size of response
78 */
79struct viortc_msg {
80 struct viortc_dev *viortc;
81 void *req;
82 void *resp;
83 struct completion responded;
84 refcount_t refcnt;
85 unsigned int req_size;
86 unsigned int resp_cap;
87 unsigned int resp_actual_size;
88};
89
90/**
91 * viortc_class_from_dev() - Get RTC class object from virtio device.
92 * @dev: virtio device
93 *
94 * Context: Any context.
95 * Return: RTC class object if available, ERR_PTR otherwise.
96 */
97struct viortc_class *viortc_class_from_dev(struct device *dev)
98{
99 struct virtio_device *vdev;
100 struct viortc_dev *viortc;
101
102 vdev = container_of(dev, typeof(*vdev), dev);
103 viortc = vdev->priv;
104
105 return viortc->viortc_class ?: ERR_PTR(-ENODEV);
106}
107
108/**
109 * viortc_alarms_supported() - Whether device and driver support alarms.
110 * @vdev: virtio device
111 *
112 * NB: Device and driver may not support alarms for the same clocks.
113 *
114 * Context: Any context.
115 * Return: True if both device and driver can support alarms.
116 */
117static bool viortc_alarms_supported(struct virtio_device *vdev)
118{
119 return IS_ENABLED(CONFIG_VIRTIO_RTC_CLASS) &&
120 virtio_has_feature(vdev, VIRTIO_RTC_F_ALARM);
121}
122
123/**
124 * viortc_feed_vq() - Make a device write-only buffer available.
125 * @viortc: device data
126 * @vq: notification virtqueue
127 * @buf: buffer
128 * @buf_len: buffer capacity in bytes
129 * @data: token, identifying buffer
130 *
131 * Context: Caller must prevent concurrent access to vq.
132 * Return: Zero on success, negative error code otherwise.
133 */
134static int viortc_feed_vq(struct viortc_dev *viortc, struct virtqueue *vq,
135 void *buf, unsigned int buf_len, void *data)
136{
137 struct scatterlist sg;
138
139 sg_init_one(&sg, buf, buf_len);
140
141 return virtqueue_add_inbuf(vq, &sg, 1, data, GFP_ATOMIC);
142}
143
144/**
145 * viortc_msg_init() - Allocate and initialize requestq message.
146 * @viortc: device data
147 * @msg_type: virtio_rtc message type
148 * @req_size: size of request buffer to be allocated
149 * @resp_cap: size of response buffer to be allocated
150 *
151 * Initializes the message refcnt to 2. The refcnt will be decremented once in
152 * the virtqueue callback, and once in the thread waiting on the message (on
153 * completion or timeout).
154 *
155 * Context: Process context.
156 * Return: non-NULL on success.
157 */
158static struct viortc_msg *viortc_msg_init(struct viortc_dev *viortc,
159 u16 msg_type, unsigned int req_size,
160 unsigned int resp_cap)
161{
162 struct device *dev = &viortc->vdev->dev;
163 struct virtio_rtc_req_head *req_head;
164 struct viortc_msg *msg;
165
166 msg = devm_kzalloc(dev, sizeof(*msg), GFP_KERNEL);
167 if (!msg)
168 return NULL;
169
170 init_completion(&msg->responded);
171
172 msg->req = devm_kzalloc(dev, req_size, GFP_KERNEL);
173 if (!msg->req)
174 goto err_free_msg;
175
176 req_head = msg->req;
177
178 msg->resp = devm_kzalloc(dev, resp_cap, GFP_KERNEL);
179 if (!msg->resp)
180 goto err_free_msg_req;
181
182 msg->viortc = viortc;
183 msg->req_size = req_size;
184 msg->resp_cap = resp_cap;
185
186 refcount_set(&msg->refcnt, 2);
187
188 req_head->msg_type = virtio_cpu_to_le(msg_type, req_head->msg_type);
189
190 return msg;
191
192err_free_msg_req:
193 devm_kfree(dev, msg->req);
194
195err_free_msg:
196 devm_kfree(dev, msg);
197
198 return NULL;
199}
200
201/**
202 * viortc_msg_release() - Decrement message refcnt, potentially free message.
203 * @msg: message requested by driver
204 *
205 * Context: Any context.
206 */
207static void viortc_msg_release(struct viortc_msg *msg)
208{
209 struct device *dev;
210
211 if (refcount_dec_and_test(&msg->refcnt)) {
212 dev = &msg->viortc->vdev->dev;
213
214 devm_kfree(dev, msg->req);
215 devm_kfree(dev, msg->resp);
216 devm_kfree(dev, msg);
217 }
218}
219
220/**
221 * viortc_do_cb() - generic virtqueue callback logic
222 * @vq: virtqueue
223 * @handle_buf: function to process a used buffer
224 *
225 * Context: virtqueue callback, typically interrupt. Takes and releases vq lock.
226 */
227static void viortc_do_cb(struct virtqueue *vq,
228 void (*handle_buf)(void *token, unsigned int len,
229 struct virtqueue *vq,
230 struct viortc_vq *viortc_vq,
231 struct viortc_dev *viortc))
232{
233 struct viortc_dev *viortc = vq->vdev->priv;
234 struct viortc_vq *viortc_vq;
235 bool cb_enabled = true;
236 unsigned long flags;
237 unsigned int len;
238 void *token;
239
240 viortc_vq = &viortc->vqs[vq->index];
241
242 for (;;) {
243 spin_lock_irqsave(&viortc_vq->lock, flags);
244
245 if (cb_enabled) {
246 virtqueue_disable_cb(vq);
247 cb_enabled = false;
248 }
249
250 token = virtqueue_get_buf(vq, &len);
251 if (!token) {
252 if (virtqueue_enable_cb(vq)) {
253 spin_unlock_irqrestore(&viortc_vq->lock, flags);
254 return;
255 }
256 cb_enabled = true;
257 }
258
259 spin_unlock_irqrestore(&viortc_vq->lock, flags);
260
261 if (token)
262 handle_buf(token, len, vq, viortc_vq, viortc);
263 }
264}
265
266/**
267 * viortc_requestq_hdlr() - process a requestq used buffer
268 * @token: token identifying the buffer
269 * @len: bytes written by device
270 * @vq: virtqueue
271 * @viortc_vq: device specific data for virtqueue
272 * @viortc: device data
273 *
274 * Signals completion for each received message.
275 *
276 * Context: virtqueue callback
277 */
278static void viortc_requestq_hdlr(void *token, unsigned int len,
279 struct virtqueue *vq,
280 struct viortc_vq *viortc_vq,
281 struct viortc_dev *viortc)
282{
283 struct viortc_msg *msg = token;
284
285 msg->resp_actual_size = len;
286
287 complete(&msg->responded);
288 viortc_msg_release(msg);
289}
290
291/**
292 * viortc_cb_requestq() - callback for requestq
293 * @vq: virtqueue
294 *
295 * Context: virtqueue callback
296 */
297static void viortc_cb_requestq(struct virtqueue *vq)
298{
299 viortc_do_cb(vq, viortc_requestq_hdlr);
300}
301
302/**
303 * viortc_alarmq_hdlr() - process an alarmq used buffer
304 * @token: token identifying the buffer
305 * @len: bytes written by device
306 * @vq: virtqueue
307 * @viortc_vq: device specific data for virtqueue
308 * @viortc: device data
309 *
310 * Processes a VIRTIO_RTC_NOTIF_ALARM notification by calling the RTC class
311 * driver. Makes the buffer available again.
312 *
313 * Context: virtqueue callback
314 */
315static void viortc_alarmq_hdlr(void *token, unsigned int len,
316 struct virtqueue *vq,
317 struct viortc_vq *viortc_vq,
318 struct viortc_dev *viortc)
319{
320 struct virtio_rtc_notif_alarm *notif = token;
321 struct virtio_rtc_notif_head *head = token;
322 unsigned long flags;
323 u16 clock_id;
324 bool notify;
325
326 if (len < sizeof(*head)) {
327 dev_err_ratelimited(&viortc->vdev->dev,
328 "%s: ignoring notification with short header\n",
329 __func__);
330 goto feed_vq;
331 }
332
333 if (virtio_le_to_cpu(head->msg_type) != VIRTIO_RTC_NOTIF_ALARM) {
334 dev_err_ratelimited(&viortc->vdev->dev,
335 "%s: ignoring unknown notification type 0x%x\n",
336 __func__, virtio_le_to_cpu(head->msg_type));
337 goto feed_vq;
338 }
339
340 if (len < sizeof(*notif)) {
341 dev_err_ratelimited(&viortc->vdev->dev,
342 "%s: ignoring too small alarm notification\n",
343 __func__);
344 goto feed_vq;
345 }
346
347 clock_id = virtio_le_to_cpu(notif->clock_id);
348
349 if (!viortc->viortc_class)
350 dev_warn_ratelimited(&viortc->vdev->dev,
351 "ignoring alarm, no RTC class device available\n");
352 else
353 viortc_class_alarm(viortc->viortc_class, clock_id);
354
355feed_vq:
356 spin_lock_irqsave(&viortc_vq->lock, flags);
357
358 if (viortc_feed_vq(viortc, vq, notif, VIORTC_ALARMQ_BUF_CAP, token))
359 dev_warn(&viortc->vdev->dev,
360 "%s: failed to re-expose input buffer\n", __func__);
361
362 notify = virtqueue_kick_prepare(vq);
363
364 spin_unlock_irqrestore(&viortc_vq->lock, flags);
365
366 if (notify)
367 virtqueue_notify(vq);
368}
369
370/**
371 * viortc_cb_alarmq() - callback for alarmq
372 * @vq: virtqueue
373 *
374 * Context: virtqueue callback
375 */
376static void viortc_cb_alarmq(struct virtqueue *vq)
377{
378 viortc_do_cb(vq, viortc_alarmq_hdlr);
379}
380
381/**
382 * viortc_get_resp_errno() - converts virtio_rtc errnos to system errnos
383 * @resp_head: message response header
384 *
385 * Return: negative system errno, or 0
386 */
387static int viortc_get_resp_errno(struct virtio_rtc_resp_head *resp_head)
388{
389 switch (virtio_le_to_cpu(resp_head->status)) {
390 case VIRTIO_RTC_S_OK:
391 return 0;
392 case VIRTIO_RTC_S_EOPNOTSUPP:
393 return -EOPNOTSUPP;
394 case VIRTIO_RTC_S_EINVAL:
395 return -EINVAL;
396 case VIRTIO_RTC_S_ENODEV:
397 return -ENODEV;
398 case VIRTIO_RTC_S_EIO:
399 default:
400 return -EIO;
401 }
402}
403
404/**
405 * viortc_msg_xfer() - send message request, wait until message response
406 * @vq: virtqueue
407 * @msg: message with driver request
408 * @timeout_jiffies: message response timeout, 0 for no timeout
409 *
410 * Context: Process context. Takes and releases vq.lock. May sleep.
411 * Return: Zero on success, negative error code otherwise.
412 */
413static int viortc_msg_xfer(struct viortc_vq *vq, struct viortc_msg *msg,
414 unsigned long timeout_jiffies)
415{
416 struct scatterlist out_sg[1];
417 struct scatterlist in_sg[1];
418 struct scatterlist *sgs[2];
419 unsigned long flags;
420 long timeout_ret;
421 bool notify;
422 int ret;
423
424 sgs[0] = out_sg;
425 sgs[1] = in_sg;
426
427 sg_init_one(out_sg, msg->req, msg->req_size);
428 sg_init_one(in_sg, msg->resp, msg->resp_cap);
429
430 spin_lock_irqsave(&vq->lock, flags);
431
432 ret = virtqueue_add_sgs(vq->vq, sgs, 1, 1, msg, GFP_ATOMIC);
433 if (ret) {
434 spin_unlock_irqrestore(&vq->lock, flags);
435 /*
436 * Release in place of the response callback, which will never
437 * come.
438 */
439 viortc_msg_release(msg);
440 return ret;
441 }
442
443 notify = virtqueue_kick_prepare(vq->vq);
444
445 spin_unlock_irqrestore(&vq->lock, flags);
446
447 if (notify)
448 virtqueue_notify(vq->vq);
449
450 if (timeout_jiffies) {
451 timeout_ret = wait_for_completion_interruptible_timeout(
452 &msg->responded, timeout_jiffies);
453
454 if (!timeout_ret)
455 return -ETIMEDOUT;
456 else if (timeout_ret < 0)
457 return (int)timeout_ret;
458 } else {
459 ret = wait_for_completion_interruptible(&msg->responded);
460 if (ret)
461 return ret;
462 }
463
464 if (msg->resp_actual_size < sizeof(struct virtio_rtc_resp_head))
465 return -EINVAL;
466
467 ret = viortc_get_resp_errno(msg->resp);
468 if (ret)
469 return ret;
470
471 /*
472 * There is not yet a case where returning a short message would make
473 * sense, so consider any deviation an error.
474 */
475 if (msg->resp_actual_size != msg->resp_cap)
476 return -EINVAL;
477
478 return 0;
479}
480
481/*
482 * common message handle macros for messages of different types
483 */
484
485/**
486 * VIORTC_DECLARE_MSG_HDL_ONSTACK() - declare message handle on stack
487 * @hdl: message handle name
488 * @msg_id: message type id
489 * @msg_req: message request type
490 * @msg_resp: message response type
491 */
492#define VIORTC_DECLARE_MSG_HDL_ONSTACK(hdl, msg_id, msg_req, msg_resp) \
493 struct { \
494 struct viortc_msg *msg; \
495 msg_req *req; \
496 msg_resp *resp; \
497 unsigned int req_size; \
498 unsigned int resp_cap; \
499 u16 msg_type; \
500 } hdl = { \
501 NULL, NULL, NULL, sizeof(msg_req), sizeof(msg_resp), (msg_id), \
502 }
503
504/**
505 * VIORTC_MSG() - extract message from message handle
506 * @hdl: message handle
507 *
508 * Return: struct viortc_msg
509 */
510#define VIORTC_MSG(hdl) ((hdl).msg)
511
512/**
513 * VIORTC_MSG_INIT() - initialize message handle
514 * @hdl: message handle
515 * @viortc: device data (struct viortc_dev *)
516 *
517 * Context: Process context.
518 * Return: 0 on success, -ENOMEM otherwise.
519 */
520#define VIORTC_MSG_INIT(hdl, viortc) \
521 ({ \
522 typeof(hdl) *_hdl = &(hdl); \
523 \
524 _hdl->msg = viortc_msg_init((viortc), _hdl->msg_type, \
525 _hdl->req_size, _hdl->resp_cap); \
526 if (_hdl->msg) { \
527 _hdl->req = _hdl->msg->req; \
528 _hdl->resp = _hdl->msg->resp; \
529 } \
530 _hdl->msg ? 0 : -ENOMEM; \
531 })
532
533/**
534 * VIORTC_MSG_WRITE() - write a request message field
535 * @hdl: message handle
536 * @dest_member: request message field name
537 * @src_ptr: pointer to data of compatible type
538 *
539 * Writes the field in little-endian format.
540 */
541#define VIORTC_MSG_WRITE(hdl, dest_member, src_ptr) \
542 do { \
543 typeof(hdl) _hdl = (hdl); \
544 typeof(src_ptr) _src_ptr = (src_ptr); \
545 \
546 /* Sanity check: must match the member's type */ \
547 typecheck(typeof(virtio_le_to_cpu(_hdl.req->dest_member)), \
548 *_src_ptr); \
549 \
550 _hdl.req->dest_member = \
551 virtio_cpu_to_le(*_src_ptr, _hdl.req->dest_member); \
552 } while (0)
553
554/**
555 * VIORTC_MSG_READ() - read from a response message field
556 * @hdl: message handle
557 * @src_member: response message field name
558 * @dest_ptr: pointer to data of compatible type
559 *
560 * Converts from little-endian format and writes to dest_ptr.
561 */
562#define VIORTC_MSG_READ(hdl, src_member, dest_ptr) \
563 do { \
564 typeof(dest_ptr) _dest_ptr = (dest_ptr); \
565 \
566 /* Sanity check: must match the member's type */ \
567 typecheck(typeof(virtio_le_to_cpu((hdl).resp->src_member)), \
568 *_dest_ptr); \
569 \
570 *_dest_ptr = virtio_le_to_cpu((hdl).resp->src_member); \
571 } while (0)
572
573/*
574 * read requests
575 */
576
577/** timeout for runtime requests, where timeouts are considered non-fatal */
578#define VIORTC_MSG_TIMEOUT secs_to_jiffies(60)
579
580/**
581 * viortc_read() - VIRTIO_RTC_REQ_READ wrapper
582 * @viortc: device data
583 * @vio_clk_id: virtio_rtc clock id
584 * @reading: clock reading [ns]
585 *
586 * Context: Process context.
587 * Return: Zero on success, negative error code otherwise.
588 */
589int viortc_read(struct viortc_dev *viortc, u16 vio_clk_id, u64 *reading)
590{
591 VIORTC_DECLARE_MSG_HDL_ONSTACK(hdl, VIRTIO_RTC_REQ_READ,
592 struct virtio_rtc_req_read,
593 struct virtio_rtc_resp_read);
594 int ret;
595
596 ret = VIORTC_MSG_INIT(hdl, viortc);
597 if (ret)
598 return ret;
599
600 VIORTC_MSG_WRITE(hdl, clock_id, &vio_clk_id);
601
602 ret = viortc_msg_xfer(&viortc->vqs[VIORTC_REQUESTQ], VIORTC_MSG(hdl),
603 VIORTC_MSG_TIMEOUT);
604 if (ret) {
605 dev_dbg(&viortc->vdev->dev, "%s: xfer returned %d\n", __func__,
606 ret);
607 goto out_release;
608 }
609
610 VIORTC_MSG_READ(hdl, clock_reading, reading);
611
612out_release:
613 viortc_msg_release(VIORTC_MSG(hdl));
614
615 return ret;
616}
617
618/**
619 * viortc_read_cross() - VIRTIO_RTC_REQ_READ_CROSS wrapper
620 * @viortc: device data
621 * @vio_clk_id: virtio_rtc clock id
622 * @hw_counter: virtio_rtc HW counter type
623 * @reading: clock reading [ns]
624 * @cycles: HW counter cycles during clock reading
625 *
626 * Context: Process context.
627 * Return: Zero on success, negative error code otherwise.
628 */
629int viortc_read_cross(struct viortc_dev *viortc, u16 vio_clk_id, u8 hw_counter,
630 u64 *reading, u64 *cycles)
631{
632 VIORTC_DECLARE_MSG_HDL_ONSTACK(hdl, VIRTIO_RTC_REQ_READ_CROSS,
633 struct virtio_rtc_req_read_cross,
634 struct virtio_rtc_resp_read_cross);
635 int ret;
636
637 ret = VIORTC_MSG_INIT(hdl, viortc);
638 if (ret)
639 return ret;
640
641 VIORTC_MSG_WRITE(hdl, clock_id, &vio_clk_id);
642 VIORTC_MSG_WRITE(hdl, hw_counter, &hw_counter);
643
644 ret = viortc_msg_xfer(&viortc->vqs[VIORTC_REQUESTQ], VIORTC_MSG(hdl),
645 VIORTC_MSG_TIMEOUT);
646 if (ret) {
647 dev_dbg(&viortc->vdev->dev, "%s: xfer returned %d\n", __func__,
648 ret);
649 goto out_release;
650 }
651
652 VIORTC_MSG_READ(hdl, clock_reading, reading);
653 VIORTC_MSG_READ(hdl, counter_cycles, cycles);
654
655out_release:
656 viortc_msg_release(VIORTC_MSG(hdl));
657
658 return ret;
659}
660
661/*
662 * control requests
663 */
664
665/**
666 * viortc_cfg() - VIRTIO_RTC_REQ_CFG wrapper
667 * @viortc: device data
668 * @num_clocks: # of virtio_rtc clocks
669 *
670 * Context: Process context.
671 * Return: Zero on success, negative error code otherwise.
672 */
673static int viortc_cfg(struct viortc_dev *viortc, u16 *num_clocks)
674{
675 VIORTC_DECLARE_MSG_HDL_ONSTACK(hdl, VIRTIO_RTC_REQ_CFG,
676 struct virtio_rtc_req_cfg,
677 struct virtio_rtc_resp_cfg);
678 int ret;
679
680 ret = VIORTC_MSG_INIT(hdl, viortc);
681 if (ret)
682 return ret;
683
684 ret = viortc_msg_xfer(&viortc->vqs[VIORTC_REQUESTQ], VIORTC_MSG(hdl),
685 0);
686 if (ret) {
687 dev_dbg(&viortc->vdev->dev, "%s: xfer returned %d\n", __func__,
688 ret);
689 goto out_release;
690 }
691
692 VIORTC_MSG_READ(hdl, num_clocks, num_clocks);
693
694out_release:
695 viortc_msg_release(VIORTC_MSG(hdl));
696
697 return ret;
698}
699
700/**
701 * viortc_clock_cap() - VIRTIO_RTC_REQ_CLOCK_CAP wrapper
702 * @viortc: device data
703 * @vio_clk_id: virtio_rtc clock id
704 * @type: virtio_rtc clock type
705 * @leap_second_smearing: virtio_rtc smearing variant
706 * @flags: struct virtio_rtc_resp_clock_cap.flags
707 *
708 * Context: Process context.
709 * Return: Zero on success, negative error code otherwise.
710 */
711static int viortc_clock_cap(struct viortc_dev *viortc, u16 vio_clk_id, u8 *type,
712 u8 *leap_second_smearing, u8 *flags)
713{
714 VIORTC_DECLARE_MSG_HDL_ONSTACK(hdl, VIRTIO_RTC_REQ_CLOCK_CAP,
715 struct virtio_rtc_req_clock_cap,
716 struct virtio_rtc_resp_clock_cap);
717 int ret;
718
719 ret = VIORTC_MSG_INIT(hdl, viortc);
720 if (ret)
721 return ret;
722
723 VIORTC_MSG_WRITE(hdl, clock_id, &vio_clk_id);
724
725 ret = viortc_msg_xfer(&viortc->vqs[VIORTC_REQUESTQ], VIORTC_MSG(hdl),
726 0);
727 if (ret) {
728 dev_dbg(&viortc->vdev->dev, "%s: xfer returned %d\n", __func__,
729 ret);
730 goto out_release;
731 }
732
733 VIORTC_MSG_READ(hdl, type, type);
734 VIORTC_MSG_READ(hdl, leap_second_smearing, leap_second_smearing);
735 VIORTC_MSG_READ(hdl, flags, flags);
736
737out_release:
738 viortc_msg_release(VIORTC_MSG(hdl));
739
740 return ret;
741}
742
743/**
744 * viortc_cross_cap() - VIRTIO_RTC_REQ_CROSS_CAP wrapper
745 * @viortc: device data
746 * @vio_clk_id: virtio_rtc clock id
747 * @hw_counter: virtio_rtc HW counter type
748 * @supported: xtstamping is supported for the vio_clk_id/hw_counter pair
749 *
750 * Context: Process context.
751 * Return: Zero on success, negative error code otherwise.
752 */
753int viortc_cross_cap(struct viortc_dev *viortc, u16 vio_clk_id, u8 hw_counter,
754 bool *supported)
755{
756 VIORTC_DECLARE_MSG_HDL_ONSTACK(hdl, VIRTIO_RTC_REQ_CROSS_CAP,
757 struct virtio_rtc_req_cross_cap,
758 struct virtio_rtc_resp_cross_cap);
759 u8 flags;
760 int ret;
761
762 ret = VIORTC_MSG_INIT(hdl, viortc);
763 if (ret)
764 return ret;
765
766 VIORTC_MSG_WRITE(hdl, clock_id, &vio_clk_id);
767 VIORTC_MSG_WRITE(hdl, hw_counter, &hw_counter);
768
769 ret = viortc_msg_xfer(&viortc->vqs[VIORTC_REQUESTQ], VIORTC_MSG(hdl),
770 0);
771 if (ret) {
772 dev_dbg(&viortc->vdev->dev, "%s: xfer returned %d\n", __func__,
773 ret);
774 goto out_release;
775 }
776
777 VIORTC_MSG_READ(hdl, flags, &flags);
778 *supported = !!(flags & VIRTIO_RTC_FLAG_CROSS_CAP);
779
780out_release:
781 viortc_msg_release(VIORTC_MSG(hdl));
782
783 return ret;
784}
785
786/**
787 * viortc_read_alarm() - VIRTIO_RTC_REQ_READ_ALARM wrapper
788 * @viortc: device data
789 * @vio_clk_id: virtio_rtc clock id
790 * @alarm_time: alarm time in ns
791 * @enabled: whether alarm is enabled
792 *
793 * Context: Process context.
794 * Return: Zero on success, negative error code otherwise.
795 */
796int viortc_read_alarm(struct viortc_dev *viortc, u16 vio_clk_id,
797 u64 *alarm_time, bool *enabled)
798{
799 VIORTC_DECLARE_MSG_HDL_ONSTACK(hdl, VIRTIO_RTC_REQ_READ_ALARM,
800 struct virtio_rtc_req_read_alarm,
801 struct virtio_rtc_resp_read_alarm);
802 u8 flags;
803 int ret;
804
805 ret = VIORTC_MSG_INIT(hdl, viortc);
806 if (ret)
807 return ret;
808
809 VIORTC_MSG_WRITE(hdl, clock_id, &vio_clk_id);
810
811 ret = viortc_msg_xfer(&viortc->vqs[VIORTC_REQUESTQ], VIORTC_MSG(hdl),
812 VIORTC_MSG_TIMEOUT);
813 if (ret) {
814 dev_dbg(&viortc->vdev->dev, "%s: xfer returned %d\n", __func__,
815 ret);
816 goto out_release;
817 }
818
819 VIORTC_MSG_READ(hdl, alarm_time, alarm_time);
820 VIORTC_MSG_READ(hdl, flags, &flags);
821
822 *enabled = !!(flags & VIRTIO_RTC_FLAG_ALARM_ENABLED);
823
824out_release:
825 viortc_msg_release(VIORTC_MSG(hdl));
826
827 return ret;
828}
829
830/**
831 * viortc_set_alarm() - VIRTIO_RTC_REQ_SET_ALARM wrapper
832 * @viortc: device data
833 * @vio_clk_id: virtio_rtc clock id
834 * @alarm_time: alarm time in ns
835 * @alarm_enable: enable or disable alarm
836 *
837 * Context: Process context.
838 * Return: Zero on success, negative error code otherwise.
839 */
840int viortc_set_alarm(struct viortc_dev *viortc, u16 vio_clk_id, u64 alarm_time,
841 bool alarm_enable)
842{
843 VIORTC_DECLARE_MSG_HDL_ONSTACK(hdl, VIRTIO_RTC_REQ_SET_ALARM,
844 struct virtio_rtc_req_set_alarm,
845 struct virtio_rtc_resp_set_alarm);
846 u8 flags = 0;
847 int ret;
848
849 ret = VIORTC_MSG_INIT(hdl, viortc);
850 if (ret)
851 return ret;
852
853 if (alarm_enable)
854 flags |= VIRTIO_RTC_FLAG_ALARM_ENABLED;
855
856 VIORTC_MSG_WRITE(hdl, clock_id, &vio_clk_id);
857 VIORTC_MSG_WRITE(hdl, alarm_time, &alarm_time);
858 VIORTC_MSG_WRITE(hdl, flags, &flags);
859
860 ret = viortc_msg_xfer(&viortc->vqs[VIORTC_REQUESTQ], VIORTC_MSG(hdl),
861 VIORTC_MSG_TIMEOUT);
862 if (ret) {
863 dev_dbg(&viortc->vdev->dev, "%s: xfer returned %d\n", __func__,
864 ret);
865 goto out_release;
866 }
867
868out_release:
869 viortc_msg_release(VIORTC_MSG(hdl));
870
871 return ret;
872}
873
874/**
875 * viortc_set_alarm_enabled() - VIRTIO_RTC_REQ_SET_ALARM_ENABLED wrapper
876 * @viortc: device data
877 * @vio_clk_id: virtio_rtc clock id
878 * @alarm_enable: enable or disable alarm
879 *
880 * Context: Process context.
881 * Return: Zero on success, negative error code otherwise.
882 */
883int viortc_set_alarm_enabled(struct viortc_dev *viortc, u16 vio_clk_id,
884 bool alarm_enable)
885{
886 VIORTC_DECLARE_MSG_HDL_ONSTACK(hdl, VIRTIO_RTC_REQ_SET_ALARM_ENABLED,
887 struct virtio_rtc_req_set_alarm_enabled,
888 struct virtio_rtc_resp_set_alarm_enabled);
889 u8 flags = 0;
890 int ret;
891
892 ret = VIORTC_MSG_INIT(hdl, viortc);
893 if (ret)
894 return ret;
895
896 if (alarm_enable)
897 flags |= VIRTIO_RTC_FLAG_ALARM_ENABLED;
898
899 VIORTC_MSG_WRITE(hdl, clock_id, &vio_clk_id);
900 VIORTC_MSG_WRITE(hdl, flags, &flags);
901
902 ret = viortc_msg_xfer(&viortc->vqs[VIORTC_REQUESTQ], VIORTC_MSG(hdl),
903 VIORTC_MSG_TIMEOUT);
904 if (ret) {
905 dev_dbg(&viortc->vdev->dev, "%s: xfer returned %d\n", __func__,
906 ret);
907 goto out_release;
908 }
909
910out_release:
911 viortc_msg_release(VIORTC_MSG(hdl));
912
913 return ret;
914}
915
916/*
917 * init, deinit
918 */
919
920/**
921 * viortc_init_rtc_class_clock() - init and register a RTC class device
922 * @viortc: device data
923 * @vio_clk_id: virtio_rtc clock id
924 * @clock_type: virtio_rtc clock type
925 * @flags: struct virtio_rtc_resp_clock_cap.flags
926 *
927 * The clock must be a UTC-like clock.
928 *
929 * Context: Process context.
930 * Return: Positive if registered, zero if not supported by configuration,
931 * negative error code otherwise.
932 */
933static int viortc_init_rtc_class_clock(struct viortc_dev *viortc,
934 u16 vio_clk_id, u8 clock_type, u8 flags)
935{
936 struct virtio_device *vdev = viortc->vdev;
937 struct viortc_class *viortc_class;
938 struct device *dev = &vdev->dev;
939 bool have_alarm;
940
941 if (clock_type != VIRTIO_RTC_CLOCK_UTC_SMEARED) {
942 dev_info(dev,
943 "not creating RTC class device for clock %d, which may step on leap seconds\n",
944 vio_clk_id);
945 return 0;
946 }
947
948 if (viortc->viortc_class) {
949 dev_warn_once(dev,
950 "multiple UTC-like clocks are present, but creating only one RTC class device\n");
951 return 0;
952 }
953
954 have_alarm = viortc_alarms_supported(vdev) &&
955 !!(flags & VIRTIO_RTC_FLAG_ALARM_CAP);
956
957 viortc_class = viortc_class_init(viortc, vio_clk_id, have_alarm, dev);
958 if (IS_ERR(viortc_class))
959 return PTR_ERR(viortc_class);
960
961 viortc->viortc_class = viortc_class;
962
963 if (have_alarm)
964 devm_device_init_wakeup(dev);
965
966 return viortc_class_register(viortc_class) ?: 1;
967}
968
969/**
970 * viortc_init_ptp_clock() - init and register PTP clock
971 * @viortc: device data
972 * @vio_clk_id: virtio_rtc clock id
973 * @clock_type: virtio_rtc clock type
974 * @leap_second_smearing: virtio_rtc leap second smearing
975 *
976 * Context: Process context.
977 * Return: Positive if registered, zero if not supported by configuration,
978 * negative error code otherwise.
979 */
980static int viortc_init_ptp_clock(struct viortc_dev *viortc, u16 vio_clk_id,
981 u8 clock_type, u8 leap_second_smearing)
982{
983 struct device *dev = &viortc->vdev->dev;
984 char ptp_clock_name[PTP_CLOCK_NAME_LEN];
985 struct viortc_ptp_clock *vio_ptp;
986
987 snprintf(ptp_clock_name, PTP_CLOCK_NAME_LEN,
988 "Virtio PTP type %hhu/variant %hhu", clock_type,
989 leap_second_smearing);
990
991 vio_ptp = viortc_ptp_register(viortc, dev, vio_clk_id, ptp_clock_name);
992 if (IS_ERR(vio_ptp)) {
993 dev_err(dev, "failed to register PTP clock '%s'\n",
994 ptp_clock_name);
995 return PTR_ERR(vio_ptp);
996 }
997
998 viortc->clocks_to_unregister[vio_clk_id] = vio_ptp;
999
1000 return !!vio_ptp;
1001}
1002
1003/**
1004 * viortc_init_clock() - init local representation of virtio_rtc clock
1005 * @viortc: device data
1006 * @vio_clk_id: virtio_rtc clock id
1007 *
1008 * Initializes PHC and/or RTC class device to represent virtio_rtc clock.
1009 *
1010 * Context: Process context.
1011 * Return: Zero on success, negative error code otherwise.
1012 */
1013static int viortc_init_clock(struct viortc_dev *viortc, u16 vio_clk_id)
1014{
1015 u8 clock_type, leap_second_smearing, flags;
1016 bool is_exposed = false;
1017 int ret;
1018
1019 ret = viortc_clock_cap(viortc, vio_clk_id, &clock_type,
1020 &leap_second_smearing, &flags);
1021 if (ret)
1022 return ret;
1023
1024 if (IS_ENABLED(CONFIG_VIRTIO_RTC_CLASS) &&
1025 (clock_type == VIRTIO_RTC_CLOCK_UTC ||
1026 clock_type == VIRTIO_RTC_CLOCK_UTC_SMEARED ||
1027 clock_type == VIRTIO_RTC_CLOCK_UTC_MAYBE_SMEARED)) {
1028 ret = viortc_init_rtc_class_clock(viortc, vio_clk_id,
1029 clock_type, flags);
1030 if (ret < 0)
1031 return ret;
1032 if (ret > 0)
1033 is_exposed = true;
1034 }
1035
1036 if (IS_ENABLED(CONFIG_VIRTIO_RTC_PTP)) {
1037 ret = viortc_init_ptp_clock(viortc, vio_clk_id, clock_type,
1038 leap_second_smearing);
1039 if (ret < 0)
1040 return ret;
1041 if (ret > 0)
1042 is_exposed = true;
1043 }
1044
1045 if (!is_exposed)
1046 dev_warn(&viortc->vdev->dev,
1047 "cannot expose clock %d (type %d, variant %d) to userspace\n",
1048 vio_clk_id, clock_type, leap_second_smearing);
1049
1050 return 0;
1051}
1052
1053/**
1054 * viortc_clocks_deinit() - unregister PHCs, stop RTC ops
1055 * @viortc: device data
1056 */
1057static void viortc_clocks_deinit(struct viortc_dev *viortc)
1058{
1059 struct viortc_ptp_clock *vio_ptp;
1060 unsigned int i;
1061
1062 for (i = 0; i < viortc->num_clocks; i++) {
1063 vio_ptp = viortc->clocks_to_unregister[i];
1064
1065 if (!vio_ptp)
1066 continue;
1067
1068 viortc->clocks_to_unregister[i] = NULL;
1069
1070 WARN_ON(viortc_ptp_unregister(vio_ptp, &viortc->vdev->dev));
1071 }
1072
1073 if (viortc->viortc_class)
1074 viortc_class_stop(viortc->viortc_class);
1075}
1076
1077/**
1078 * viortc_clocks_init() - init local representations of virtio_rtc clocks
1079 * @viortc: device data
1080 *
1081 * Context: Process context.
1082 * Return: Zero on success, negative error code otherwise.
1083 */
1084static int viortc_clocks_init(struct viortc_dev *viortc)
1085{
1086 u16 num_clocks;
1087 unsigned int i;
1088 int ret;
1089
1090 ret = viortc_cfg(viortc, &num_clocks);
1091 if (ret)
1092 return ret;
1093
1094 if (num_clocks < 1) {
1095 dev_err(&viortc->vdev->dev, "device reported 0 clocks\n");
1096 return -ENODEV;
1097 }
1098
1099 viortc->num_clocks = num_clocks;
1100
1101 viortc->clocks_to_unregister =
1102 devm_kcalloc(&viortc->vdev->dev, num_clocks,
1103 sizeof(*viortc->clocks_to_unregister), GFP_KERNEL);
1104 if (!viortc->clocks_to_unregister)
1105 return -ENOMEM;
1106
1107 for (i = 0; i < num_clocks; i++) {
1108 ret = viortc_init_clock(viortc, i);
1109 if (ret)
1110 goto err_deinit_clocks;
1111 }
1112
1113 return 0;
1114
1115err_deinit_clocks:
1116 viortc_clocks_deinit(viortc);
1117
1118 return ret;
1119}
1120
1121/**
1122 * viortc_populate_vq() - populate alarmq with device-writable buffers
1123 * @viortc: device data
1124 * @viortc_vq: device specific data for virtqueue
1125 * @buf_cap: device-writable buffer size in bytes
1126 * @lock: lock queue during accesses
1127 *
1128 * Populates the alarmq with pre-allocated buffers.
1129 *
1130 * The caller is responsible for kicking the device.
1131 *
1132 * Context: Process context.
1133 * Return: Zero on success, negative error code otherwise.
1134 */
1135static int viortc_populate_vq(struct viortc_dev *viortc,
1136 struct viortc_vq *viortc_vq, u32 buf_cap,
1137 bool lock)
1138{
1139 unsigned int num_elems, i;
1140 struct virtqueue *vq;
1141 unsigned long flags;
1142 void *buf;
1143 int ret;
1144
1145 num_elems = viortc->num_alarmq_bufs;
1146 vq = viortc_vq->vq;
1147
1148 for (i = 0; i < num_elems; i++) {
1149 buf = viortc->alarmq_bufs[i];
1150
1151 if (lock) {
1152 spin_lock_irqsave(&viortc_vq->lock, flags);
1153
1154 ret = viortc_feed_vq(viortc, vq, buf, buf_cap, buf);
1155
1156 spin_unlock_irqrestore(&viortc_vq->lock, flags);
1157 } else {
1158 ret = viortc_feed_vq(viortc, vq, buf, buf_cap, buf);
1159 }
1160
1161 if (ret)
1162 return ret;
1163 }
1164
1165 return 0;
1166}
1167
1168/**
1169 * viortc_alloc_vq_bufs() - allocate alarmq buffers
1170 * @viortc: device data
1171 * @num_elems: # of buffers
1172 * @buf_cap: per-buffer device-writable bytes
1173 *
1174 * Context: Process context.
1175 * Return: Zero on success, negative error code otherwise.
1176 */
1177static int viortc_alloc_vq_bufs(struct viortc_dev *viortc,
1178 unsigned int num_elems, u32 buf_cap)
1179{
1180 struct device *dev = &viortc->vdev->dev;
1181 void **buf_list;
1182 unsigned int i;
1183 void *buf;
1184
1185 buf_list = devm_kcalloc(dev, num_elems, sizeof(*buf_list), GFP_KERNEL);
1186 if (!buf_list)
1187 return -ENOMEM;
1188
1189 viortc->alarmq_bufs = buf_list;
1190 viortc->num_alarmq_bufs = num_elems;
1191
1192 for (i = 0; i < num_elems; i++) {
1193 buf = devm_kzalloc(dev, buf_cap, GFP_KERNEL);
1194 if (!buf)
1195 return -ENOMEM;
1196
1197 buf_list[i] = buf;
1198 }
1199
1200 return 0;
1201}
1202
1203/**
1204 * viortc_init_vqs() - init virtqueues
1205 * @viortc: device data
1206 *
1207 * Inits virtqueues and associated data.
1208 *
1209 * Context: Process context.
1210 * Return: Zero on success, negative error code otherwise.
1211 */
1212static int viortc_init_vqs(struct viortc_dev *viortc)
1213{
1214 struct virtqueue *vqs[VIORTC_MAX_NR_QUEUES];
1215 struct virtqueue_info vqs_info[] = {
1216 { "requestq", viortc_cb_requestq },
1217 { "alarmq", viortc_cb_alarmq },
1218 };
1219 struct virtio_device *vdev = viortc->vdev;
1220 unsigned int num_elems;
1221 int nr_queues, ret;
1222 bool have_alarms;
1223
1224 have_alarms = viortc_alarms_supported(vdev);
1225
1226 if (have_alarms)
1227 nr_queues = VIORTC_ALARMQ + 1;
1228 else
1229 nr_queues = VIORTC_REQUESTQ + 1;
1230
1231 ret = virtio_find_vqs(vdev, nr_queues, vqs, vqs_info, NULL);
1232 if (ret)
1233 return ret;
1234
1235 viortc->vqs[VIORTC_REQUESTQ].vq = vqs[VIORTC_REQUESTQ];
1236 spin_lock_init(&viortc->vqs[VIORTC_REQUESTQ].lock);
1237
1238 if (have_alarms) {
1239 viortc->vqs[VIORTC_ALARMQ].vq = vqs[VIORTC_ALARMQ];
1240 spin_lock_init(&viortc->vqs[VIORTC_ALARMQ].lock);
1241
1242 num_elems = virtqueue_get_vring_size(vqs[VIORTC_ALARMQ]);
1243 if (num_elems == 0)
1244 return -ENOSPC;
1245
1246 if (!viortc->alarmq_bufs) {
1247 ret = viortc_alloc_vq_bufs(viortc, num_elems,
1248 VIORTC_ALARMQ_BUF_CAP);
1249 if (ret)
1250 return ret;
1251 } else {
1252 viortc->num_alarmq_bufs =
1253 min(num_elems, viortc->num_alarmq_bufs);
1254 }
1255 }
1256
1257 return 0;
1258}
1259
1260static void __viortc_remove(struct viortc_dev *viortc)
1261{
1262 struct virtio_device *vdev = viortc->vdev;
1263
1264 viortc_clocks_deinit(viortc);
1265 virtio_reset_device(vdev);
1266 vdev->config->del_vqs(vdev);
1267}
1268
1269/**
1270 * viortc_probe() - probe a virtio_rtc virtio device
1271 * @vdev: virtio device
1272 *
1273 * Context: Process context.
1274 * Return: Zero on success, negative error code otherwise.
1275 */
1276static int viortc_probe(struct virtio_device *vdev)
1277{
1278 struct viortc_vq *alarm_viortc_vq;
1279 struct virtqueue *alarm_vq;
1280 struct viortc_dev *viortc;
1281 unsigned long flags;
1282 bool notify;
1283 int ret;
1284
1285 viortc = devm_kzalloc(&vdev->dev, sizeof(*viortc), GFP_KERNEL);
1286 if (!viortc)
1287 return -ENOMEM;
1288
1289 vdev->priv = viortc;
1290 viortc->vdev = vdev;
1291
1292 ret = viortc_init_vqs(viortc);
1293 if (ret)
1294 goto err_reset_vdev;
1295
1296 virtio_device_ready(vdev);
1297
1298 ret = viortc_clocks_init(viortc);
1299 if (ret)
1300 goto err_reset_vdev;
1301
1302 if (viortc_alarms_supported(vdev)) {
1303 alarm_viortc_vq = &viortc->vqs[VIORTC_ALARMQ];
1304 alarm_vq = alarm_viortc_vq->vq;
1305
1306 ret = viortc_populate_vq(viortc, alarm_viortc_vq,
1307 VIORTC_ALARMQ_BUF_CAP, true);
1308 if (ret)
1309 goto err_deinit_clocks;
1310
1311 spin_lock_irqsave(&alarm_viortc_vq->lock, flags);
1312 notify = virtqueue_kick_prepare(alarm_vq);
1313 spin_unlock_irqrestore(&alarm_viortc_vq->lock, flags);
1314
1315 if (notify && !virtqueue_notify(alarm_vq)) {
1316 ret = -EIO;
1317 goto err_deinit_clocks;
1318 }
1319 }
1320
1321 return 0;
1322
1323err_deinit_clocks:
1324 viortc_clocks_deinit(viortc);
1325
1326err_reset_vdev:
1327 virtio_reset_device(vdev);
1328 vdev->config->del_vqs(vdev);
1329
1330 return ret;
1331}
1332
1333/**
1334 * viortc_remove() - remove a virtio_rtc virtio device
1335 * @vdev: virtio device
1336 */
1337static void viortc_remove(struct virtio_device *vdev)
1338{
1339 struct viortc_dev *viortc = vdev->priv;
1340
1341 __viortc_remove(viortc);
1342}
1343
1344static int viortc_freeze(struct virtio_device *dev)
1345{
1346 /*
1347 * Do not reset the device, so that the device may still wake up the
1348 * system through an alarmq notification.
1349 */
1350
1351 return 0;
1352}
1353
1354static int viortc_restore(struct virtio_device *dev)
1355{
1356 struct viortc_dev *viortc = dev->priv;
1357 struct viortc_vq *alarm_viortc_vq;
1358 struct virtqueue *alarm_vq;
1359 bool notify = false;
1360 int ret;
1361
1362 dev->config->del_vqs(dev);
1363
1364 ret = viortc_init_vqs(viortc);
1365 if (ret)
1366 goto err_remove;
1367
1368 alarm_viortc_vq = &viortc->vqs[VIORTC_ALARMQ];
1369 alarm_vq = alarm_viortc_vq->vq;
1370
1371 if (viortc_alarms_supported(dev)) {
1372 ret = viortc_populate_vq(viortc, alarm_viortc_vq,
1373 VIORTC_ALARMQ_BUF_CAP, false);
1374 if (ret)
1375 goto err_remove;
1376
1377 notify = virtqueue_kick_prepare(alarm_vq);
1378 }
1379
1380 virtio_device_ready(dev);
1381
1382 if (notify && !virtqueue_notify(alarm_vq))
1383 return -EIO;
1384
1385 return 0;
1386
1387err_remove:
1388 __viortc_remove(viortc);
1389 return ret;
1390}
1391
1392static unsigned int features[] = {
1393#if IS_ENABLED(CONFIG_VIRTIO_RTC_CLASS)
1394 VIRTIO_RTC_F_ALARM,
1395#endif
1396};
1397
1398static struct virtio_device_id id_table[] = {
1399 { VIRTIO_ID_CLOCK, VIRTIO_DEV_ANY_ID },
1400 { 0 },
1401};
1402MODULE_DEVICE_TABLE(virtio, id_table);
1403
1404static struct virtio_driver virtio_rtc_drv = {
1405 .driver.name = KBUILD_MODNAME,
1406 .feature_table = features,
1407 .feature_table_size = ARRAY_SIZE(features),
1408 .id_table = id_table,
1409 .probe = viortc_probe,
1410 .remove = viortc_remove,
1411 .freeze = pm_sleep_ptr(viortc_freeze),
1412 .restore = pm_sleep_ptr(viortc_restore),
1413};
1414
1415module_virtio_driver(virtio_rtc_drv);
1416
1417MODULE_DESCRIPTION("Virtio RTC driver");
1418MODULE_AUTHOR("Qualcomm Innovation Center, Inc.");
1419MODULE_LICENSE("GPL");