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