Quelle  virtio_rtc_driver.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * virtio_rtc driver core
 *
 * Copyright (C) 2022-2024 OpenSynergy GmbH
 * Copyright (c) 2024 Qualcomm Innovation Center, Inc. All rights reserved.
 */

#include <linux/completion.h>
#include <linux/device.h>
#include <linux/module.h>
#include <linux/pm.h>
#include <linux/virtio.h>
#include <linux/virtio_config.h>
#include <linux/virtio_ids.h>

#include <uapi/linux/virtio_rtc.h>

#include "virtio_rtc_internal.h"

#define VIORTC_ALARMQ_BUF_CAP sizeof(union virtio_rtc_notif_alarmq)

/* virtqueue order */
enum {
 VIORTC_REQUESTQ,
 VIORTC_ALARMQ,
 VIORTC_MAX_NR_QUEUES,
};

/**
 * struct viortc_vq - virtqueue abstraction
 * @vq: virtqueue
 * @lock: protects access to vq
 */
struct viortc_vq {
 struct virtqueue *vq;
 spinlock_t lock;
};

/**
 * struct viortc_dev - virtio_rtc device data
 * @vdev: virtio device
 * @viortc_class: RTC class wrapper for UTC-like clock, NULL if not available
 * @vqs: virtqueues
 * @clocks_to_unregister: Clock references, which are only used during device
 *                        removal.
 *   For other uses, there would be a race between device
 *   creation and setting the pointers here.
 * @alarmq_bufs: alarmq buffers list
 * @num_alarmq_bufs: # of alarmq buffers
 * @num_clocks: # of virtio_rtc clocks
 */
struct viortc_dev {
 struct virtio_device *vdev;
 struct viortc_class *viortc_class;
 struct viortc_vq vqs[VIORTC_MAX_NR_QUEUES];
 struct viortc_ptp_clock **clocks_to_unregister;
 void **alarmq_bufs;
 unsigned int num_alarmq_bufs;
 u16 num_clocks;
};

/**
 * struct viortc_msg - Message requested by driver, responded by device.
 * @viortc: device data
 * @req: request buffer
 * @resp: response buffer
 * @responded: vqueue callback signals response reception
 * @refcnt: Message reference count, message and buffers will be deallocated
 *     once 0. refcnt is decremented in the vqueue callback and in the
 *     thread waiting on the responded completion.
 *          If a message response wait function times out, the message will be
 *          freed upon late reception (refcnt will reach 0 in the callback), or
 *          device removal.
 * @req_size: size of request in bytes
 * @resp_cap: maximum size of response in bytes
 * @resp_actual_size: actual size of response
 */
struct viortc_msg {
 struct viortc_dev *viortc;
 void *req;
 void *resp;
 struct completion responded;
 refcount_t refcnt;
 unsigned int req_size;
 unsigned int resp_cap;
 unsigned int resp_actual_size;
};

/**
 * viortc_class_from_dev() - Get RTC class object from virtio device.
 * @dev: virtio device
 *
 * Context: Any context.
 * Return: RTC class object if available, ERR_PTR otherwise.
 */
struct viortc_class *viortc_class_from_dev(struct device *dev)
{
 struct virtio_device *vdev;
 struct viortc_dev *viortc;

 vdev = container_of(dev, typeof(*vdev), dev);
 viortc = vdev->priv;

 return viortc->viortc_class ?: ERR_PTR(-ENODEV);
}

/**
 * viortc_alarms_supported() - Whether device and driver support alarms.
 * @vdev: virtio device
 *
 * NB: Device and driver may not support alarms for the same clocks.
 *
 * Context: Any context.
 * Return: True if both device and driver can support alarms.
 */
static bool viortc_alarms_supported(struct virtio_device *vdev)
{
 return IS_ENABLED(CONFIG_VIRTIO_RTC_CLASS) &&
        virtio_has_feature(vdev, VIRTIO_RTC_F_ALARM);
}

/**
 * viortc_feed_vq() - Make a device write-only buffer available.
 * @viortc: device data
 * @vq: notification virtqueue
 * @buf: buffer
 * @buf_len: buffer capacity in bytes
 * @data: token, identifying buffer
 *
 * Context: Caller must prevent concurrent access to vq.
 * Return: Zero on success, negative error code otherwise.
 */
static int viortc_feed_vq(struct viortc_dev *viortc, struct virtqueue *vq,
     void *buf, unsigned int buf_len, void *data)
{
 struct scatterlist sg;

 sg_init_one(&sg, buf, buf_len);

 return virtqueue_add_inbuf(vq, &sg, 1, data, GFP_ATOMIC);
}

/**
 * viortc_msg_init() - Allocate and initialize requestq message.
 * @viortc: device data
 * @msg_type: virtio_rtc message type
 * @req_size: size of request buffer to be allocated
 * @resp_cap: size of response buffer to be allocated
 *
 * Initializes the message refcnt to 2. The refcnt will be decremented once in
 * the virtqueue callback, and once in the thread waiting on the message (on
 * completion or timeout).
 *
 * Context: Process context.
 * Return: non-NULL on success.
 */
static struct viortc_msg *viortc_msg_init(struct viortc_dev *viortc,
       u16 msg_type, unsigned int req_size,
       unsigned int resp_cap)
{
 struct device *dev = &viortc->vdev->dev;
 struct virtio_rtc_req_head *req_head;
 struct viortc_msg *msg;

 msg = devm_kzalloc(dev, sizeof(*msg), GFP_KERNEL);
 if (!msg)
  return NULL;

 init_completion(&msg->responded);

 msg->req = devm_kzalloc(dev, req_size, GFP_KERNEL);
 if (!msg->req)
  goto err_free_msg;

 req_head = msg->req;

 msg->resp = devm_kzalloc(dev, resp_cap, GFP_KERNEL);
 if (!msg->resp)
  goto err_free_msg_req;

 msg->viortc = viortc;
 msg->req_size = req_size;
 msg->resp_cap = resp_cap;

 refcount_set(&msg->refcnt, 2);

 req_head->msg_type = virtio_cpu_to_le(msg_type, req_head->msg_type);

 return msg;

err_free_msg_req:
 devm_kfree(dev, msg->req);

err_free_msg:
 devm_kfree(dev, msg);

 return NULL;
}

