1
2#ifndef _LINUX_VIRTIO_H
3#define _LINUX_VIRTIO_H
4
5
6#include <linux/types.h>
7#include <linux/scatterlist.h>
8#include <linux/spinlock.h>
9#include <linux/device.h>
10#include <linux/mod_devicetable.h>
11#include <linux/gfp.h>
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27struct virtqueue {
28 struct list_head list;
29 void (*callback)(struct virtqueue *vq);
30 const char *name;
31 struct virtio_device *vdev;
32 unsigned int index;
33 unsigned int num_free;
34 void *priv;
35};
36
37int virtqueue_add_outbuf(struct virtqueue *vq,
38 struct scatterlist sg[], unsigned int num,
39 void *data,
40 gfp_t gfp);
41
42int virtqueue_add_inbuf(struct virtqueue *vq,
43 struct scatterlist sg[], unsigned int num,
44 void *data,
45 gfp_t gfp);
46
47int virtqueue_add_inbuf_ctx(struct virtqueue *vq,
48 struct scatterlist sg[], unsigned int num,
49 void *data,
50 void *ctx,
51 gfp_t gfp);
52
53int virtqueue_add_sgs(struct virtqueue *vq,
54 struct scatterlist *sgs[],
55 unsigned int out_sgs,
56 unsigned int in_sgs,
57 void *data,
58 gfp_t gfp);
59
60bool virtqueue_kick(struct virtqueue *vq);
61
62bool virtqueue_kick_prepare(struct virtqueue *vq);
63
64bool virtqueue_notify(struct virtqueue *vq);
65
66void *virtqueue_get_buf(struct virtqueue *vq, unsigned int *len);
67
68void *virtqueue_get_buf_ctx(struct virtqueue *vq, unsigned int *len,
69 void **ctx);
70
71void virtqueue_disable_cb(struct virtqueue *vq);
72
73bool virtqueue_enable_cb(struct virtqueue *vq);
74
75unsigned virtqueue_enable_cb_prepare(struct virtqueue *vq);
76
77bool virtqueue_poll(struct virtqueue *vq, unsigned);
78
79bool virtqueue_enable_cb_delayed(struct virtqueue *vq);
80
81void *virtqueue_detach_unused_buf(struct virtqueue *vq);
82
83unsigned int virtqueue_get_vring_size(struct virtqueue *vq);
84
85bool virtqueue_is_broken(struct virtqueue *vq);
86
87const struct vring *virtqueue_get_vring(struct virtqueue *vq);
88dma_addr_t virtqueue_get_desc_addr(struct virtqueue *vq);
89dma_addr_t virtqueue_get_avail_addr(struct virtqueue *vq);
90dma_addr_t virtqueue_get_used_addr(struct virtqueue *vq);
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107struct virtio_device {
108 int index;
109 bool failed;
110 bool config_enabled;
111 bool config_change_pending;
112 spinlock_t config_lock;
113 spinlock_t vqs_list_lock;
114 struct device dev;
115 struct virtio_device_id id;
116 const struct virtio_config_ops *config;
117 const struct vringh_config_ops *vringh_config;
118 struct list_head vqs;
119 u64 features;
120 void *priv;
121};
122
123static inline struct virtio_device *dev_to_virtio(struct device *_dev)
124{
125 return container_of(_dev, struct virtio_device, dev);
126}
127
128void virtio_add_status(struct virtio_device *dev, unsigned int status);
129int register_virtio_device(struct virtio_device *dev);
130void unregister_virtio_device(struct virtio_device *dev);
131bool is_virtio_device(struct device *dev);
132
133void virtio_break_device(struct virtio_device *dev);
134
135void virtio_config_changed(struct virtio_device *dev);
136int virtio_finalize_features(struct virtio_device *dev);
137#ifdef CONFIG_PM_SLEEP
138int virtio_device_freeze(struct virtio_device *dev);
139int virtio_device_restore(struct virtio_device *dev);
140#endif
141
142size_t virtio_max_dma_size(struct virtio_device *vdev);
143
144#define virtio_device_for_each_vq(vdev, vq) \
145 list_for_each_entry(vq, &vdev->vqs, list)
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164struct virtio_driver {
165 struct device_driver driver;
166 const struct virtio_device_id *id_table;
167 const unsigned int *feature_table;
168 unsigned int feature_table_size;
169 const unsigned int *feature_table_legacy;
170 unsigned int feature_table_size_legacy;
171 int (*validate)(struct virtio_device *dev);
172 int (*probe)(struct virtio_device *dev);
173 void (*scan)(struct virtio_device *dev);
174 void (*remove)(struct virtio_device *dev);
175 void (*config_changed)(struct virtio_device *dev);
176#ifdef CONFIG_PM
177 int (*freeze)(struct virtio_device *dev);
178 int (*restore)(struct virtio_device *dev);
179#endif
180};
181
182static inline struct virtio_driver *drv_to_virtio(struct device_driver *drv)
183{
184 return container_of(drv, struct virtio_driver, driver);
185}
186
187int register_virtio_driver(struct virtio_driver *drv);
188void unregister_virtio_driver(struct virtio_driver *drv);
189
190
191
192
193
194
195#define module_virtio_driver(__virtio_driver) \
196 module_driver(__virtio_driver, register_virtio_driver, \
197 unregister_virtio_driver)
198#endif
199