include/linux/virtio.h

0001 /* SPDX-License-Identifier: GPL-2.0 */
0002 #ifndef _LINUX_VIRTIO_H
0003 #define _LINUX_VIRTIO_H
0004 /* Everything a virtio driver needs to work with any particular virtio
0005  * implementation. */
0006 #include <linux/types.h>
0007 #include <linux/scatterlist.h>
0008 #include <linux/spinlock.h>
0009 #include <linux/device.h>
0010 #include <linux/mod_devicetable.h>
0011 #include <linux/gfp.h>
0012
0013 /**
0014  * struct virtqueue - a queue to register buffers for sending or receiving.
0015  * @list: the chain of virtqueues for this device
0016  * @callback: the function to call when buffers are consumed (can be NULL).
0017  * @name: the name of this virtqueue (mainly for debugging)
0018  * @vdev: the virtio device this queue was created for.
0019  * @priv: a pointer for the virtqueue implementation to use.
0020  * @index: the zero-based ordinal number for this queue.
0021  * @num_free: number of elements we expect to be able to fit.
0022  * @num_max: the maximum number of elements supported by the device.
0023  * @reset: vq is in reset state or not.
0024  *
0025  * A note on @num_free: with indirect buffers, each buffer needs one
0026  * element in the queue, otherwise a buffer will need one element per
0027  * sg element.
0028  */
0029 struct virtqueue {
0030     struct list_head list;
0031     void (*callback)(struct virtqueue *vq);
0032     const char *name;
0033     struct virtio_device *vdev;
0034     unsigned int index;
0035     unsigned int num_free;
0036     unsigned int num_max;
0037     void *priv;
0038     bool reset;
0039 };
0040
0041 int virtqueue_add_outbuf(struct virtqueue *vq,
0042              struct scatterlist sg[], unsigned int num,
0043              void *data,
0044              gfp_t gfp);
0045
0046 int virtqueue_add_inbuf(struct virtqueue *vq,
0047             struct scatterlist sg[], unsigned int num,
0048             void *data,
0049             gfp_t gfp);
0050
0051 int virtqueue_add_inbuf_ctx(struct virtqueue *vq,
0052                 struct scatterlist sg[], unsigned int num,
0053                 void *data,
0054                 void *ctx,
0055                 gfp_t gfp);
0056
0057 int virtqueue_add_sgs(struct virtqueue *vq,
0058               struct scatterlist *sgs[],
0059               unsigned int out_sgs,
0060               unsigned int in_sgs,
0061               void *data,
0062               gfp_t gfp);
0063
0064 bool virtqueue_kick(struct virtqueue *vq);
0065
0066 bool virtqueue_kick_prepare(struct virtqueue *vq);
0067
0068 bool virtqueue_notify(struct virtqueue *vq);
0069
0070 void *virtqueue_get_buf(struct virtqueue *vq, unsigned int *len);
0071
0072 void *virtqueue_get_buf_ctx(struct virtqueue *vq, unsigned int *len,
0073                 void **ctx);
0074
0075 void virtqueue_disable_cb(struct virtqueue *vq);
0076
0077 bool virtqueue_enable_cb(struct virtqueue *vq);
0078
0079 unsigned virtqueue_enable_cb_prepare(struct virtqueue *vq);
0080
0081 bool virtqueue_poll(struct virtqueue *vq, unsigned);
0082
0083 bool virtqueue_enable_cb_delayed(struct virtqueue *vq);
0084
0085 void *virtqueue_detach_unused_buf(struct virtqueue *vq);
0086
0087 unsigned int virtqueue_get_vring_size(struct virtqueue *vq);
0088
0089 bool virtqueue_is_broken(struct virtqueue *vq);
0090
0091 const struct vring *virtqueue_get_vring(struct virtqueue *vq);
0092 dma_addr_t virtqueue_get_desc_addr(struct virtqueue *vq);
0093 dma_addr_t virtqueue_get_avail_addr(struct virtqueue *vq);
0094 dma_addr_t virtqueue_get_used_addr(struct virtqueue *vq);
0095
0096 int virtqueue_resize(struct virtqueue *vq, u32 num,
0097              void (*recycle)(struct virtqueue *vq, void *buf));
0098
0099 /**
0100  * struct virtio_device - representation of a device using virtio
0101  * @index: unique position on the virtio bus
0102  * @failed: saved value for VIRTIO_CONFIG_S_FAILED bit (for restore)
0103  * @config_enabled: configuration change reporting enabled
0104  * @config_change_pending: configuration change reported while disabled
0105  * @config_lock: protects configuration change reporting
0106  * @dev: underlying device.
0107  * @id: the device type identification (used to match it with a driver).
0108  * @config: the configuration ops for this device.
0109  * @vringh_config: configuration ops for host vrings.
0110  * @vqs: the list of virtqueues for this device.
0111  * @features: the features supported by both driver and device.
0112  * @priv: private pointer for the driver's use.
0113  */
0114 struct virtio_device {
0115     int index;
0116     bool failed;
0117     bool config_enabled;
0118     bool config_change_pending;
0119     spinlock_t config_lock;
0120     spinlock_t vqs_list_lock; /* Protects VQs list access */
0121     struct device dev;
0122     struct virtio_device_id id;
0123     const struct virtio_config_ops *config;
0124     const struct vringh_config_ops *vringh_config;
0125     struct list_head vqs;
0126     u64 features;
0127     void *priv;
0128 };
0129
0130 static inline struct virtio_device *dev_to_virtio(struct device *_dev)
0131 {
0132     return container_of(_dev, struct virtio_device, dev);
0133 }
0134
0135 void virtio_add_status(struct virtio_device *dev, unsigned int status);
0136 int register_virtio_device(struct virtio_device *dev);
0137 void unregister_virtio_device(struct virtio_device *dev);
0138 bool is_virtio_device(struct device *dev);
0139
0140 void virtio_break_device(struct virtio_device *dev);
0141 void __virtio_unbreak_device(struct virtio_device *dev);
0142
0143 void __virtqueue_break(struct virtqueue *_vq);
0144 void __virtqueue_unbreak(struct virtqueue *_vq);
0145
0146 void virtio_config_changed(struct virtio_device *dev);
0147 #ifdef CONFIG_PM_SLEEP
0148 int virtio_device_freeze(struct virtio_device *dev);
0149 int virtio_device_restore(struct virtio_device *dev);
0150 #endif
0151 void virtio_reset_device(struct virtio_device *dev);
0152
0153 size_t virtio_max_dma_size(struct virtio_device *vdev);
0154
0155 #define virtio_device_for_each_vq(vdev, vq) \
0156     list_for_each_entry(vq, &vdev->vqs, list)
0157
0158 /**
0159  * struct virtio_driver - operations for a virtio I/O driver
0160  * @driver: underlying device driver (populate name and owner).
0161  * @id_table: the ids serviced by this driver.
0162  * @feature_table: an array of feature numbers supported by this driver.
0163  * @feature_table_size: number of entries in the feature table array.
0164  * @feature_table_legacy: same as feature_table but when working in legacy mode.
0165  * @feature_table_size_legacy: number of entries in feature table legacy array.
0166  * @probe: the function to call when a device is found.  Returns 0 or -errno.
0167  * @scan: optional function to call after successful probe; intended
0168  *    for virtio-scsi to invoke a scan.
0169  * @remove: the function to call when a device is removed.
0170  * @config_changed: optional function to call when the device configuration
0171  *    changes; may be called in interrupt context.
0172  * @freeze: optional function to call during suspend/hibernation.
0173  * @restore: optional function to call on resume.
0174  */
0175 struct virtio_driver {
0176     struct device_driver driver;
0177     const struct virtio_device_id *id_table;
0178     const unsigned int *feature_table;
0179     unsigned int feature_table_size;
0180     const unsigned int *feature_table_legacy;
0181     unsigned int feature_table_size_legacy;
0182     int (*validate)(struct virtio_device *dev);
0183     int (*probe)(struct virtio_device *dev);
0184     void (*scan)(struct virtio_device *dev);
0185     void (*remove)(struct virtio_device *dev);
0186     void (*config_changed)(struct virtio_device *dev);
0187 #ifdef CONFIG_PM
0188     int (*freeze)(struct virtio_device *dev);
0189     int (*restore)(struct virtio_device *dev);
0190 #endif
0191 };
0192
0193 static inline struct virtio_driver *drv_to_virtio(struct device_driver *drv)
0194 {
0195     return container_of(drv, struct virtio_driver, driver);
0196 }
0197
0198 int register_virtio_driver(struct virtio_driver *drv);
0199 void unregister_virtio_driver(struct virtio_driver *drv);
0200
0201 /* module_virtio_driver() - Helper macro for drivers that don't do
0202  * anything special in module init/exit.  This eliminates a lot of
0203  * boilerplate.  Each module may only use this macro once, and
0204  * calling it replaces module_init() and module_exit()
0205  */
0206 #define module_virtio_driver(__virtio_driver) \
0207     module_driver(__virtio_driver, register_virtio_driver, \
0208             unregister_virtio_driver)
0209 #endif /* _LINUX_VIRTIO_H */