/**
 * viortc_msg_release() - Decrement message refcnt, potentially free message.
 * @msg: message requested by driver
 *
 * Context: Any context.
 */
static void viortc_msg_release(struct viortc_msg *msg)
{
 struct device *dev;

 if (refcount_dec_and_test(&msg->refcnt)) {
  dev = &msg->viortc->vdev->dev;

  devm_kfree(dev, msg->req);
  devm_kfree(dev, msg->resp);
  devm_kfree(dev, msg);
 }
}

/**
 * viortc_do_cb() - generic virtqueue callback logic
 * @vq: virtqueue
 * @handle_buf: function to process a used buffer
 *
 * Context: virtqueue callback, typically interrupt. Takes and releases vq lock.
 */
static void viortc_do_cb(struct virtqueue *vq,
    void (*handle_buf)(void *token, unsigned int len,
         struct virtqueue *vq,
         struct viortc_vq *viortc_vq,
         struct viortc_dev *viortc))
{
 struct viortc_dev *viortc = vq->vdev->priv;
 struct viortc_vq *viortc_vq;
 bool cb_enabled = true;
 unsigned long flags;
 unsigned int len;
 void *token;

 viortc_vq = &viortc->vqs[vq->index];

 for (;;) {
  spin_lock_irqsave(&viortc_vq->lock, flags);

  if (cb_enabled) {
   virtqueue_disable_cb(vq);
   cb_enabled = false;
  }

  token = virtqueue_get_buf(vq, &len);
  if (!token) {
   if (virtqueue_enable_cb(vq)) {
    spin_unlock_irqrestore(&viortc_vq->lock, flags);
    return;
   }
   cb_enabled = true;
  }

  spin_unlock_irqrestore(&viortc_vq->lock, flags);

  if (token)
   handle_buf(token, len, vq, viortc_vq, viortc);
 }
}

/**
 * viortc_requestq_hdlr() - process a requestq used buffer
 * @token: token identifying the buffer
 * @len: bytes written by device
 * @vq: virtqueue
 * @viortc_vq: device specific data for virtqueue
 * @viortc: device data
 *
 * Signals completion for each received message.
 *
 * Context: virtqueue callback
 */
static void viortc_requestq_hdlr(void *token, unsigned int len,
     struct virtqueue *vq,
     struct viortc_vq *viortc_vq,
     struct viortc_dev *viortc)
{
 struct viortc_msg *msg = token;

 msg->resp_actual_size = len;

 complete(&msg->responded);
 viortc_msg_release(msg);
}

/**
 * viortc_cb_requestq() - callback for requestq
 * @vq: virtqueue
 *
 * Context: virtqueue callback
 */
static void viortc_cb_requestq(struct virtqueue *vq)
{
 viortc_do_cb(vq, viortc_requestq_hdlr);
}

/**
 * viortc_alarmq_hdlr() - process an alarmq used buffer
 * @token: token identifying the buffer
 * @len: bytes written by device
 * @vq: virtqueue
 * @viortc_vq: device specific data for virtqueue
 * @viortc: device data
 *
 * Processes a VIRTIO_RTC_NOTIF_ALARM notification by calling the RTC class
 * driver. Makes the buffer available again.
 *
 * Context: virtqueue callback
 */
static void viortc_alarmq_hdlr(void *token, unsigned int len,
          struct virtqueue *vq,
          struct viortc_vq *viortc_vq,
          struct viortc_dev *viortc)
{
 struct virtio_rtc_notif_alarm *notif = token;
 struct virtio_rtc_notif_head *head = token;
 unsigned long flags;
 u16 clock_id;
 bool notify;

 if (len < sizeof(*head)) {
  dev_err_ratelimited(&viortc->vdev->dev,
        "%s: ignoring notification with short header\n",
        __func__);
  goto feed_vq;
 }

 if (virtio_le_to_cpu(head->msg_type) != VIRTIO_RTC_NOTIF_ALARM) {
  dev_err_ratelimited(&viortc->vdev->dev,
        "%s: ignoring unknown notification type 0x%x\n",
        __func__, virtio_le_to_cpu(head->msg_type));
  goto feed_vq;
 }

 if (len < sizeof(*notif)) {
  dev_err_ratelimited(&viortc->vdev->dev,
        "%s: ignoring too small alarm notification\n",
        __func__);
  goto feed_vq;
 }

 clock_id = virtio_le_to_cpu(notif->clock_id);

 if (!viortc->viortc_class)
  dev_warn_ratelimited(&viortc->vdev->dev,
         "ignoring alarm, no RTC class device available\n");
 else
  viortc_class_alarm(viortc->viortc_class, clock_id);

feed_vq:
 spin_lock_irqsave(&viortc_vq->lock, flags);

 if (viortc_feed_vq(viortc, vq, notif, VIORTC_ALARMQ_BUF_CAP, token))
  dev_warn(&viortc->vdev->dev,
    "%s: failed to re-expose input buffer\n", __func__);

 notify = virtqueue_kick_prepare(vq);

 spin_unlock_irqrestore(&viortc_vq->lock, flags);

 if (notify)
  virtqueue_notify(vq);
}

/**
 * viortc_cb_alarmq() - callback for alarmq
 * @vq: virtqueue
 *
 * Context: virtqueue callback
 */
