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 11 /** 12 * virtqueue - a queue to register buffers for sending or receiving. 13 * @callback: the function to call when buffers are consumed (can be NULL). 14 * @vdev: the virtio device this queue was created for. 15 * @vq_ops: the operations for this virtqueue (see below). 16 * @priv: a pointer for the virtqueue implementation to use. 17 */ 18 struct virtqueue 19 { 20 void (*callback)(struct virtqueue *vq); 21 struct virtio_device *vdev; 22 struct virtqueue_ops *vq_ops; 23 void *priv; 24 }; 25 26 /** 27 * virtqueue_ops - operations for virtqueue abstraction layer 28 * @add_buf: expose buffer to other end 29 * vq: the struct virtqueue we're talking about. 30 * sg: the description of the buffer(s). 31 * out_num: the number of sg readable by other side 32 * in_num: the number of sg which are writable (after readable ones) 33 * data: the token identifying the buffer. 34 * Returns 0 or an error. 35 * @kick: update after add_buf 36 * vq: the struct virtqueue 37 * After one or more add_buf calls, invoke this to kick the other side. 38 * @get_buf: get the next used buffer 39 * vq: the struct virtqueue we're talking about. 40 * len: the length written into the buffer 41 * Returns NULL or the "data" token handed to add_buf. 42 * @disable_cb: disable callbacks 43 * vq: the struct virtqueue we're talking about. 44 * Note that this is not necessarily synchronous, hence unreliable and only 45 * useful as an optimization. 46 * @enable_cb: restart callbacks after disable_cb. 47 * vq: the struct virtqueue we're talking about. 48 * This re-enables callbacks; it returns "false" if there are pending 49 * buffers in the queue, to detect a possible race between the driver 50 * checking for more work, and enabling callbacks. 51 * 52 * Locking rules are straightforward: the driver is responsible for 53 * locking. No two operations may be invoked simultaneously, with the exception 54 * of @disable_cb. 55 * 56 * All operations can be called in any context. 57 */ 58 struct virtqueue_ops { 59 int (*add_buf)(struct virtqueue *vq, 60 struct scatterlist sg[], 61 unsigned int out_num, 62 unsigned int in_num, 63 void *data); 64 65 void (*kick)(struct virtqueue *vq); 66 67 void *(*get_buf)(struct virtqueue *vq, unsigned int *len); 68 69 void (*disable_cb)(struct virtqueue *vq); 70 bool (*enable_cb)(struct virtqueue *vq); 71 }; 72 73 /** 74 * virtio_device - representation of a device using virtio 75 * @index: unique position on the virtio bus 76 * @dev: underlying device. 77 * @id: the device type identification (used to match it with a driver). 78 * @config: the configuration ops for this device. 79 * @priv: private pointer for the driver's use. 80 */ 81 struct virtio_device 82 { 83 int index; 84 struct device dev; 85 struct virtio_device_id id; 86 struct virtio_config_ops *config; 87 void *priv; 88 }; 89 90 int register_virtio_device(struct virtio_device *dev); 91 void unregister_virtio_device(struct virtio_device *dev); 92 93 /** 94 * virtio_driver - operations for a virtio I/O driver 95 * @driver: underlying device driver (populate name and owner). 96 * @id_table: the ids serviced by this driver. 97 * @probe: the function to call when a device is found. Returns a token for 98 * remove, or PTR_ERR(). 99 * @remove: the function when a device is removed. 100 * @config_changed: optional function to call when the device configuration 101 * changes; may be called in interrupt context. 102 */ 103 struct virtio_driver { 104 struct device_driver driver; 105 const struct virtio_device_id *id_table; 106 int (*probe)(struct virtio_device *dev); 107 void (*remove)(struct virtio_device *dev); 108 void (*config_changed)(struct virtio_device *dev); 109 }; 110 111 int register_virtio_driver(struct virtio_driver *drv); 112 void unregister_virtio_driver(struct virtio_driver *drv); 113 #endif /* _LINUX_VIRTIO_H */ 114