4 * Copyright IBM, Corp. 2007
5 * Copyright (c) 2009 CodeSourcery
8 * Anthony Liguori <aliguori@us.ibm.com>
9 * Paul Brook <paul@codesourcery.com>
11 * This work is licensed under the terms of the GNU GPL, version 2. See
12 * the COPYING file in the top-level directory.
19 #include "virtio-blk.h"
20 #include "virtio-net.h"
21 #include "virtio-serial.h"
23 #include "qemu-error.h"
29 #include "virtio-pci.h"
31 /* from Linux's linux/virtio_pci.h */
33 /* A 32-bit r/o bitmask of the features supported by the host */
34 #define VIRTIO_PCI_HOST_FEATURES 0
36 /* A 32-bit r/w bitmask of features activated by the guest */
37 #define VIRTIO_PCI_GUEST_FEATURES 4
39 /* A 32-bit r/w PFN for the currently selected queue */
40 #define VIRTIO_PCI_QUEUE_PFN 8
42 /* A 16-bit r/o queue size for the currently selected queue */
43 #define VIRTIO_PCI_QUEUE_NUM 12
45 /* A 16-bit r/w queue selector */
46 #define VIRTIO_PCI_QUEUE_SEL 14
48 /* A 16-bit r/w queue notifier */
49 #define VIRTIO_PCI_QUEUE_NOTIFY 16
51 /* An 8-bit device status register. */
52 #define VIRTIO_PCI_STATUS 18
54 /* An 8-bit r/o interrupt status register. Reading the value will return the
55 * current contents of the ISR and will also clear it. This is effectively
56 * a read-and-acknowledge. */
57 #define VIRTIO_PCI_ISR 19
59 /* MSI-X registers: only enabled if MSI-X is enabled. */
60 /* A 16-bit vector for configuration changes. */
61 #define VIRTIO_MSI_CONFIG_VECTOR 20
62 /* A 16-bit vector for selected queue notifications. */
63 #define VIRTIO_MSI_QUEUE_VECTOR 22
65 /* Config space size */
66 #define VIRTIO_PCI_CONFIG_NOMSI 20
67 #define VIRTIO_PCI_CONFIG_MSI 24
68 #define VIRTIO_PCI_REGION_SIZE(dev) (msix_present(dev) ? \
69 VIRTIO_PCI_CONFIG_MSI : \
70 VIRTIO_PCI_CONFIG_NOMSI)
72 /* The remaining space is defined by each driver as the per-driver
73 * configuration space */
74 #define VIRTIO_PCI_CONFIG(dev) (msix_enabled(dev) ? \
75 VIRTIO_PCI_CONFIG_MSI : \
76 VIRTIO_PCI_CONFIG_NOMSI)
78 /* How many bits to shift physical queue address written to QUEUE_PFN.
79 * 12 is historical, and due to x86 page size. */
80 #define VIRTIO_PCI_QUEUE_ADDR_SHIFT 12
82 /* Flags track per-device state like workarounds for quirks in older guests. */
83 #define VIRTIO_PCI_FLAG_BUS_MASTER_BUG (1 << 0)
85 /* Performance improves when virtqueue kick processing is decoupled from the
86 * vcpu thread using ioeventfd for some devices. */
87 #define VIRTIO_PCI_FLAG_USE_IOEVENTFD_BIT 1
88 #define VIRTIO_PCI_FLAG_USE_IOEVENTFD (1 << VIRTIO_PCI_FLAG_USE_IOEVENTFD_BIT)
90 /* QEMU doesn't strictly need write barriers since everything runs in
91 * lock-step. We'll leave the calls to wmb() in though to make it obvious for
92 * KVM or if kqemu gets SMP support.
94 #define wmb() do { } while (0)
98 static void virtio_pci_notify(void *opaque
, uint16_t vector
)
100 VirtIOPCIProxy
*proxy
= opaque
;
101 if (msix_enabled(&proxy
->pci_dev
))
102 msix_notify(&proxy
->pci_dev
, vector
);
104 qemu_set_irq(proxy
->pci_dev
.irq
[0], proxy
->vdev
->isr
& 1);
107 static void virtio_pci_save_config(void * opaque
, QEMUFile
*f
)
109 VirtIOPCIProxy
*proxy
= opaque
;
110 pci_device_save(&proxy
->pci_dev
, f
);
111 msix_save(&proxy
->pci_dev
, f
);
112 if (msix_present(&proxy
->pci_dev
))
113 qemu_put_be16(f
, proxy
->vdev
->config_vector
);
116 static void virtio_pci_save_queue(void * opaque
, int n
, QEMUFile
*f
)
118 VirtIOPCIProxy
*proxy
= opaque
;
119 if (msix_present(&proxy
->pci_dev
))
120 qemu_put_be16(f
, virtio_queue_vector(proxy
->vdev
, n
));
123 static int virtio_pci_load_config(void * opaque
, QEMUFile
*f
)
125 VirtIOPCIProxy
*proxy
= opaque
;
127 ret
= pci_device_load(&proxy
->pci_dev
, f
);
131 msix_load(&proxy
->pci_dev
, f
);
132 if (msix_present(&proxy
->pci_dev
)) {
133 qemu_get_be16s(f
, &proxy
->vdev
->config_vector
);
135 proxy
->vdev
->config_vector
= VIRTIO_NO_VECTOR
;
137 if (proxy
->vdev
->config_vector
!= VIRTIO_NO_VECTOR
) {
138 return msix_vector_use(&proxy
->pci_dev
, proxy
->vdev
->config_vector
);
143 static int virtio_pci_load_queue(void * opaque
, int n
, QEMUFile
*f
)
145 VirtIOPCIProxy
*proxy
= opaque
;
147 if (msix_present(&proxy
->pci_dev
)) {
148 qemu_get_be16s(f
, &vector
);
150 vector
= VIRTIO_NO_VECTOR
;
152 virtio_queue_set_vector(proxy
->vdev
, n
, vector
);
153 if (vector
!= VIRTIO_NO_VECTOR
) {
154 return msix_vector_use(&proxy
->pci_dev
, vector
);
159 static int virtio_pci_set_host_notifier_internal(VirtIOPCIProxy
*proxy
,
162 VirtQueue
*vq
= virtio_get_queue(proxy
->vdev
, n
);
163 EventNotifier
*notifier
= virtio_queue_get_host_notifier(vq
);
166 r
= event_notifier_init(notifier
, 1);
168 error_report("%s: unable to init event notifier: %d",
172 r
= kvm_set_ioeventfd_pio_word(event_notifier_get_fd(notifier
),
173 proxy
->addr
+ VIRTIO_PCI_QUEUE_NOTIFY
,
176 error_report("%s: unable to map ioeventfd: %d",
178 event_notifier_cleanup(notifier
);
181 r
= kvm_set_ioeventfd_pio_word(event_notifier_get_fd(notifier
),
182 proxy
->addr
+ VIRTIO_PCI_QUEUE_NOTIFY
,
185 error_report("%s: unable to unmap ioeventfd: %d",
190 /* Handle the race condition where the guest kicked and we deassigned
191 * before we got around to handling the kick.
193 if (event_notifier_test_and_clear(notifier
)) {
194 virtio_queue_notify_vq(vq
);
197 event_notifier_cleanup(notifier
);
202 static void virtio_pci_host_notifier_read(void *opaque
)
204 VirtQueue
*vq
= opaque
;
205 EventNotifier
*n
= virtio_queue_get_host_notifier(vq
);
206 if (event_notifier_test_and_clear(n
)) {
207 virtio_queue_notify_vq(vq
);
211 static void virtio_pci_set_host_notifier_fd_handler(VirtIOPCIProxy
*proxy
,
214 VirtQueue
*vq
= virtio_get_queue(proxy
->vdev
, n
);
215 EventNotifier
*notifier
= virtio_queue_get_host_notifier(vq
);
217 qemu_set_fd_handler(event_notifier_get_fd(notifier
),
218 virtio_pci_host_notifier_read
, NULL
, vq
);
220 qemu_set_fd_handler(event_notifier_get_fd(notifier
),
225 static void virtio_pci_start_ioeventfd(VirtIOPCIProxy
*proxy
)
229 if (!(proxy
->flags
& VIRTIO_PCI_FLAG_USE_IOEVENTFD
) ||
230 proxy
->ioeventfd_disabled
||
231 proxy
->ioeventfd_started
) {
235 for (n
= 0; n
< VIRTIO_PCI_QUEUE_MAX
; n
++) {
236 if (!virtio_queue_get_num(proxy
->vdev
, n
)) {
240 r
= virtio_pci_set_host_notifier_internal(proxy
, n
, true);
245 virtio_pci_set_host_notifier_fd_handler(proxy
, n
, true);
247 proxy
->ioeventfd_started
= true;
252 if (!virtio_queue_get_num(proxy
->vdev
, n
)) {
256 virtio_pci_set_host_notifier_fd_handler(proxy
, n
, false);
257 r
= virtio_pci_set_host_notifier_internal(proxy
, n
, false);
260 proxy
->ioeventfd_started
= false;
261 error_report("%s: failed. Fallback to a userspace (slower).", __func__
);
264 static void virtio_pci_stop_ioeventfd(VirtIOPCIProxy
*proxy
)
269 if (!proxy
->ioeventfd_started
) {
273 for (n
= 0; n
< VIRTIO_PCI_QUEUE_MAX
; n
++) {
274 if (!virtio_queue_get_num(proxy
->vdev
, n
)) {
278 virtio_pci_set_host_notifier_fd_handler(proxy
, n
, false);
279 r
= virtio_pci_set_host_notifier_internal(proxy
, n
, false);
282 proxy
->ioeventfd_started
= false;
285 static void virtio_pci_reset(DeviceState
*d
)
287 VirtIOPCIProxy
*proxy
= container_of(d
, VirtIOPCIProxy
, pci_dev
.qdev
);
288 virtio_pci_stop_ioeventfd(proxy
);
289 virtio_reset(proxy
->vdev
);
290 msix_reset(&proxy
->pci_dev
);
291 proxy
->flags
&= ~VIRTIO_PCI_FLAG_BUS_MASTER_BUG
;
294 static void virtio_ioport_write(void *opaque
, uint32_t addr
, uint32_t val
)
296 VirtIOPCIProxy
*proxy
= opaque
;
297 VirtIODevice
*vdev
= proxy
->vdev
;
298 target_phys_addr_t pa
;
301 case VIRTIO_PCI_GUEST_FEATURES
:
302 /* Guest does not negotiate properly? We have to assume nothing. */
303 if (val
& (1 << VIRTIO_F_BAD_FEATURE
)) {
304 if (vdev
->bad_features
)
305 val
= proxy
->host_features
& vdev
->bad_features(vdev
);
309 if (vdev
->set_features
)
310 vdev
->set_features(vdev
, val
);
311 vdev
->guest_features
= val
;
313 case VIRTIO_PCI_QUEUE_PFN
:
314 pa
= (target_phys_addr_t
)val
<< VIRTIO_PCI_QUEUE_ADDR_SHIFT
;
316 virtio_pci_stop_ioeventfd(proxy
);
317 virtio_reset(proxy
->vdev
);
318 msix_unuse_all_vectors(&proxy
->pci_dev
);
321 virtio_queue_set_addr(vdev
, vdev
->queue_sel
, pa
);
323 case VIRTIO_PCI_QUEUE_SEL
:
324 if (val
< VIRTIO_PCI_QUEUE_MAX
)
325 vdev
->queue_sel
= val
;
327 case VIRTIO_PCI_QUEUE_NOTIFY
:
328 if (val
< VIRTIO_PCI_QUEUE_MAX
) {
329 virtio_queue_notify(vdev
, val
);
332 case VIRTIO_PCI_STATUS
:
333 if (!(val
& VIRTIO_CONFIG_S_DRIVER_OK
)) {
334 virtio_pci_stop_ioeventfd(proxy
);
337 virtio_set_status(vdev
, val
& 0xFF);
339 if (val
& VIRTIO_CONFIG_S_DRIVER_OK
) {
340 virtio_pci_start_ioeventfd(proxy
);
343 if (vdev
->status
== 0) {
344 virtio_reset(proxy
->vdev
);
345 msix_unuse_all_vectors(&proxy
->pci_dev
);
348 /* Linux before 2.6.34 sets the device as OK without enabling
349 the PCI device bus master bit. In this case we need to disable
350 some safety checks. */
351 if ((val
& VIRTIO_CONFIG_S_DRIVER_OK
) &&
352 !(proxy
->pci_dev
.config
[PCI_COMMAND
] & PCI_COMMAND_MASTER
)) {
353 proxy
->flags
|= VIRTIO_PCI_FLAG_BUS_MASTER_BUG
;
356 case VIRTIO_MSI_CONFIG_VECTOR
:
357 msix_vector_unuse(&proxy
->pci_dev
, vdev
->config_vector
);
358 /* Make it possible for guest to discover an error took place. */
359 if (msix_vector_use(&proxy
->pci_dev
, val
) < 0)
360 val
= VIRTIO_NO_VECTOR
;
361 vdev
->config_vector
= val
;
363 case VIRTIO_MSI_QUEUE_VECTOR
:
364 msix_vector_unuse(&proxy
->pci_dev
,
365 virtio_queue_vector(vdev
, vdev
->queue_sel
));
366 /* Make it possible for guest to discover an error took place. */
367 if (msix_vector_use(&proxy
->pci_dev
, val
) < 0)
368 val
= VIRTIO_NO_VECTOR
;
369 virtio_queue_set_vector(vdev
, vdev
->queue_sel
, val
);
372 error_report("%s: unexpected address 0x%x value 0x%x",
373 __func__
, addr
, val
);
378 static uint32_t virtio_ioport_read(VirtIOPCIProxy
*proxy
, uint32_t addr
)
380 VirtIODevice
*vdev
= proxy
->vdev
;
381 uint32_t ret
= 0xFFFFFFFF;
384 case VIRTIO_PCI_HOST_FEATURES
:
385 ret
= proxy
->host_features
;
387 case VIRTIO_PCI_GUEST_FEATURES
:
388 ret
= vdev
->guest_features
;
390 case VIRTIO_PCI_QUEUE_PFN
:
391 ret
= virtio_queue_get_addr(vdev
, vdev
->queue_sel
)
392 >> VIRTIO_PCI_QUEUE_ADDR_SHIFT
;
394 case VIRTIO_PCI_QUEUE_NUM
:
395 ret
= virtio_queue_get_num(vdev
, vdev
->queue_sel
);
397 case VIRTIO_PCI_QUEUE_SEL
:
398 ret
= vdev
->queue_sel
;
400 case VIRTIO_PCI_STATUS
:
404 /* reading from the ISR also clears it. */
407 qemu_set_irq(proxy
->pci_dev
.irq
[0], 0);
409 case VIRTIO_MSI_CONFIG_VECTOR
:
410 ret
= vdev
->config_vector
;
412 case VIRTIO_MSI_QUEUE_VECTOR
:
413 ret
= virtio_queue_vector(vdev
, vdev
->queue_sel
);
422 static uint32_t virtio_pci_config_readb(void *opaque
, uint32_t addr
)
424 VirtIOPCIProxy
*proxy
= opaque
;
425 uint32_t config
= VIRTIO_PCI_CONFIG(&proxy
->pci_dev
);
428 return virtio_ioport_read(proxy
, addr
);
430 return virtio_config_readb(proxy
->vdev
, addr
);
433 static uint32_t virtio_pci_config_readw(void *opaque
, uint32_t addr
)
435 VirtIOPCIProxy
*proxy
= opaque
;
436 uint32_t config
= VIRTIO_PCI_CONFIG(&proxy
->pci_dev
);
439 return virtio_ioport_read(proxy
, addr
);
441 return virtio_config_readw(proxy
->vdev
, addr
);
444 static uint32_t virtio_pci_config_readl(void *opaque
, uint32_t addr
)
446 VirtIOPCIProxy
*proxy
= opaque
;
447 uint32_t config
= VIRTIO_PCI_CONFIG(&proxy
->pci_dev
);
450 return virtio_ioport_read(proxy
, addr
);
452 return virtio_config_readl(proxy
->vdev
, addr
);
455 static void virtio_pci_config_writeb(void *opaque
, uint32_t addr
, uint32_t val
)
457 VirtIOPCIProxy
*proxy
= opaque
;
458 uint32_t config
= VIRTIO_PCI_CONFIG(&proxy
->pci_dev
);
461 virtio_ioport_write(proxy
, addr
, val
);
465 virtio_config_writeb(proxy
->vdev
, addr
, val
);
468 static void virtio_pci_config_writew(void *opaque
, uint32_t addr
, uint32_t val
)
470 VirtIOPCIProxy
*proxy
= opaque
;
471 uint32_t config
= VIRTIO_PCI_CONFIG(&proxy
->pci_dev
);
474 virtio_ioport_write(proxy
, addr
, val
);
478 virtio_config_writew(proxy
->vdev
, addr
, val
);
481 static void virtio_pci_config_writel(void *opaque
, uint32_t addr
, uint32_t val
)
483 VirtIOPCIProxy
*proxy
= opaque
;
484 uint32_t config
= VIRTIO_PCI_CONFIG(&proxy
->pci_dev
);
487 virtio_ioport_write(proxy
, addr
, val
);
491 virtio_config_writel(proxy
->vdev
, addr
, val
);
494 static void virtio_map(PCIDevice
*pci_dev
, int region_num
,
495 pcibus_t addr
, pcibus_t size
, int type
)
497 VirtIOPCIProxy
*proxy
= container_of(pci_dev
, VirtIOPCIProxy
, pci_dev
);
498 VirtIODevice
*vdev
= proxy
->vdev
;
499 unsigned config_len
= VIRTIO_PCI_REGION_SIZE(pci_dev
) + vdev
->config_len
;
503 register_ioport_write(addr
, config_len
, 1, virtio_pci_config_writeb
, proxy
);
504 register_ioport_write(addr
, config_len
, 2, virtio_pci_config_writew
, proxy
);
505 register_ioport_write(addr
, config_len
, 4, virtio_pci_config_writel
, proxy
);
506 register_ioport_read(addr
, config_len
, 1, virtio_pci_config_readb
, proxy
);
507 register_ioport_read(addr
, config_len
, 2, virtio_pci_config_readw
, proxy
);
508 register_ioport_read(addr
, config_len
, 4, virtio_pci_config_readl
, proxy
);
510 if (vdev
->config_len
)
511 vdev
->get_config(vdev
, vdev
->config
);
514 static void virtio_write_config(PCIDevice
*pci_dev
, uint32_t address
,
515 uint32_t val
, int len
)
517 VirtIOPCIProxy
*proxy
= DO_UPCAST(VirtIOPCIProxy
, pci_dev
, pci_dev
);
519 if (PCI_COMMAND
== address
) {
520 if (!(val
& PCI_COMMAND_MASTER
)) {
521 if (!(proxy
->flags
& VIRTIO_PCI_FLAG_BUS_MASTER_BUG
)) {
522 virtio_pci_stop_ioeventfd(proxy
);
523 virtio_set_status(proxy
->vdev
,
524 proxy
->vdev
->status
& ~VIRTIO_CONFIG_S_DRIVER_OK
);
529 pci_default_write_config(pci_dev
, address
, val
, len
);
530 msix_write_config(pci_dev
, address
, val
, len
);
533 static unsigned virtio_pci_get_features(void *opaque
)
535 VirtIOPCIProxy
*proxy
= opaque
;
536 return proxy
->host_features
;
539 static void virtio_pci_guest_notifier_read(void *opaque
)
541 VirtQueue
*vq
= opaque
;
542 EventNotifier
*n
= virtio_queue_get_guest_notifier(vq
);
543 if (event_notifier_test_and_clear(n
)) {
548 static int virtio_pci_set_guest_notifier(void *opaque
, int n
, bool assign
)
550 VirtIOPCIProxy
*proxy
= opaque
;
551 VirtQueue
*vq
= virtio_get_queue(proxy
->vdev
, n
);
552 EventNotifier
*notifier
= virtio_queue_get_guest_notifier(vq
);
555 int r
= event_notifier_init(notifier
, 0);
559 qemu_set_fd_handler(event_notifier_get_fd(notifier
),
560 virtio_pci_guest_notifier_read
, NULL
, vq
);
562 qemu_set_fd_handler(event_notifier_get_fd(notifier
),
564 event_notifier_cleanup(notifier
);
570 static bool virtio_pci_query_guest_notifiers(void *opaque
)
572 VirtIOPCIProxy
*proxy
= opaque
;
573 return msix_enabled(&proxy
->pci_dev
);
576 static int virtio_pci_set_guest_notifiers(void *opaque
, bool assign
)
578 VirtIOPCIProxy
*proxy
= opaque
;
579 VirtIODevice
*vdev
= proxy
->vdev
;
582 for (n
= 0; n
< VIRTIO_PCI_QUEUE_MAX
; n
++) {
583 if (!virtio_queue_get_num(vdev
, n
)) {
587 r
= virtio_pci_set_guest_notifier(opaque
, n
, assign
);
596 /* We get here on assignment failure. Recover by undoing for VQs 0 .. n. */
598 virtio_pci_set_guest_notifier(opaque
, n
, !assign
);
603 static int virtio_pci_set_host_notifier(void *opaque
, int n
, bool assign
)
605 VirtIOPCIProxy
*proxy
= opaque
;
607 /* Stop using ioeventfd for virtqueue kick if the device starts using host
608 * notifiers. This makes it easy to avoid stepping on each others' toes.
610 proxy
->ioeventfd_disabled
= assign
;
612 virtio_pci_stop_ioeventfd(proxy
);
614 /* We don't need to start here: it's not needed because backend
615 * currently only stops on status change away from ok,
616 * reset, vmstop and such. If we do add code to start here,
617 * need to check vmstate, device state etc. */
618 return virtio_pci_set_host_notifier_internal(proxy
, n
, assign
);
621 static void virtio_pci_vmstate_change(void *opaque
, bool running
)
623 VirtIOPCIProxy
*proxy
= opaque
;
626 /* Try to find out if the guest has bus master disabled, but is
627 in ready state. Then we have a buggy guest OS. */
628 if ((proxy
->vdev
->status
& VIRTIO_CONFIG_S_DRIVER_OK
) &&
629 !(proxy
->pci_dev
.config
[PCI_COMMAND
] & PCI_COMMAND_MASTER
)) {
630 proxy
->flags
|= VIRTIO_PCI_FLAG_BUS_MASTER_BUG
;
632 virtio_pci_start_ioeventfd(proxy
);
634 virtio_pci_stop_ioeventfd(proxy
);
638 static const VirtIOBindings virtio_pci_bindings
= {
639 .notify
= virtio_pci_notify
,
640 .save_config
= virtio_pci_save_config
,
641 .load_config
= virtio_pci_load_config
,
642 .save_queue
= virtio_pci_save_queue
,
643 .load_queue
= virtio_pci_load_queue
,
644 .get_features
= virtio_pci_get_features
,
645 .query_guest_notifiers
= virtio_pci_query_guest_notifiers
,
646 .set_host_notifier
= virtio_pci_set_host_notifier
,
647 .set_guest_notifiers
= virtio_pci_set_guest_notifiers
,
648 .vmstate_change
= virtio_pci_vmstate_change
,
651 void virtio_init_pci(VirtIOPCIProxy
*proxy
, VirtIODevice
*vdev
)
658 config
= proxy
->pci_dev
.config
;
660 if (proxy
->class_code
) {
661 pci_config_set_class(config
, proxy
->class_code
);
663 pci_set_word(config
+ 0x2c, pci_get_word(config
+ PCI_VENDOR_ID
));
664 pci_set_word(config
+ 0x2e, vdev
->device_id
);
667 if (vdev
->nvectors
&& !msix_init(&proxy
->pci_dev
, vdev
->nvectors
, 1, 0)) {
668 pci_register_bar(&proxy
->pci_dev
, 1,
669 msix_bar_size(&proxy
->pci_dev
),
670 PCI_BASE_ADDRESS_SPACE_MEMORY
,
675 proxy
->pci_dev
.config_write
= virtio_write_config
;
677 size
= VIRTIO_PCI_REGION_SIZE(&proxy
->pci_dev
) + vdev
->config_len
;
679 size
= 1 << qemu_fls(size
);
681 pci_register_bar(&proxy
->pci_dev
, 0, size
, PCI_BASE_ADDRESS_SPACE_IO
,
684 if (!kvm_has_many_ioeventfds()) {
685 proxy
->flags
&= ~VIRTIO_PCI_FLAG_USE_IOEVENTFD
;
688 virtio_bind_device(vdev
, &virtio_pci_bindings
, proxy
);
689 proxy
->host_features
|= 0x1 << VIRTIO_F_NOTIFY_ON_EMPTY
;
690 proxy
->host_features
|= 0x1 << VIRTIO_F_BAD_FEATURE
;
691 proxy
->host_features
= vdev
->get_features(vdev
, proxy
->host_features
);
694 static int virtio_blk_init_pci(PCIDevice
*pci_dev
)
696 VirtIOPCIProxy
*proxy
= DO_UPCAST(VirtIOPCIProxy
, pci_dev
, pci_dev
);
699 if (proxy
->class_code
!= PCI_CLASS_STORAGE_SCSI
&&
700 proxy
->class_code
!= PCI_CLASS_STORAGE_OTHER
)
701 proxy
->class_code
= PCI_CLASS_STORAGE_SCSI
;
703 vdev
= virtio_blk_init(&pci_dev
->qdev
, &proxy
->block
,
704 &proxy
->block_serial
);
708 vdev
->nvectors
= proxy
->nvectors
;
709 virtio_init_pci(proxy
, vdev
);
710 /* make the actual value visible */
711 proxy
->nvectors
= vdev
->nvectors
;
715 static int virtio_exit_pci(PCIDevice
*pci_dev
)
717 return msix_uninit(pci_dev
);
720 static int virtio_blk_exit_pci(PCIDevice
*pci_dev
)
722 VirtIOPCIProxy
*proxy
= DO_UPCAST(VirtIOPCIProxy
, pci_dev
, pci_dev
);
724 virtio_pci_stop_ioeventfd(proxy
);
725 virtio_blk_exit(proxy
->vdev
);
726 blockdev_mark_auto_del(proxy
->block
.bs
);
727 return virtio_exit_pci(pci_dev
);
730 static int virtio_serial_init_pci(PCIDevice
*pci_dev
)
732 VirtIOPCIProxy
*proxy
= DO_UPCAST(VirtIOPCIProxy
, pci_dev
, pci_dev
);
735 if (proxy
->class_code
!= PCI_CLASS_COMMUNICATION_OTHER
&&
736 proxy
->class_code
!= PCI_CLASS_DISPLAY_OTHER
&& /* qemu 0.10 */
737 proxy
->class_code
!= PCI_CLASS_OTHERS
) /* qemu-kvm */
738 proxy
->class_code
= PCI_CLASS_COMMUNICATION_OTHER
;
740 vdev
= virtio_serial_init(&pci_dev
->qdev
, &proxy
->serial
);
744 vdev
->nvectors
= proxy
->nvectors
== DEV_NVECTORS_UNSPECIFIED
745 ? proxy
->serial
.max_virtserial_ports
+ 1
747 virtio_init_pci(proxy
, vdev
);
748 proxy
->nvectors
= vdev
->nvectors
;
752 static int virtio_serial_exit_pci(PCIDevice
*pci_dev
)
754 VirtIOPCIProxy
*proxy
= DO_UPCAST(VirtIOPCIProxy
, pci_dev
, pci_dev
);
756 virtio_pci_stop_ioeventfd(proxy
);
757 virtio_serial_exit(proxy
->vdev
);
758 return virtio_exit_pci(pci_dev
);
761 static int virtio_net_init_pci(PCIDevice
*pci_dev
)
763 VirtIOPCIProxy
*proxy
= DO_UPCAST(VirtIOPCIProxy
, pci_dev
, pci_dev
);
766 vdev
= virtio_net_init(&pci_dev
->qdev
, &proxy
->nic
, &proxy
->net
);
768 vdev
->nvectors
= proxy
->nvectors
;
769 virtio_init_pci(proxy
, vdev
);
771 /* make the actual value visible */
772 proxy
->nvectors
= vdev
->nvectors
;
776 static int virtio_net_exit_pci(PCIDevice
*pci_dev
)
778 VirtIOPCIProxy
*proxy
= DO_UPCAST(VirtIOPCIProxy
, pci_dev
, pci_dev
);
780 virtio_pci_stop_ioeventfd(proxy
);
781 virtio_net_exit(proxy
->vdev
);
782 return virtio_exit_pci(pci_dev
);
785 static int virtio_balloon_init_pci(PCIDevice
*pci_dev
)
787 VirtIOPCIProxy
*proxy
= DO_UPCAST(VirtIOPCIProxy
, pci_dev
, pci_dev
);
790 vdev
= virtio_balloon_init(&pci_dev
->qdev
);
794 virtio_init_pci(proxy
, vdev
);
798 static PCIDeviceInfo virtio_info
[] = {
800 .qdev
.name
= "virtio-blk-pci",
801 .qdev
.alias
= "virtio-blk",
802 .qdev
.size
= sizeof(VirtIOPCIProxy
),
803 .init
= virtio_blk_init_pci
,
804 .exit
= virtio_blk_exit_pci
,
805 .vendor_id
= PCI_VENDOR_ID_REDHAT_QUMRANET
,
806 .device_id
= PCI_DEVICE_ID_VIRTIO_BLOCK
,
807 .revision
= VIRTIO_PCI_ABI_VERSION
,
808 .class_id
= PCI_CLASS_STORAGE_SCSI
,
809 .qdev
.props
= (Property
[]) {
810 DEFINE_PROP_HEX32("class", VirtIOPCIProxy
, class_code
, 0),
811 DEFINE_BLOCK_PROPERTIES(VirtIOPCIProxy
, block
),
812 DEFINE_PROP_STRING("serial", VirtIOPCIProxy
, block_serial
),
813 DEFINE_PROP_BIT("ioeventfd", VirtIOPCIProxy
, flags
,
814 VIRTIO_PCI_FLAG_USE_IOEVENTFD_BIT
, true),
815 DEFINE_PROP_UINT32("vectors", VirtIOPCIProxy
, nvectors
, 2),
816 DEFINE_VIRTIO_BLK_FEATURES(VirtIOPCIProxy
, host_features
),
817 DEFINE_PROP_END_OF_LIST(),
819 .qdev
.reset
= virtio_pci_reset
,
821 .qdev
.name
= "virtio-net-pci",
822 .qdev
.alias
= "virtio-net",
823 .qdev
.size
= sizeof(VirtIOPCIProxy
),
824 .init
= virtio_net_init_pci
,
825 .exit
= virtio_net_exit_pci
,
826 .romfile
= "pxe-virtio.rom",
827 .vendor_id
= PCI_VENDOR_ID_REDHAT_QUMRANET
,
828 .device_id
= PCI_DEVICE_ID_VIRTIO_NET
,
829 .revision
= VIRTIO_PCI_ABI_VERSION
,
830 .class_id
= PCI_CLASS_NETWORK_ETHERNET
,
831 .qdev
.props
= (Property
[]) {
832 DEFINE_PROP_BIT("ioeventfd", VirtIOPCIProxy
, flags
,
833 VIRTIO_PCI_FLAG_USE_IOEVENTFD_BIT
, false),
834 DEFINE_PROP_UINT32("vectors", VirtIOPCIProxy
, nvectors
, 3),
835 DEFINE_VIRTIO_NET_FEATURES(VirtIOPCIProxy
, host_features
),
836 DEFINE_NIC_PROPERTIES(VirtIOPCIProxy
, nic
),
837 DEFINE_PROP_UINT32("x-txtimer", VirtIOPCIProxy
,
838 net
.txtimer
, TX_TIMER_INTERVAL
),
839 DEFINE_PROP_INT32("x-txburst", VirtIOPCIProxy
,
840 net
.txburst
, TX_BURST
),
841 DEFINE_PROP_STRING("tx", VirtIOPCIProxy
, net
.tx
),
842 DEFINE_PROP_END_OF_LIST(),
844 .qdev
.reset
= virtio_pci_reset
,
846 .qdev
.name
= "virtio-serial-pci",
847 .qdev
.alias
= "virtio-serial",
848 .qdev
.size
= sizeof(VirtIOPCIProxy
),
849 .init
= virtio_serial_init_pci
,
850 .exit
= virtio_serial_exit_pci
,
851 .vendor_id
= PCI_VENDOR_ID_REDHAT_QUMRANET
,
852 .device_id
= PCI_DEVICE_ID_VIRTIO_CONSOLE
,
853 .revision
= VIRTIO_PCI_ABI_VERSION
,
854 .class_id
= PCI_CLASS_COMMUNICATION_OTHER
,
855 .qdev
.props
= (Property
[]) {
856 DEFINE_PROP_BIT("ioeventfd", VirtIOPCIProxy
, flags
,
857 VIRTIO_PCI_FLAG_USE_IOEVENTFD_BIT
, true),
858 DEFINE_PROP_UINT32("vectors", VirtIOPCIProxy
, nvectors
,
859 DEV_NVECTORS_UNSPECIFIED
),
860 DEFINE_PROP_HEX32("class", VirtIOPCIProxy
, class_code
, 0),
861 DEFINE_VIRTIO_COMMON_FEATURES(VirtIOPCIProxy
, host_features
),
862 DEFINE_PROP_UINT32("max_ports", VirtIOPCIProxy
,
863 serial
.max_virtserial_ports
, 31),
864 DEFINE_PROP_END_OF_LIST(),
866 .qdev
.reset
= virtio_pci_reset
,
868 .qdev
.name
= "virtio-balloon-pci",
869 .qdev
.alias
= "virtio-balloon",
870 .qdev
.size
= sizeof(VirtIOPCIProxy
),
871 .init
= virtio_balloon_init_pci
,
872 .exit
= virtio_exit_pci
,
873 .vendor_id
= PCI_VENDOR_ID_REDHAT_QUMRANET
,
874 .device_id
= PCI_DEVICE_ID_VIRTIO_BALLOON
,
875 .revision
= VIRTIO_PCI_ABI_VERSION
,
876 .class_id
= PCI_CLASS_MEMORY_RAM
,
877 .qdev
.props
= (Property
[]) {
878 DEFINE_VIRTIO_COMMON_FEATURES(VirtIOPCIProxy
, host_features
),
879 DEFINE_PROP_END_OF_LIST(),
881 .qdev
.reset
= virtio_pci_reset
,
887 static void virtio_pci_register_devices(void)
889 pci_qdev_register_many(virtio_info
);
892 device_init(virtio_pci_register_devices
)