static void viortc_cb_alarmq(struct virtqueue *vq)
{
 viortc_do_cb(vq, viortc_alarmq_hdlr);
}

/**
 * viortc_get_resp_errno() - converts virtio_rtc errnos to system errnos
 * @resp_head: message response header
 *
 * Return: negative system errno, or 0
 */
static int viortc_get_resp_errno(struct virtio_rtc_resp_head *resp_head)
{
 switch (virtio_le_to_cpu(resp_head->status)) {
 case VIRTIO_RTC_S_OK:
  return 0;
 case VIRTIO_RTC_S_EOPNOTSUPP:
  return -EOPNOTSUPP;
 case VIRTIO_RTC_S_EINVAL:
  return -EINVAL;
 case VIRTIO_RTC_S_ENODEV:
  return -ENODEV;
 case VIRTIO_RTC_S_EIO:
 default:
  return -EIO;
 }
}

/**
 * viortc_msg_xfer() - send message request, wait until message response
 * @vq: virtqueue
 * @msg: message with driver request
 * @timeout_jiffies: message response timeout, 0 for no timeout
 *
 * Context: Process context. Takes and releases vq.lock. May sleep.
 * Return: Zero on success, negative error code otherwise.
 */
static int viortc_msg_xfer(struct viortc_vq *vq, struct viortc_msg *msg,
      unsigned long timeout_jiffies)
{
 struct scatterlist out_sg[1];
 struct scatterlist in_sg[1];
 struct scatterlist *sgs[2];
 unsigned long flags;
 long timeout_ret;
 bool notify;
 int ret;

 sgs[0] = out_sg;
 sgs[1] = in_sg;

 sg_init_one(out_sg, msg->req, msg->req_size);
 sg_init_one(in_sg, msg->resp, msg->resp_cap);

 spin_lock_irqsave(&vq->lock, flags);

 ret = virtqueue_add_sgs(vq->vq, sgs, 1, 1, msg, GFP_ATOMIC);
 if (ret) {
  spin_unlock_irqrestore(&vq->lock, flags);
  /*
 * Release in place of the response callback, which will never
 * come.
 */
  viortc_msg_release(msg);
  return ret;
 }

 notify = virtqueue_kick_prepare(vq->vq);

 spin_unlock_irqrestore(&vq->lock, flags);

 if (notify)
  virtqueue_notify(vq->vq);

 if (timeout_jiffies) {
  timeout_ret = wait_for_completion_interruptible_timeout(
   &msg->responded, timeout_jiffies);

  if (!timeout_ret)
   return -ETIMEDOUT;
  else if (timeout_ret < 0)
   return (int)timeout_ret;
 } else {
  ret = wait_for_completion_interruptible(&msg->responded);
  if (ret)
   return ret;
 }

 if (msg->resp_actual_size < sizeof(struct virtio_rtc_resp_head))
  return -EINVAL;

 ret = viortc_get_resp_errno(msg->resp);
 if (ret)
  return ret;

 /*
 * There is not yet a case where returning a short message would make
 * sense, so consider any deviation an error.
 */
 if (msg->resp_actual_size != msg->resp_cap)
  return -EINVAL;

 return 0;
}

/*
 * common message handle macros for messages of different types
 */

/**
 * VIORTC_DECLARE_MSG_HDL_ONSTACK() - declare message handle on stack
 * @hdl: message handle name
 * @msg_id: message type id
 * @msg_req: message request type
 * @msg_resp: message response type
 */
#define VIORTC_DECLARE_MSG_HDL_ONSTACK(hdl, msg_id, msg_req, msg_resp)         \
 struct {                                                               \
  struct viortc_msg *msg;                                        \
  msg_req *req;                                                  \
  msg_resp *resp;                                                \
  unsigned int req_size;                                         \
  unsigned int resp_cap;                                         \
  u16 msg_type;                                                  \
 } hdl = {                                                              \
  NULL, NULL, NULL, sizeof(msg_req), sizeof(msg_resp), (msg_id), \
 }

/**
 * VIORTC_MSG() - extract message from message handle
 * @hdl: message handle
 *
 * Return: struct viortc_msg
 */
#define VIORTC_MSG(hdl) ((hdl).msg)

/**
 * VIORTC_MSG_INIT() - initialize message handle
 * @hdl: message handle
 * @viortc: device data (struct viortc_dev *)
 *
 * Context: Process context.
 * Return: 0 on success, -ENOMEM otherwise.
 */
#define VIORTC_MSG_INIT(hdl, viortc)                                         \
 ({                                                                   \
  typeof(hdl) *_hdl = &(hdl);                                  \
              \
  _hdl->msg = viortc_msg_init((viortc), _hdl->msg_type,        \
         _hdl->req_size, _hdl->resp_cap); \
  if (_hdl->msg) {                                             \
   _hdl->req = _hdl->msg->req;                          \
   _hdl->resp = _hdl->msg->resp;                        \
  }                                                            \
  _hdl->msg ? 0 : -ENOMEM;                                     \
 })

/**
 * VIORTC_MSG_WRITE() - write a request message field
 * @hdl: message handle
 * @dest_member: request message field name
 * @src_ptr: pointer to data of compatible type
 *
 * Writes the field in little-endian format.
 */
#define VIORTC_MSG_WRITE(hdl, dest_member, src_ptr)                         \
 do {                                                                \
  typeof(hdl) _hdl = (hdl);                                   \
  typeof(src_ptr) _src_ptr = (src_ptr);                       \
             \
  /* Sanity check: must match the member's type */            \
  typecheck(typeof(virtio_le_to_cpu(_hdl.req->dest_member)),  \
     *_src_ptr);                                       \
             \
  _hdl.req->dest_member =                                     \
   virtio_cpu_to_le(*_src_ptr, _hdl.req->dest_member); \
 } while (0)

