1#ifndef _LINUX_VIRTIO_H 2#define _LINUX_VIRTIO_H 3/* Everything a virtio driver needs to work with any particular virtio 4 * implementation. */ 5#include <linux/types.h> 6#include <linux/scatterlist.h> 7#include <linux/spinlock.h> 8#include <linux/device.h> 9#include <linux/mod_devicetable.h> 10#include <linux/gfp.h> 11 12/** 13 * virtqueue - a queue to register buffers for sending or receiving. 14 * @list: the chain of virtqueues for this device 15 * @callback: the function to call when buffers are consumed (can be NULL). 16 * @name: the name of this virtqueue (mainly for debugging) 17 * @vdev: the virtio device this queue was created for. 18 * @priv: a pointer for the virtqueue implementation to use. 19 */ 20struct virtqueue { 21 struct list_head list; 22 void (*callback)(struct virtqueue *vq); 23 const char *name; 24 struct virtio_device *vdev; 25 void *priv; 26}; 27 28/** 29 * operations for virtqueue 30 * virtqueue_add_buf: expose buffer to other end 31 * vq: the struct virtqueue we're talking about. 32 * sg: the description of the buffer(s). 33 * out_num: the number of sg readable by other side 34 * in_num: the number of sg which are writable (after readable ones) 35 * data: the token identifying the buffer. 36 * gfp: how to do memory allocations (if necessary). 37 * Returns remaining capacity of queue (sg segments) or a negative error. 38 * virtqueue_kick: update after add_buf 39 * vq: the struct virtqueue 40 * After one or more add_buf calls, invoke this to kick the other side. 41 * virtqueue_get_buf: get the next used buffer 42 * vq: the struct virtqueue we're talking about. 43 * len: the length written into the buffer 44 * Returns NULL or the "data" token handed to add_buf. 45 * virtqueue_disable_cb: disable callbacks 46 * vq: the struct virtqueue we're talking about. 47 * Note that this is not necessarily synchronous, hence unreliable and only 48 * useful as an optimization. 49 * virtqueue_enable_cb: restart callbacks after disable_cb. 50 * vq: the struct virtqueue we're talking about. 51 * This re-enables callbacks; it returns "false" if there are pending 52 * buffers in the queue, to detect a possible race between the driver 53 * checking for more work, and enabling callbacks. 54 * virtqueue_detach_unused_buf: detach first unused buffer 55 * vq: the struct virtqueue we're talking about. 56 * Returns NULL or the "data" token handed to add_buf 57 * 58 * Locking rules are straightforward: the driver is responsible for 59 * locking. No two operations may be invoked simultaneously, with the exception 60 * of virtqueue_disable_cb. 61 * 62 * All operations can be called in any context. 63 */ 64 65int virtqueue_add_buf_gfp(struct virtqueue *vq, 66 struct scatterlist sg[], 67 unsigned int out_num, 68 unsigned int in_num, 69 void *data, 70 gfp_t gfp); 71 72static inline int virtqueue_add_buf(struct virtqueue *vq, 73 struct scatterlist sg[], 74 unsigned int out_num, 75 unsigned int in_num, 76 void *data) 77{ 78 return virtqueue_add_buf_gfp(vq, sg, out_num, in_num, data, GFP_ATOMIC); 79} 80 81void virtqueue_kick(struct virtqueue *vq); 82 83void *virtqueue_get_buf(struct virtqueue *vq, unsigned int *len); 84 85void virtqueue_disable_cb(struct virtqueue *vq); 86 87bool virtqueue_enable_cb(struct virtqueue *vq); 88 89void *virtqueue_detach_unused_buf(struct virtqueue *vq); 90 91/** 92 * virtio_device - representation of a device using virtio 93 * @index: unique position on the virtio bus 94 * @dev: underlying device. 95 * @id: the device type identification (used to match it with a driver). 96 * @config: the configuration ops for this device. 97 * @vqs: the list of virtqueues for this device. 98 * @features: the features supported by both driver and device. 99 * @priv: private pointer for the driver's use. 100 */ 101struct virtio_device { 102 int index; 103 struct device dev; 104 struct virtio_device_id id; 105 struct virtio_config_ops *config; 106 struct list_head vqs; 107 /* Note that this is a Linux set_bit-style bitmap. */ 108 unsigned long features[1]; 109 void *priv; 110}; 111 112#define dev_to_virtio(dev) container_of(dev, struct virtio_device, dev) 113int register_virtio_device(struct virtio_device *dev); 114void unregister_virtio_device(struct virtio_device *dev); 115 116/** 117 * virtio_driver - operations for a virtio I/O driver 118 * @driver: underlying device driver (populate name and owner). 119 * @id_table: the ids serviced by this driver. 120 * @feature_table: an array of feature numbers supported by this device. 121 * @feature_table_size: number of entries in the feature table array. 122 * @probe: the function to call when a device is found. Returns 0 or -errno. 123 * @remove: the function when a device is removed. 124 * @config_changed: optional function to call when the device configuration 125 * changes; may be called in interrupt context. 126 */ 127struct virtio_driver { 128 struct device_driver driver; 129 const struct virtio_device_id *id_table; 130 const unsigned int *feature_table; 131 unsigned int feature_table_size; 132 int (*probe)(struct virtio_device *dev); 133 void (*remove)(struct virtio_device *dev); 134 void (*config_changed)(struct virtio_device *dev); 135}; 136 137int register_virtio_driver(struct virtio_driver *drv); 138void unregister_virtio_driver(struct virtio_driver *drv); 139#endif /* _LINUX_VIRTIO_H */ 140