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