/**
 * VIORTC_MSG_READ() - read from a response message field
 * @hdl: message handle
 * @src_member: response message field name
 * @dest_ptr: pointer to data of compatible type
 *
 * Converts from little-endian format and writes to dest_ptr.
 */
#define VIORTC_MSG_READ(hdl, src_member, dest_ptr)                          \
 do {                                                                \
  typeof(dest_ptr) _dest_ptr = (dest_ptr);                    \
             \
  /* Sanity check: must match the member's type */            \
  typecheck(typeof(virtio_le_to_cpu((hdl).resp->src_member)), \
     *_dest_ptr);                                      \
             \
  *_dest_ptr = virtio_le_to_cpu((hdl).resp->src_member);      \
 } while (0)

/*
 * read requests
 */

/** timeout for clock readings, where timeouts are considered non-fatal */
#define VIORTC_MSG_READ_TIMEOUT secs_to_jiffies(60)

/**
 * viortc_read() - VIRTIO_RTC_REQ_READ wrapper
 * @viortc: device data
 * @vio_clk_id: virtio_rtc clock id
 * @reading: clock reading [ns]
 *
 * Context: Process context.
 * Return: Zero on success, negative error code otherwise.
 */
int viortc_read(struct viortc_dev *viortc, u16 vio_clk_id, u64 *reading)
{
 VIORTC_DECLARE_MSG_HDL_ONSTACK(hdl, VIRTIO_RTC_REQ_READ,
           struct virtio_rtc_req_read,
           struct virtio_rtc_resp_read);
 int ret;

 ret = VIORTC_MSG_INIT(hdl, viortc);
 if (ret)
  return ret;

 VIORTC_MSG_WRITE(hdl, clock_id, &vio_clk_id);

 ret = viortc_msg_xfer(&viortc->vqs[VIORTC_REQUESTQ], VIORTC_MSG(hdl),
         VIORTC_MSG_READ_TIMEOUT);
 if (ret) {
  dev_dbg(&viortc->vdev->dev, "%s: xfer returned %d\n", __func__,
   ret);
  goto out_release;
 }

 VIORTC_MSG_READ(hdl, clock_reading, reading);

out_release:
 viortc_msg_release(VIORTC_MSG(hdl));

 return ret;
}

/**
 * viortc_read_cross() - VIRTIO_RTC_REQ_READ_CROSS wrapper
 * @viortc: device data
 * @vio_clk_id: virtio_rtc clock id
 * @hw_counter: virtio_rtc HW counter type
 * @reading: clock reading [ns]
 * @cycles: HW counter cycles during clock reading
 *
 * Context: Process context.
 * Return: Zero on success, negative error code otherwise.
 */
int viortc_read_cross(struct viortc_dev *viortc, u16 vio_clk_id, u8 hw_counter,
        u64 *reading, u64 *cycles)
{
 VIORTC_DECLARE_MSG_HDL_ONSTACK(hdl, VIRTIO_RTC_REQ_READ_CROSS,
           struct virtio_rtc_req_read_cross,
           struct virtio_rtc_resp_read_cross);
 int ret;

 ret = VIORTC_MSG_INIT(hdl, viortc);
 if (ret)
  return ret;

 VIORTC_MSG_WRITE(hdl, clock_id, &vio_clk_id);
 VIORTC_MSG_WRITE(hdl, hw_counter, &hw_counter);

 ret = viortc_msg_xfer(&viortc->vqs[VIORTC_REQUESTQ], VIORTC_MSG(hdl),
         VIORTC_MSG_READ_TIMEOUT);
 if (ret) {
  dev_dbg(&viortc->vdev->dev, "%s: xfer returned %d\n", __func__,
   ret);
  goto out_release;
 }

 VIORTC_MSG_READ(hdl, clock_reading, reading);
 VIORTC_MSG_READ(hdl, counter_cycles, cycles);

out_release:
 viortc_msg_release(VIORTC_MSG(hdl));

 return ret;
}

/*
 * control requests
 */

/**
 * viortc_cfg() - VIRTIO_RTC_REQ_CFG wrapper
 * @viortc: device data
 * @num_clocks: # of virtio_rtc clocks
 *
 * Context: Process context.
 * Return: Zero on success, negative error code otherwise.
 */
static int viortc_cfg(struct viortc_dev *viortc, u16 *num_clocks)
{
 VIORTC_DECLARE_MSG_HDL_ONSTACK(hdl, VIRTIO_RTC_REQ_CFG,
           struct virtio_rtc_req_cfg,
           struct virtio_rtc_resp_cfg);
 int ret;

 ret = VIORTC_MSG_INIT(hdl, viortc);
 if (ret)
  return ret;

 ret = viortc_msg_xfer(&viortc->vqs[VIORTC_REQUESTQ], VIORTC_MSG(hdl),
         0);
 if (ret) {
  dev_dbg(&viortc->vdev->dev, "%s: xfer returned %d\n", __func__,
   ret);
  goto out_release;
 }

 VIORTC_MSG_READ(hdl, num_clocks, num_clocks);

out_release:
 viortc_msg_release(VIORTC_MSG(hdl));

 return ret;
}

/**
 * viortc_clock_cap() - VIRTIO_RTC_REQ_CLOCK_CAP wrapper
 * @viortc: device data
 * @vio_clk_id: virtio_rtc clock id
 * @type: virtio_rtc clock type
 * @leap_second_smearing: virtio_rtc smearing variant
 * @flags: struct virtio_rtc_resp_clock_cap.flags
 *
 * Context: Process context.
 * Return: Zero on success, negative error code otherwise.
 */
