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-bus.h"
  33 #include "qemu/error-report.h"
  34 #include "qemu/log.h"
  35 #include "trace.h"
  36
  37 /* QOM macros */
  38 /* virtio-mmio-bus */
  39 #define TYPE_VIRTIO_MMIO_BUS "virtio-mmio-bus"
  40 #define VIRTIO_MMIO_BUS(obj) \
  41         OBJECT_CHECK(VirtioBusState, (obj), TYPE_VIRTIO_MMIO_BUS)
  42 #define VIRTIO_MMIO_BUS_GET_CLASS(obj) \
  43         OBJECT_GET_CLASS(VirtioBusClass, (obj), TYPE_VIRTIO_MMIO_BUS)
  44 #define VIRTIO_MMIO_BUS_CLASS(klass) \
  45         OBJECT_CLASS_CHECK(VirtioBusClass, (klass), TYPE_VIRTIO_MMIO_BUS)
  46
  47 /* virtio-mmio */
  48 #define TYPE_VIRTIO_MMIO "virtio-mmio"
  49 #define VIRTIO_MMIO(obj) \
  50         OBJECT_CHECK(VirtIOMMIOProxy, (obj), TYPE_VIRTIO_MMIO)
  51
  52 #define VIRT_MAGIC 0x74726976 /* 'virt' */
  53 #define VIRT_VERSION 1
  54 #define VIRT_VENDOR 0x554D4551 /* 'QEMU' */
  55
  56 typedef struct {
  57     /* Generic */
  58     SysBusDevice parent_obj;
  59     MemoryRegion iomem;
  60     qemu_irq irq;
  61     /* Guest accessible state needing migration and reset */
  62     uint32_t host_features_sel;
  63     uint32_t guest_features_sel;
  64     uint32_t guest_page_shift;
  65     /* virtio-bus */
  66     VirtioBusState bus;
  67     bool format_transport_address;
  68 } VirtIOMMIOProxy;
  69
  70 static bool virtio_mmio_ioeventfd_enabled(DeviceState *d)
  71 {
  72     return kvm_eventfds_enabled();
  73 }
  74
  75 static int virtio_mmio_ioeventfd_assign(DeviceState *d,
  76                                         EventNotifier *notifier,
  77                                         int n, bool assign)
  78 {
  79     VirtIOMMIOProxy *proxy = VIRTIO_MMIO(d);
  80
  81     if (assign) {
  82         memory_region_add_eventfd(&proxy->iomem, VIRTIO_MMIO_QUEUE_NOTIFY, 4,
  83                                   true, n, notifier);
  84     } else {
  85         memory_region_del_eventfd(&proxy->iomem, VIRTIO_MMIO_QUEUE_NOTIFY, 4,
  86                                   true, n, notifier);
  87     }
  88     return 0;
  89 }
  90
  91 static void virtio_mmio_start_ioeventfd(VirtIOMMIOProxy *proxy)
  92 {
  93     virtio_bus_start_ioeventfd(&proxy->bus);
  94 }
  95
  96 static void virtio_mmio_stop_ioeventfd(VirtIOMMIOProxy *proxy)
  97 {
  98     virtio_bus_stop_ioeventfd(&proxy->bus);
  99 }
 100
 101 static uint64_t virtio_mmio_read(void *opaque, hwaddr offset, unsigned size)
 102 {
 103     VirtIOMMIOProxy *proxy = (VirtIOMMIOProxy *)opaque;
 104     VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus);
 105
 106     trace_virtio_mmio_read(offset);
 107
 108     if (!vdev) {
 109         /* If no backend is present, we treat most registers as
 110          * read-as-zero, except for the magic number, version and
 111          * vendor ID. This is not strictly sanctioned by the virtio
 112          * spec, but it allows us to provide transports with no backend
 113          * plugged in which don't confuse Linux's virtio code: the
 114          * probe won't complain about the bad magic number, but the
 115          * device ID of zero means no backend will claim it.
 116          */
 117         switch (offset) {
 118         case VIRTIO_MMIO_MAGIC_VALUE:
 119             return VIRT_MAGIC;
 120         case VIRTIO_MMIO_VERSION:
 121             return VIRT_VERSION;
 122         case VIRTIO_MMIO_VENDOR_ID:
 123             return VIRT_VENDOR;
 124         default:
 125             return 0;
 126         }
 127     }
 128
 129     if (offset >= VIRTIO_MMIO_CONFIG) {
 130         offset -= VIRTIO_MMIO_CONFIG;
 131         switch (size) {
 132         case 1:
 133             return virtio_config_readb(vdev, offset);
 134         case 2:
 135             return virtio_config_readw(vdev, offset);
 136         case 4:
 137             return virtio_config_readl(vdev, offset);
 138         default:
 139             abort();
 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         return VIRT_VERSION;
 153     case VIRTIO_MMIO_DEVICE_ID:
 154         return vdev->device_id;
 155     case VIRTIO_MMIO_VENDOR_ID:
 156         return VIRT_VENDOR;
 157     case VIRTIO_MMIO_DEVICE_FEATURES:
 158         if (proxy->host_features_sel) {
 159             return 0;
 160         }
 161         return vdev->host_features;
 162     case VIRTIO_MMIO_QUEUE_NUM_MAX:
 163         if (!virtio_queue_get_num(vdev, vdev->queue_sel)) {
 164             return 0;
 165         }
 166         return VIRTQUEUE_MAX_SIZE;
 167     case VIRTIO_MMIO_QUEUE_PFN:
 168         return virtio_queue_get_addr(vdev, vdev->queue_sel)
 169             >> proxy->guest_page_shift;
 170     case VIRTIO_MMIO_INTERRUPT_STATUS:
 171         return atomic_read(&vdev->isr);
 172     case VIRTIO_MMIO_STATUS:
 173         return vdev->status;
 174     case VIRTIO_MMIO_DEVICE_FEATURES_SEL:
 175     case VIRTIO_MMIO_DRIVER_FEATURES:
 176     case VIRTIO_MMIO_DRIVER_FEATURES_SEL:
 177     case VIRTIO_MMIO_GUEST_PAGE_SIZE:
 178     case VIRTIO_MMIO_QUEUE_SEL:
 179     case VIRTIO_MMIO_QUEUE_NUM:
 180     case VIRTIO_MMIO_QUEUE_ALIGN:
 181     case VIRTIO_MMIO_QUEUE_NOTIFY:
 182     case VIRTIO_MMIO_INTERRUPT_ACK:
 183         qemu_log_mask(LOG_GUEST_ERROR,
 184                       "%s: read of write-only register\n",
 185                       __func__);
 186         return 0;
 187     default:
 188         qemu_log_mask(LOG_GUEST_ERROR, "%s: bad register offset\n", __func__);
 189         return 0;
 190     }
 191     return 0;
 192 }
 193
 194 static void virtio_mmio_write(void *opaque, hwaddr offset, uint64_t value,
 195                               unsigned size)
 196 {
 197     VirtIOMMIOProxy *proxy = (VirtIOMMIOProxy *)opaque;
 198     VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus);
 199
 200     trace_virtio_mmio_write_offset(offset, value);
 201
 202     if (!vdev) {
 203         /* If no backend is present, we just make all registers
 204          * write-ignored. This allows us to provide transports with
 205          * no backend plugged in.
 206          */
 207         return;
 208     }
 209
 210     if (offset >= VIRTIO_MMIO_CONFIG) {
 211         offset -= VIRTIO_MMIO_CONFIG;
 212         switch (size) {
 213         case 1:
 214             virtio_config_writeb(vdev, offset, value);
 215             break;
 216         case 2:
 217             virtio_config_writew(vdev, offset, value);
 218             break;
 219         case 4:
 220             virtio_config_writel(vdev, offset, value);
 221             break;
 222         default:
 223             abort();
 224         }
 225         return;
 226     }
 227     if (size != 4) {
 228         qemu_log_mask(LOG_GUEST_ERROR,
 229                       "%s: wrong size access to register!\n",
 230                       __func__);
 231         return;
 232     }
 233     switch (offset) {
 234     case VIRTIO_MMIO_DEVICE_FEATURES_SEL:
 235         proxy->host_features_sel = value;
 236         break;
 237     case VIRTIO_MMIO_DRIVER_FEATURES:
 238         if (!proxy->guest_features_sel) {
 239             virtio_set_features(vdev, value);
 240         }
 241         break;
 242     case VIRTIO_MMIO_DRIVER_FEATURES_SEL:
 243         proxy->guest_features_sel = value;
 244         break;
 245     case VIRTIO_MMIO_GUEST_PAGE_SIZE:
 246         proxy->guest_page_shift = ctz32(value);
 247         if (proxy->guest_page_shift > 31) {
 248             proxy->guest_page_shift = 0;
 249         }
 250         trace_virtio_mmio_guest_page(value, proxy->guest_page_shift);
 251         break;
 252     case VIRTIO_MMIO_QUEUE_SEL:
 253         if (value < VIRTIO_QUEUE_MAX) {
 254             vdev->queue_sel = value;
 255         }
 256         break;
 257     case VIRTIO_MMIO_QUEUE_NUM:
 258         trace_virtio_mmio_queue_write(value, VIRTQUEUE_MAX_SIZE);
 259         virtio_queue_set_num(vdev, vdev->queue_sel, value);
 260         /* Note: only call this function for legacy devices */
 261         virtio_queue_update_rings(vdev, vdev->queue_sel);
 262         break;
 263     case VIRTIO_MMIO_QUEUE_ALIGN:
 264         /* Note: this is only valid for legacy devices */
 265         virtio_queue_set_align(vdev, vdev->queue_sel, value);
 266         break;
 267     case VIRTIO_MMIO_QUEUE_PFN:
 268         if (value == 0) {
 269             virtio_reset(vdev);
 270         } else {
 271             virtio_queue_set_addr(vdev, vdev->queue_sel,
 272                                   value << proxy->guest_page_shift);
 273         }
 274         break;
 275     case VIRTIO_MMIO_QUEUE_NOTIFY:
 276         if (value < VIRTIO_QUEUE_MAX) {
 277             virtio_queue_notify(vdev, value);
 278         }
 279         break;
 280     case VIRTIO_MMIO_INTERRUPT_ACK:
 281         atomic_and(&vdev->isr, ~value);
 282         virtio_update_irq(vdev);
 283         break;
 284     case VIRTIO_MMIO_STATUS:
 285         if (!(value & VIRTIO_CONFIG_S_DRIVER_OK)) {
 286             virtio_mmio_stop_ioeventfd(proxy);
 287         }
 288
 289         virtio_set_status(vdev, value & 0xff);
 290
 291         if (value & VIRTIO_CONFIG_S_DRIVER_OK) {
 292             virtio_mmio_start_ioeventfd(proxy);
 293         }
 294
 295         if (vdev->status == 0) {
 296             virtio_reset(vdev);
 297         }
 298         break;
 299     case VIRTIO_MMIO_MAGIC_VALUE:
 300     case VIRTIO_MMIO_VERSION:
 301     case VIRTIO_MMIO_DEVICE_ID:
 302     case VIRTIO_MMIO_VENDOR_ID:
 303     case VIRTIO_MMIO_DEVICE_FEATURES:
 304     case VIRTIO_MMIO_QUEUE_NUM_MAX:
 305     case VIRTIO_MMIO_INTERRUPT_STATUS:
 306         qemu_log_mask(LOG_GUEST_ERROR,
 307                       "%s: write to readonly register\n",
 308                       __func__);
 309         break;
 310
 311     default:
 312         qemu_log_mask(LOG_GUEST_ERROR, "%s: bad register offset\n", __func__);
 313     }
 314 }
 315
 316 static const MemoryRegionOps virtio_mem_ops = {
 317     .read = virtio_mmio_read,
 318     .write = virtio_mmio_write,
 319     .endianness = DEVICE_NATIVE_ENDIAN,
 320 };
 321
 322 static void virtio_mmio_update_irq(DeviceState *opaque, uint16_t vector)
 323 {
 324     VirtIOMMIOProxy *proxy = VIRTIO_MMIO(opaque);
 325     VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus);
 326     int level;
 327
 328     if (!vdev) {
 329         return;
 330     }
 331     level = (atomic_read(&vdev->isr) != 0);
 332     trace_virtio_mmio_setting_irq(level);
 333     qemu_set_irq(proxy->irq, level);
 334 }
 335
 336 static int virtio_mmio_load_config(DeviceState *opaque, QEMUFile *f)
 337 {
 338     VirtIOMMIOProxy *proxy = VIRTIO_MMIO(opaque);
 339
 340     proxy->host_features_sel = qemu_get_be32(f);
 341     proxy->guest_features_sel = qemu_get_be32(f);
 342     proxy->guest_page_shift = qemu_get_be32(f);
 343     return 0;
 344 }
 345
 346 static void virtio_mmio_save_config(DeviceState *opaque, QEMUFile *f)
 347 {
 348     VirtIOMMIOProxy *proxy = VIRTIO_MMIO(opaque);
 349
 350     qemu_put_be32(f, proxy->host_features_sel);
 351     qemu_put_be32(f, proxy->guest_features_sel);
 352     qemu_put_be32(f, proxy->guest_page_shift);
 353 }
 354
 355 static void virtio_mmio_reset(DeviceState *d)
 356 {
 357     VirtIOMMIOProxy *proxy = VIRTIO_MMIO(d);
 358
 359     virtio_mmio_stop_ioeventfd(proxy);
 360     virtio_bus_reset(&proxy->bus);
 361     proxy->host_features_sel = 0;
 362     proxy->guest_features_sel = 0;
 363     proxy->guest_page_shift = 0;
 364 }
 365
 366 static int virtio_mmio_set_guest_notifier(DeviceState *d, int n, bool assign,
 367                                           bool with_irqfd)
 368 {
 369     VirtIOMMIOProxy *proxy = VIRTIO_MMIO(d);
 370     VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus);
 371     VirtioDeviceClass *vdc = VIRTIO_DEVICE_GET_CLASS(vdev);
 372     VirtQueue *vq = virtio_get_queue(vdev, n);
 373     EventNotifier *notifier = virtio_queue_get_guest_notifier(vq);
 374
 375     if (assign) {
 376         int r = event_notifier_init(notifier, 0);
 377         if (r < 0) {
 378             return r;
 379         }
 380         virtio_queue_set_guest_notifier_fd_handler(vq, true, with_irqfd);
 381     } else {
 382         virtio_queue_set_guest_notifier_fd_handler(vq, false, with_irqfd);
 383         event_notifier_cleanup(notifier);
 384     }
 385
 386     if (vdc->guest_notifier_mask && vdev->use_guest_notifier_mask) {
 387         vdc->guest_notifier_mask(vdev, n, !assign);
 388     }
 389
 390     return 0;
 391 }
 392
 393 static int virtio_mmio_set_guest_notifiers(DeviceState *d, int nvqs,
 394                                            bool assign)
 395 {
 396     VirtIOMMIOProxy *proxy = VIRTIO_MMIO(d);
 397     VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus);
 398     /* TODO: need to check if kvm-arm supports irqfd */
 399     bool with_irqfd = false;
 400     int r, n;
 401
 402     nvqs = MIN(nvqs, VIRTIO_QUEUE_MAX);
 403
 404     for (n = 0; n < nvqs; n++) {
 405         if (!virtio_queue_get_num(vdev, n)) {
 406             break;
 407         }
 408
 409         r = virtio_mmio_set_guest_notifier(d, n, assign, with_irqfd);
 410         if (r < 0) {
 411             goto assign_error;
 412         }
 413     }
 414
 415     return 0;
 416
 417 assign_error:
 418     /* We get here on assignment failure. Recover by undoing for VQs 0 .. n. */
 419     assert(assign);
 420     while (--n >= 0) {
 421         virtio_mmio_set_guest_notifier(d, n, !assign, false);
 422     }
 423     return r;
 424 }
 425
 426 /* virtio-mmio device */
 427
 428 static Property virtio_mmio_properties[] = {
 429     DEFINE_PROP_BOOL("format_transport_address", VirtIOMMIOProxy,
 430                      format_transport_address, true),
 431     DEFINE_PROP_END_OF_LIST(),
 432 };
 433
 434 static void virtio_mmio_realizefn(DeviceState *d, Error **errp)
 435 {
 436     VirtIOMMIOProxy *proxy = VIRTIO_MMIO(d);
 437     SysBusDevice *sbd = SYS_BUS_DEVICE(d);
 438
 439     qbus_create_inplace(&proxy->bus, sizeof(proxy->bus), TYPE_VIRTIO_MMIO_BUS,
 440                         d, NULL);
 441     sysbus_init_irq(sbd, &proxy->irq);
 442     memory_region_init_io(&proxy->iomem, OBJECT(d), &virtio_mem_ops, proxy,
 443                           TYPE_VIRTIO_MMIO, 0x200);
 444     sysbus_init_mmio(sbd, &proxy->iomem);
 445 }
 446
 447 static void virtio_mmio_class_init(ObjectClass *klass, void *data)
 448 {
 449     DeviceClass *dc = DEVICE_CLASS(klass);
 450
 451     dc->realize = virtio_mmio_realizefn;
 452     dc->reset = virtio_mmio_reset;
 453     set_bit(DEVICE_CATEGORY_MISC, dc->categories);
 454     dc->props = virtio_mmio_properties;
 455 }
 456
 457 static const TypeInfo virtio_mmio_info = {
 458     .name          = TYPE_VIRTIO_MMIO,
 459     .parent        = TYPE_SYS_BUS_DEVICE,
 460     .instance_size = sizeof(VirtIOMMIOProxy),
 461     .class_init    = virtio_mmio_class_init,
 462 };
 463
 464 /* virtio-mmio-bus. */
 465
 466 static char *virtio_mmio_bus_get_dev_path(DeviceState *dev)
 467 {
 468     BusState *virtio_mmio_bus;
 469     VirtIOMMIOProxy *virtio_mmio_proxy;
 470     char *proxy_path;
 471     SysBusDevice *proxy_sbd;
 472     char *path;
 473
 474     virtio_mmio_bus = qdev_get_parent_bus(dev);
 475     virtio_mmio_proxy = VIRTIO_MMIO(virtio_mmio_bus->parent);
 476     proxy_path = qdev_get_dev_path(DEVICE(virtio_mmio_proxy));
 477
 478     /*
 479      * If @format_transport_address is false, then we just perform the same as
 480      * virtio_bus_get_dev_path(): we delegate the address formatting for the
 481      * device on the virtio-mmio bus to the bus that the virtio-mmio proxy
 482      * (i.e., the device that implements the virtio-mmio bus) resides on. In
 483      * this case the base address of the virtio-mmio transport will be
 484      * invisible.
 485      */
 486     if (!virtio_mmio_proxy->format_transport_address) {
 487         return proxy_path;
 488     }
 489
 490     /* Otherwise, we append the base address of the transport. */
 491     proxy_sbd = SYS_BUS_DEVICE(virtio_mmio_proxy);
 492     assert(proxy_sbd->num_mmio == 1);
 493     assert(proxy_sbd->mmio[0].memory == &virtio_mmio_proxy->iomem);
 494
 495     if (proxy_path) {
 496         path = g_strdup_printf("%s/virtio-mmio@" TARGET_FMT_plx, proxy_path,
 497                                proxy_sbd->mmio[0].addr);
 498     } else {
 499         path = g_strdup_printf("virtio-mmio@" TARGET_FMT_plx,
 500                                proxy_sbd->mmio[0].addr);
 501     }
 502     g_free(proxy_path);
 503     return path;
 504 }
 505
 506 static void virtio_mmio_bus_class_init(ObjectClass *klass, void *data)
 507 {
 508     BusClass *bus_class = BUS_CLASS(klass);
 509     VirtioBusClass *k = VIRTIO_BUS_CLASS(klass);
 510
 511     k->notify = virtio_mmio_update_irq;
 512     k->save_config = virtio_mmio_save_config;
 513     k->load_config = virtio_mmio_load_config;
 514     k->set_guest_notifiers = virtio_mmio_set_guest_notifiers;
 515     k->ioeventfd_enabled = virtio_mmio_ioeventfd_enabled;
 516     k->ioeventfd_assign = virtio_mmio_ioeventfd_assign;
 517     k->has_variable_vring_alignment = true;
 518     bus_class->max_dev = 1;
 519     bus_class->get_dev_path = virtio_mmio_bus_get_dev_path;
 520 }
 521
 522 static const TypeInfo virtio_mmio_bus_info = {
 523     .name          = TYPE_VIRTIO_MMIO_BUS,
 524     .parent        = TYPE_VIRTIO_BUS,
 525     .instance_size = sizeof(VirtioBusState),
 526     .class_init    = virtio_mmio_bus_class_init,
 527 };
 528
 529 static void virtio_mmio_register_types(void)
 530 {
 531     type_register_static(&virtio_mmio_bus_info);
 532     type_register_static(&virtio_mmio_info);
 533 }
 534
 535 type_init(virtio_mmio_register_types)