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