static int viortc_clock_cap(struct viortc_dev *viortc, u16 vio_clk_id, u8 *type,
       u8 *leap_second_smearing, u8 *flags)
{
 VIORTC_DECLARE_MSG_HDL_ONSTACK(hdl, VIRTIO_RTC_REQ_CLOCK_CAP,
           struct virtio_rtc_req_clock_cap,
           struct virtio_rtc_resp_clock_cap);
 int ret;

 ret = VIORTC_MSG_INIT(hdl, viortc);
 if (ret)
  return ret;

 VIORTC_MSG_WRITE(hdl, clock_id, &vio_clk_id);

 ret = viortc_msg_xfer(&viortc->vqs[VIORTC_REQUESTQ], VIORTC_MSG(hdl),
         0);
 if (ret) {
  dev_dbg(&viortc->vdev->dev, "%s: xfer returned %d\n", __func__,
   ret);
  goto out_release;
 }

 VIORTC_MSG_READ(hdl, type, type);
 VIORTC_MSG_READ(hdl, leap_second_smearing, leap_second_smearing);
 VIORTC_MSG_READ(hdl, flags, flags);

out_release:
 viortc_msg_release(VIORTC_MSG(hdl));

 return ret;
}

/**
 * viortc_cross_cap() - VIRTIO_RTC_REQ_CROSS_CAP wrapper
 * @viortc: device data
 * @vio_clk_id: virtio_rtc clock id
 * @hw_counter: virtio_rtc HW counter type
 * @supported: xtstamping is supported for the vio_clk_id/hw_counter pair
 *
 * Context: Process context.
 * Return: Zero on success, negative error code otherwise.
 */
int viortc_cross_cap(struct viortc_dev *viortc, u16 vio_clk_id, u8 hw_counter,
       bool *supported)
{
 VIORTC_DECLARE_MSG_HDL_ONSTACK(hdl, VIRTIO_RTC_REQ_CROSS_CAP,
           struct virtio_rtc_req_cross_cap,
           struct virtio_rtc_resp_cross_cap);
 u8 flags;
 int ret;

 ret = VIORTC_MSG_INIT(hdl, viortc);
 if (ret)
  return ret;

 VIORTC_MSG_WRITE(hdl, clock_id, &vio_clk_id);
 VIORTC_MSG_WRITE(hdl, hw_counter, &hw_counter);

 ret = viortc_msg_xfer(&viortc->vqs[VIORTC_REQUESTQ], VIORTC_MSG(hdl),
         0);
 if (ret) {
  dev_dbg(&viortc->vdev->dev, "%s: xfer returned %d\n", __func__,
   ret);
  goto out_release;
 }

 VIORTC_MSG_READ(hdl, flags, &flags);
 *supported = !!(flags & VIRTIO_RTC_FLAG_CROSS_CAP);

out_release:
 viortc_msg_release(VIORTC_MSG(hdl));

 return ret;
}

/**
 * viortc_read_alarm() - VIRTIO_RTC_REQ_READ_ALARM wrapper
 * @viortc: device data
 * @vio_clk_id: virtio_rtc clock id
 * @alarm_time: alarm time in ns
 * @enabled: whether alarm is enabled
 *
 * Context: Process context.
 * Return: Zero on success, negative error code otherwise.
 */
int viortc_read_alarm(struct viortc_dev *viortc, u16 vio_clk_id,
        u64 *alarm_time, bool *enabled)
{
 VIORTC_DECLARE_MSG_HDL_ONSTACK(hdl, VIRTIO_RTC_REQ_READ_ALARM,
           struct virtio_rtc_req_read_alarm,
           struct virtio_rtc_resp_read_alarm);
 u8 flags;
 int ret;

 ret = VIORTC_MSG_INIT(hdl, viortc);
 if (ret)
  return ret;

 VIORTC_MSG_WRITE(hdl, clock_id, &vio_clk_id);

 ret = viortc_msg_xfer(&viortc->vqs[VIORTC_REQUESTQ], VIORTC_MSG(hdl),
         0);
 if (ret) {
  dev_dbg(&viortc->vdev->dev, "%s: xfer returned %d\n", __func__,
   ret);
  goto out_release;
 }

 VIORTC_MSG_READ(hdl, alarm_time, alarm_time);
 VIORTC_MSG_READ(hdl, flags, &flags);

 *enabled = !!(flags & VIRTIO_RTC_FLAG_ALARM_ENABLED);

out_release:
 viortc_msg_release(VIORTC_MSG(hdl));

 return ret;
}

/**
 * viortc_set_alarm() - VIRTIO_RTC_REQ_SET_ALARM wrapper
 * @viortc: device data
 * @vio_clk_id: virtio_rtc clock id
 * @alarm_time: alarm time in ns
 * @alarm_enable: enable or disable alarm
 *
 * Context: Process context.
 * Return: Zero on success, negative error code otherwise.
 */
int viortc_set_alarm(struct viortc_dev *viortc, u16 vio_clk_id, u64 alarm_time,
       bool alarm_enable)
{
 VIORTC_DECLARE_MSG_HDL_ONSTACK(hdl, VIRTIO_RTC_REQ_SET_ALARM,
           struct virtio_rtc_req_set_alarm,
           struct virtio_rtc_resp_set_alarm);
 u8 flags = 0;
 int ret;

 ret = VIORTC_MSG_INIT(hdl, viortc);
 if (ret)
  return ret;

 if (alarm_enable)
  flags |= VIRTIO_RTC_FLAG_ALARM_ENABLED;

 VIORTC_MSG_WRITE(hdl, clock_id, &vio_clk_id);
 VIORTC_MSG_WRITE(hdl, alarm_time, &alarm_time);
 VIORTC_MSG_WRITE(hdl, flags, &flags);

 ret = viortc_msg_xfer(&viortc->vqs[VIORTC_REQUESTQ], VIORTC_MSG(hdl),
         0);
 if (ret) {
  dev_dbg(&viortc->vdev->dev, "%s: xfer returned %d\n", __func__,
   ret);
  goto out_release;
 }

out_release:
 viortc_msg_release(VIORTC_MSG(hdl));

 return ret;
}

