PPC: e500: msync is 440 only, e500 has real sync
[qemu.git] / hw / virtio-pci.c
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 * Contributions after 2012-01-13 are licensed under the terms of the
15 * GNU GPL, version 2 or (at your option) any later version.
16 */
17
18 #include <inttypes.h>
19
20 #include "virtio.h"
21 #include "virtio-blk.h"
22 #include "virtio-net.h"
23 #include "virtio-serial.h"
24 #include "pci.h"
25 #include "qemu-error.h"
26 #include "msix.h"
27 #include "net.h"
28 #include "loader.h"
29 #include "kvm.h"
30 #include "blockdev.h"
31 #include "virtio-pci.h"
32 #include "range.h"
33
34 /* from Linux's linux/virtio_pci.h */
35
36 /* A 32-bit r/o bitmask of the features supported by the host */
37 #define VIRTIO_PCI_HOST_FEATURES 0
38
39 /* A 32-bit r/w bitmask of features activated by the guest */
40 #define VIRTIO_PCI_GUEST_FEATURES 4
41
42 /* A 32-bit r/w PFN for the currently selected queue */
43 #define VIRTIO_PCI_QUEUE_PFN 8
44
45 /* A 16-bit r/o queue size for the currently selected queue */
46 #define VIRTIO_PCI_QUEUE_NUM 12
47
48 /* A 16-bit r/w queue selector */
49 #define VIRTIO_PCI_QUEUE_SEL 14
50
51 /* A 16-bit r/w queue notifier */
52 #define VIRTIO_PCI_QUEUE_NOTIFY 16
53
54 /* An 8-bit device status register. */
55 #define VIRTIO_PCI_STATUS 18
56
57 /* An 8-bit r/o interrupt status register. Reading the value will return the
58 * current contents of the ISR and will also clear it. This is effectively
59 * a read-and-acknowledge. */
60 #define VIRTIO_PCI_ISR 19
61
62 /* MSI-X registers: only enabled if MSI-X is enabled. */
63 /* A 16-bit vector for configuration changes. */
64 #define VIRTIO_MSI_CONFIG_VECTOR 20
65 /* A 16-bit vector for selected queue notifications. */
66 #define VIRTIO_MSI_QUEUE_VECTOR 22
67
68 /* Config space size */
69 #define VIRTIO_PCI_CONFIG_NOMSI 20
70 #define VIRTIO_PCI_CONFIG_MSI 24
71 #define VIRTIO_PCI_REGION_SIZE(dev) (msix_present(dev) ? \
72 VIRTIO_PCI_CONFIG_MSI : \
73 VIRTIO_PCI_CONFIG_NOMSI)
74
75 /* The remaining space is defined by each driver as the per-driver
76 * configuration space */
77 #define VIRTIO_PCI_CONFIG(dev) (msix_enabled(dev) ? \
78 VIRTIO_PCI_CONFIG_MSI : \
79 VIRTIO_PCI_CONFIG_NOMSI)
80
81 /* How many bits to shift physical queue address written to QUEUE_PFN.
82 * 12 is historical, and due to x86 page size. */
83 #define VIRTIO_PCI_QUEUE_ADDR_SHIFT 12
84
85 /* Flags track per-device state like workarounds for quirks in older guests. */
86 #define VIRTIO_PCI_FLAG_BUS_MASTER_BUG (1 << 0)
87
88 /* QEMU doesn't strictly need write barriers since everything runs in
89 * lock-step. We'll leave the calls to wmb() in though to make it obvious for
90 * KVM or if kqemu gets SMP support.
91 */
92 #define wmb() do { } while (0)
93
94 /* HACK for virtio to determine if it's running a big endian guest */
95 bool virtio_is_big_endian(void);
96
97 /* virtio device */
98
99 static void virtio_pci_notify(void *opaque, uint16_t vector)
100 {
101 VirtIOPCIProxy *proxy = opaque;
102 if (msix_enabled(&proxy->pci_dev))
103 msix_notify(&proxy->pci_dev, vector);
104 else
105 qemu_set_irq(proxy->pci_dev.irq[0], proxy->vdev->isr & 1);
106 }
107
108 static void virtio_pci_save_config(void * opaque, QEMUFile *f)
109 {
110 VirtIOPCIProxy *proxy = opaque;
111 pci_device_save(&proxy->pci_dev, f);
112 msix_save(&proxy->pci_dev, f);
113 if (msix_present(&proxy->pci_dev))
114 qemu_put_be16(f, proxy->vdev->config_vector);
115 }
116
117 static void virtio_pci_save_queue(void * opaque, int n, QEMUFile *f)
118 {
119 VirtIOPCIProxy *proxy = opaque;
120 if (msix_present(&proxy->pci_dev))
121 qemu_put_be16(f, virtio_queue_vector(proxy->vdev, n));
122 }
123
124 static int virtio_pci_load_config(void * opaque, QEMUFile *f)
125 {
126 VirtIOPCIProxy *proxy = opaque;
127 int ret;
128 ret = pci_device_load(&proxy->pci_dev, f);
129 if (ret) {
130 return ret;
131 }
132 msix_load(&proxy->pci_dev, f);
133 if (msix_present(&proxy->pci_dev)) {
134 qemu_get_be16s(f, &proxy->vdev->config_vector);
135 } else {
136 proxy->vdev->config_vector = VIRTIO_NO_VECTOR;
137 }
138 if (proxy->vdev->config_vector != VIRTIO_NO_VECTOR) {
139 return msix_vector_use(&proxy->pci_dev, proxy->vdev->config_vector);
140 }
141 return 0;
142 }
143
144 static int virtio_pci_load_queue(void * opaque, int n, QEMUFile *f)
145 {
146 VirtIOPCIProxy *proxy = opaque;
147 uint16_t vector;
148 if (msix_present(&proxy->pci_dev)) {
149 qemu_get_be16s(f, &vector);
150 } else {
151 vector = VIRTIO_NO_VECTOR;
152 }
153 virtio_queue_set_vector(proxy->vdev, n, vector);
154 if (vector != VIRTIO_NO_VECTOR) {
155 return msix_vector_use(&proxy->pci_dev, vector);
156 }
157 return 0;
158 }
159
160 static int virtio_pci_set_host_notifier_internal(VirtIOPCIProxy *proxy,
161 int n, bool assign)
162 {
163 VirtQueue *vq = virtio_get_queue(proxy->vdev, n);
164 EventNotifier *notifier = virtio_queue_get_host_notifier(vq);
165 int r = 0;
166
167 if (assign) {
168 r = event_notifier_init(notifier, 1);
169 if (r < 0) {
170 error_report("%s: unable to init event notifier: %d",
171 __func__, r);
172 return r;
173 }
174 memory_region_add_eventfd(&proxy->bar, VIRTIO_PCI_QUEUE_NOTIFY, 2,
175 true, n, event_notifier_get_fd(notifier));
176 } else {
177 memory_region_del_eventfd(&proxy->bar, VIRTIO_PCI_QUEUE_NOTIFY, 2,
178 true, n, event_notifier_get_fd(notifier));
179 /* Handle the race condition where the guest kicked and we deassigned
180 * before we got around to handling the kick.
181 */
182 if (event_notifier_test_and_clear(notifier)) {
183 virtio_queue_notify_vq(vq);
184 }
185
186 event_notifier_cleanup(notifier);
187 }
188 return r;
189 }
190
191 static void virtio_pci_host_notifier_read(void *opaque)
192 {
193 VirtQueue *vq = opaque;
194 EventNotifier *n = virtio_queue_get_host_notifier(vq);
195 if (event_notifier_test_and_clear(n)) {
196 virtio_queue_notify_vq(vq);
197 }
198 }
199
200 static void virtio_pci_set_host_notifier_fd_handler(VirtIOPCIProxy *proxy,
201 int n, bool assign)
202 {
203 VirtQueue *vq = virtio_get_queue(proxy->vdev, n);
204 EventNotifier *notifier = virtio_queue_get_host_notifier(vq);
205 if (assign) {
206 qemu_set_fd_handler(event_notifier_get_fd(notifier),
207 virtio_pci_host_notifier_read, NULL, vq);
208 } else {
209 qemu_set_fd_handler(event_notifier_get_fd(notifier),
210 NULL, NULL, NULL);
211 }
212 }
213
214 static void virtio_pci_start_ioeventfd(VirtIOPCIProxy *proxy)
215 {
216 int n, r;
217
218 if (!(proxy->flags & VIRTIO_PCI_FLAG_USE_IOEVENTFD) ||
219 proxy->ioeventfd_disabled ||
220 proxy->ioeventfd_started) {
221 return;
222 }
223
224 for (n = 0; n < VIRTIO_PCI_QUEUE_MAX; n++) {
225 if (!virtio_queue_get_num(proxy->vdev, n)) {
226 continue;
227 }
228
229 r = virtio_pci_set_host_notifier_internal(proxy, n, true);
230 if (r < 0) {
231 goto assign_error;
232 }
233
234 virtio_pci_set_host_notifier_fd_handler(proxy, n, true);
235 }
236 proxy->ioeventfd_started = true;
237 return;
238
239 assign_error:
240 while (--n >= 0) {
241 if (!virtio_queue_get_num(proxy->vdev, n)) {
242 continue;
243 }
244
245 virtio_pci_set_host_notifier_fd_handler(proxy, n, false);
246 r = virtio_pci_set_host_notifier_internal(proxy, n, false);
247 assert(r >= 0);
248 }
249 proxy->ioeventfd_started = false;
250 error_report("%s: failed. Fallback to a userspace (slower).", __func__);
251 }
252
253 static void virtio_pci_stop_ioeventfd(VirtIOPCIProxy *proxy)
254 {
255 int r;
256 int n;
257
258 if (!proxy->ioeventfd_started) {
259 return;
260 }
261
262 for (n = 0; n < VIRTIO_PCI_QUEUE_MAX; n++) {
263 if (!virtio_queue_get_num(proxy->vdev, n)) {
264 continue;
265 }
266
267 virtio_pci_set_host_notifier_fd_handler(proxy, n, false);
268 r = virtio_pci_set_host_notifier_internal(proxy, n, false);
269 assert(r >= 0);
270 }
271 proxy->ioeventfd_started = false;
272 }
273
274 void virtio_pci_reset(DeviceState *d)
275 {
276 VirtIOPCIProxy *proxy = container_of(d, VirtIOPCIProxy, pci_dev.qdev);
277 virtio_pci_stop_ioeventfd(proxy);
278 virtio_reset(proxy->vdev);
279 msix_reset(&proxy->pci_dev);
280 proxy->flags &= ~VIRTIO_PCI_FLAG_BUS_MASTER_BUG;
281 }
282
283 static void virtio_ioport_write(void *opaque, uint32_t addr, uint32_t val)
284 {
285 VirtIOPCIProxy *proxy = opaque;
286 VirtIODevice *vdev = proxy->vdev;
287 target_phys_addr_t pa;
288
289 switch (addr) {
290 case VIRTIO_PCI_GUEST_FEATURES:
291 /* Guest does not negotiate properly? We have to assume nothing. */
292 if (val & (1 << VIRTIO_F_BAD_FEATURE)) {
293 val = vdev->bad_features ? vdev->bad_features(vdev) : 0;
294 }
295 virtio_set_features(vdev, val);
296 break;
297 case VIRTIO_PCI_QUEUE_PFN:
298 pa = (target_phys_addr_t)val << VIRTIO_PCI_QUEUE_ADDR_SHIFT;
299 if (pa == 0) {
300 virtio_pci_stop_ioeventfd(proxy);
301 virtio_reset(proxy->vdev);
302 msix_unuse_all_vectors(&proxy->pci_dev);
303 }
304 else
305 virtio_queue_set_addr(vdev, vdev->queue_sel, pa);
306 break;
307 case VIRTIO_PCI_QUEUE_SEL:
308 if (val < VIRTIO_PCI_QUEUE_MAX)
309 vdev->queue_sel = val;
310 break;
311 case VIRTIO_PCI_QUEUE_NOTIFY:
312 if (val < VIRTIO_PCI_QUEUE_MAX) {
313 virtio_queue_notify(vdev, val);
314 }
315 break;
316 case VIRTIO_PCI_STATUS:
317 if (!(val & VIRTIO_CONFIG_S_DRIVER_OK)) {
318 virtio_pci_stop_ioeventfd(proxy);
319 }
320
321 virtio_set_status(vdev, val & 0xFF);
322
323 if (val & VIRTIO_CONFIG_S_DRIVER_OK) {
324 virtio_pci_start_ioeventfd(proxy);
325 }
326
327 if (vdev->status == 0) {
328 virtio_reset(proxy->vdev);
329 msix_unuse_all_vectors(&proxy->pci_dev);
330 }
331
332 /* Linux before 2.6.34 sets the device as OK without enabling
333 the PCI device bus master bit. In this case we need to disable
334 some safety checks. */
335 if ((val & VIRTIO_CONFIG_S_DRIVER_OK) &&
336 !(proxy->pci_dev.config[PCI_COMMAND] & PCI_COMMAND_MASTER)) {
337 proxy->flags |= VIRTIO_PCI_FLAG_BUS_MASTER_BUG;
338 }
339 break;
340 case VIRTIO_MSI_CONFIG_VECTOR:
341 msix_vector_unuse(&proxy->pci_dev, vdev->config_vector);
342 /* Make it possible for guest to discover an error took place. */
343 if (msix_vector_use(&proxy->pci_dev, val) < 0)
344 val = VIRTIO_NO_VECTOR;
345 vdev->config_vector = val;
346 break;
347 case VIRTIO_MSI_QUEUE_VECTOR:
348 msix_vector_unuse(&proxy->pci_dev,
349 virtio_queue_vector(vdev, vdev->queue_sel));
350 /* Make it possible for guest to discover an error took place. */
351 if (msix_vector_use(&proxy->pci_dev, val) < 0)
352 val = VIRTIO_NO_VECTOR;
353 virtio_queue_set_vector(vdev, vdev->queue_sel, val);
354 break;
355 default:
356 error_report("%s: unexpected address 0x%x value 0x%x",
357 __func__, addr, val);
358 break;
359 }
360 }
361
362 static uint32_t virtio_ioport_read(VirtIOPCIProxy *proxy, uint32_t addr)
363 {
364 VirtIODevice *vdev = proxy->vdev;
365 uint32_t ret = 0xFFFFFFFF;
366
367 switch (addr) {
368 case VIRTIO_PCI_HOST_FEATURES:
369 ret = proxy->host_features;
370 break;
371 case VIRTIO_PCI_GUEST_FEATURES:
372 ret = vdev->guest_features;
373 break;
374 case VIRTIO_PCI_QUEUE_PFN:
375 ret = virtio_queue_get_addr(vdev, vdev->queue_sel)
376 >> VIRTIO_PCI_QUEUE_ADDR_SHIFT;
377 break;
378 case VIRTIO_PCI_QUEUE_NUM:
379 ret = virtio_queue_get_num(vdev, vdev->queue_sel);
380 break;
381 case VIRTIO_PCI_QUEUE_SEL:
382 ret = vdev->queue_sel;
383 break;
384 case VIRTIO_PCI_STATUS:
385 ret = vdev->status;
386 break;
387 case VIRTIO_PCI_ISR:
388 /* reading from the ISR also clears it. */
389 ret = vdev->isr;
390 vdev->isr = 0;
391 qemu_set_irq(proxy->pci_dev.irq[0], 0);
392 break;
393 case VIRTIO_MSI_CONFIG_VECTOR:
394 ret = vdev->config_vector;
395 break;
396 case VIRTIO_MSI_QUEUE_VECTOR:
397 ret = virtio_queue_vector(vdev, vdev->queue_sel);
398 break;
399 default:
400 break;
401 }
402
403 return ret;
404 }
405
406 static uint32_t virtio_pci_config_readb(void *opaque, uint32_t addr)
407 {
408 VirtIOPCIProxy *proxy = opaque;
409 uint32_t config = VIRTIO_PCI_CONFIG(&proxy->pci_dev);
410 if (addr < config)
411 return virtio_ioport_read(proxy, addr);
412 addr -= config;
413 return virtio_config_readb(proxy->vdev, addr);
414 }
415
416 static uint32_t virtio_pci_config_readw(void *opaque, uint32_t addr)
417 {
418 VirtIOPCIProxy *proxy = opaque;
419 uint32_t config = VIRTIO_PCI_CONFIG(&proxy->pci_dev);
420 uint16_t val;
421 if (addr < config)
422 return virtio_ioport_read(proxy, addr);
423 addr -= config;
424 val = virtio_config_readw(proxy->vdev, addr);
425 if (virtio_is_big_endian()) {
426 /*
427 * virtio is odd, ioports are LE but config space is target native
428 * endian. However, in qemu, all PIO is LE, so we need to re-swap
429 * on BE targets
430 */
431 val = bswap16(val);
432 }
433 return val;
434 }
435
436 static uint32_t virtio_pci_config_readl(void *opaque, uint32_t addr)
437 {
438 VirtIOPCIProxy *proxy = opaque;
439 uint32_t config = VIRTIO_PCI_CONFIG(&proxy->pci_dev);
440 uint32_t val;
441 if (addr < config)
442 return virtio_ioport_read(proxy, addr);
443 addr -= config;
444 val = virtio_config_readl(proxy->vdev, addr);
445 if (virtio_is_big_endian()) {
446 val = bswap32(val);
447 }
448 return val;
449 }
450
451 static void virtio_pci_config_writeb(void *opaque, uint32_t addr, uint32_t val)
452 {
453 VirtIOPCIProxy *proxy = opaque;
454 uint32_t config = VIRTIO_PCI_CONFIG(&proxy->pci_dev);
455 if (addr < config) {
456 virtio_ioport_write(proxy, addr, val);
457 return;
458 }
459 addr -= config;
460 virtio_config_writeb(proxy->vdev, addr, val);
461 }
462
463 static void virtio_pci_config_writew(void *opaque, uint32_t addr, uint32_t val)
464 {
465 VirtIOPCIProxy *proxy = opaque;
466 uint32_t config = VIRTIO_PCI_CONFIG(&proxy->pci_dev);
467 if (addr < config) {
468 virtio_ioport_write(proxy, addr, val);
469 return;
470 }
471 addr -= config;
472 if (virtio_is_big_endian()) {
473 val = bswap16(val);
474 }
475 virtio_config_writew(proxy->vdev, addr, val);
476 }
477
478 static void virtio_pci_config_writel(void *opaque, uint32_t addr, uint32_t val)
479 {
480 VirtIOPCIProxy *proxy = opaque;
481 uint32_t config = VIRTIO_PCI_CONFIG(&proxy->pci_dev);
482 if (addr < config) {
483 virtio_ioport_write(proxy, addr, val);
484 return;
485 }
486 addr -= config;
487 if (virtio_is_big_endian()) {
488 val = bswap32(val);
489 }
490 virtio_config_writel(proxy->vdev, addr, val);
491 }
492
493 const MemoryRegionPortio virtio_portio[] = {
494 { 0, 0x10000, 1, .write = virtio_pci_config_writeb, },
495 { 0, 0x10000, 2, .write = virtio_pci_config_writew, },
496 { 0, 0x10000, 4, .write = virtio_pci_config_writel, },
497 { 0, 0x10000, 1, .read = virtio_pci_config_readb, },
498 { 0, 0x10000, 2, .read = virtio_pci_config_readw, },
499 { 0, 0x10000, 4, .read = virtio_pci_config_readl, },
500 PORTIO_END_OF_LIST()
501 };
502
503 static const MemoryRegionOps virtio_pci_config_ops = {
504 .old_portio = virtio_portio,
505 .endianness = DEVICE_LITTLE_ENDIAN,
506 };
507
508 static void virtio_write_config(PCIDevice *pci_dev, uint32_t address,
509 uint32_t val, int len)
510 {
511 VirtIOPCIProxy *proxy = DO_UPCAST(VirtIOPCIProxy, pci_dev, pci_dev);
512
513 pci_default_write_config(pci_dev, address, val, len);
514
515 if (range_covers_byte(address, len, PCI_COMMAND) &&
516 !(pci_dev->config[PCI_COMMAND] & PCI_COMMAND_MASTER) &&
517 !(proxy->flags & VIRTIO_PCI_FLAG_BUS_MASTER_BUG)) {
518 virtio_pci_stop_ioeventfd(proxy);
519 virtio_set_status(proxy->vdev,
520 proxy->vdev->status & ~VIRTIO_CONFIG_S_DRIVER_OK);
521 }
522
523 msix_write_config(pci_dev, address, val, len);
524 }
525
526 static unsigned virtio_pci_get_features(void *opaque)
527 {
528 VirtIOPCIProxy *proxy = opaque;
529 return proxy->host_features;
530 }
531
532 static void virtio_pci_guest_notifier_read(void *opaque)
533 {
534 VirtQueue *vq = opaque;
535 EventNotifier *n = virtio_queue_get_guest_notifier(vq);
536 if (event_notifier_test_and_clear(n)) {
537 virtio_irq(vq);
538 }
539 }
540
541 static int virtio_pci_set_guest_notifier(void *opaque, int n, bool assign)
542 {
543 VirtIOPCIProxy *proxy = opaque;
544 VirtQueue *vq = virtio_get_queue(proxy->vdev, n);
545 EventNotifier *notifier = virtio_queue_get_guest_notifier(vq);
546
547 if (assign) {
548 int r = event_notifier_init(notifier, 0);
549 if (r < 0) {
550 return r;
551 }
552 qemu_set_fd_handler(event_notifier_get_fd(notifier),
553 virtio_pci_guest_notifier_read, NULL, vq);
554 } else {
555 qemu_set_fd_handler(event_notifier_get_fd(notifier),
556 NULL, NULL, NULL);
557 event_notifier_cleanup(notifier);
558 }
559
560 return 0;
561 }
562
563 static bool virtio_pci_query_guest_notifiers(void *opaque)
564 {
565 VirtIOPCIProxy *proxy = opaque;
566 return msix_enabled(&proxy->pci_dev);
567 }
568
569 static int virtio_pci_set_guest_notifiers(void *opaque, bool assign)
570 {
571 VirtIOPCIProxy *proxy = opaque;
572 VirtIODevice *vdev = proxy->vdev;
573 int r, n;
574
575 for (n = 0; n < VIRTIO_PCI_QUEUE_MAX; n++) {
576 if (!virtio_queue_get_num(vdev, n)) {
577 break;
578 }
579
580 r = virtio_pci_set_guest_notifier(opaque, n, assign);
581 if (r < 0) {
582 goto assign_error;
583 }
584 }
585
586 return 0;
587
588 assign_error:
589 /* We get here on assignment failure. Recover by undoing for VQs 0 .. n. */
590 while (--n >= 0) {
591 virtio_pci_set_guest_notifier(opaque, n, !assign);
592 }
593 return r;
594 }
595
596 static int virtio_pci_set_host_notifier(void *opaque, int n, bool assign)
597 {
598 VirtIOPCIProxy *proxy = opaque;
599
600 /* Stop using ioeventfd for virtqueue kick if the device starts using host
601 * notifiers. This makes it easy to avoid stepping on each others' toes.
602 */
603 proxy->ioeventfd_disabled = assign;
604 if (assign) {
605 virtio_pci_stop_ioeventfd(proxy);
606 }
607 /* We don't need to start here: it's not needed because backend
608 * currently only stops on status change away from ok,
609 * reset, vmstop and such. If we do add code to start here,
610 * need to check vmstate, device state etc. */
611 return virtio_pci_set_host_notifier_internal(proxy, n, assign);
612 }
613
614 static void virtio_pci_vmstate_change(void *opaque, bool running)
615 {
616 VirtIOPCIProxy *proxy = opaque;
617
618 if (running) {
619 /* Try to find out if the guest has bus master disabled, but is
620 in ready state. Then we have a buggy guest OS. */
621 if ((proxy->vdev->status & VIRTIO_CONFIG_S_DRIVER_OK) &&
622 !(proxy->pci_dev.config[PCI_COMMAND] & PCI_COMMAND_MASTER)) {
623 proxy->flags |= VIRTIO_PCI_FLAG_BUS_MASTER_BUG;
624 }
625 virtio_pci_start_ioeventfd(proxy);
626 } else {
627 virtio_pci_stop_ioeventfd(proxy);
628 }
629 }
630
631 static const VirtIOBindings virtio_pci_bindings = {
632 .notify = virtio_pci_notify,
633 .save_config = virtio_pci_save_config,
634 .load_config = virtio_pci_load_config,
635 .save_queue = virtio_pci_save_queue,
636 .load_queue = virtio_pci_load_queue,
637 .get_features = virtio_pci_get_features,
638 .query_guest_notifiers = virtio_pci_query_guest_notifiers,
639 .set_host_notifier = virtio_pci_set_host_notifier,
640 .set_guest_notifiers = virtio_pci_set_guest_notifiers,
641 .vmstate_change = virtio_pci_vmstate_change,
642 };
643
644 void virtio_init_pci(VirtIOPCIProxy *proxy, VirtIODevice *vdev)
645 {
646 uint8_t *config;
647 uint32_t size;
648
649 proxy->vdev = vdev;
650
651 config = proxy->pci_dev.config;
652
653 if (proxy->class_code) {
654 pci_config_set_class(config, proxy->class_code);
655 }
656 pci_set_word(config + PCI_SUBSYSTEM_VENDOR_ID,
657 pci_get_word(config + PCI_VENDOR_ID));
658 pci_set_word(config + PCI_SUBSYSTEM_ID, vdev->device_id);
659 config[PCI_INTERRUPT_PIN] = 1;
660
661 memory_region_init(&proxy->msix_bar, "virtio-msix", 4096);
662 if (vdev->nvectors && !msix_init(&proxy->pci_dev, vdev->nvectors,
663 &proxy->msix_bar, 1, 0)) {
664 pci_register_bar(&proxy->pci_dev, 1, PCI_BASE_ADDRESS_SPACE_MEMORY,
665 &proxy->msix_bar);
666 } else
667 vdev->nvectors = 0;
668
669 proxy->pci_dev.config_write = virtio_write_config;
670
671 size = VIRTIO_PCI_REGION_SIZE(&proxy->pci_dev) + vdev->config_len;
672 if (size & (size-1))
673 size = 1 << qemu_fls(size);
674
675 memory_region_init_io(&proxy->bar, &virtio_pci_config_ops, proxy,
676 "virtio-pci", size);
677 pci_register_bar(&proxy->pci_dev, 0, PCI_BASE_ADDRESS_SPACE_IO,
678 &proxy->bar);
679
680 if (!kvm_has_many_ioeventfds()) {
681 proxy->flags &= ~VIRTIO_PCI_FLAG_USE_IOEVENTFD;
682 }
683
684 virtio_bind_device(vdev, &virtio_pci_bindings, proxy);
685 proxy->host_features |= 0x1 << VIRTIO_F_NOTIFY_ON_EMPTY;
686 proxy->host_features |= 0x1 << VIRTIO_F_BAD_FEATURE;
687 proxy->host_features = vdev->get_features(vdev, proxy->host_features);
688 }
689
690 static int virtio_blk_init_pci(PCIDevice *pci_dev)
691 {
692 VirtIOPCIProxy *proxy = DO_UPCAST(VirtIOPCIProxy, pci_dev, pci_dev);
693 VirtIODevice *vdev;
694
695 if (proxy->class_code != PCI_CLASS_STORAGE_SCSI &&
696 proxy->class_code != PCI_CLASS_STORAGE_OTHER)
697 proxy->class_code = PCI_CLASS_STORAGE_SCSI;
698
699 vdev = virtio_blk_init(&pci_dev->qdev, &proxy->block,
700 &proxy->block_serial);
701 if (!vdev) {
702 return -1;
703 }
704 vdev->nvectors = proxy->nvectors;
705 virtio_init_pci(proxy, vdev);
706 /* make the actual value visible */
707 proxy->nvectors = vdev->nvectors;
708 return 0;
709 }
710
711 static int virtio_exit_pci(PCIDevice *pci_dev)
712 {
713 VirtIOPCIProxy *proxy = DO_UPCAST(VirtIOPCIProxy, pci_dev, pci_dev);
714 int r;
715
716 memory_region_destroy(&proxy->bar);
717 r = msix_uninit(pci_dev, &proxy->msix_bar);
718 memory_region_destroy(&proxy->msix_bar);
719 return r;
720 }
721
722 static int virtio_blk_exit_pci(PCIDevice *pci_dev)
723 {
724 VirtIOPCIProxy *proxy = DO_UPCAST(VirtIOPCIProxy, pci_dev, pci_dev);
725
726 virtio_pci_stop_ioeventfd(proxy);
727 virtio_blk_exit(proxy->vdev);
728 blockdev_mark_auto_del(proxy->block.bs);
729 return virtio_exit_pci(pci_dev);
730 }
731
732 static int virtio_serial_init_pci(PCIDevice *pci_dev)
733 {
734 VirtIOPCIProxy *proxy = DO_UPCAST(VirtIOPCIProxy, pci_dev, pci_dev);
735 VirtIODevice *vdev;
736
737 if (proxy->class_code != PCI_CLASS_COMMUNICATION_OTHER &&
738 proxy->class_code != PCI_CLASS_DISPLAY_OTHER && /* qemu 0.10 */
739 proxy->class_code != PCI_CLASS_OTHERS) /* qemu-kvm */
740 proxy->class_code = PCI_CLASS_COMMUNICATION_OTHER;
741
742 vdev = virtio_serial_init(&pci_dev->qdev, &proxy->serial);
743 if (!vdev) {
744 return -1;
745 }
746 vdev->nvectors = proxy->nvectors == DEV_NVECTORS_UNSPECIFIED
747 ? proxy->serial.max_virtserial_ports + 1
748 : proxy->nvectors;
749 virtio_init_pci(proxy, vdev);
750 proxy->nvectors = vdev->nvectors;
751 return 0;
752 }
753
754 static int virtio_serial_exit_pci(PCIDevice *pci_dev)
755 {
756 VirtIOPCIProxy *proxy = DO_UPCAST(VirtIOPCIProxy, pci_dev, pci_dev);
757
758 virtio_pci_stop_ioeventfd(proxy);
759 virtio_serial_exit(proxy->vdev);
760 return virtio_exit_pci(pci_dev);
761 }
762
763 static int virtio_net_init_pci(PCIDevice *pci_dev)
764 {
765 VirtIOPCIProxy *proxy = DO_UPCAST(VirtIOPCIProxy, pci_dev, pci_dev);
766 VirtIODevice *vdev;
767
768 vdev = virtio_net_init(&pci_dev->qdev, &proxy->nic, &proxy->net);
769
770 vdev->nvectors = proxy->nvectors;
771 virtio_init_pci(proxy, vdev);
772
773 /* make the actual value visible */
774 proxy->nvectors = vdev->nvectors;
775 return 0;
776 }
777
778 static int virtio_net_exit_pci(PCIDevice *pci_dev)
779 {
780 VirtIOPCIProxy *proxy = DO_UPCAST(VirtIOPCIProxy, pci_dev, pci_dev);
781
782 virtio_pci_stop_ioeventfd(proxy);
783 virtio_net_exit(proxy->vdev);
784 return virtio_exit_pci(pci_dev);
785 }
786
787 static int virtio_balloon_init_pci(PCIDevice *pci_dev)
788 {
789 VirtIOPCIProxy *proxy = DO_UPCAST(VirtIOPCIProxy, pci_dev, pci_dev);
790 VirtIODevice *vdev;
791
792 vdev = virtio_balloon_init(&pci_dev->qdev);
793 if (!vdev) {
794 return -1;
795 }
796 virtio_init_pci(proxy, vdev);
797 return 0;
798 }
799
800 static int virtio_balloon_exit_pci(PCIDevice *pci_dev)
801 {
802 VirtIOPCIProxy *proxy = DO_UPCAST(VirtIOPCIProxy, pci_dev, pci_dev);
803
804 virtio_pci_stop_ioeventfd(proxy);
805 virtio_balloon_exit(proxy->vdev);
806 return virtio_exit_pci(pci_dev);
807 }
808
809 static Property virtio_blk_properties[] = {
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, VIRTIO_PCI_FLAG_USE_IOEVENTFD_BIT, true),
814 DEFINE_PROP_UINT32("vectors", VirtIOPCIProxy, nvectors, 2),
815 DEFINE_VIRTIO_BLK_FEATURES(VirtIOPCIProxy, host_features),
816 DEFINE_PROP_END_OF_LIST(),
817 };
818
819 static void virtio_blk_class_init(ObjectClass *klass, void *data)
820 {
821 PCIDeviceClass *k = PCI_DEVICE_CLASS(klass);
822
823 k->init = virtio_blk_init_pci;
824 k->exit = virtio_blk_exit_pci;
825 k->vendor_id = PCI_VENDOR_ID_REDHAT_QUMRANET;
826 k->device_id = PCI_DEVICE_ID_VIRTIO_BLOCK;
827 k->revision = VIRTIO_PCI_ABI_VERSION;
828 k->class_id = PCI_CLASS_STORAGE_SCSI;
829 }
830
831 static DeviceInfo virtio_blk_info = {
832 .name = "virtio-blk-pci",
833 .alias = "virtio-blk",
834 .size = sizeof(VirtIOPCIProxy),
835 .props = virtio_blk_properties,
836 .reset = virtio_pci_reset,
837 .class_init = virtio_blk_class_init,
838 };
839
840 static Property virtio_net_properties[] = {
841 DEFINE_PROP_BIT("ioeventfd", VirtIOPCIProxy, flags, VIRTIO_PCI_FLAG_USE_IOEVENTFD_BIT, false),
842 DEFINE_PROP_UINT32("vectors", VirtIOPCIProxy, nvectors, 3),
843 DEFINE_VIRTIO_NET_FEATURES(VirtIOPCIProxy, host_features),
844 DEFINE_NIC_PROPERTIES(VirtIOPCIProxy, nic),
845 DEFINE_PROP_UINT32("x-txtimer", VirtIOPCIProxy, net.txtimer, TX_TIMER_INTERVAL),
846 DEFINE_PROP_INT32("x-txburst", VirtIOPCIProxy, net.txburst, TX_BURST),
847 DEFINE_PROP_STRING("tx", VirtIOPCIProxy, net.tx),
848 DEFINE_PROP_END_OF_LIST(),
849 };
850
851 static void virtio_net_class_init(ObjectClass *klass, void *data)
852 {
853 PCIDeviceClass *k = PCI_DEVICE_CLASS(klass);
854
855 k->init = virtio_net_init_pci;
856 k->exit = virtio_net_exit_pci;
857 k->romfile = "pxe-virtio.rom";
858 k->vendor_id = PCI_VENDOR_ID_REDHAT_QUMRANET;
859 k->device_id = PCI_DEVICE_ID_VIRTIO_NET;
860 k->revision = VIRTIO_PCI_ABI_VERSION;
861 k->class_id = PCI_CLASS_NETWORK_ETHERNET;
862 }
863
864 static DeviceInfo virtio_net_info = {
865 .name = "virtio-net-pci",
866 .alias = "virtio-net",
867 .size = sizeof(VirtIOPCIProxy),
868 .props = virtio_net_properties,
869 .reset = virtio_pci_reset,
870 .class_init = virtio_net_class_init,
871 };
872
873 static Property virtio_serial_properties[] = {
874 DEFINE_PROP_BIT("ioeventfd", VirtIOPCIProxy, flags, VIRTIO_PCI_FLAG_USE_IOEVENTFD_BIT, true),
875 DEFINE_PROP_UINT32("vectors", VirtIOPCIProxy, nvectors, DEV_NVECTORS_UNSPECIFIED),
876 DEFINE_PROP_HEX32("class", VirtIOPCIProxy, class_code, 0),
877 DEFINE_VIRTIO_COMMON_FEATURES(VirtIOPCIProxy, host_features),
878 DEFINE_PROP_UINT32("max_ports", VirtIOPCIProxy, serial.max_virtserial_ports, 31),
879 DEFINE_PROP_END_OF_LIST(),
880 };
881
882 static void virtio_serial_class_init(ObjectClass *klass, void *data)
883 {
884 PCIDeviceClass *k = PCI_DEVICE_CLASS(klass);
885
886 k->init = virtio_serial_init_pci;
887 k->exit = virtio_serial_exit_pci;
888 k->vendor_id = PCI_VENDOR_ID_REDHAT_QUMRANET;
889 k->device_id = PCI_DEVICE_ID_VIRTIO_CONSOLE;
890 k->revision = VIRTIO_PCI_ABI_VERSION;
891 k->class_id = PCI_CLASS_COMMUNICATION_OTHER;
892 }
893
894 static DeviceInfo virtio_serial_info = {
895 .name = "virtio-serial-pci",
896 .alias = "virtio-serial",
897 .size = sizeof(VirtIOPCIProxy),
898 .props = virtio_serial_properties,
899 .reset = virtio_pci_reset,
900 .class_init = virtio_serial_class_init,
901 };
902
903 static Property virtio_balloon_properties[] = {
904 DEFINE_VIRTIO_COMMON_FEATURES(VirtIOPCIProxy, host_features),
905 DEFINE_PROP_END_OF_LIST(),
906 };
907
908 static void virtio_balloon_class_init(ObjectClass *klass, void *data)
909 {
910 PCIDeviceClass *k = PCI_DEVICE_CLASS(klass);
911
912 k->init = virtio_balloon_init_pci;
913 k->exit = virtio_balloon_exit_pci;
914 k->vendor_id = PCI_VENDOR_ID_REDHAT_QUMRANET;
915 k->device_id = PCI_DEVICE_ID_VIRTIO_BALLOON;
916 k->revision = VIRTIO_PCI_ABI_VERSION;
917 k->class_id = PCI_CLASS_MEMORY_RAM;
918 }
919
920 static DeviceInfo virtio_balloon_info = {
921 .name = "virtio-balloon-pci",
922 .alias = "virtio-balloon",
923 .size = sizeof(VirtIOPCIProxy),
924 .props = virtio_balloon_properties,
925 .reset = virtio_pci_reset,
926 .class_init = virtio_balloon_class_init,
927 };
928
929 static void virtio_pci_register_devices(void)
930 {
931 pci_qdev_register(&virtio_blk_info);
932 pci_qdev_register(&virtio_net_info);
933 pci_qdev_register(&virtio_serial_info);
934 pci_qdev_register(&virtio_balloon_info);
935 }
936
937 device_init(virtio_pci_register_devices)