1 /* 2 * Virtio MMIO bindings 3 * 4 * Copyright (c) 2011 Linaro Limited 5 * 6 * Author: 7 * Peter Maydell <peter.maydell@linaro.org> 8 * 9 * This program is free software; you can redistribute it and/or modify 10 * it under the terms of the GNU General Public License; either version 2 11 * of the License, or (at your option) any later version. 12 * 13 * This program is distributed in the hope that it will be useful, 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 * GNU General Public License for more details. 17 * 18 * You should have received a copy of the GNU General Public License along 19 * with this program; if not, see <http://www.gnu.org/licenses/>. 20 */ 21 22 #include "qemu/osdep.h" 23 #include "standard-headers/linux/virtio_mmio.h" 24 #include "hw/irq.h" 25 #include "hw/qdev-properties.h" 26 #include "hw/sysbus.h" 27 #include "hw/virtio/virtio.h" 28 #include "migration/qemu-file-types.h" 29 #include "qemu/host-utils.h" 30 #include "qemu/module.h" 31 #include "sysemu/kvm.h" 32 #include "sysemu/replay.h" 33 #include "hw/virtio/virtio-mmio.h" 34 #include "qemu/error-report.h" 35 #include "qemu/log.h" 36 #include "trace.h" 37 38 static bool virtio_mmio_ioeventfd_enabled(DeviceState *d) 39 { 40 VirtIOMMIOProxy *proxy = VIRTIO_MMIO(d); 41 42 return (proxy->flags & VIRTIO_IOMMIO_FLAG_USE_IOEVENTFD) != 0; 43 } 44 45 static int virtio_mmio_ioeventfd_assign(DeviceState *d, 46 EventNotifier *notifier, 47 int n, bool assign) 48 { 49 VirtIOMMIOProxy *proxy = VIRTIO_MMIO(d); 50 51 if (assign) { 52 memory_region_add_eventfd(&proxy->iomem, VIRTIO_MMIO_QUEUE_NOTIFY, 4, 53 true, n, notifier); 54 } else { 55 memory_region_del_eventfd(&proxy->iomem, VIRTIO_MMIO_QUEUE_NOTIFY, 4, 56 true, n, notifier); 57 } 58 return 0; 59 } 60 61 static void virtio_mmio_start_ioeventfd(VirtIOMMIOProxy *proxy) 62 { 63 virtio_bus_start_ioeventfd(&proxy->bus); 64 } 65 66 static void virtio_mmio_stop_ioeventfd(VirtIOMMIOProxy *proxy) 67 { 68 virtio_bus_stop_ioeventfd(&proxy->bus); 69 } 70 71 static void virtio_mmio_soft_reset(VirtIOMMIOProxy *proxy) 72 { 73 int i; 74 75 virtio_bus_reset(&proxy->bus); 76 77 if (!proxy->legacy) { 78 for (i = 0; i < VIRTIO_QUEUE_MAX; i++) { 79 proxy->vqs[i].enabled = 0; 80 } 81 } 82 } 83 84 static uint64_t virtio_mmio_read(void *opaque, hwaddr offset, unsigned size) 85 { 86 VirtIOMMIOProxy *proxy = (VirtIOMMIOProxy *)opaque; 87 VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus); 88 89 trace_virtio_mmio_read(offset); 90 91 if (!vdev) { 92 /* If no backend is present, we treat most registers as 93 * read-as-zero, except for the magic number, version and 94 * vendor ID. This is not strictly sanctioned by the virtio 95 * spec, but it allows us to provide transports with no backend 96 * plugged in which don't confuse Linux's virtio code: the 97 * probe won't complain about the bad magic number, but the 98 * device ID of zero means no backend will claim it. 99 */ 100 switch (offset) { 101 case VIRTIO_MMIO_MAGIC_VALUE: 102 return VIRT_MAGIC; 103 case VIRTIO_MMIO_VERSION: 104 if (proxy->legacy) { 105 return VIRT_VERSION_LEGACY; 106 } else { 107 return VIRT_VERSION; 108 } 109 case VIRTIO_MMIO_VENDOR_ID: 110 return VIRT_VENDOR; 111 default: 112 return 0; 113 } 114 } 115 116 if (offset >= VIRTIO_MMIO_CONFIG) { 117 offset -= VIRTIO_MMIO_CONFIG; 118 if (proxy->legacy) { 119 switch (size) { 120 case 1: 121 return virtio_config_readb(vdev, offset); 122 case 2: 123 return virtio_config_readw(vdev, offset); 124 case 4: 125 return virtio_config_readl(vdev, offset); 126 default: 127 abort(); 128 } 129 } else { 130 switch (size) { 131 case 1: 132 return virtio_config_modern_readb(vdev, offset); 133 case 2: 134 return virtio_config_modern_readw(vdev, offset); 135 case 4: 136 return virtio_config_modern_readl(vdev, offset); 137 default: 138 abort(); 139 } 140 } 141 } 142 if (size != 4) { 143 qemu_log_mask(LOG_GUEST_ERROR, 144 "%s: wrong size access to register!\n", 145 __func__); 146 return 0; 147 } 148 switch (offset) { 149 case VIRTIO_MMIO_MAGIC_VALUE: 150 return VIRT_MAGIC; 151 case VIRTIO_MMIO_VERSION: 152 if (proxy->legacy) { 153 return VIRT_VERSION_LEGACY; 154 } else { 155 return VIRT_VERSION; 156 } 157 case VIRTIO_MMIO_DEVICE_ID: 158 return vdev->device_id; 159 case VIRTIO_MMIO_VENDOR_ID: 160 return VIRT_VENDOR; 161 case VIRTIO_MMIO_DEVICE_FEATURES: 162 if (proxy->legacy) { 163 if (proxy->host_features_sel) { 164 return 0; 165 } else { 166 return vdev->host_features; 167 } 168 } else { 169 VirtioDeviceClass *vdc = VIRTIO_DEVICE_GET_CLASS(vdev); 170 return (vdev->host_features & ~vdc->legacy_features) 171 >> (32 * proxy->host_features_sel); 172 } 173 case VIRTIO_MMIO_QUEUE_NUM_MAX: 174 if (!virtio_queue_get_num(vdev, vdev->queue_sel)) { 175 return 0; 176 } 177 return VIRTQUEUE_MAX_SIZE; 178 case VIRTIO_MMIO_QUEUE_PFN: 179 if (!proxy->legacy) { 180 qemu_log_mask(LOG_GUEST_ERROR, 181 "%s: read from legacy register (0x%" 182 HWADDR_PRIx ") in non-legacy mode\n", 183 __func__, offset); 184 return 0; 185 } 186 return virtio_queue_get_addr(vdev, vdev->queue_sel) 187 >> proxy->guest_page_shift; 188 case VIRTIO_MMIO_QUEUE_READY: 189 if (proxy->legacy) { 190 qemu_log_mask(LOG_GUEST_ERROR, 191 "%s: read from non-legacy register (0x%" 192 HWADDR_PRIx ") in legacy mode\n", 193 __func__, offset); 194 return 0; 195 } 196 return proxy->vqs[vdev->queue_sel].enabled; 197 case VIRTIO_MMIO_INTERRUPT_STATUS: 198 return qatomic_read(&vdev->isr); 199 case VIRTIO_MMIO_STATUS: 200 return vdev->status; 201 case VIRTIO_MMIO_CONFIG_GENERATION: 202 if (proxy->legacy) { 203 qemu_log_mask(LOG_GUEST_ERROR, 204 "%s: read from non-legacy register (0x%" 205 HWADDR_PRIx ") in legacy mode\n", 206 __func__, offset); 207 return 0; 208 } 209 return vdev->generation; 210 case VIRTIO_MMIO_SHM_LEN_LOW: 211 case VIRTIO_MMIO_SHM_LEN_HIGH: 212 /* 213 * VIRTIO_MMIO_SHM_SEL is unimplemented 214 * according to the linux driver, if region length is -1 215 * the shared memory doesn't exist 216 */ 217 return -1; 218 case VIRTIO_MMIO_DEVICE_FEATURES_SEL: 219 case VIRTIO_MMIO_DRIVER_FEATURES: 220 case VIRTIO_MMIO_DRIVER_FEATURES_SEL: 221 case VIRTIO_MMIO_GUEST_PAGE_SIZE: 222 case VIRTIO_MMIO_QUEUE_SEL: 223 case VIRTIO_MMIO_QUEUE_NUM: 224 case VIRTIO_MMIO_QUEUE_ALIGN: 225 case VIRTIO_MMIO_QUEUE_NOTIFY: 226 case VIRTIO_MMIO_INTERRUPT_ACK: 227 case VIRTIO_MMIO_QUEUE_DESC_LOW: 228 case VIRTIO_MMIO_QUEUE_DESC_HIGH: 229 case VIRTIO_MMIO_QUEUE_AVAIL_LOW: 230 case VIRTIO_MMIO_QUEUE_AVAIL_HIGH: 231 case VIRTIO_MMIO_QUEUE_USED_LOW: 232 case VIRTIO_MMIO_QUEUE_USED_HIGH: 233 qemu_log_mask(LOG_GUEST_ERROR, 234 "%s: read of write-only register (0x%" HWADDR_PRIx ")\n", 235 __func__, offset); 236 return 0; 237 default: 238 qemu_log_mask(LOG_GUEST_ERROR, 239 "%s: bad register offset (0x%" HWADDR_PRIx ")\n", 240 __func__, offset); 241 return 0; 242 } 243 return 0; 244 } 245 246 static void virtio_mmio_write(void *opaque, hwaddr offset, uint64_t value, 247 unsigned size) 248 { 249 VirtIOMMIOProxy *proxy = (VirtIOMMIOProxy *)opaque; 250 VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus); 251 uint16_t vq_idx; 252 253 trace_virtio_mmio_write_offset(offset, value); 254 255 if (!vdev) { 256 /* If no backend is present, we just make all registers 257 * write-ignored. This allows us to provide transports with 258 * no backend plugged in. 259 */ 260 return; 261 } 262 263 if (offset >= VIRTIO_MMIO_CONFIG) { 264 offset -= VIRTIO_MMIO_CONFIG; 265 if (proxy->legacy) { 266 switch (size) { 267 case 1: 268 virtio_config_writeb(vdev, offset, value); 269 break; 270 case 2: 271 virtio_config_writew(vdev, offset, value); 272 break; 273 case 4: 274 virtio_config_writel(vdev, offset, value); 275 break; 276 default: 277 abort(); 278 } 279 return; 280 } else { 281 switch (size) { 282 case 1: 283 virtio_config_modern_writeb(vdev, offset, value); 284 break; 285 case 2: 286 virtio_config_modern_writew(vdev, offset, value); 287 break; 288 case 4: 289 virtio_config_modern_writel(vdev, offset, value); 290 break; 291 default: 292 abort(); 293 } 294 return; 295 } 296 } 297 if (size != 4) { 298 qemu_log_mask(LOG_GUEST_ERROR, 299 "%s: wrong size access to register!\n", 300 __func__); 301 return; 302 } 303 switch (offset) { 304 case VIRTIO_MMIO_DEVICE_FEATURES_SEL: 305 if (value) { 306 proxy->host_features_sel = 1; 307 } else { 308 proxy->host_features_sel = 0; 309 } 310 break; 311 case VIRTIO_MMIO_DRIVER_FEATURES: 312 if (proxy->legacy) { 313 if (proxy->guest_features_sel) { 314 qemu_log_mask(LOG_GUEST_ERROR, 315 "%s: attempt to write guest features with " 316 "guest_features_sel > 0 in legacy mode\n", 317 __func__); 318 } else { 319 virtio_set_features(vdev, value); 320 } 321 } else { 322 proxy->guest_features[proxy->guest_features_sel] = value; 323 } 324 break; 325 case VIRTIO_MMIO_DRIVER_FEATURES_SEL: 326 if (value) { 327 proxy->guest_features_sel = 1; 328 } else { 329 proxy->guest_features_sel = 0; 330 } 331 break; 332 case VIRTIO_MMIO_GUEST_PAGE_SIZE: 333 if (!proxy->legacy) { 334 qemu_log_mask(LOG_GUEST_ERROR, 335 "%s: write to legacy register (0x%" 336 HWADDR_PRIx ") in non-legacy mode\n", 337 __func__, offset); 338 return; 339 } 340 proxy->guest_page_shift = ctz32(value); 341 if (proxy->guest_page_shift > 31) { 342 proxy->guest_page_shift = 0; 343 } 344 trace_virtio_mmio_guest_page(value, proxy->guest_page_shift); 345 break; 346 case VIRTIO_MMIO_QUEUE_SEL: 347 if (value < VIRTIO_QUEUE_MAX) { 348 vdev->queue_sel = value; 349 } 350 break; 351 case VIRTIO_MMIO_QUEUE_NUM: 352 trace_virtio_mmio_queue_write(value, VIRTQUEUE_MAX_SIZE); 353 virtio_queue_set_num(vdev, vdev->queue_sel, value); 354 355 if (proxy->legacy) { 356 virtio_queue_update_rings(vdev, vdev->queue_sel); 357 } else { 358 virtio_init_region_cache(vdev, vdev->queue_sel); 359 proxy->vqs[vdev->queue_sel].num = value; 360 } 361 break; 362 case VIRTIO_MMIO_QUEUE_ALIGN: 363 if (!proxy->legacy) { 364 qemu_log_mask(LOG_GUEST_ERROR, 365 "%s: write to legacy register (0x%" 366 HWADDR_PRIx ") in non-legacy mode\n", 367 __func__, offset); 368 return; 369 } 370 virtio_queue_set_align(vdev, vdev->queue_sel, value); 371 break; 372 case VIRTIO_MMIO_QUEUE_PFN: 373 if (!proxy->legacy) { 374 qemu_log_mask(LOG_GUEST_ERROR, 375 "%s: write to legacy register (0x%" 376 HWADDR_PRIx ") in non-legacy mode\n", 377 __func__, offset); 378 return; 379 } 380 if (value == 0) { 381 virtio_mmio_soft_reset(proxy); 382 } else { 383 virtio_queue_set_addr(vdev, vdev->queue_sel, 384 value << proxy->guest_page_shift); 385 } 386 break; 387 case VIRTIO_MMIO_QUEUE_READY: 388 if (proxy->legacy) { 389 qemu_log_mask(LOG_GUEST_ERROR, 390 "%s: write to non-legacy register (0x%" 391 HWADDR_PRIx ") in legacy mode\n", 392 __func__, offset); 393 return; 394 } 395 if (value) { 396 virtio_queue_set_num(vdev, vdev->queue_sel, 397 proxy->vqs[vdev->queue_sel].num); 398 virtio_queue_set_rings(vdev, vdev->queue_sel, 399 ((uint64_t)proxy->vqs[vdev->queue_sel].desc[1]) << 32 | 400 proxy->vqs[vdev->queue_sel].desc[0], 401 ((uint64_t)proxy->vqs[vdev->queue_sel].avail[1]) << 32 | 402 proxy->vqs[vdev->queue_sel].avail[0], 403 ((uint64_t)proxy->vqs[vdev->queue_sel].used[1]) << 32 | 404 proxy->vqs[vdev->queue_sel].used[0]); 405 proxy->vqs[vdev->queue_sel].enabled = 1; 406 } else { 407 proxy->vqs[vdev->queue_sel].enabled = 0; 408 } 409 break; 410 case VIRTIO_MMIO_QUEUE_NOTIFY: 411 vq_idx = value; 412 if (vq_idx < VIRTIO_QUEUE_MAX && virtio_queue_get_num(vdev, vq_idx)) { 413 if (virtio_vdev_has_feature(vdev, VIRTIO_F_NOTIFICATION_DATA)) { 414 VirtQueue *vq = virtio_get_queue(vdev, vq_idx); 415 416 virtio_queue_set_shadow_avail_idx(vq, (value >> 16) & 0xFFFF); 417 } 418 virtio_queue_notify(vdev, vq_idx); 419 } 420 break; 421 case VIRTIO_MMIO_INTERRUPT_ACK: 422 qatomic_and(&vdev->isr, ~value); 423 virtio_update_irq(vdev); 424 break; 425 case VIRTIO_MMIO_STATUS: 426 if (!(value & VIRTIO_CONFIG_S_DRIVER_OK)) { 427 virtio_mmio_stop_ioeventfd(proxy); 428 } 429 430 if (!proxy->legacy && (value & VIRTIO_CONFIG_S_FEATURES_OK)) { 431 virtio_set_features(vdev, 432 ((uint64_t)proxy->guest_features[1]) << 32 | 433 proxy->guest_features[0]); 434 } 435 436 virtio_set_status(vdev, value & 0xff); 437 438 if (value & VIRTIO_CONFIG_S_DRIVER_OK) { 439 virtio_mmio_start_ioeventfd(proxy); 440 } 441 442 if (vdev->status == 0) { 443 virtio_mmio_soft_reset(proxy); 444 } 445 break; 446 case VIRTIO_MMIO_QUEUE_DESC_LOW: 447 if (proxy->legacy) { 448 qemu_log_mask(LOG_GUEST_ERROR, 449 "%s: write to non-legacy register (0x%" 450 HWADDR_PRIx ") in legacy mode\n", 451 __func__, offset); 452 return; 453 } 454 proxy->vqs[vdev->queue_sel].desc[0] = value; 455 break; 456 case VIRTIO_MMIO_QUEUE_DESC_HIGH: 457 if (proxy->legacy) { 458 qemu_log_mask(LOG_GUEST_ERROR, 459 "%s: write to non-legacy register (0x%" 460 HWADDR_PRIx ") in legacy mode\n", 461 __func__, offset); 462 return; 463 } 464 proxy->vqs[vdev->queue_sel].desc[1] = value; 465 break; 466 case VIRTIO_MMIO_QUEUE_AVAIL_LOW: 467 if (proxy->legacy) { 468 qemu_log_mask(LOG_GUEST_ERROR, 469 "%s: write to non-legacy register (0x%" 470 HWADDR_PRIx ") in legacy mode\n", 471 __func__, offset); 472 return; 473 } 474 proxy->vqs[vdev->queue_sel].avail[0] = value; 475 break; 476 case VIRTIO_MMIO_QUEUE_AVAIL_HIGH: 477 if (proxy->legacy) { 478 qemu_log_mask(LOG_GUEST_ERROR, 479 "%s: write to non-legacy register (0x%" 480 HWADDR_PRIx ") in legacy mode\n", 481 __func__, offset); 482 return; 483 } 484 proxy->vqs[vdev->queue_sel].avail[1] = value; 485 break; 486 case VIRTIO_MMIO_QUEUE_USED_LOW: 487 if (proxy->legacy) { 488 qemu_log_mask(LOG_GUEST_ERROR, 489 "%s: write to non-legacy register (0x%" 490 HWADDR_PRIx ") in legacy mode\n", 491 __func__, offset); 492 return; 493 } 494 proxy->vqs[vdev->queue_sel].used[0] = value; 495 break; 496 case VIRTIO_MMIO_QUEUE_USED_HIGH: 497 if (proxy->legacy) { 498 qemu_log_mask(LOG_GUEST_ERROR, 499 "%s: write to non-legacy register (0x%" 500 HWADDR_PRIx ") in legacy mode\n", 501 __func__, offset); 502 return; 503 } 504 proxy->vqs[vdev->queue_sel].used[1] = value; 505 break; 506 case VIRTIO_MMIO_MAGIC_VALUE: 507 case VIRTIO_MMIO_VERSION: 508 case VIRTIO_MMIO_DEVICE_ID: 509 case VIRTIO_MMIO_VENDOR_ID: 510 case VIRTIO_MMIO_DEVICE_FEATURES: 511 case VIRTIO_MMIO_QUEUE_NUM_MAX: 512 case VIRTIO_MMIO_INTERRUPT_STATUS: 513 case VIRTIO_MMIO_CONFIG_GENERATION: 514 qemu_log_mask(LOG_GUEST_ERROR, 515 "%s: write to read-only register (0x%" HWADDR_PRIx ")\n", 516 __func__, offset); 517 break; 518 519 default: 520 qemu_log_mask(LOG_GUEST_ERROR, 521 "%s: bad register offset (0x%" HWADDR_PRIx ")\n", 522 __func__, offset); 523 } 524 } 525 526 static const MemoryRegionOps virtio_legacy_mem_ops = { 527 .read = virtio_mmio_read, 528 .write = virtio_mmio_write, 529 .endianness = DEVICE_NATIVE_ENDIAN, 530 }; 531 532 static const MemoryRegionOps virtio_mem_ops = { 533 .read = virtio_mmio_read, 534 .write = virtio_mmio_write, 535 .endianness = DEVICE_LITTLE_ENDIAN, 536 }; 537 538 static void virtio_mmio_update_irq(DeviceState *opaque, uint16_t vector) 539 { 540 VirtIOMMIOProxy *proxy = VIRTIO_MMIO(opaque); 541 VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus); 542 int level; 543 544 if (!vdev) { 545 return; 546 } 547 level = (qatomic_read(&vdev->isr) != 0); 548 trace_virtio_mmio_setting_irq(level); 549 qemu_set_irq(proxy->irq, level); 550 } 551 552 static int virtio_mmio_load_config(DeviceState *opaque, QEMUFile *f) 553 { 554 VirtIOMMIOProxy *proxy = VIRTIO_MMIO(opaque); 555 556 proxy->host_features_sel = qemu_get_be32(f); 557 proxy->guest_features_sel = qemu_get_be32(f); 558 proxy->guest_page_shift = qemu_get_be32(f); 559 return 0; 560 } 561 562 static void virtio_mmio_save_config(DeviceState *opaque, QEMUFile *f) 563 { 564 VirtIOMMIOProxy *proxy = VIRTIO_MMIO(opaque); 565 566 qemu_put_be32(f, proxy->host_features_sel); 567 qemu_put_be32(f, proxy->guest_features_sel); 568 qemu_put_be32(f, proxy->guest_page_shift); 569 } 570 571 static const VMStateDescription vmstate_virtio_mmio_queue_state = { 572 .name = "virtio_mmio/queue_state", 573 .version_id = 1, 574 .minimum_version_id = 1, 575 .fields = (const VMStateField[]) { 576 VMSTATE_UINT16(num, VirtIOMMIOQueue), 577 VMSTATE_BOOL(enabled, VirtIOMMIOQueue), 578 VMSTATE_UINT32_ARRAY(desc, VirtIOMMIOQueue, 2), 579 VMSTATE_UINT32_ARRAY(avail, VirtIOMMIOQueue, 2), 580 VMSTATE_UINT32_ARRAY(used, VirtIOMMIOQueue, 2), 581 VMSTATE_END_OF_LIST() 582 } 583 }; 584 585 static const VMStateDescription vmstate_virtio_mmio_state_sub = { 586 .name = "virtio_mmio/state", 587 .version_id = 1, 588 .minimum_version_id = 1, 589 .fields = (const VMStateField[]) { 590 VMSTATE_UINT32_ARRAY(guest_features, VirtIOMMIOProxy, 2), 591 VMSTATE_STRUCT_ARRAY(vqs, VirtIOMMIOProxy, VIRTIO_QUEUE_MAX, 0, 592 vmstate_virtio_mmio_queue_state, 593 VirtIOMMIOQueue), 594 VMSTATE_END_OF_LIST() 595 } 596 }; 597 598 static const VMStateDescription vmstate_virtio_mmio = { 599 .name = "virtio_mmio", 600 .version_id = 1, 601 .minimum_version_id = 1, 602 .fields = (const VMStateField[]) { 603 VMSTATE_END_OF_LIST() 604 }, 605 .subsections = (const VMStateDescription * const []) { 606 &vmstate_virtio_mmio_state_sub, 607 NULL 608 } 609 }; 610 611 static void virtio_mmio_save_extra_state(DeviceState *opaque, QEMUFile *f) 612 { 613 VirtIOMMIOProxy *proxy = VIRTIO_MMIO(opaque); 614 615 vmstate_save_state(f, &vmstate_virtio_mmio, proxy, NULL); 616 } 617 618 static int virtio_mmio_load_extra_state(DeviceState *opaque, QEMUFile *f) 619 { 620 VirtIOMMIOProxy *proxy = VIRTIO_MMIO(opaque); 621 622 return vmstate_load_state(f, &vmstate_virtio_mmio, proxy, 1); 623 } 624 625 static bool virtio_mmio_has_extra_state(DeviceState *opaque) 626 { 627 VirtIOMMIOProxy *proxy = VIRTIO_MMIO(opaque); 628 629 return !proxy->legacy; 630 } 631 632 static void virtio_mmio_reset(DeviceState *d) 633 { 634 VirtIOMMIOProxy *proxy = VIRTIO_MMIO(d); 635 int i; 636 637 virtio_mmio_soft_reset(proxy); 638 639 proxy->host_features_sel = 0; 640 proxy->guest_features_sel = 0; 641 proxy->guest_page_shift = 0; 642 643 if (!proxy->legacy) { 644 proxy->guest_features[0] = proxy->guest_features[1] = 0; 645 646 for (i = 0; i < VIRTIO_QUEUE_MAX; i++) { 647 proxy->vqs[i].num = 0; 648 proxy->vqs[i].desc[0] = proxy->vqs[i].desc[1] = 0; 649 proxy->vqs[i].avail[0] = proxy->vqs[i].avail[1] = 0; 650 proxy->vqs[i].used[0] = proxy->vqs[i].used[1] = 0; 651 } 652 } 653 } 654 655 static int virtio_mmio_set_guest_notifier(DeviceState *d, int n, bool assign, 656 bool with_irqfd) 657 { 658 VirtIOMMIOProxy *proxy = VIRTIO_MMIO(d); 659 VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus); 660 VirtioDeviceClass *vdc = VIRTIO_DEVICE_GET_CLASS(vdev); 661 VirtQueue *vq = virtio_get_queue(vdev, n); 662 EventNotifier *notifier = virtio_queue_get_guest_notifier(vq); 663 664 if (assign) { 665 int r = event_notifier_init(notifier, 0); 666 if (r < 0) { 667 return r; 668 } 669 virtio_queue_set_guest_notifier_fd_handler(vq, true, with_irqfd); 670 } else { 671 virtio_queue_set_guest_notifier_fd_handler(vq, false, with_irqfd); 672 event_notifier_cleanup(notifier); 673 } 674 675 if (vdc->guest_notifier_mask && vdev->use_guest_notifier_mask) { 676 vdc->guest_notifier_mask(vdev, n, !assign); 677 } 678 679 return 0; 680 } 681 static int virtio_mmio_set_config_guest_notifier(DeviceState *d, bool assign, 682 bool with_irqfd) 683 { 684 VirtIOMMIOProxy *proxy = VIRTIO_MMIO(d); 685 VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus); 686 VirtioDeviceClass *vdc = VIRTIO_DEVICE_GET_CLASS(vdev); 687 EventNotifier *notifier = virtio_config_get_guest_notifier(vdev); 688 int r = 0; 689 690 if (assign) { 691 r = event_notifier_init(notifier, 0); 692 if (r < 0) { 693 return r; 694 } 695 virtio_config_set_guest_notifier_fd_handler(vdev, assign, with_irqfd); 696 } else { 697 virtio_config_set_guest_notifier_fd_handler(vdev, assign, with_irqfd); 698 event_notifier_cleanup(notifier); 699 } 700 if (vdc->guest_notifier_mask && vdev->use_guest_notifier_mask) { 701 vdc->guest_notifier_mask(vdev, VIRTIO_CONFIG_IRQ_IDX, !assign); 702 } 703 return r; 704 } 705 static int virtio_mmio_set_guest_notifiers(DeviceState *d, int nvqs, 706 bool assign) 707 { 708 VirtIOMMIOProxy *proxy = VIRTIO_MMIO(d); 709 VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus); 710 /* TODO: need to check if kvm-arm supports irqfd */ 711 bool with_irqfd = false; 712 int r, n; 713 714 nvqs = MIN(nvqs, VIRTIO_QUEUE_MAX); 715 716 for (n = 0; n < nvqs; n++) { 717 if (!virtio_queue_get_num(vdev, n)) { 718 break; 719 } 720 721 r = virtio_mmio_set_guest_notifier(d, n, assign, with_irqfd); 722 if (r < 0) { 723 goto assign_error; 724 } 725 } 726 r = virtio_mmio_set_config_guest_notifier(d, assign, with_irqfd); 727 if (r < 0) { 728 goto assign_error; 729 } 730 731 return 0; 732 733 assign_error: 734 /* We get here on assignment failure. Recover by undoing for VQs 0 .. n. */ 735 assert(assign); 736 while (--n >= 0) { 737 virtio_mmio_set_guest_notifier(d, n, !assign, false); 738 } 739 return r; 740 } 741 742 static void virtio_mmio_pre_plugged(DeviceState *d, Error **errp) 743 { 744 VirtIOMMIOProxy *proxy = VIRTIO_MMIO(d); 745 VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus); 746 747 if (!proxy->legacy) { 748 virtio_add_feature(&vdev->host_features, VIRTIO_F_VERSION_1); 749 } 750 } 751 752 /* virtio-mmio device */ 753 754 static Property virtio_mmio_properties[] = { 755 DEFINE_PROP_BOOL("format_transport_address", VirtIOMMIOProxy, 756 format_transport_address, true), 757 DEFINE_PROP_BOOL("force-legacy", VirtIOMMIOProxy, legacy, true), 758 DEFINE_PROP_BIT("ioeventfd", VirtIOMMIOProxy, flags, 759 VIRTIO_IOMMIO_FLAG_USE_IOEVENTFD_BIT, true), 760 DEFINE_PROP_END_OF_LIST(), 761 }; 762 763 static void virtio_mmio_realizefn(DeviceState *d, Error **errp) 764 { 765 VirtIOMMIOProxy *proxy = VIRTIO_MMIO(d); 766 SysBusDevice *sbd = SYS_BUS_DEVICE(d); 767 768 qbus_init(&proxy->bus, sizeof(proxy->bus), TYPE_VIRTIO_MMIO_BUS, d, NULL); 769 sysbus_init_irq(sbd, &proxy->irq); 770 771 /* fd-based ioevents can't be synchronized in record/replay */ 772 if (replay_mode != REPLAY_MODE_NONE) { 773 proxy->flags &= ~VIRTIO_IOMMIO_FLAG_USE_IOEVENTFD; 774 } 775 776 if (proxy->legacy) { 777 memory_region_init_io(&proxy->iomem, OBJECT(d), 778 &virtio_legacy_mem_ops, proxy, 779 TYPE_VIRTIO_MMIO, 0x200); 780 } else { 781 memory_region_init_io(&proxy->iomem, OBJECT(d), 782 &virtio_mem_ops, proxy, 783 TYPE_VIRTIO_MMIO, 0x200); 784 } 785 sysbus_init_mmio(sbd, &proxy->iomem); 786 } 787 788 static void virtio_mmio_class_init(ObjectClass *klass, void *data) 789 { 790 DeviceClass *dc = DEVICE_CLASS(klass); 791 792 dc->realize = virtio_mmio_realizefn; 793 device_class_set_legacy_reset(dc, virtio_mmio_reset); 794 set_bit(DEVICE_CATEGORY_MISC, dc->categories); 795 device_class_set_props(dc, virtio_mmio_properties); 796 } 797 798 static const TypeInfo virtio_mmio_info = { 799 .name = TYPE_VIRTIO_MMIO, 800 .parent = TYPE_SYS_BUS_DEVICE, 801 .instance_size = sizeof(VirtIOMMIOProxy), 802 .class_init = virtio_mmio_class_init, 803 }; 804 805 /* virtio-mmio-bus. */ 806 807 static char *virtio_mmio_bus_get_dev_path(DeviceState *dev) 808 { 809 BusState *virtio_mmio_bus; 810 VirtIOMMIOProxy *virtio_mmio_proxy; 811 char *proxy_path; 812 char *path; 813 MemoryRegionSection section; 814 815 virtio_mmio_bus = qdev_get_parent_bus(dev); 816 virtio_mmio_proxy = VIRTIO_MMIO(virtio_mmio_bus->parent); 817 proxy_path = qdev_get_dev_path(DEVICE(virtio_mmio_proxy)); 818 819 /* 820 * If @format_transport_address is false, then we just perform the same as 821 * virtio_bus_get_dev_path(): we delegate the address formatting for the 822 * device on the virtio-mmio bus to the bus that the virtio-mmio proxy 823 * (i.e., the device that implements the virtio-mmio bus) resides on. In 824 * this case the base address of the virtio-mmio transport will be 825 * invisible. 826 */ 827 if (!virtio_mmio_proxy->format_transport_address) { 828 return proxy_path; 829 } 830 831 /* Otherwise, we append the base address of the transport. */ 832 section = memory_region_find(&virtio_mmio_proxy->iomem, 0, 0x200); 833 assert(section.mr); 834 835 if (proxy_path) { 836 path = g_strdup_printf("%s/virtio-mmio@" HWADDR_FMT_plx, proxy_path, 837 section.offset_within_address_space); 838 } else { 839 path = g_strdup_printf("virtio-mmio@" HWADDR_FMT_plx, 840 section.offset_within_address_space); 841 } 842 memory_region_unref(section.mr); 843 844 g_free(proxy_path); 845 return path; 846 } 847 848 static void virtio_mmio_vmstate_change(DeviceState *d, bool running) 849 { 850 VirtIOMMIOProxy *proxy = VIRTIO_MMIO(d); 851 852 if (running) { 853 virtio_mmio_start_ioeventfd(proxy); 854 } else { 855 virtio_mmio_stop_ioeventfd(proxy); 856 } 857 } 858 859 static void virtio_mmio_bus_class_init(ObjectClass *klass, void *data) 860 { 861 BusClass *bus_class = BUS_CLASS(klass); 862 VirtioBusClass *k = VIRTIO_BUS_CLASS(klass); 863 864 k->notify = virtio_mmio_update_irq; 865 k->save_config = virtio_mmio_save_config; 866 k->load_config = virtio_mmio_load_config; 867 k->save_extra_state = virtio_mmio_save_extra_state; 868 k->load_extra_state = virtio_mmio_load_extra_state; 869 k->has_extra_state = virtio_mmio_has_extra_state; 870 k->set_guest_notifiers = virtio_mmio_set_guest_notifiers; 871 k->ioeventfd_enabled = virtio_mmio_ioeventfd_enabled; 872 k->ioeventfd_assign = virtio_mmio_ioeventfd_assign; 873 k->pre_plugged = virtio_mmio_pre_plugged; 874 k->vmstate_change = virtio_mmio_vmstate_change; 875 k->has_variable_vring_alignment = true; 876 bus_class->max_dev = 1; 877 bus_class->get_dev_path = virtio_mmio_bus_get_dev_path; 878 } 879 880 static const TypeInfo virtio_mmio_bus_info = { 881 .name = TYPE_VIRTIO_MMIO_BUS, 882 .parent = TYPE_VIRTIO_BUS, 883 .instance_size = sizeof(VirtioBusState), 884 .class_init = virtio_mmio_bus_class_init, 885 }; 886 887 static void virtio_mmio_register_types(void) 888 { 889 type_register_static(&virtio_mmio_bus_info); 890 type_register_static(&virtio_mmio_info); 891 } 892 893 type_init(virtio_mmio_register_types) 894