/**
 * viortc_set_alarm_enabled() - VIRTIO_RTC_REQ_SET_ALARM_ENABLED wrapper
 * @viortc: device data
 * @vio_clk_id: virtio_rtc clock id
 * @alarm_enable: enable or disable alarm
 *
 * Context: Process context.
 * Return: Zero on success, negative error code otherwise.
 */
int viortc_set_alarm_enabled(struct viortc_dev *viortc, u16 vio_clk_id,
        bool alarm_enable)
{
 VIORTC_DECLARE_MSG_HDL_ONSTACK(hdl, VIRTIO_RTC_REQ_SET_ALARM_ENABLED,
           struct virtio_rtc_req_set_alarm_enabled,
           struct virtio_rtc_resp_set_alarm_enabled);
 u8 flags = 0;
 int ret;

 ret = VIORTC_MSG_INIT(hdl, viortc);
 if (ret)
  return ret;

 if (alarm_enable)
  flags |= VIRTIO_RTC_FLAG_ALARM_ENABLED;

 VIORTC_MSG_WRITE(hdl, clock_id, &vio_clk_id);
 VIORTC_MSG_WRITE(hdl, flags, &flags);

 ret = viortc_msg_xfer(&viortc->vqs[VIORTC_REQUESTQ], VIORTC_MSG(hdl),
         0);
 if (ret) {
  dev_dbg(&viortc->vdev->dev, "%s: xfer returned %d\n", __func__,
   ret);
  goto out_release;
 }

out_release:
 viortc_msg_release(VIORTC_MSG(hdl));

 return ret;
}

/*
 * init, deinit
 */

/**
 * viortc_init_rtc_class_clock() - init and register a RTC class device
 * @viortc: device data
 * @vio_clk_id: virtio_rtc clock id
 * @clock_type: virtio_rtc clock type
 * @flags: struct virtio_rtc_resp_clock_cap.flags
 *
 * The clock must be a UTC-like clock.
 *
 * Context: Process context.
 * Return: Positive if registered, zero if not supported by configuration,
 *         negative error code otherwise.
 */
static int viortc_init_rtc_class_clock(struct viortc_dev *viortc,
           u16 vio_clk_id, u8 clock_type, u8 flags)
{
 struct virtio_device *vdev = viortc->vdev;
 struct viortc_class *viortc_class;
 struct device *dev = &vdev->dev;
 bool have_alarm;

 if (clock_type != VIRTIO_RTC_CLOCK_UTC_SMEARED) {
  dev_info(dev,
    "not creating RTC class device for clock %d, which may step on leap seconds\n",
    vio_clk_id);
  return 0;
 }

 if (viortc->viortc_class) {
  dev_warn_once(dev,
         "multiple UTC-like clocks are present, but creating only one RTC class device\n");
  return 0;
 }

 have_alarm = viortc_alarms_supported(vdev) &&
       !!(flags & VIRTIO_RTC_FLAG_ALARM_CAP);

 viortc_class = viortc_class_init(viortc, vio_clk_id, have_alarm, dev);
 if (IS_ERR(viortc_class))
  return PTR_ERR(viortc_class);

 viortc->viortc_class = viortc_class;

 if (have_alarm)
  devm_device_init_wakeup(dev);

 return viortc_class_register(viortc_class) ?: 1;
}

/**
 * viortc_init_ptp_clock() - init and register PTP clock
 * @viortc: device data
 * @vio_clk_id: virtio_rtc clock id
 * @clock_type: virtio_rtc clock type
 * @leap_second_smearing: virtio_rtc leap second smearing
 *
 * Context: Process context.
 * Return: Positive if registered, zero if not supported by configuration,
 *         negative error code otherwise.
 */
static int viortc_init_ptp_clock(struct viortc_dev *viortc, u16 vio_clk_id,
     u8 clock_type, u8 leap_second_smearing)
{
 struct device *dev = &viortc->vdev->dev;
 char ptp_clock_name[PTP_CLOCK_NAME_LEN];
 struct viortc_ptp_clock *vio_ptp;

 snprintf(ptp_clock_name, PTP_CLOCK_NAME_LEN,
   "Virtio PTP type %hhu/variant %hhu", clock_type,
   leap_second_smearing);

 vio_ptp = viortc_ptp_register(viortc, dev, vio_clk_id, ptp_clock_name);
 if (IS_ERR(vio_ptp)) {
  dev_err(dev, "failed to register PTP clock '%s'\n",
   ptp_clock_name);
  return PTR_ERR(vio_ptp);
 }

 viortc->clocks_to_unregister[vio_clk_id] = vio_ptp;

 return !!vio_ptp;
}

/**
 * viortc_init_clock() - init local representation of virtio_rtc clock
 * @viortc: device data
 * @vio_clk_id: virtio_rtc clock id
 *
 * Initializes PHC and/or RTC class device to represent virtio_rtc clock.
 *
 * Context: Process context.
 * Return: Zero on success, negative error code otherwise.
 */
