hw/virtio/virtio-mmio.c

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