xref: /qemu/include/hw/virtio/virtio-pci.h (revision 7df2c7181a0792257b775a5c4171254d80083689) 
1 /*
2  * Virtio PCI Bindings
3  *
4  * Copyright IBM, Corp. 2007
5  * Copyright (c) 2009 CodeSourcery
6  *
7  * Authors:
8  *  Anthony Liguori   <aliguori@us.ibm.com>
9  *  Paul Brook        <paul@codesourcery.com>
10  *
11  * This work is licensed under the terms of the GNU GPL, version 2.  See
12  * the COPYING file in the top-level directory.
13  */
14 
15 #ifndef QEMU_VIRTIO_PCI_H
16 #define QEMU_VIRTIO_PCI_H
17 
18 #include "hw/pci/msi.h"
19 #include "hw/virtio/virtio-blk.h"
20 #include "hw/virtio/virtio-net.h"
21 #include "hw/virtio/virtio-rng.h"
22 #include "hw/virtio/virtio-serial.h"
23 #include "hw/virtio/virtio-scsi.h"
24 #include "hw/virtio/virtio-balloon.h"
25 #include "hw/virtio/virtio-bus.h"
26 #include "hw/virtio/virtio-input.h"
27 #include "hw/virtio/virtio-gpu.h"
28 #include "hw/virtio/virtio-crypto.h"
29 #include "hw/virtio/vhost-user-scsi.h"
30 #if defined(CONFIG_VHOST_USER) && defined(CONFIG_LINUX)
31 #include "hw/virtio/vhost-user-blk.h"
32 #endif
33 
34 #ifdef CONFIG_VIRTFS
35 #include "hw/9pfs/virtio-9p.h"
36 #endif
37 #ifdef CONFIG_VHOST_SCSI
38 #include "hw/virtio/vhost-scsi.h"
39 #endif
40 
41 typedef struct VirtIOPCIProxy VirtIOPCIProxy;
42 typedef struct VirtIOBlkPCI VirtIOBlkPCI;
43 typedef struct VirtIOSCSIPCI VirtIOSCSIPCI;
44 typedef struct VirtIOBalloonPCI VirtIOBalloonPCI;
45 typedef struct VirtIOSerialPCI VirtIOSerialPCI;
46 typedef struct VirtIONetPCI VirtIONetPCI;
47 typedef struct VHostSCSIPCI VHostSCSIPCI;
48 typedef struct VHostUserSCSIPCI VHostUserSCSIPCI;
49 typedef struct VHostUserBlkPCI VHostUserBlkPCI;
50 typedef struct VirtIORngPCI VirtIORngPCI;
51 typedef struct VirtIOInputPCI VirtIOInputPCI;
52 typedef struct VirtIOInputHIDPCI VirtIOInputHIDPCI;
53 typedef struct VirtIOGPUPCI VirtIOGPUPCI;
54 typedef struct VirtIOCryptoPCI VirtIOCryptoPCI;
55 
56 /* virtio-pci-bus */
57 
58 typedef struct VirtioBusState VirtioPCIBusState;
59 typedef struct VirtioBusClass VirtioPCIBusClass;
60 
61 #define TYPE_VIRTIO_PCI_BUS "virtio-pci-bus"
62 #define VIRTIO_PCI_BUS(obj) \
63         OBJECT_CHECK(VirtioPCIBusState, (obj), TYPE_VIRTIO_PCI_BUS)
64 #define VIRTIO_PCI_BUS_GET_CLASS(obj) \
65         OBJECT_GET_CLASS(VirtioPCIBusClass, obj, TYPE_VIRTIO_PCI_BUS)
66 #define VIRTIO_PCI_BUS_CLASS(klass) \
67         OBJECT_CLASS_CHECK(VirtioPCIBusClass, klass, TYPE_VIRTIO_PCI_BUS)
68 
69 enum {
70     VIRTIO_PCI_FLAG_BUS_MASTER_BUG_MIGRATION_BIT,
71     VIRTIO_PCI_FLAG_USE_IOEVENTFD_BIT,
72     VIRTIO_PCI_FLAG_MIGRATE_EXTRA_BIT,
73     VIRTIO_PCI_FLAG_MODERN_PIO_NOTIFY_BIT,
74     VIRTIO_PCI_FLAG_DISABLE_PCIE_BIT,
75     VIRTIO_PCI_FLAG_PAGE_PER_VQ_BIT,
76     VIRTIO_PCI_FLAG_ATS_BIT,
77     VIRTIO_PCI_FLAG_INIT_DEVERR_BIT,
78     VIRTIO_PCI_FLAG_INIT_LNKCTL_BIT,
79     VIRTIO_PCI_FLAG_INIT_PM_BIT,
80 };
81 
82 /* Need to activate work-arounds for buggy guests at vmstate load. */
83 #define VIRTIO_PCI_FLAG_BUS_MASTER_BUG_MIGRATION \
84     (1 << VIRTIO_PCI_FLAG_BUS_MASTER_BUG_MIGRATION_BIT)
85 
86 /* Performance improves when virtqueue kick processing is decoupled from the
87  * vcpu thread using ioeventfd for some devices. */
88 #define VIRTIO_PCI_FLAG_USE_IOEVENTFD   (1 << VIRTIO_PCI_FLAG_USE_IOEVENTFD_BIT)
89 
90 /* virtio version flags */
91 #define VIRTIO_PCI_FLAG_DISABLE_PCIE (1 << VIRTIO_PCI_FLAG_DISABLE_PCIE_BIT)
92 
93 /* migrate extra state */
94 #define VIRTIO_PCI_FLAG_MIGRATE_EXTRA (1 << VIRTIO_PCI_FLAG_MIGRATE_EXTRA_BIT)
95 
96 /* have pio notification for modern device ? */
97 #define VIRTIO_PCI_FLAG_MODERN_PIO_NOTIFY \
98     (1 << VIRTIO_PCI_FLAG_MODERN_PIO_NOTIFY_BIT)
99 
100 /* page per vq flag to be used by split drivers within guests */
101 #define VIRTIO_PCI_FLAG_PAGE_PER_VQ \
102     (1 << VIRTIO_PCI_FLAG_PAGE_PER_VQ_BIT)
103 
104 /* address space translation service */
105 #define VIRTIO_PCI_FLAG_ATS (1 << VIRTIO_PCI_FLAG_ATS_BIT)
106 
107 /* Init error enabling flags */
108 #define VIRTIO_PCI_FLAG_INIT_DEVERR (1 << VIRTIO_PCI_FLAG_INIT_DEVERR_BIT)
109 
110 /* Init Link Control register */
111 #define VIRTIO_PCI_FLAG_INIT_LNKCTL (1 << VIRTIO_PCI_FLAG_INIT_LNKCTL_BIT)
112 
113 /* Init Power Management */
114 #define VIRTIO_PCI_FLAG_INIT_PM (1 << VIRTIO_PCI_FLAG_INIT_PM_BIT)
115 
116 typedef struct {
117     MSIMessage msg;
118     int virq;
119     unsigned int users;
120 } VirtIOIRQFD;
121 
122 /*
123  * virtio-pci: This is the PCIDevice which has a virtio-pci-bus.
124  */
125 #define TYPE_VIRTIO_PCI "virtio-pci"
126 #define VIRTIO_PCI_GET_CLASS(obj) \
127         OBJECT_GET_CLASS(VirtioPCIClass, obj, TYPE_VIRTIO_PCI)
128 #define VIRTIO_PCI_CLASS(klass) \
129         OBJECT_CLASS_CHECK(VirtioPCIClass, klass, TYPE_VIRTIO_PCI)
130 #define VIRTIO_PCI(obj) \
131         OBJECT_CHECK(VirtIOPCIProxy, (obj), TYPE_VIRTIO_PCI)
132 
133 typedef struct VirtioPCIClass {
134     PCIDeviceClass parent_class;
135     DeviceRealize parent_dc_realize;
136     void (*realize)(VirtIOPCIProxy *vpci_dev, Error **errp);
137 } VirtioPCIClass;
138 
139 typedef struct VirtIOPCIRegion {
140     MemoryRegion mr;
141     uint32_t offset;
142     uint32_t size;
143     uint32_t type;
144 } VirtIOPCIRegion;
145 
146 typedef struct VirtIOPCIQueue {
147   uint16_t num;
148   bool enabled;
149   uint32_t desc[2];
150   uint32_t avail[2];
151   uint32_t used[2];
152 } VirtIOPCIQueue;
153 
154 struct VirtIOPCIProxy {
155     PCIDevice pci_dev;
156     MemoryRegion bar;
157     union {
158         struct {
159             VirtIOPCIRegion common;
160             VirtIOPCIRegion isr;
161             VirtIOPCIRegion device;
162             VirtIOPCIRegion notify;
163             VirtIOPCIRegion notify_pio;
164         };
165         VirtIOPCIRegion regs[5];
166     };
167     MemoryRegion modern_bar;
168     MemoryRegion io_bar;
169     uint32_t legacy_io_bar_idx;
170     uint32_t msix_bar_idx;
171     uint32_t modern_io_bar_idx;
172     uint32_t modern_mem_bar_idx;
173     int config_cap;
174     uint32_t flags;
175     bool disable_modern;
176     bool ignore_backend_features;
177     OnOffAuto disable_legacy;
178     uint32_t class_code;
179     uint32_t nvectors;
180     uint32_t dfselect;
181     uint32_t gfselect;
182     uint32_t guest_features[2];
183     VirtIOPCIQueue vqs[VIRTIO_QUEUE_MAX];
184 
185     VirtIOIRQFD *vector_irqfd;
186     int nvqs_with_notifiers;
187     VirtioBusState bus;
188 };
189 
190 static inline bool virtio_pci_modern(VirtIOPCIProxy *proxy)
191 {
192     return !proxy->disable_modern;
193 }
194 
195 static inline bool virtio_pci_legacy(VirtIOPCIProxy *proxy)
196 {
197     return proxy->disable_legacy == ON_OFF_AUTO_OFF;
198 }
199 
200 static inline void virtio_pci_force_virtio_1(VirtIOPCIProxy *proxy)
201 {
202     proxy->disable_modern = false;
203     proxy->disable_legacy = ON_OFF_AUTO_ON;
204 }
205 
206 static inline void virtio_pci_disable_modern(VirtIOPCIProxy *proxy)
207 {
208     proxy->disable_modern = true;
209 }
210 
211 /*
212  * virtio-scsi-pci: This extends VirtioPCIProxy.
213  */
214 #define TYPE_VIRTIO_SCSI_PCI "virtio-scsi-pci-base"
215 #define VIRTIO_SCSI_PCI(obj) \
216         OBJECT_CHECK(VirtIOSCSIPCI, (obj), TYPE_VIRTIO_SCSI_PCI)
217 
218 struct VirtIOSCSIPCI {
219     VirtIOPCIProxy parent_obj;
220     VirtIOSCSI vdev;
221 };
222 
223 #ifdef CONFIG_VHOST_SCSI
224 /*
225  * vhost-scsi-pci: This extends VirtioPCIProxy.
226  */
227 #define TYPE_VHOST_SCSI_PCI "vhost-scsi-pci-base"
228 #define VHOST_SCSI_PCI(obj) \
229         OBJECT_CHECK(VHostSCSIPCI, (obj), TYPE_VHOST_SCSI_PCI)
230 
231 struct VHostSCSIPCI {
232     VirtIOPCIProxy parent_obj;
233     VHostSCSI vdev;
234 };
235 #endif
236 
237 #define TYPE_VHOST_USER_SCSI_PCI "vhost-user-scsi-pci-base"
238 #define VHOST_USER_SCSI_PCI(obj) \
239         OBJECT_CHECK(VHostUserSCSIPCI, (obj), TYPE_VHOST_USER_SCSI_PCI)
240 
241 struct VHostUserSCSIPCI {
242     VirtIOPCIProxy parent_obj;
243     VHostUserSCSI vdev;
244 };
245 
246 #if defined(CONFIG_VHOST_USER) && defined(CONFIG_LINUX)
247 /*
248  * vhost-user-blk-pci: This extends VirtioPCIProxy.
249  */
250 #define TYPE_VHOST_USER_BLK_PCI "vhost-user-blk-pci-base"
251 #define VHOST_USER_BLK_PCI(obj) \
252         OBJECT_CHECK(VHostUserBlkPCI, (obj), TYPE_VHOST_USER_BLK_PCI)
253 
254 struct VHostUserBlkPCI {
255     VirtIOPCIProxy parent_obj;
256     VHostUserBlk vdev;
257 };
258 #endif
259 
260 /*
261  * virtio-blk-pci: This extends VirtioPCIProxy.
262  */
263 #define TYPE_VIRTIO_BLK_PCI "virtio-blk-pci-base"
264 #define VIRTIO_BLK_PCI(obj) \
265         OBJECT_CHECK(VirtIOBlkPCI, (obj), TYPE_VIRTIO_BLK_PCI)
266 
267 struct VirtIOBlkPCI {
268     VirtIOPCIProxy parent_obj;
269     VirtIOBlock vdev;
270 };
271 
272 /*
273  * virtio-balloon-pci: This extends VirtioPCIProxy.
274  */
275 #define TYPE_VIRTIO_BALLOON_PCI "virtio-balloon-pci-base"
276 #define VIRTIO_BALLOON_PCI(obj) \
277         OBJECT_CHECK(VirtIOBalloonPCI, (obj), TYPE_VIRTIO_BALLOON_PCI)
278 
279 struct VirtIOBalloonPCI {
280     VirtIOPCIProxy parent_obj;
281     VirtIOBalloon vdev;
282 };
283 
284 /*
285  * virtio-serial-pci: This extends VirtioPCIProxy.
286  */
287 #define TYPE_VIRTIO_SERIAL_PCI "virtio-serial-pci-base"
288 #define VIRTIO_SERIAL_PCI(obj) \
289         OBJECT_CHECK(VirtIOSerialPCI, (obj), TYPE_VIRTIO_SERIAL_PCI)
290 
291 struct VirtIOSerialPCI {
292     VirtIOPCIProxy parent_obj;
293     VirtIOSerial vdev;
294 };
295 
296 /*
297  * virtio-net-pci: This extends VirtioPCIProxy.
298  */
299 #define TYPE_VIRTIO_NET_PCI "virtio-net-pci-base"
300 #define VIRTIO_NET_PCI(obj) \
301         OBJECT_CHECK(VirtIONetPCI, (obj), TYPE_VIRTIO_NET_PCI)
302 
303 struct VirtIONetPCI {
304     VirtIOPCIProxy parent_obj;
305     VirtIONet vdev;
306 };
307 
308 /*
309  * virtio-9p-pci: This extends VirtioPCIProxy.
310  */
311 
312 #ifdef CONFIG_VIRTFS
313 
314 #define TYPE_VIRTIO_9P_PCI "virtio-9p-pci-base"
315 #define VIRTIO_9P_PCI(obj) \
316         OBJECT_CHECK(V9fsPCIState, (obj), TYPE_VIRTIO_9P_PCI)
317 
318 typedef struct V9fsPCIState {
319     VirtIOPCIProxy parent_obj;
320     V9fsVirtioState vdev;
321 } V9fsPCIState;
322 
323 #endif
324 
325 /*
326  * virtio-rng-pci: This extends VirtioPCIProxy.
327  */
328 #define TYPE_VIRTIO_RNG_PCI "virtio-rng-pci-base"
329 #define VIRTIO_RNG_PCI(obj) \
330         OBJECT_CHECK(VirtIORngPCI, (obj), TYPE_VIRTIO_RNG_PCI)
331 
332 struct VirtIORngPCI {
333     VirtIOPCIProxy parent_obj;
334     VirtIORNG vdev;
335 };
336 
337 /*
338  * virtio-input-pci: This extends VirtioPCIProxy.
339  */
340 #define TYPE_VIRTIO_INPUT_PCI "virtio-input-pci"
341 #define VIRTIO_INPUT_PCI(obj) \
342         OBJECT_CHECK(VirtIOInputPCI, (obj), TYPE_VIRTIO_INPUT_PCI)
343 
344 struct VirtIOInputPCI {
345     VirtIOPCIProxy parent_obj;
346     VirtIOInput vdev;
347 };
348 
349 #define TYPE_VIRTIO_INPUT_HID_PCI "virtio-input-hid-pci"
350 #define TYPE_VIRTIO_KEYBOARD_PCI  "virtio-keyboard-pci"
351 #define TYPE_VIRTIO_MOUSE_PCI     "virtio-mouse-pci"
352 #define TYPE_VIRTIO_TABLET_PCI    "virtio-tablet-pci"
353 #define VIRTIO_INPUT_HID_PCI(obj) \
354         OBJECT_CHECK(VirtIOInputHIDPCI, (obj), TYPE_VIRTIO_INPUT_HID_PCI)
355 
356 struct VirtIOInputHIDPCI {
357     VirtIOPCIProxy parent_obj;
358     VirtIOInputHID vdev;
359 };
360 
361 /*
362  * virtio-gpu-pci: This extends VirtioPCIProxy.
363  */
364 #define TYPE_VIRTIO_GPU_PCI "virtio-gpu-pci"
365 #define VIRTIO_GPU_PCI(obj) \
366         OBJECT_CHECK(VirtIOGPUPCI, (obj), TYPE_VIRTIO_GPU_PCI)
367 
368 struct VirtIOGPUPCI {
369     VirtIOPCIProxy parent_obj;
370     VirtIOGPU vdev;
371 };
372 
373 /*
374  * virtio-crypto-pci: This extends VirtioPCIProxy.
375  */
376 #define TYPE_VIRTIO_CRYPTO_PCI "virtio-crypto-pci"
377 #define VIRTIO_CRYPTO_PCI(obj) \
378         OBJECT_CHECK(VirtIOCryptoPCI, (obj), TYPE_VIRTIO_CRYPTO_PCI)
379 
380 struct VirtIOCryptoPCI {
381     VirtIOPCIProxy parent_obj;
382     VirtIOCrypto vdev;
383 };
384 
385 /* Virtio ABI version, if we increment this, we break the guest driver. */
386 #define VIRTIO_PCI_ABI_VERSION          0
387 
388 /* Input for virtio_pci_types_register() */
389 typedef struct VirtioPCIDeviceTypeInfo {
390     /*
391      * Common base class for the subclasses below.
392      *
393      * Required only if transitional_name or non_transitional_name is set.
394      *
395      * We need a separate base type instead of making all types
396      * inherit from generic_name for two reasons:
397      * 1) generic_name implements INTERFACE_PCIE_DEVICE, but
398      *    transitional_name does not.
399      * 2) generic_name has the "disable-legacy" and "disable-modern"
400      *    properties, transitional_name and non_transitional name don't.
401      */
402     const char *base_name;
403     /*
404      * Generic device type.  Optional.
405      *
406      * Supports both transitional and non-transitional modes,
407      * using the disable-legacy and disable-modern properties.
408      * If disable-legacy=auto, (non-)transitional mode is selected
409      * depending on the bus where the device is plugged.
410      *
411      * Implements both INTERFACE_PCIE_DEVICE and INTERFACE_CONVENTIONAL_PCI_DEVICE,
412      * but PCI Express is supported only in non-transitional mode.
413      *
414      * The only type implemented by QEMU 3.1 and older.
415      */
416     const char *generic_name;
417     /*
418      * The transitional device type.  Optional.
419      *
420      * Implements both INTERFACE_PCIE_DEVICE and INTERFACE_CONVENTIONAL_PCI_DEVICE.
421      */
422     const char *transitional_name;
423     /*
424      * The non-transitional device type.  Optional.
425      *
426      * Implements INTERFACE_CONVENTIONAL_PCI_DEVICE only.
427      */
428     const char *non_transitional_name;
429 
430     /* Parent type.  If NULL, TYPE_VIRTIO_PCI is used */
431     const char *parent;
432 
433     /* Same as TypeInfo fields: */
434     size_t instance_size;
435     void (*instance_init)(Object *obj);
436     void (*class_init)(ObjectClass *klass, void *data);
437 } VirtioPCIDeviceTypeInfo;
438 
439 /* Register virtio-pci type(s).  @t must be static. */
440 void virtio_pci_types_register(const VirtioPCIDeviceTypeInfo *t);
441 
442 #endif
443