static int viortc_init_clock(struct viortc_dev *viortc, u16 vio_clk_id)
{
 u8 clock_type, leap_second_smearing, flags;
 bool is_exposed = false;
 int ret;

 ret = viortc_clock_cap(viortc, vio_clk_id, &clock_type,
          &leap_second_smearing, &flags);
 if (ret)
  return ret;

 if (IS_ENABLED(CONFIG_VIRTIO_RTC_CLASS) &&
     (clock_type == VIRTIO_RTC_CLOCK_UTC ||
      clock_type == VIRTIO_RTC_CLOCK_UTC_SMEARED ||
      clock_type == VIRTIO_RTC_CLOCK_UTC_MAYBE_SMEARED)) {
  ret = viortc_init_rtc_class_clock(viortc, vio_clk_id,
        clock_type, flags);
  if (ret < 0)
   return ret;
  if (ret > 0)
   is_exposed = true;
 }

 if (IS_ENABLED(CONFIG_VIRTIO_RTC_PTP)) {
  ret = viortc_init_ptp_clock(viortc, vio_clk_id, clock_type,
         leap_second_smearing);
  if (ret < 0)
   return ret;
  if (ret > 0)
   is_exposed = true;
 }

 if (!is_exposed)
  dev_warn(&viortc->vdev->dev,
    "cannot expose clock %d (type %d, variant %d) to userspace\n",
    vio_clk_id, clock_type, leap_second_smearing);

 return 0;
}

/**
 * viortc_clocks_deinit() - unregister PHCs, stop RTC ops
 * @viortc: device data
 */
static void viortc_clocks_deinit(struct viortc_dev *viortc)
{
 struct viortc_ptp_clock *vio_ptp;
 unsigned int i;

 for (i = 0; i < viortc->num_clocks; i++) {
  vio_ptp = viortc->clocks_to_unregister[i];

  if (!vio_ptp)
   continue;

  viortc->clocks_to_unregister[i] = NULL;

  WARN_ON(viortc_ptp_unregister(vio_ptp, &viortc->vdev->dev));
 }

 if (viortc->viortc_class)
  viortc_class_stop(viortc->viortc_class);
}

/**
 * viortc_clocks_init() - init local representations of virtio_rtc clocks
 * @viortc: device data
 *
 * Context: Process context.
 * Return: Zero on success, negative error code otherwise.
 */
static int viortc_clocks_init(struct viortc_dev *viortc)
{
 u16 num_clocks;
 unsigned int i;
 int ret;

 ret = viortc_cfg(viortc, &num_clocks);
 if (ret)
  return ret;

 if (num_clocks < 1) {
  dev_err(&viortc->vdev->dev, "device reported 0 clocks\n");
  return -ENODEV;
 }

 viortc->num_clocks = num_clocks;

 viortc->clocks_to_unregister =
  devm_kcalloc(&viortc->vdev->dev, num_clocks,
        sizeof(*viortc->clocks_to_unregister), GFP_KERNEL);
 if (!viortc->clocks_to_unregister)
  return -ENOMEM;

 for (i = 0; i < num_clocks; i++) {
  ret = viortc_init_clock(viortc, i);
  if (ret)
   goto err_deinit_clocks;
 }

 return 0;

err_deinit_clocks:
 viortc_clocks_deinit(viortc);

 return ret;
}

/**
 * viortc_populate_vq() - populate alarmq with device-writable buffers
 * @viortc: device data
 * @viortc_vq: device specific data for virtqueue
 * @buf_cap: device-writable buffer size in bytes
 * @lock: lock queue during accesses
 *
 * Populates the alarmq with pre-allocated buffers.
 *
 * The caller is responsible for kicking the device.
 *
 * Context: Process context.
 * Return: Zero on success, negative error code otherwise.
 */
static int viortc_populate_vq(struct viortc_dev *viortc,
         struct viortc_vq *viortc_vq, u32 buf_cap,
         bool lock)
{
 unsigned int num_elems, i;
 struct virtqueue *vq;
 unsigned long flags;
 void *buf;
 int ret;

 num_elems = viortc->num_alarmq_bufs;
 vq = viortc_vq->vq;

 for (i = 0; i < num_elems; i++) {
  buf = viortc->alarmq_bufs[i];

  if (lock) {
   spin_lock_irqsave(&viortc_vq->lock, flags);

   ret = viortc_feed_vq(viortc, vq, buf, buf_cap, buf);

   spin_unlock_irqrestore(&viortc_vq->lock, flags);
  } else {
   ret = viortc_feed_vq(viortc, vq, buf, buf_cap, buf);
  }

  if (ret)
   return ret;
 }

 return 0;
}

/**
 * viortc_alloc_vq_bufs() - allocate alarmq buffers
 * @viortc: device data
 * @num_elems: # of buffers
 * @buf_cap: per-buffer device-writable bytes
 *
 * Context: Process context.
 * Return: Zero on success, negative error code otherwise.
 */
static int viortc_alloc_vq_bufs(struct viortc_dev *viortc,
    unsigned int num_elems, u32 buf_cap)
{
 struct device *dev = &viortc->vdev->dev;
 void **buf_list;
 unsigned int i;
 void *buf;

 buf_list = devm_kcalloc(dev, num_elems, sizeof(*buf_list), GFP_KERNEL);
 if (!buf_list)
  return -ENOMEM;

 viortc->alarmq_bufs = buf_list;
 viortc->num_alarmq_bufs = num_elems;

 for (i = 0; i < num_elems; i++) {
  buf = devm_kzalloc(dev, buf_cap, GFP_KERNEL);
  if (!buf)
   return -ENOMEM;

  buf_list[i] = buf;
 }

 return 0;
}

/**
 * viortc_init_vqs() - init virtqueues
 * @viortc: device data
 *
 * Inits virtqueues and associated data.
 *
 * Context: Process context.
 * Return: Zero on success, negative error code otherwise.
 */
