]>
Commit | Line | Data |
---|---|---|
ec3d41c4 RR |
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). | |
ec3d41c4 RR |
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 | { | |
18445c4d | 20 | void (*callback)(struct virtqueue *vq); |
ec3d41c4 RR |
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. | |
18445c4d RR |
42 | * @disable_cb: disable callbacks |
43 | * vq: the struct virtqueue we're talking about. | |
2557a933 RR |
44 | * Note that this is not necessarily synchronous, hence unreliable and only |
45 | * useful as an optimization. | |
18445c4d | 46 | * @enable_cb: restart callbacks after disable_cb. |
ec3d41c4 | 47 | * vq: the struct virtqueue we're talking about. |
4265f161 CB |
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. | |
ec3d41c4 RR |
51 | * |
52 | * Locking rules are straightforward: the driver is responsible for | |
2557a933 RR |
53 | * locking. No two operations may be invoked simultaneously, with the exception |
54 | * of @disable_cb. | |
ec3d41c4 RR |
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 | ||
18445c4d RR |
69 | void (*disable_cb)(struct virtqueue *vq); |
70 | bool (*enable_cb)(struct virtqueue *vq); | |
ec3d41c4 RR |
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. | |
c45a6816 | 79 | * @features: the features supported by both driver and device. |
ec3d41c4 RR |
80 | * @priv: private pointer for the driver's use. |
81 | */ | |
82 | struct virtio_device | |
83 | { | |
84 | int index; | |
85 | struct device dev; | |
86 | struct virtio_device_id id; | |
87 | struct virtio_config_ops *config; | |
c45a6816 RR |
88 | /* Note that this is a Linux set_bit-style bitmap. */ |
89 | unsigned long features[1]; | |
ec3d41c4 RR |
90 | void *priv; |
91 | }; | |
92 | ||
93 | int register_virtio_device(struct virtio_device *dev); | |
94 | void unregister_virtio_device(struct virtio_device *dev); | |
95 | ||
96 | /** | |
97 | * virtio_driver - operations for a virtio I/O driver | |
98 | * @driver: underlying device driver (populate name and owner). | |
99 | * @id_table: the ids serviced by this driver. | |
c45a6816 RR |
100 | * @feature_table: an array of feature numbers supported by this device. |
101 | * @feature_table_size: number of entries in the feature table array. | |
ec3d41c4 RR |
102 | * @probe: the function to call when a device is found. Returns a token for |
103 | * remove, or PTR_ERR(). | |
104 | * @remove: the function when a device is removed. | |
f957d1f0 RR |
105 | * @config_changed: optional function to call when the device configuration |
106 | * changes; may be called in interrupt context. | |
ec3d41c4 RR |
107 | */ |
108 | struct virtio_driver { | |
109 | struct device_driver driver; | |
110 | const struct virtio_device_id *id_table; | |
c45a6816 RR |
111 | const unsigned int *feature_table; |
112 | unsigned int feature_table_size; | |
ec3d41c4 RR |
113 | int (*probe)(struct virtio_device *dev); |
114 | void (*remove)(struct virtio_device *dev); | |
f957d1f0 | 115 | void (*config_changed)(struct virtio_device *dev); |
ec3d41c4 RR |
116 | }; |
117 | ||
118 | int register_virtio_driver(struct virtio_driver *drv); | |
119 | void unregister_virtio_driver(struct virtio_driver *drv); | |
120 | #endif /* _LINUX_VIRTIO_H */ |