virtio.h

Go to the documentation of this file.

/*
 * SPDX-License-Identifier: BSD-3-Clause
 *
 * $FreeBSD$
 */
 
#ifndef _VIRTIO_H_
#define _VIRTIO_H_
 
#include <openamp/virtqueue.h>
#include <metal/errno.h>
#include <metal/spinlock.h>
 
#if defined __cplusplus
extern "C" {
#endif
 
/* VirtIO device IDs. */
#define VIRTIO_ID_NETWORK        1UL
#define VIRTIO_ID_BLOCK          2UL
#define VIRTIO_ID_CONSOLE        3UL
#define VIRTIO_ID_ENTROPY        4UL
#define VIRTIO_ID_BALLOON        5UL
#define VIRTIO_ID_IOMEMORY       6UL
#define VIRTIO_ID_RPMSG          7UL /* remote processor messaging */
#define VIRTIO_ID_SCSI           8UL
#define VIRTIO_ID_9P             9UL
#define VIRTIO_ID_MAC80211_WLAN  10UL
#define VIRTIO_ID_RPROC_SERIAL   11UL
#define VIRTIO_ID_CAIF           12UL
#define VIRTIO_ID_MEMORY_BALLOON 13UL
#define VIRTIO_ID_GPU            16UL
#define VIRTIO_ID_CLOCK          17UL
#define VIRTIO_ID_INPUT          18UL
#define VIRTIO_ID_VSOCK          19UL
#define VIRTIO_ID_CRYPTO         20UL
#define VIRTIO_ID_SIGNAL_DIST    21UL
#define VIRTIO_ID_PSTORE         22UL
#define VIRTIO_ID_IOMMU          23UL
#define VIRTIO_ID_MEM            24UL
#define VIRTIO_ID_SOUND          25UL
#define VIRTIO_ID_FS             26UL
#define VIRTIO_ID_PMEM           27UL
#define VIRTIO_ID_RPMB           28UL
#define VIRTIO_ID_MAC80211_HWSIM 29UL
#define VIRTIO_ID_VIDEO_ENCODER  30UL
#define VIRTIO_ID_VIDEO_DECODER  31UL
#define VIRTIO_ID_SCMI           32UL
#define VIRTIO_ID_NITRO_SEC_MOD  33UL
#define VIRTIO_ID_I2C_ADAPTER    34UL
#define VIRTIO_ID_WATCHDOG       35UL
#define VIRTIO_ID_CAN            36UL
#define VIRTIO_ID_PARAM_SERV     38UL
#define VIRTIO_ID_AUDIO_POLICY   39UL
#define VIRTIO_ID_BT             40UL
#define VIRTIO_ID_GPIO           41UL
#define VIRTIO_ID_RDMA           42UL
#define VIRTIO_DEV_ANY_ID        -1UL
 
/* Status byte for guest to report progress. */
#define VIRTIO_CONFIG_STATUS_RESET       0x00
#define VIRTIO_CONFIG_STATUS_ACK         0x01
#define VIRTIO_CONFIG_STATUS_DRIVER      0x02
#define VIRTIO_CONFIG_STATUS_DRIVER_OK   0x04
#define VIRTIO_CONFIG_FEATURES_OK        0x08
#define VIRTIO_CONFIG_STATUS_NEEDS_RESET 0x40
#define VIRTIO_CONFIG_STATUS_FAILED      0x80
 
/* Virtio device role */
#define VIRTIO_DEV_DRIVER       0UL
#define VIRTIO_DEV_DEVICE       1UL
 
#define VIRTIO_ENABLED(option) (option == 1)
 
#ifdef VIRTIO_DRIVER_SUPPORT
#define VIRTIO_ROLE_IS_DRIVER(vdev) \
        (VIRTIO_ENABLED(VIRTIO_DRIVER_SUPPORT) && ((vdev)->role) == VIRTIO_DEV_DRIVER)
#else
/* Default definition without code size optimization */
#define VIRTIO_ROLE_IS_DRIVER(vdev) ((vdev)->role == VIRTIO_DEV_DRIVER)
#endif
 
#ifdef VIRTIO_DEVICE_SUPPORT
#define VIRTIO_ROLE_IS_DEVICE(vdev) \
        (VIRTIO_ENABLED(VIRTIO_DEVICE_SUPPORT) && ((vdev)->role) == VIRTIO_DEV_DEVICE)
#else
/* Default definition without code size optimization */
#define VIRTIO_ROLE_IS_DEVICE(vdev) ((vdev)->role == VIRTIO_DEV_DEVICE)
#endif
 
struct virtio_device_id {
        uint32_t device;
 
        uint32_t vendor;
 
        uint32_t version;
};
 
/*
 * Generate interrupt when the virtqueue ring is
 * completely used, even if we've suppressed them.
 */
#define VIRTIO_F_NOTIFY_ON_EMPTY (1 << 24)
 
/*
 * This feature indicates that the device accepts arbitrary
 * descriptor layouts.
 */
#define VIRTIO_F_ANY_LAYOUT (1 << 27)
 
/*
 * The guest should never negotiate this feature; it
 * is used to detect faulty drivers.
 */
#define VIRTIO_F_BAD_FEATURE (1 << 30)
 
/*
 * Some VirtIO feature bits (currently bits 28 through 31) are
 * reserved for the transport being used (eg. virtio_ring), the
 * rest are per-device feature bits.
 */
#define VIRTIO_TRANSPORT_F_START      28
#define VIRTIO_TRANSPORT_F_END        32
 
#ifdef VIRTIO_DEBUG
#include <metal/log.h>
 
#define VIRTIO_ASSERT(_exp, _msg) do { \
                int exp = (_exp); \
                if (!(exp)) { \
                        metal_log(METAL_LOG_EMERGENCY, \
                                  "FATAL: %s - " _msg, __func__); \
                        metal_assert(exp); \
                } \
        } while (0)