static int viortc_init_vqs(struct viortc_dev *viortc)
{
 struct virtqueue *vqs[VIORTC_MAX_NR_QUEUES];
 struct virtqueue_info vqs_info[] = {
  { "requestq", viortc_cb_requestq },
  { "alarmq", viortc_cb_alarmq },
 };
 struct virtio_device *vdev = viortc->vdev;
 unsigned int num_elems;
 int nr_queues, ret;
 bool have_alarms;

 have_alarms = viortc_alarms_supported(vdev);

 if (have_alarms)
  nr_queues = VIORTC_ALARMQ + 1;
 else
  nr_queues = VIORTC_REQUESTQ + 1;

 ret = virtio_find_vqs(vdev, nr_queues, vqs, vqs_info, NULL);
 if (ret)
  return ret;

 viortc->vqs[VIORTC_REQUESTQ].vq = vqs[VIORTC_REQUESTQ];
 spin_lock_init(&viortc->vqs[VIORTC_REQUESTQ].lock);

 if (have_alarms) {
  viortc->vqs[VIORTC_ALARMQ].vq = vqs[VIORTC_ALARMQ];
  spin_lock_init(&viortc->vqs[VIORTC_ALARMQ].lock);

  num_elems = virtqueue_get_vring_size(vqs[VIORTC_ALARMQ]);
  if (num_elems == 0)
   return -ENOSPC;

  if (!viortc->alarmq_bufs) {
   ret = viortc_alloc_vq_bufs(viortc, num_elems,
         VIORTC_ALARMQ_BUF_CAP);
   if (ret)
    return ret;
  } else {
   viortc->num_alarmq_bufs =
    min(num_elems, viortc->num_alarmq_bufs);
  }
 }

 return 0;
}

/**
 * viortc_probe() - probe a virtio_rtc virtio device
 * @vdev: virtio device
 *
 * Context: Process context.
 * Return: Zero on success, negative error code otherwise.
 */
static int viortc_probe(struct virtio_device *vdev)
{
 struct viortc_vq *alarm_viortc_vq;
 struct virtqueue *alarm_vq;
 struct viortc_dev *viortc;
 unsigned long flags;
 bool notify;
 int ret;

 viortc = devm_kzalloc(&vdev->dev, sizeof(*viortc), GFP_KERNEL);
 if (!viortc)
  return -ENOMEM;

 vdev->priv = viortc;
 viortc->vdev = vdev;

 ret = viortc_init_vqs(viortc);
 if (ret)
  return ret;

 virtio_device_ready(vdev);

 ret = viortc_clocks_init(viortc);
 if (ret)
  goto err_reset_vdev;

 if (viortc_alarms_supported(vdev)) {
  alarm_viortc_vq = &viortc->vqs[VIORTC_ALARMQ];
  alarm_vq = alarm_viortc_vq->vq;

  ret = viortc_populate_vq(viortc, alarm_viortc_vq,
      VIORTC_ALARMQ_BUF_CAP, true);
  if (ret)
   goto err_deinit_clocks;

  spin_lock_irqsave(&alarm_viortc_vq->lock, flags);
  notify = virtqueue_kick_prepare(alarm_vq);
  spin_unlock_irqrestore(&alarm_viortc_vq->lock, flags);

  if (notify && !virtqueue_notify(alarm_vq)) {
   ret = -EIO;
   goto err_deinit_clocks;
  }
 }

 return 0;

err_deinit_clocks:
 viortc_clocks_deinit(viortc);

err_reset_vdev:
 virtio_reset_device(vdev);
 vdev->config->del_vqs(vdev);

 return ret;
}

/**
 * viortc_remove() - remove a virtio_rtc virtio device
 * @vdev: virtio device
 */
static void viortc_remove(struct virtio_device *vdev)
{
 struct viortc_dev *viortc = vdev->priv;

 viortc_clocks_deinit(viortc);

 virtio_reset_device(vdev);
 vdev->config->del_vqs(vdev);
}

static int viortc_freeze(struct virtio_device *dev)
{
 /*
 * Do not reset the device, so that the device may still wake up the
 * system through an alarmq notification.
 */

 return 0;
}

static int viortc_restore(struct virtio_device *dev)
{
 struct viortc_dev *viortc = dev->priv;
 struct viortc_vq *alarm_viortc_vq;
 struct virtqueue *alarm_vq;
 bool notify = false;
 int ret;

 ret = viortc_init_vqs(viortc);
 if (ret)
  return ret;

 alarm_viortc_vq = &viortc->vqs[VIORTC_ALARMQ];
 alarm_vq = alarm_viortc_vq->vq;

 if (viortc_alarms_supported(dev)) {
  ret = viortc_populate_vq(viortc, alarm_viortc_vq,
      VIORTC_ALARMQ_BUF_CAP, false);
  if (ret)
   return ret;

  notify = virtqueue_kick_prepare(alarm_vq);
 }

 virtio_device_ready(dev);

 if (notify && !virtqueue_notify(alarm_vq))
  ret = -EIO;

 return ret;
}

static unsigned int features[] = {
#if IS_ENABLED(CONFIG_VIRTIO_RTC_CLASS)
 VIRTIO_RTC_F_ALARM,
#endif
};

static struct virtio_device_id id_table[] = {
 { VIRTIO_ID_CLOCK, VIRTIO_DEV_ANY_ID },
 { 0 },
};
MODULE_DEVICE_TABLE(virtio, id_table);

static struct virtio_driver virtio_rtc_drv = {
 .driver.name = KBUILD_MODNAME,
 .feature_table = features,
 .feature_table_size = ARRAY_SIZE(features),
 .id_table = id_table,
 .probe = viortc_probe,
 .remove = viortc_remove,
 .freeze = pm_sleep_ptr(viortc_freeze),
 .restore = pm_sleep_ptr(viortc_restore),
};

module_virtio_driver(virtio_rtc_drv);

MODULE_DESCRIPTION("Virtio RTC driver");
MODULE_AUTHOR("Qualcomm Innovation Center, Inc.");
MODULE_LICENSE("GPL");