git
/
linux
mirror of https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
linux/drivers/virtio/virtio_rtc_driver.c

1408 lines
35 KiB
C
Raw Blame History

// 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");
Reference in New Issue View Git Blame Copy Permalink