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