#else
#define VIRTIO_ASSERT(_exp, _msg) metal_assert(_exp)
#endif /* VIRTIO_DEBUG */
 
#define VIRTIO_MMIO_VRING_ALIGNMENT           4096
 
typedef void (*virtio_dev_reset_cb)(struct virtio_device *vdev);
 
struct virtio_dispatch;
struct virtio_memory_ops;
 
struct virtio_feature_desc {
        uint32_t vfd_val;
 
        const char *vfd_str;
};
 
struct virtio_vring_info {
        struct virtqueue *vq;
 
        struct vring_alloc_info info;
 
        uint32_t notifyid;
 
        struct metal_io_region *io;
};
 
struct virtio_device {
        uint32_t notifyid;
 
        struct virtio_device_id id;
 
        uint64_t features;
 
        unsigned int role;
 
        virtio_dev_reset_cb reset_cb;
 
        const struct virtio_dispatch *func;
 
        const struct virtio_memory_ops *mmops;
 
        void *priv;
 
        unsigned int vrings_num;
 
        struct virtio_vring_info *vrings_info;
};
 
/*
 * Helper functions.
 */
 
struct virtio_dispatch {
        int (*create_virtqueues)(struct virtio_device *vdev,
                                 unsigned int flags,
                                 unsigned int nvqs, const char *names[],
                                 vq_callback callbacks[],
                                 void *callback_args[]);
 
        void (*delete_virtqueues)(struct virtio_device *vdev);
 
        uint8_t (*get_status)(struct virtio_device *dev);
 
        void (*set_status)(struct virtio_device *dev, uint8_t status);
 
        uint32_t (*get_features)(struct virtio_device *dev);
 
        void (*set_features)(struct virtio_device *dev, uint32_t feature);
 
        uint32_t (*negotiate_features)(struct virtio_device *dev,
                                       uint32_t features);
 
        void (*read_config)(struct virtio_device *dev, uint32_t offset,
                            void *dst, int length);
 
        void (*write_config)(struct virtio_device *dev, uint32_t offset,
                             void *src, int length);
 
        void (*reset_device)(struct virtio_device *dev);
 
        void (*notify)(struct virtqueue *vq);
};
 
struct virtio_memory_ops {
        void *(*alloc)(struct virtio_device *dev, size_t size, size_t align);
 
        void (*free)(struct virtio_device *dev, void *buf);
};
 
int virtio_create_virtqueues(struct virtio_device *vdev, unsigned int flags,
                             unsigned int nvqs, const char *names[],
                             vq_callback callbacks[], void *callback_args[]);
 
static inline void virtio_delete_virtqueues(struct virtio_device *vdev)
{
        if (!vdev || !vdev->func || !vdev->func->delete_virtqueues)
                return;
 
        vdev->func->delete_virtqueues(vdev);
}
 
static inline uint32_t virtio_get_devid(const struct virtio_device *vdev)
{
        if (!vdev)
                return 0;
        return vdev->id.device;
}
 
static inline int virtio_get_status(struct virtio_device *vdev, uint8_t *status)
{
        if (!vdev || !status)
                return -EINVAL;
 
        if (!vdev->func || !vdev->func->get_status)
                return -ENXIO;
 
        *status = vdev->func->get_status(vdev);
        return 0;
}
 
static inline int virtio_set_status(struct virtio_device *vdev, uint8_t status)
{
        if (!vdev)
                return -EINVAL;
 
        if (!vdev->func || !vdev->func->set_status)
                return -ENXIO;
 
        vdev->func->set_status(vdev, status);
        return 0;
}
 
static inline int virtio_read_config(struct virtio_device *vdev,
                                     uint32_t offset, void *dst, int len)
{
        if (!vdev || !dst)
                return -EINVAL;
 
        if (!vdev->func || !vdev->func->read_config)
                return -ENXIO;
 
        vdev->func->read_config(vdev, offset, dst, len);
        return 0;
}
 
static inline int virtio_write_config(struct virtio_device *vdev,
                                      uint32_t offset, void *src, int len)
{
        if (!vdev || !src)
                return -EINVAL;
 
        if (!vdev->func || !vdev->func->write_config)
                return -ENXIO;
 
        vdev->func->write_config(vdev, offset, src, len);
        return 0;
}
 
static inline int virtio_get_features(struct virtio_device *vdev,
                                      uint32_t *features)
{
        if (!vdev || !features)
                return -EINVAL;
 
        if (!vdev->func || !vdev->func->get_features)
                return -ENXIO;
 
        *features = vdev->func->get_features(vdev);
        if (VIRTIO_ROLE_IS_DEVICE(vdev))
                vdev->features = *features;
 
        return 0;
}
 
static inline int virtio_set_features(struct virtio_device *vdev,
                                      uint32_t features)
{
        if (!vdev)
                return -EINVAL;
 
        if (!vdev->func || !vdev->func->set_features)
                return -ENXIO;
 
        vdev->func->set_features(vdev, features);
        return 0;
}
 
static inline int virtio_negotiate_features(struct virtio_device *vdev,
                                            uint32_t features,
                                            uint32_t *final_features)
{
        if (!vdev)
                return -EINVAL;
 
        if (!vdev->func || !vdev->func->negotiate_features)
                return -ENXIO;
 
        vdev->features = vdev->func->negotiate_features(vdev, features);
        if (final_features)
                *final_features = vdev->features;
        return 0;
}
 
static inline int virtio_reset_device(struct virtio_device *vdev)
{
        if (!vdev)
                return -EINVAL;
 
        if (!vdev->func || !vdev->func->reset_device)
                return -ENXIO;
 
        vdev->func->reset_device(vdev);
        return 0;
}
 
static inline int virtio_alloc_buf(struct virtio_device *vdev, void **buf,
                                   size_t size, size_t align)
{
        if (!vdev || !buf)
                return -EINVAL;
 
        if (!vdev->mmops || !vdev->mmops->alloc)
                return -ENXIO;
 
        *buf = vdev->mmops->alloc(vdev, size, align);
        if (!*buf)
                return -ENOMEM;
 
        return 0;
}
 
static inline int virtio_free_buf(struct virtio_device *vdev, void *buf)
{
        if (!vdev)
                return -EINVAL;
 
        if (!vdev->mmops || !vdev->mmops->free)
                return -ENXIO;
 
        vdev->mmops->free(vdev, buf);
 
        return 0;
}
 
static inline bool virtio_has_feature(struct virtio_device *vdev,
                                      unsigned int feature_bit)
{
        uint32_t features;
 
        if (!vdev && feature_bit >= sizeof(features) * 8)
                return false;
 
        if (!vdev->features)
                virtio_get_features(vdev, &features);
 
        return (vdev->features & (1UL << feature_bit)) != 0;
}
 
#if defined __cplusplus
}
#endif
 
#endif                          /* _VIRTIO_H_ */