1 /* 2 * virtio ccw target implementation 3 * 4 * Copyright 2012,2015 IBM Corp. 5 * Author(s): Cornelia Huck <cornelia.huck@de.ibm.com> 6 * Pierre Morel <pmorel@linux.vnet.ibm.com> 7 * 8 * This work is licensed under the terms of the GNU GPL, version 2 or (at 9 * your option) any later version. See the COPYING file in the top-level 10 * directory. 11 */ 12 13 #include "qemu/osdep.h" 14 #include "qapi/error.h" 15 #include "hw/hw.h" 16 #include "sysemu/block-backend.h" 17 #include "sysemu/blockdev.h" 18 #include "sysemu/sysemu.h" 19 #include "sysemu/kvm.h" 20 #include "net/net.h" 21 #include "hw/virtio/virtio.h" 22 #include "hw/virtio/virtio-serial.h" 23 #include "hw/virtio/virtio-net.h" 24 #include "hw/sysbus.h" 25 #include "qemu/bitops.h" 26 #include "qemu/error-report.h" 27 #include "hw/virtio/virtio-access.h" 28 #include "hw/virtio/virtio-bus.h" 29 #include "hw/s390x/adapter.h" 30 #include "hw/s390x/s390_flic.h" 31 32 #include "hw/s390x/ioinst.h" 33 #include "hw/s390x/css.h" 34 #include "virtio-ccw.h" 35 #include "trace.h" 36 #include "hw/s390x/css-bridge.h" 37 38 #define NR_CLASSIC_INDICATOR_BITS 64 39 40 static void virtio_ccw_bus_new(VirtioBusState *bus, size_t bus_size, 41 VirtioCcwDevice *dev); 42 43 VirtIODevice *virtio_ccw_get_vdev(SubchDev *sch) 44 { 45 VirtIODevice *vdev = NULL; 46 VirtioCcwDevice *dev = sch->driver_data; 47 48 if (dev) { 49 vdev = virtio_bus_get_device(&dev->bus); 50 } 51 return vdev; 52 } 53 54 static void virtio_ccw_start_ioeventfd(VirtioCcwDevice *dev) 55 { 56 virtio_bus_start_ioeventfd(&dev->bus); 57 } 58 59 static void virtio_ccw_stop_ioeventfd(VirtioCcwDevice *dev) 60 { 61 virtio_bus_stop_ioeventfd(&dev->bus); 62 } 63 64 static bool virtio_ccw_ioeventfd_enabled(DeviceState *d) 65 { 66 VirtioCcwDevice *dev = VIRTIO_CCW_DEVICE(d); 67 68 return (dev->flags & VIRTIO_CCW_FLAG_USE_IOEVENTFD) != 0; 69 } 70 71 static int virtio_ccw_ioeventfd_assign(DeviceState *d, EventNotifier *notifier, 72 int n, bool assign) 73 { 74 VirtioCcwDevice *dev = VIRTIO_CCW_DEVICE(d); 75 CcwDevice *ccw_dev = CCW_DEVICE(dev); 76 SubchDev *sch = ccw_dev->sch; 77 uint32_t sch_id = (css_build_subchannel_id(sch) << 16) | sch->schid; 78 79 return s390_assign_subch_ioeventfd(notifier, sch_id, n, assign); 80 } 81 82 /* Communication blocks used by several channel commands. */ 83 typedef struct VqInfoBlockLegacy { 84 uint64_t queue; 85 uint32_t align; 86 uint16_t index; 87 uint16_t num; 88 } QEMU_PACKED VqInfoBlockLegacy; 89 90 typedef struct VqInfoBlock { 91 uint64_t desc; 92 uint32_t res0; 93 uint16_t index; 94 uint16_t num; 95 uint64_t avail; 96 uint64_t used; 97 } QEMU_PACKED VqInfoBlock; 98 99 typedef struct VqConfigBlock { 100 uint16_t index; 101 uint16_t num_max; 102 } QEMU_PACKED VqConfigBlock; 103 104 typedef struct VirtioFeatDesc { 105 uint32_t features; 106 uint8_t index; 107 } QEMU_PACKED VirtioFeatDesc; 108 109 typedef struct VirtioThinintInfo { 110 hwaddr summary_indicator; 111 hwaddr device_indicator; 112 uint64_t ind_bit; 113 uint8_t isc; 114 } QEMU_PACKED VirtioThinintInfo; 115 116 typedef struct VirtioRevInfo { 117 uint16_t revision; 118 uint16_t length; 119 uint8_t data[0]; 120 } QEMU_PACKED VirtioRevInfo; 121 122 /* Specify where the virtqueues for the subchannel are in guest memory. */ 123 static int virtio_ccw_set_vqs(SubchDev *sch, VqInfoBlock *info, 124 VqInfoBlockLegacy *linfo) 125 { 126 VirtIODevice *vdev = virtio_ccw_get_vdev(sch); 127 uint16_t index = info ? info->index : linfo->index; 128 uint16_t num = info ? info->num : linfo->num; 129 uint64_t desc = info ? info->desc : linfo->queue; 130 131 if (index >= VIRTIO_QUEUE_MAX) { 132 return -EINVAL; 133 } 134 135 /* Current code in virtio.c relies on 4K alignment. */ 136 if (linfo && desc && (linfo->align != 4096)) { 137 return -EINVAL; 138 } 139 140 if (!vdev) { 141 return -EINVAL; 142 } 143 144 if (info) { 145 virtio_queue_set_rings(vdev, index, desc, info->avail, info->used); 146 } else { 147 virtio_queue_set_addr(vdev, index, desc); 148 } 149 if (!desc) { 150 virtio_queue_set_vector(vdev, index, VIRTIO_NO_VECTOR); 151 } else { 152 if (info) { 153 /* virtio-1 allows changing the ring size. */ 154 if (virtio_queue_get_max_num(vdev, index) < num) { 155 /* Fail if we exceed the maximum number. */ 156 return -EINVAL; 157 } 158 virtio_queue_set_num(vdev, index, num); 159 } else if (virtio_queue_get_num(vdev, index) > num) { 160 /* Fail if we don't have a big enough queue. */ 161 return -EINVAL; 162 } 163 /* We ignore possible increased num for legacy for compatibility. */ 164 virtio_queue_set_vector(vdev, index, index); 165 } 166 /* tell notify handler in case of config change */ 167 vdev->config_vector = VIRTIO_QUEUE_MAX; 168 return 0; 169 } 170 171 static void virtio_ccw_reset_virtio(VirtioCcwDevice *dev, VirtIODevice *vdev) 172 { 173 CcwDevice *ccw_dev = CCW_DEVICE(dev); 174 175 virtio_ccw_stop_ioeventfd(dev); 176 virtio_reset(vdev); 177 if (dev->indicators) { 178 release_indicator(&dev->routes.adapter, dev->indicators); 179 dev->indicators = NULL; 180 } 181 if (dev->indicators2) { 182 release_indicator(&dev->routes.adapter, dev->indicators2); 183 dev->indicators2 = NULL; 184 } 185 if (dev->summary_indicator) { 186 release_indicator(&dev->routes.adapter, dev->summary_indicator); 187 dev->summary_indicator = NULL; 188 } 189 ccw_dev->sch->thinint_active = false; 190 } 191 192 static int virtio_ccw_handle_set_vq(SubchDev *sch, CCW1 ccw, bool check_len, 193 bool is_legacy) 194 { 195 int ret; 196 VqInfoBlock info; 197 VqInfoBlockLegacy linfo; 198 size_t info_len = is_legacy ? sizeof(linfo) : sizeof(info); 199 200 if (check_len) { 201 if (ccw.count != info_len) { 202 return -EINVAL; 203 } 204 } else if (ccw.count < info_len) { 205 /* Can't execute command. */ 206 return -EINVAL; 207 } 208 if (!ccw.cda) { 209 return -EFAULT; 210 } 211 if (is_legacy) { 212 linfo.queue = address_space_ldq_be(&address_space_memory, ccw.cda, 213 MEMTXATTRS_UNSPECIFIED, NULL); 214 linfo.align = address_space_ldl_be(&address_space_memory, 215 ccw.cda + sizeof(linfo.queue), 216 MEMTXATTRS_UNSPECIFIED, 217 NULL); 218 linfo.index = address_space_lduw_be(&address_space_memory, 219 ccw.cda + sizeof(linfo.queue) 220 + sizeof(linfo.align), 221 MEMTXATTRS_UNSPECIFIED, 222 NULL); 223 linfo.num = address_space_lduw_be(&address_space_memory, 224 ccw.cda + sizeof(linfo.queue) 225 + sizeof(linfo.align) 226 + sizeof(linfo.index), 227 MEMTXATTRS_UNSPECIFIED, 228 NULL); 229 ret = virtio_ccw_set_vqs(sch, NULL, &linfo); 230 } else { 231 info.desc = address_space_ldq_be(&address_space_memory, ccw.cda, 232 MEMTXATTRS_UNSPECIFIED, NULL); 233 info.index = address_space_lduw_be(&address_space_memory, 234 ccw.cda + sizeof(info.desc) 235 + sizeof(info.res0), 236 MEMTXATTRS_UNSPECIFIED, NULL); 237 info.num = address_space_lduw_be(&address_space_memory, 238 ccw.cda + sizeof(info.desc) 239 + sizeof(info.res0) 240 + sizeof(info.index), 241 MEMTXATTRS_UNSPECIFIED, NULL); 242 info.avail = address_space_ldq_be(&address_space_memory, 243 ccw.cda + sizeof(info.desc) 244 + sizeof(info.res0) 245 + sizeof(info.index) 246 + sizeof(info.num), 247 MEMTXATTRS_UNSPECIFIED, NULL); 248 info.used = address_space_ldq_be(&address_space_memory, 249 ccw.cda + sizeof(info.desc) 250 + sizeof(info.res0) 251 + sizeof(info.index) 252 + sizeof(info.num) 253 + sizeof(info.avail), 254 MEMTXATTRS_UNSPECIFIED, NULL); 255 ret = virtio_ccw_set_vqs(sch, &info, NULL); 256 } 257 sch->curr_status.scsw.count = 0; 258 return ret; 259 } 260 261 static int virtio_ccw_cb(SubchDev *sch, CCW1 ccw) 262 { 263 int ret; 264 VirtioRevInfo revinfo; 265 uint8_t status; 266 VirtioFeatDesc features; 267 void *config; 268 hwaddr indicators; 269 VqConfigBlock vq_config; 270 VirtioCcwDevice *dev = sch->driver_data; 271 VirtIODevice *vdev = virtio_ccw_get_vdev(sch); 272 bool check_len; 273 int len; 274 hwaddr hw_len; 275 VirtioThinintInfo *thinint; 276 277 if (!dev) { 278 return -EINVAL; 279 } 280 281 trace_virtio_ccw_interpret_ccw(sch->cssid, sch->ssid, sch->schid, 282 ccw.cmd_code); 283 check_len = !((ccw.flags & CCW_FLAG_SLI) && !(ccw.flags & CCW_FLAG_DC)); 284 285 if (dev->force_revision_1 && dev->revision < 0 && 286 ccw.cmd_code != CCW_CMD_SET_VIRTIO_REV) { 287 /* 288 * virtio-1 drivers must start with negotiating to a revision >= 1, 289 * so post a command reject for all other commands 290 */ 291 return -ENOSYS; 292 } 293 294 /* Look at the command. */ 295 switch (ccw.cmd_code) { 296 case CCW_CMD_SET_VQ: 297 ret = virtio_ccw_handle_set_vq(sch, ccw, check_len, dev->revision < 1); 298 break; 299 case CCW_CMD_VDEV_RESET: 300 virtio_ccw_reset_virtio(dev, vdev); 301 ret = 0; 302 break; 303 case CCW_CMD_READ_FEAT: 304 if (check_len) { 305 if (ccw.count != sizeof(features)) { 306 ret = -EINVAL; 307 break; 308 } 309 } else if (ccw.count < sizeof(features)) { 310 /* Can't execute command. */ 311 ret = -EINVAL; 312 break; 313 } 314 if (!ccw.cda) { 315 ret = -EFAULT; 316 } else { 317 VirtioDeviceClass *vdc = VIRTIO_DEVICE_GET_CLASS(vdev); 318 319 features.index = address_space_ldub(&address_space_memory, 320 ccw.cda 321 + sizeof(features.features), 322 MEMTXATTRS_UNSPECIFIED, 323 NULL); 324 if (features.index == 0) { 325 if (dev->revision >= 1) { 326 /* Don't offer legacy features for modern devices. */ 327 features.features = (uint32_t) 328 (vdev->host_features & ~vdc->legacy_features); 329 } else { 330 features.features = (uint32_t)vdev->host_features; 331 } 332 } else if ((features.index == 1) && (dev->revision >= 1)) { 333 /* 334 * Only offer feature bits beyond 31 if the guest has 335 * negotiated at least revision 1. 336 */ 337 features.features = (uint32_t)(vdev->host_features >> 32); 338 } else { 339 /* Return zeroes if the guest supports more feature bits. */ 340 features.features = 0; 341 } 342 address_space_stl_le(&address_space_memory, ccw.cda, 343 features.features, MEMTXATTRS_UNSPECIFIED, 344 NULL); 345 sch->curr_status.scsw.count = ccw.count - sizeof(features); 346 ret = 0; 347 } 348 break; 349 case CCW_CMD_WRITE_FEAT: 350 if (check_len) { 351 if (ccw.count != sizeof(features)) { 352 ret = -EINVAL; 353 break; 354 } 355 } else if (ccw.count < sizeof(features)) { 356 /* Can't execute command. */ 357 ret = -EINVAL; 358 break; 359 } 360 if (!ccw.cda) { 361 ret = -EFAULT; 362 } else { 363 features.index = address_space_ldub(&address_space_memory, 364 ccw.cda 365 + sizeof(features.features), 366 MEMTXATTRS_UNSPECIFIED, 367 NULL); 368 features.features = address_space_ldl_le(&address_space_memory, 369 ccw.cda, 370 MEMTXATTRS_UNSPECIFIED, 371 NULL); 372 if (features.index == 0) { 373 virtio_set_features(vdev, 374 (vdev->guest_features & 0xffffffff00000000ULL) | 375 features.features); 376 } else if ((features.index == 1) && (dev->revision >= 1)) { 377 /* 378 * If the guest did not negotiate at least revision 1, 379 * we did not offer it any feature bits beyond 31. Such a 380 * guest passing us any bit here is therefore buggy. 381 */ 382 virtio_set_features(vdev, 383 (vdev->guest_features & 0x00000000ffffffffULL) | 384 ((uint64_t)features.features << 32)); 385 } else { 386 /* 387 * If the guest supports more feature bits, assert that it 388 * passes us zeroes for those we don't support. 389 */ 390 if (features.features) { 391 fprintf(stderr, "Guest bug: features[%i]=%x (expected 0)\n", 392 features.index, features.features); 393 /* XXX: do a unit check here? */ 394 } 395 } 396 sch->curr_status.scsw.count = ccw.count - sizeof(features); 397 ret = 0; 398 } 399 break; 400 case CCW_CMD_READ_CONF: 401 if (check_len) { 402 if (ccw.count > vdev->config_len) { 403 ret = -EINVAL; 404 break; 405 } 406 } 407 len = MIN(ccw.count, vdev->config_len); 408 if (!ccw.cda) { 409 ret = -EFAULT; 410 } else { 411 virtio_bus_get_vdev_config(&dev->bus, vdev->config); 412 /* XXX config space endianness */ 413 cpu_physical_memory_write(ccw.cda, vdev->config, len); 414 sch->curr_status.scsw.count = ccw.count - len; 415 ret = 0; 416 } 417 break; 418 case CCW_CMD_WRITE_CONF: 419 if (check_len) { 420 if (ccw.count > vdev->config_len) { 421 ret = -EINVAL; 422 break; 423 } 424 } 425 len = MIN(ccw.count, vdev->config_len); 426 hw_len = len; 427 if (!ccw.cda) { 428 ret = -EFAULT; 429 } else { 430 config = cpu_physical_memory_map(ccw.cda, &hw_len, 0); 431 if (!config) { 432 ret = -EFAULT; 433 } else { 434 len = hw_len; 435 /* XXX config space endianness */ 436 memcpy(vdev->config, config, len); 437 cpu_physical_memory_unmap(config, hw_len, 0, hw_len); 438 virtio_bus_set_vdev_config(&dev->bus, vdev->config); 439 sch->curr_status.scsw.count = ccw.count - len; 440 ret = 0; 441 } 442 } 443 break; 444 case CCW_CMD_READ_STATUS: 445 if (check_len) { 446 if (ccw.count != sizeof(status)) { 447 ret = -EINVAL; 448 break; 449 } 450 } else if (ccw.count < sizeof(status)) { 451 /* Can't execute command. */ 452 ret = -EINVAL; 453 break; 454 } 455 if (!ccw.cda) { 456 ret = -EFAULT; 457 } else { 458 address_space_stb(&address_space_memory, ccw.cda, vdev->status, 459 MEMTXATTRS_UNSPECIFIED, NULL); 460 sch->curr_status.scsw.count = ccw.count - sizeof(vdev->status);; 461 ret = 0; 462 } 463 break; 464 case CCW_CMD_WRITE_STATUS: 465 if (check_len) { 466 if (ccw.count != sizeof(status)) { 467 ret = -EINVAL; 468 break; 469 } 470 } else if (ccw.count < sizeof(status)) { 471 /* Can't execute command. */ 472 ret = -EINVAL; 473 break; 474 } 475 if (!ccw.cda) { 476 ret = -EFAULT; 477 } else { 478 status = address_space_ldub(&address_space_memory, ccw.cda, 479 MEMTXATTRS_UNSPECIFIED, NULL); 480 if (!(status & VIRTIO_CONFIG_S_DRIVER_OK)) { 481 virtio_ccw_stop_ioeventfd(dev); 482 } 483 if (virtio_set_status(vdev, status) == 0) { 484 if (vdev->status == 0) { 485 virtio_ccw_reset_virtio(dev, vdev); 486 } 487 if (status & VIRTIO_CONFIG_S_DRIVER_OK) { 488 virtio_ccw_start_ioeventfd(dev); 489 } 490 sch->curr_status.scsw.count = ccw.count - sizeof(status); 491 ret = 0; 492 } else { 493 /* Trigger a command reject. */ 494 ret = -ENOSYS; 495 } 496 } 497 break; 498 case CCW_CMD_SET_IND: 499 if (check_len) { 500 if (ccw.count != sizeof(indicators)) { 501 ret = -EINVAL; 502 break; 503 } 504 } else if (ccw.count < sizeof(indicators)) { 505 /* Can't execute command. */ 506 ret = -EINVAL; 507 break; 508 } 509 if (sch->thinint_active) { 510 /* Trigger a command reject. */ 511 ret = -ENOSYS; 512 break; 513 } 514 if (virtio_get_num_queues(vdev) > NR_CLASSIC_INDICATOR_BITS) { 515 /* More queues than indicator bits --> trigger a reject */ 516 ret = -ENOSYS; 517 break; 518 } 519 if (!ccw.cda) { 520 ret = -EFAULT; 521 } else { 522 indicators = address_space_ldq_be(&address_space_memory, ccw.cda, 523 MEMTXATTRS_UNSPECIFIED, NULL); 524 dev->indicators = get_indicator(indicators, sizeof(uint64_t)); 525 sch->curr_status.scsw.count = ccw.count - sizeof(indicators); 526 ret = 0; 527 } 528 break; 529 case CCW_CMD_SET_CONF_IND: 530 if (check_len) { 531 if (ccw.count != sizeof(indicators)) { 532 ret = -EINVAL; 533 break; 534 } 535 } else if (ccw.count < sizeof(indicators)) { 536 /* Can't execute command. */ 537 ret = -EINVAL; 538 break; 539 } 540 if (!ccw.cda) { 541 ret = -EFAULT; 542 } else { 543 indicators = address_space_ldq_be(&address_space_memory, ccw.cda, 544 MEMTXATTRS_UNSPECIFIED, NULL); 545 dev->indicators2 = get_indicator(indicators, sizeof(uint64_t)); 546 sch->curr_status.scsw.count = ccw.count - sizeof(indicators); 547 ret = 0; 548 } 549 break; 550 case CCW_CMD_READ_VQ_CONF: 551 if (check_len) { 552 if (ccw.count != sizeof(vq_config)) { 553 ret = -EINVAL; 554 break; 555 } 556 } else if (ccw.count < sizeof(vq_config)) { 557 /* Can't execute command. */ 558 ret = -EINVAL; 559 break; 560 } 561 if (!ccw.cda) { 562 ret = -EFAULT; 563 } else { 564 vq_config.index = address_space_lduw_be(&address_space_memory, 565 ccw.cda, 566 MEMTXATTRS_UNSPECIFIED, 567 NULL); 568 if (vq_config.index >= VIRTIO_QUEUE_MAX) { 569 ret = -EINVAL; 570 break; 571 } 572 vq_config.num_max = virtio_queue_get_num(vdev, 573 vq_config.index); 574 address_space_stw_be(&address_space_memory, 575 ccw.cda + sizeof(vq_config.index), 576 vq_config.num_max, 577 MEMTXATTRS_UNSPECIFIED, 578 NULL); 579 sch->curr_status.scsw.count = ccw.count - sizeof(vq_config); 580 ret = 0; 581 } 582 break; 583 case CCW_CMD_SET_IND_ADAPTER: 584 if (check_len) { 585 if (ccw.count != sizeof(*thinint)) { 586 ret = -EINVAL; 587 break; 588 } 589 } else if (ccw.count < sizeof(*thinint)) { 590 /* Can't execute command. */ 591 ret = -EINVAL; 592 break; 593 } 594 len = sizeof(*thinint); 595 hw_len = len; 596 if (!ccw.cda) { 597 ret = -EFAULT; 598 } else if (dev->indicators && !sch->thinint_active) { 599 /* Trigger a command reject. */ 600 ret = -ENOSYS; 601 } else { 602 thinint = cpu_physical_memory_map(ccw.cda, &hw_len, 0); 603 if (!thinint) { 604 ret = -EFAULT; 605 } else { 606 uint64_t ind_bit = ldq_be_p(&thinint->ind_bit); 607 608 len = hw_len; 609 dev->summary_indicator = 610 get_indicator(ldq_be_p(&thinint->summary_indicator), 611 sizeof(uint8_t)); 612 dev->indicators = 613 get_indicator(ldq_be_p(&thinint->device_indicator), 614 ind_bit / 8 + 1); 615 dev->thinint_isc = thinint->isc; 616 dev->routes.adapter.ind_offset = ind_bit; 617 dev->routes.adapter.summary_offset = 7; 618 cpu_physical_memory_unmap(thinint, hw_len, 0, hw_len); 619 dev->routes.adapter.adapter_id = css_get_adapter_id( 620 CSS_IO_ADAPTER_VIRTIO, 621 dev->thinint_isc); 622 sch->thinint_active = ((dev->indicators != NULL) && 623 (dev->summary_indicator != NULL)); 624 sch->curr_status.scsw.count = ccw.count - len; 625 ret = 0; 626 } 627 } 628 break; 629 case CCW_CMD_SET_VIRTIO_REV: 630 len = sizeof(revinfo); 631 if (ccw.count < len) { 632 ret = -EINVAL; 633 break; 634 } 635 if (!ccw.cda) { 636 ret = -EFAULT; 637 break; 638 } 639 revinfo.revision = 640 address_space_lduw_be(&address_space_memory, ccw.cda, 641 MEMTXATTRS_UNSPECIFIED, NULL); 642 revinfo.length = 643 address_space_lduw_be(&address_space_memory, 644 ccw.cda + sizeof(revinfo.revision), 645 MEMTXATTRS_UNSPECIFIED, NULL); 646 if (ccw.count < len + revinfo.length || 647 (check_len && ccw.count > len + revinfo.length)) { 648 ret = -EINVAL; 649 break; 650 } 651 /* 652 * Once we start to support revisions with additional data, we'll 653 * need to fetch it here. Nothing to do for now, though. 654 */ 655 if (dev->revision >= 0 || 656 revinfo.revision > virtio_ccw_rev_max(dev) || 657 (dev->force_revision_1 && !revinfo.revision)) { 658 ret = -ENOSYS; 659 break; 660 } 661 ret = 0; 662 dev->revision = revinfo.revision; 663 break; 664 default: 665 ret = -ENOSYS; 666 break; 667 } 668 return ret; 669 } 670 671 static void virtio_sch_disable_cb(SubchDev *sch) 672 { 673 VirtioCcwDevice *dev = sch->driver_data; 674 675 dev->revision = -1; 676 } 677 678 static void virtio_ccw_device_realize(VirtioCcwDevice *dev, Error **errp) 679 { 680 VirtIOCCWDeviceClass *k = VIRTIO_CCW_DEVICE_GET_CLASS(dev); 681 CcwDevice *ccw_dev = CCW_DEVICE(dev); 682 CCWDeviceClass *ck = CCW_DEVICE_GET_CLASS(ccw_dev); 683 DeviceState *parent = DEVICE(ccw_dev); 684 BusState *qbus = qdev_get_parent_bus(parent); 685 VirtualCssBus *cbus = VIRTUAL_CSS_BUS(qbus); 686 SubchDev *sch; 687 Error *err = NULL; 688 689 sch = css_create_sch(ccw_dev->devno, true, cbus->squash_mcss, errp); 690 if (!sch) { 691 return; 692 } 693 if (!virtio_ccw_rev_max(dev) && dev->force_revision_1) { 694 error_setg(&err, "Invalid value of property max_rev " 695 "(is %d expected >= 1)", virtio_ccw_rev_max(dev)); 696 goto out_err; 697 } 698 699 sch->driver_data = dev; 700 sch->ccw_cb = virtio_ccw_cb; 701 sch->disable_cb = virtio_sch_disable_cb; 702 sch->id.reserved = 0xff; 703 sch->id.cu_type = VIRTIO_CCW_CU_TYPE; 704 sch->do_subchannel_work = do_subchannel_work_virtual; 705 ccw_dev->sch = sch; 706 dev->indicators = NULL; 707 dev->revision = -1; 708 css_sch_build_virtual_schib(sch, 0, VIRTIO_CCW_CHPID_TYPE); 709 710 trace_virtio_ccw_new_device( 711 sch->cssid, sch->ssid, sch->schid, sch->devno, 712 ccw_dev->devno.valid ? "user-configured" : "auto-configured"); 713 714 if (!kvm_eventfds_enabled()) { 715 dev->flags &= ~VIRTIO_CCW_FLAG_USE_IOEVENTFD; 716 } 717 718 if (k->realize) { 719 k->realize(dev, &err); 720 if (err) { 721 goto out_err; 722 } 723 } 724 725 ck->realize(ccw_dev, &err); 726 if (err) { 727 goto out_err; 728 } 729 730 return; 731 732 out_err: 733 error_propagate(errp, err); 734 css_subch_assign(sch->cssid, sch->ssid, sch->schid, sch->devno, NULL); 735 ccw_dev->sch = NULL; 736 g_free(sch); 737 } 738 739 static int virtio_ccw_exit(VirtioCcwDevice *dev) 740 { 741 CcwDevice *ccw_dev = CCW_DEVICE(dev); 742 SubchDev *sch = ccw_dev->sch; 743 744 if (sch) { 745 css_subch_assign(sch->cssid, sch->ssid, sch->schid, sch->devno, NULL); 746 g_free(sch); 747 } 748 if (dev->indicators) { 749 release_indicator(&dev->routes.adapter, dev->indicators); 750 dev->indicators = NULL; 751 } 752 return 0; 753 } 754 755 static void virtio_ccw_net_realize(VirtioCcwDevice *ccw_dev, Error **errp) 756 { 757 DeviceState *qdev = DEVICE(ccw_dev); 758 VirtIONetCcw *dev = VIRTIO_NET_CCW(ccw_dev); 759 DeviceState *vdev = DEVICE(&dev->vdev); 760 761 virtio_net_set_netclient_name(&dev->vdev, qdev->id, 762 object_get_typename(OBJECT(qdev))); 763 qdev_set_parent_bus(vdev, BUS(&ccw_dev->bus)); 764 object_property_set_bool(OBJECT(vdev), true, "realized", errp); 765 } 766 767 static void virtio_ccw_net_instance_init(Object *obj) 768 { 769 VirtIONetCcw *dev = VIRTIO_NET_CCW(obj); 770 771 virtio_instance_init_common(obj, &dev->vdev, sizeof(dev->vdev), 772 TYPE_VIRTIO_NET); 773 object_property_add_alias(obj, "bootindex", OBJECT(&dev->vdev), 774 "bootindex", &error_abort); 775 } 776 777 static void virtio_ccw_blk_realize(VirtioCcwDevice *ccw_dev, Error **errp) 778 { 779 VirtIOBlkCcw *dev = VIRTIO_BLK_CCW(ccw_dev); 780 DeviceState *vdev = DEVICE(&dev->vdev); 781 782 qdev_set_parent_bus(vdev, BUS(&ccw_dev->bus)); 783 object_property_set_bool(OBJECT(vdev), true, "realized", errp); 784 } 785 786 static void virtio_ccw_blk_instance_init(Object *obj) 787 { 788 VirtIOBlkCcw *dev = VIRTIO_BLK_CCW(obj); 789 790 virtio_instance_init_common(obj, &dev->vdev, sizeof(dev->vdev), 791 TYPE_VIRTIO_BLK); 792 object_property_add_alias(obj, "iothread", OBJECT(&dev->vdev),"iothread", 793 &error_abort); 794 object_property_add_alias(obj, "bootindex", OBJECT(&dev->vdev), 795 "bootindex", &error_abort); 796 } 797 798 static void virtio_ccw_serial_realize(VirtioCcwDevice *ccw_dev, Error **errp) 799 { 800 VirtioSerialCcw *dev = VIRTIO_SERIAL_CCW(ccw_dev); 801 DeviceState *vdev = DEVICE(&dev->vdev); 802 DeviceState *proxy = DEVICE(ccw_dev); 803 char *bus_name; 804 805 /* 806 * For command line compatibility, this sets the virtio-serial-device bus 807 * name as before. 808 */ 809 if (proxy->id) { 810 bus_name = g_strdup_printf("%s.0", proxy->id); 811 virtio_device_set_child_bus_name(VIRTIO_DEVICE(vdev), bus_name); 812 g_free(bus_name); 813 } 814 815 qdev_set_parent_bus(vdev, BUS(&ccw_dev->bus)); 816 object_property_set_bool(OBJECT(vdev), true, "realized", errp); 817 } 818 819 820 static void virtio_ccw_serial_instance_init(Object *obj) 821 { 822 VirtioSerialCcw *dev = VIRTIO_SERIAL_CCW(obj); 823 824 virtio_instance_init_common(obj, &dev->vdev, sizeof(dev->vdev), 825 TYPE_VIRTIO_SERIAL); 826 } 827 828 static void virtio_ccw_balloon_realize(VirtioCcwDevice *ccw_dev, Error **errp) 829 { 830 VirtIOBalloonCcw *dev = VIRTIO_BALLOON_CCW(ccw_dev); 831 DeviceState *vdev = DEVICE(&dev->vdev); 832 833 qdev_set_parent_bus(vdev, BUS(&ccw_dev->bus)); 834 object_property_set_bool(OBJECT(vdev), true, "realized", errp); 835 } 836 837 static void virtio_ccw_balloon_instance_init(Object *obj) 838 { 839 VirtIOBalloonCcw *dev = VIRTIO_BALLOON_CCW(obj); 840 841 virtio_instance_init_common(obj, &dev->vdev, sizeof(dev->vdev), 842 TYPE_VIRTIO_BALLOON); 843 object_property_add_alias(obj, "guest-stats", OBJECT(&dev->vdev), 844 "guest-stats", &error_abort); 845 object_property_add_alias(obj, "guest-stats-polling-interval", 846 OBJECT(&dev->vdev), 847 "guest-stats-polling-interval", &error_abort); 848 } 849 850 static void virtio_ccw_scsi_realize(VirtioCcwDevice *ccw_dev, Error **errp) 851 { 852 VirtIOSCSICcw *dev = VIRTIO_SCSI_CCW(ccw_dev); 853 DeviceState *vdev = DEVICE(&dev->vdev); 854 DeviceState *qdev = DEVICE(ccw_dev); 855 char *bus_name; 856 857 /* 858 * For command line compatibility, this sets the virtio-scsi-device bus 859 * name as before. 860 */ 861 if (qdev->id) { 862 bus_name = g_strdup_printf("%s.0", qdev->id); 863 virtio_device_set_child_bus_name(VIRTIO_DEVICE(vdev), bus_name); 864 g_free(bus_name); 865 } 866 867 qdev_set_parent_bus(vdev, BUS(&ccw_dev->bus)); 868 object_property_set_bool(OBJECT(vdev), true, "realized", errp); 869 } 870 871 static void virtio_ccw_scsi_instance_init(Object *obj) 872 { 873 VirtIOSCSICcw *dev = VIRTIO_SCSI_CCW(obj); 874 875 virtio_instance_init_common(obj, &dev->vdev, sizeof(dev->vdev), 876 TYPE_VIRTIO_SCSI); 877 object_property_add_alias(obj, "iothread", OBJECT(&dev->vdev), "iothread", 878 &error_abort); 879 } 880 881 #ifdef CONFIG_VHOST_SCSI 882 static void vhost_ccw_scsi_realize(VirtioCcwDevice *ccw_dev, Error **errp) 883 { 884 VHostSCSICcw *dev = VHOST_SCSI_CCW(ccw_dev); 885 DeviceState *vdev = DEVICE(&dev->vdev); 886 887 qdev_set_parent_bus(vdev, BUS(&ccw_dev->bus)); 888 object_property_set_bool(OBJECT(vdev), true, "realized", errp); 889 } 890 891 static void vhost_ccw_scsi_instance_init(Object *obj) 892 { 893 VHostSCSICcw *dev = VHOST_SCSI_CCW(obj); 894 895 virtio_instance_init_common(obj, &dev->vdev, sizeof(dev->vdev), 896 TYPE_VHOST_SCSI); 897 } 898 #endif 899 900 static void virtio_ccw_rng_realize(VirtioCcwDevice *ccw_dev, Error **errp) 901 { 902 VirtIORNGCcw *dev = VIRTIO_RNG_CCW(ccw_dev); 903 DeviceState *vdev = DEVICE(&dev->vdev); 904 Error *err = NULL; 905 906 qdev_set_parent_bus(vdev, BUS(&ccw_dev->bus)); 907 object_property_set_bool(OBJECT(vdev), true, "realized", &err); 908 if (err) { 909 error_propagate(errp, err); 910 return; 911 } 912 913 object_property_set_link(OBJECT(dev), 914 OBJECT(dev->vdev.conf.rng), "rng", 915 NULL); 916 } 917 918 static void virtio_ccw_crypto_realize(VirtioCcwDevice *ccw_dev, Error **errp) 919 { 920 VirtIOCryptoCcw *dev = VIRTIO_CRYPTO_CCW(ccw_dev); 921 DeviceState *vdev = DEVICE(&dev->vdev); 922 Error *err = NULL; 923 924 qdev_set_parent_bus(vdev, BUS(&ccw_dev->bus)); 925 object_property_set_bool(OBJECT(vdev), true, "realized", &err); 926 if (err) { 927 error_propagate(errp, err); 928 return; 929 } 930 931 object_property_set_link(OBJECT(vdev), 932 OBJECT(dev->vdev.conf.cryptodev), "cryptodev", 933 NULL); 934 } 935 936 /* DeviceState to VirtioCcwDevice. Note: used on datapath, 937 * be careful and test performance if you change this. 938 */ 939 static inline VirtioCcwDevice *to_virtio_ccw_dev_fast(DeviceState *d) 940 { 941 CcwDevice *ccw_dev = to_ccw_dev_fast(d); 942 943 return container_of(ccw_dev, VirtioCcwDevice, parent_obj); 944 } 945 946 static uint8_t virtio_set_ind_atomic(SubchDev *sch, uint64_t ind_loc, 947 uint8_t to_be_set) 948 { 949 uint8_t ind_old, ind_new; 950 hwaddr len = 1; 951 uint8_t *ind_addr; 952 953 ind_addr = cpu_physical_memory_map(ind_loc, &len, 1); 954 if (!ind_addr) { 955 error_report("%s(%x.%x.%04x): unable to access indicator", 956 __func__, sch->cssid, sch->ssid, sch->schid); 957 return -1; 958 } 959 do { 960 ind_old = *ind_addr; 961 ind_new = ind_old | to_be_set; 962 } while (atomic_cmpxchg(ind_addr, ind_old, ind_new) != ind_old); 963 trace_virtio_ccw_set_ind(ind_loc, ind_old, ind_new); 964 cpu_physical_memory_unmap(ind_addr, len, 1, len); 965 966 return ind_old; 967 } 968 969 static void virtio_ccw_notify(DeviceState *d, uint16_t vector) 970 { 971 VirtioCcwDevice *dev = to_virtio_ccw_dev_fast(d); 972 CcwDevice *ccw_dev = to_ccw_dev_fast(d); 973 SubchDev *sch = ccw_dev->sch; 974 uint64_t indicators; 975 976 /* queue indicators + secondary indicators */ 977 if (vector >= VIRTIO_QUEUE_MAX + 64) { 978 return; 979 } 980 981 if (vector < VIRTIO_QUEUE_MAX) { 982 if (!dev->indicators) { 983 return; 984 } 985 if (sch->thinint_active) { 986 /* 987 * In the adapter interrupt case, indicators points to a 988 * memory area that may be (way) larger than 64 bit and 989 * ind_bit indicates the start of the indicators in a big 990 * endian notation. 991 */ 992 uint64_t ind_bit = dev->routes.adapter.ind_offset; 993 994 virtio_set_ind_atomic(sch, dev->indicators->addr + 995 (ind_bit + vector) / 8, 996 0x80 >> ((ind_bit + vector) % 8)); 997 if (!virtio_set_ind_atomic(sch, dev->summary_indicator->addr, 998 0x01)) { 999 css_adapter_interrupt(dev->thinint_isc); 1000 } 1001 } else { 1002 indicators = address_space_ldq(&address_space_memory, 1003 dev->indicators->addr, 1004 MEMTXATTRS_UNSPECIFIED, 1005 NULL); 1006 indicators |= 1ULL << vector; 1007 address_space_stq(&address_space_memory, dev->indicators->addr, 1008 indicators, MEMTXATTRS_UNSPECIFIED, NULL); 1009 css_conditional_io_interrupt(sch); 1010 } 1011 } else { 1012 if (!dev->indicators2) { 1013 return; 1014 } 1015 vector = 0; 1016 indicators = address_space_ldq(&address_space_memory, 1017 dev->indicators2->addr, 1018 MEMTXATTRS_UNSPECIFIED, 1019 NULL); 1020 indicators |= 1ULL << vector; 1021 address_space_stq(&address_space_memory, dev->indicators2->addr, 1022 indicators, MEMTXATTRS_UNSPECIFIED, NULL); 1023 css_conditional_io_interrupt(sch); 1024 } 1025 } 1026 1027 static void virtio_ccw_reset(DeviceState *d) 1028 { 1029 VirtioCcwDevice *dev = VIRTIO_CCW_DEVICE(d); 1030 VirtIODevice *vdev = virtio_bus_get_device(&dev->bus); 1031 CcwDevice *ccw_dev = CCW_DEVICE(d); 1032 1033 virtio_ccw_reset_virtio(dev, vdev); 1034 css_reset_sch(ccw_dev->sch); 1035 } 1036 1037 static void virtio_ccw_vmstate_change(DeviceState *d, bool running) 1038 { 1039 VirtioCcwDevice *dev = VIRTIO_CCW_DEVICE(d); 1040 1041 if (running) { 1042 virtio_ccw_start_ioeventfd(dev); 1043 } else { 1044 virtio_ccw_stop_ioeventfd(dev); 1045 } 1046 } 1047 1048 static bool virtio_ccw_query_guest_notifiers(DeviceState *d) 1049 { 1050 CcwDevice *dev = CCW_DEVICE(d); 1051 1052 return !!(dev->sch->curr_status.pmcw.flags & PMCW_FLAGS_MASK_ENA); 1053 } 1054 1055 static int virtio_ccw_get_mappings(VirtioCcwDevice *dev) 1056 { 1057 int r; 1058 CcwDevice *ccw_dev = CCW_DEVICE(dev); 1059 1060 if (!ccw_dev->sch->thinint_active) { 1061 return -EINVAL; 1062 } 1063 1064 r = map_indicator(&dev->routes.adapter, dev->summary_indicator); 1065 if (r) { 1066 return r; 1067 } 1068 r = map_indicator(&dev->routes.adapter, dev->indicators); 1069 if (r) { 1070 return r; 1071 } 1072 dev->routes.adapter.summary_addr = dev->summary_indicator->map; 1073 dev->routes.adapter.ind_addr = dev->indicators->map; 1074 1075 return 0; 1076 } 1077 1078 static int virtio_ccw_setup_irqroutes(VirtioCcwDevice *dev, int nvqs) 1079 { 1080 int i; 1081 VirtIODevice *vdev = virtio_bus_get_device(&dev->bus); 1082 int ret; 1083 S390FLICState *fs = s390_get_flic(); 1084 S390FLICStateClass *fsc = S390_FLIC_COMMON_GET_CLASS(fs); 1085 1086 ret = virtio_ccw_get_mappings(dev); 1087 if (ret) { 1088 return ret; 1089 } 1090 for (i = 0; i < nvqs; i++) { 1091 if (!virtio_queue_get_num(vdev, i)) { 1092 break; 1093 } 1094 } 1095 dev->routes.num_routes = i; 1096 return fsc->add_adapter_routes(fs, &dev->routes); 1097 } 1098 1099 static void virtio_ccw_release_irqroutes(VirtioCcwDevice *dev, int nvqs) 1100 { 1101 S390FLICState *fs = s390_get_flic(); 1102 S390FLICStateClass *fsc = S390_FLIC_COMMON_GET_CLASS(fs); 1103 1104 fsc->release_adapter_routes(fs, &dev->routes); 1105 } 1106 1107 static int virtio_ccw_add_irqfd(VirtioCcwDevice *dev, int n) 1108 { 1109 VirtIODevice *vdev = virtio_bus_get_device(&dev->bus); 1110 VirtQueue *vq = virtio_get_queue(vdev, n); 1111 EventNotifier *notifier = virtio_queue_get_guest_notifier(vq); 1112 1113 return kvm_irqchip_add_irqfd_notifier_gsi(kvm_state, notifier, NULL, 1114 dev->routes.gsi[n]); 1115 } 1116 1117 static void virtio_ccw_remove_irqfd(VirtioCcwDevice *dev, int n) 1118 { 1119 VirtIODevice *vdev = virtio_bus_get_device(&dev->bus); 1120 VirtQueue *vq = virtio_get_queue(vdev, n); 1121 EventNotifier *notifier = virtio_queue_get_guest_notifier(vq); 1122 int ret; 1123 1124 ret = kvm_irqchip_remove_irqfd_notifier_gsi(kvm_state, notifier, 1125 dev->routes.gsi[n]); 1126 assert(ret == 0); 1127 } 1128 1129 static int virtio_ccw_set_guest_notifier(VirtioCcwDevice *dev, int n, 1130 bool assign, bool with_irqfd) 1131 { 1132 VirtIODevice *vdev = virtio_bus_get_device(&dev->bus); 1133 VirtQueue *vq = virtio_get_queue(vdev, n); 1134 EventNotifier *notifier = virtio_queue_get_guest_notifier(vq); 1135 VirtioDeviceClass *k = VIRTIO_DEVICE_GET_CLASS(vdev); 1136 1137 if (assign) { 1138 int r = event_notifier_init(notifier, 0); 1139 1140 if (r < 0) { 1141 return r; 1142 } 1143 virtio_queue_set_guest_notifier_fd_handler(vq, true, with_irqfd); 1144 if (with_irqfd) { 1145 r = virtio_ccw_add_irqfd(dev, n); 1146 if (r) { 1147 virtio_queue_set_guest_notifier_fd_handler(vq, false, 1148 with_irqfd); 1149 return r; 1150 } 1151 } 1152 /* 1153 * We do not support individual masking for channel devices, so we 1154 * need to manually trigger any guest masking callbacks here. 1155 */ 1156 if (k->guest_notifier_mask && vdev->use_guest_notifier_mask) { 1157 k->guest_notifier_mask(vdev, n, false); 1158 } 1159 /* get lost events and re-inject */ 1160 if (k->guest_notifier_pending && 1161 k->guest_notifier_pending(vdev, n)) { 1162 event_notifier_set(notifier); 1163 } 1164 } else { 1165 if (k->guest_notifier_mask && vdev->use_guest_notifier_mask) { 1166 k->guest_notifier_mask(vdev, n, true); 1167 } 1168 if (with_irqfd) { 1169 virtio_ccw_remove_irqfd(dev, n); 1170 } 1171 virtio_queue_set_guest_notifier_fd_handler(vq, false, with_irqfd); 1172 event_notifier_cleanup(notifier); 1173 } 1174 return 0; 1175 } 1176 1177 static int virtio_ccw_set_guest_notifiers(DeviceState *d, int nvqs, 1178 bool assigned) 1179 { 1180 VirtioCcwDevice *dev = VIRTIO_CCW_DEVICE(d); 1181 VirtIODevice *vdev = virtio_bus_get_device(&dev->bus); 1182 CcwDevice *ccw_dev = CCW_DEVICE(d); 1183 bool with_irqfd = ccw_dev->sch->thinint_active && kvm_irqfds_enabled(); 1184 int r, n; 1185 1186 if (with_irqfd && assigned) { 1187 /* irq routes need to be set up before assigning irqfds */ 1188 r = virtio_ccw_setup_irqroutes(dev, nvqs); 1189 if (r < 0) { 1190 goto irqroute_error; 1191 } 1192 } 1193 for (n = 0; n < nvqs; n++) { 1194 if (!virtio_queue_get_num(vdev, n)) { 1195 break; 1196 } 1197 r = virtio_ccw_set_guest_notifier(dev, n, assigned, with_irqfd); 1198 if (r < 0) { 1199 goto assign_error; 1200 } 1201 } 1202 if (with_irqfd && !assigned) { 1203 /* release irq routes after irqfds have been released */ 1204 virtio_ccw_release_irqroutes(dev, nvqs); 1205 } 1206 return 0; 1207 1208 assign_error: 1209 while (--n >= 0) { 1210 virtio_ccw_set_guest_notifier(dev, n, !assigned, false); 1211 } 1212 irqroute_error: 1213 if (with_irqfd && assigned) { 1214 virtio_ccw_release_irqroutes(dev, nvqs); 1215 } 1216 return r; 1217 } 1218 1219 static void virtio_ccw_save_queue(DeviceState *d, int n, QEMUFile *f) 1220 { 1221 VirtioCcwDevice *dev = VIRTIO_CCW_DEVICE(d); 1222 VirtIODevice *vdev = virtio_bus_get_device(&dev->bus); 1223 1224 qemu_put_be16(f, virtio_queue_vector(vdev, n)); 1225 } 1226 1227 static int virtio_ccw_load_queue(DeviceState *d, int n, QEMUFile *f) 1228 { 1229 VirtioCcwDevice *dev = VIRTIO_CCW_DEVICE(d); 1230 VirtIODevice *vdev = virtio_bus_get_device(&dev->bus); 1231 uint16_t vector; 1232 1233 qemu_get_be16s(f, &vector); 1234 virtio_queue_set_vector(vdev, n , vector); 1235 1236 return 0; 1237 } 1238 1239 static void virtio_ccw_save_config(DeviceState *d, QEMUFile *f) 1240 { 1241 VirtioCcwDevice *dev = VIRTIO_CCW_DEVICE(d); 1242 CcwDevice *ccw_dev = CCW_DEVICE(d); 1243 SubchDev *s = ccw_dev->sch; 1244 VirtIODevice *vdev = virtio_ccw_get_vdev(s); 1245 1246 subch_device_save(s, f); 1247 if (dev->indicators != NULL) { 1248 qemu_put_be32(f, dev->indicators->len); 1249 qemu_put_be64(f, dev->indicators->addr); 1250 } else { 1251 qemu_put_be32(f, 0); 1252 qemu_put_be64(f, 0UL); 1253 } 1254 if (dev->indicators2 != NULL) { 1255 qemu_put_be32(f, dev->indicators2->len); 1256 qemu_put_be64(f, dev->indicators2->addr); 1257 } else { 1258 qemu_put_be32(f, 0); 1259 qemu_put_be64(f, 0UL); 1260 } 1261 if (dev->summary_indicator != NULL) { 1262 qemu_put_be32(f, dev->summary_indicator->len); 1263 qemu_put_be64(f, dev->summary_indicator->addr); 1264 } else { 1265 qemu_put_be32(f, 0); 1266 qemu_put_be64(f, 0UL); 1267 } 1268 qemu_put_be16(f, vdev->config_vector); 1269 qemu_put_be64(f, dev->routes.adapter.ind_offset); 1270 qemu_put_byte(f, dev->thinint_isc); 1271 qemu_put_be32(f, dev->revision); 1272 } 1273 1274 static int virtio_ccw_load_config(DeviceState *d, QEMUFile *f) 1275 { 1276 VirtioCcwDevice *dev = VIRTIO_CCW_DEVICE(d); 1277 CcwDevice *ccw_dev = CCW_DEVICE(d); 1278 CCWDeviceClass *ck = CCW_DEVICE_GET_CLASS(ccw_dev); 1279 SubchDev *s = ccw_dev->sch; 1280 VirtIODevice *vdev = virtio_ccw_get_vdev(s); 1281 int len; 1282 1283 s->driver_data = dev; 1284 subch_device_load(s, f); 1285 /* Re-fill subch_id after loading the subchannel states.*/ 1286 if (ck->refill_ids) { 1287 ck->refill_ids(ccw_dev); 1288 } 1289 len = qemu_get_be32(f); 1290 if (len != 0) { 1291 dev->indicators = get_indicator(qemu_get_be64(f), len); 1292 } else { 1293 qemu_get_be64(f); 1294 dev->indicators = NULL; 1295 } 1296 len = qemu_get_be32(f); 1297 if (len != 0) { 1298 dev->indicators2 = get_indicator(qemu_get_be64(f), len); 1299 } else { 1300 qemu_get_be64(f); 1301 dev->indicators2 = NULL; 1302 } 1303 len = qemu_get_be32(f); 1304 if (len != 0) { 1305 dev->summary_indicator = get_indicator(qemu_get_be64(f), len); 1306 } else { 1307 qemu_get_be64(f); 1308 dev->summary_indicator = NULL; 1309 } 1310 qemu_get_be16s(f, &vdev->config_vector); 1311 dev->routes.adapter.ind_offset = qemu_get_be64(f); 1312 dev->thinint_isc = qemu_get_byte(f); 1313 dev->revision = qemu_get_be32(f); 1314 if (s->thinint_active) { 1315 dev->routes.adapter.adapter_id = css_get_adapter_id( 1316 CSS_IO_ADAPTER_VIRTIO, 1317 dev->thinint_isc); 1318 } 1319 1320 return 0; 1321 } 1322 1323 static void virtio_ccw_pre_plugged(DeviceState *d, Error **errp) 1324 { 1325 VirtioCcwDevice *dev = VIRTIO_CCW_DEVICE(d); 1326 VirtIODevice *vdev = virtio_bus_get_device(&dev->bus); 1327 1328 if (dev->max_rev >= 1) { 1329 virtio_add_feature(&vdev->host_features, VIRTIO_F_VERSION_1); 1330 } 1331 } 1332 1333 /* This is called by virtio-bus just after the device is plugged. */ 1334 static void virtio_ccw_device_plugged(DeviceState *d, Error **errp) 1335 { 1336 VirtioCcwDevice *dev = VIRTIO_CCW_DEVICE(d); 1337 VirtIODevice *vdev = virtio_bus_get_device(&dev->bus); 1338 CcwDevice *ccw_dev = CCW_DEVICE(d); 1339 SubchDev *sch = ccw_dev->sch; 1340 int n = virtio_get_num_queues(vdev); 1341 S390FLICState *flic = s390_get_flic(); 1342 1343 if (!virtio_has_feature(vdev->host_features, VIRTIO_F_VERSION_1)) { 1344 dev->max_rev = 0; 1345 } 1346 1347 if (virtio_get_num_queues(vdev) > VIRTIO_QUEUE_MAX) { 1348 error_setg(errp, "The number of virtqueues %d " 1349 "exceeds virtio limit %d", n, 1350 VIRTIO_QUEUE_MAX); 1351 return; 1352 } 1353 if (virtio_get_num_queues(vdev) > flic->adapter_routes_max_batch) { 1354 error_setg(errp, "The number of virtqueues %d " 1355 "exceeds flic adapter route limit %d", n, 1356 flic->adapter_routes_max_batch); 1357 return; 1358 } 1359 1360 sch->id.cu_model = virtio_bus_get_vdev_id(&dev->bus); 1361 1362 1363 css_generate_sch_crws(sch->cssid, sch->ssid, sch->schid, 1364 d->hotplugged, 1); 1365 } 1366 1367 static void virtio_ccw_device_unplugged(DeviceState *d) 1368 { 1369 VirtioCcwDevice *dev = VIRTIO_CCW_DEVICE(d); 1370 1371 virtio_ccw_stop_ioeventfd(dev); 1372 } 1373 /**************** Virtio-ccw Bus Device Descriptions *******************/ 1374 1375 static Property virtio_ccw_net_properties[] = { 1376 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice, flags, 1377 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT, true), 1378 DEFINE_PROP_UINT32("max_revision", VirtioCcwDevice, max_rev, 1379 VIRTIO_CCW_MAX_REV), 1380 DEFINE_PROP_END_OF_LIST(), 1381 }; 1382 1383 static void virtio_ccw_net_class_init(ObjectClass *klass, void *data) 1384 { 1385 DeviceClass *dc = DEVICE_CLASS(klass); 1386 VirtIOCCWDeviceClass *k = VIRTIO_CCW_DEVICE_CLASS(klass); 1387 1388 k->realize = virtio_ccw_net_realize; 1389 k->exit = virtio_ccw_exit; 1390 dc->reset = virtio_ccw_reset; 1391 dc->props = virtio_ccw_net_properties; 1392 set_bit(DEVICE_CATEGORY_NETWORK, dc->categories); 1393 } 1394 1395 static const TypeInfo virtio_ccw_net = { 1396 .name = TYPE_VIRTIO_NET_CCW, 1397 .parent = TYPE_VIRTIO_CCW_DEVICE, 1398 .instance_size = sizeof(VirtIONetCcw), 1399 .instance_init = virtio_ccw_net_instance_init, 1400 .class_init = virtio_ccw_net_class_init, 1401 }; 1402 1403 static Property virtio_ccw_blk_properties[] = { 1404 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice, flags, 1405 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT, true), 1406 DEFINE_PROP_UINT32("max_revision", VirtioCcwDevice, max_rev, 1407 VIRTIO_CCW_MAX_REV), 1408 DEFINE_PROP_END_OF_LIST(), 1409 }; 1410 1411 static void virtio_ccw_blk_class_init(ObjectClass *klass, void *data) 1412 { 1413 DeviceClass *dc = DEVICE_CLASS(klass); 1414 VirtIOCCWDeviceClass *k = VIRTIO_CCW_DEVICE_CLASS(klass); 1415 1416 k->realize = virtio_ccw_blk_realize; 1417 k->exit = virtio_ccw_exit; 1418 dc->reset = virtio_ccw_reset; 1419 dc->props = virtio_ccw_blk_properties; 1420 set_bit(DEVICE_CATEGORY_STORAGE, dc->categories); 1421 } 1422 1423 static const TypeInfo virtio_ccw_blk = { 1424 .name = TYPE_VIRTIO_BLK_CCW, 1425 .parent = TYPE_VIRTIO_CCW_DEVICE, 1426 .instance_size = sizeof(VirtIOBlkCcw), 1427 .instance_init = virtio_ccw_blk_instance_init, 1428 .class_init = virtio_ccw_blk_class_init, 1429 }; 1430 1431 static Property virtio_ccw_serial_properties[] = { 1432 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice, flags, 1433 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT, true), 1434 DEFINE_PROP_UINT32("max_revision", VirtioCcwDevice, max_rev, 1435 VIRTIO_CCW_MAX_REV), 1436 DEFINE_PROP_END_OF_LIST(), 1437 }; 1438 1439 static void virtio_ccw_serial_class_init(ObjectClass *klass, void *data) 1440 { 1441 DeviceClass *dc = DEVICE_CLASS(klass); 1442 VirtIOCCWDeviceClass *k = VIRTIO_CCW_DEVICE_CLASS(klass); 1443 1444 k->realize = virtio_ccw_serial_realize; 1445 k->exit = virtio_ccw_exit; 1446 dc->reset = virtio_ccw_reset; 1447 dc->props = virtio_ccw_serial_properties; 1448 set_bit(DEVICE_CATEGORY_INPUT, dc->categories); 1449 } 1450 1451 static const TypeInfo virtio_ccw_serial = { 1452 .name = TYPE_VIRTIO_SERIAL_CCW, 1453 .parent = TYPE_VIRTIO_CCW_DEVICE, 1454 .instance_size = sizeof(VirtioSerialCcw), 1455 .instance_init = virtio_ccw_serial_instance_init, 1456 .class_init = virtio_ccw_serial_class_init, 1457 }; 1458 1459 static Property virtio_ccw_balloon_properties[] = { 1460 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice, flags, 1461 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT, true), 1462 DEFINE_PROP_UINT32("max_revision", VirtioCcwDevice, max_rev, 1463 VIRTIO_CCW_MAX_REV), 1464 DEFINE_PROP_END_OF_LIST(), 1465 }; 1466 1467 static void virtio_ccw_balloon_class_init(ObjectClass *klass, void *data) 1468 { 1469 DeviceClass *dc = DEVICE_CLASS(klass); 1470 VirtIOCCWDeviceClass *k = VIRTIO_CCW_DEVICE_CLASS(klass); 1471 1472 k->realize = virtio_ccw_balloon_realize; 1473 k->exit = virtio_ccw_exit; 1474 dc->reset = virtio_ccw_reset; 1475 dc->props = virtio_ccw_balloon_properties; 1476 set_bit(DEVICE_CATEGORY_MISC, dc->categories); 1477 } 1478 1479 static const TypeInfo virtio_ccw_balloon = { 1480 .name = TYPE_VIRTIO_BALLOON_CCW, 1481 .parent = TYPE_VIRTIO_CCW_DEVICE, 1482 .instance_size = sizeof(VirtIOBalloonCcw), 1483 .instance_init = virtio_ccw_balloon_instance_init, 1484 .class_init = virtio_ccw_balloon_class_init, 1485 }; 1486 1487 static Property virtio_ccw_scsi_properties[] = { 1488 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice, flags, 1489 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT, true), 1490 DEFINE_PROP_UINT32("max_revision", VirtioCcwDevice, max_rev, 1491 VIRTIO_CCW_MAX_REV), 1492 DEFINE_PROP_END_OF_LIST(), 1493 }; 1494 1495 static void virtio_ccw_scsi_class_init(ObjectClass *klass, void *data) 1496 { 1497 DeviceClass *dc = DEVICE_CLASS(klass); 1498 VirtIOCCWDeviceClass *k = VIRTIO_CCW_DEVICE_CLASS(klass); 1499 1500 k->realize = virtio_ccw_scsi_realize; 1501 k->exit = virtio_ccw_exit; 1502 dc->reset = virtio_ccw_reset; 1503 dc->props = virtio_ccw_scsi_properties; 1504 set_bit(DEVICE_CATEGORY_STORAGE, dc->categories); 1505 } 1506 1507 static const TypeInfo virtio_ccw_scsi = { 1508 .name = TYPE_VIRTIO_SCSI_CCW, 1509 .parent = TYPE_VIRTIO_CCW_DEVICE, 1510 .instance_size = sizeof(VirtIOSCSICcw), 1511 .instance_init = virtio_ccw_scsi_instance_init, 1512 .class_init = virtio_ccw_scsi_class_init, 1513 }; 1514 1515 #ifdef CONFIG_VHOST_SCSI 1516 static Property vhost_ccw_scsi_properties[] = { 1517 DEFINE_PROP_UINT32("max_revision", VirtioCcwDevice, max_rev, 1518 VIRTIO_CCW_MAX_REV), 1519 DEFINE_PROP_END_OF_LIST(), 1520 }; 1521 1522 static void vhost_ccw_scsi_class_init(ObjectClass *klass, void *data) 1523 { 1524 DeviceClass *dc = DEVICE_CLASS(klass); 1525 VirtIOCCWDeviceClass *k = VIRTIO_CCW_DEVICE_CLASS(klass); 1526 1527 k->realize = vhost_ccw_scsi_realize; 1528 k->exit = virtio_ccw_exit; 1529 dc->reset = virtio_ccw_reset; 1530 dc->props = vhost_ccw_scsi_properties; 1531 set_bit(DEVICE_CATEGORY_STORAGE, dc->categories); 1532 } 1533 1534 static const TypeInfo vhost_ccw_scsi = { 1535 .name = TYPE_VHOST_SCSI_CCW, 1536 .parent = TYPE_VIRTIO_CCW_DEVICE, 1537 .instance_size = sizeof(VHostSCSICcw), 1538 .instance_init = vhost_ccw_scsi_instance_init, 1539 .class_init = vhost_ccw_scsi_class_init, 1540 }; 1541 #endif 1542 1543 static void virtio_ccw_rng_instance_init(Object *obj) 1544 { 1545 VirtIORNGCcw *dev = VIRTIO_RNG_CCW(obj); 1546 1547 virtio_instance_init_common(obj, &dev->vdev, sizeof(dev->vdev), 1548 TYPE_VIRTIO_RNG); 1549 object_property_add_alias(obj, "rng", OBJECT(&dev->vdev), 1550 "rng", &error_abort); 1551 } 1552 1553 static Property virtio_ccw_rng_properties[] = { 1554 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice, flags, 1555 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT, true), 1556 DEFINE_PROP_UINT32("max_revision", VirtioCcwDevice, max_rev, 1557 VIRTIO_CCW_MAX_REV), 1558 DEFINE_PROP_END_OF_LIST(), 1559 }; 1560 1561 static void virtio_ccw_rng_class_init(ObjectClass *klass, void *data) 1562 { 1563 DeviceClass *dc = DEVICE_CLASS(klass); 1564 VirtIOCCWDeviceClass *k = VIRTIO_CCW_DEVICE_CLASS(klass); 1565 1566 k->realize = virtio_ccw_rng_realize; 1567 k->exit = virtio_ccw_exit; 1568 dc->reset = virtio_ccw_reset; 1569 dc->props = virtio_ccw_rng_properties; 1570 set_bit(DEVICE_CATEGORY_MISC, dc->categories); 1571 } 1572 1573 static const TypeInfo virtio_ccw_rng = { 1574 .name = TYPE_VIRTIO_RNG_CCW, 1575 .parent = TYPE_VIRTIO_CCW_DEVICE, 1576 .instance_size = sizeof(VirtIORNGCcw), 1577 .instance_init = virtio_ccw_rng_instance_init, 1578 .class_init = virtio_ccw_rng_class_init, 1579 }; 1580 1581 static Property virtio_ccw_crypto_properties[] = { 1582 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice, flags, 1583 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT, true), 1584 DEFINE_PROP_UINT32("max_revision", VirtioCcwDevice, max_rev, 1585 VIRTIO_CCW_MAX_REV), 1586 DEFINE_PROP_END_OF_LIST(), 1587 }; 1588 1589 static void virtio_ccw_crypto_instance_init(Object *obj) 1590 { 1591 VirtIOCryptoCcw *dev = VIRTIO_CRYPTO_CCW(obj); 1592 VirtioCcwDevice *ccw_dev = VIRTIO_CCW_DEVICE(obj); 1593 1594 ccw_dev->force_revision_1 = true; 1595 virtio_instance_init_common(obj, &dev->vdev, sizeof(dev->vdev), 1596 TYPE_VIRTIO_CRYPTO); 1597 1598 object_property_add_alias(obj, "cryptodev", OBJECT(&dev->vdev), 1599 "cryptodev", &error_abort); 1600 } 1601 1602 static void virtio_ccw_crypto_class_init(ObjectClass *klass, void *data) 1603 { 1604 DeviceClass *dc = DEVICE_CLASS(klass); 1605 VirtIOCCWDeviceClass *k = VIRTIO_CCW_DEVICE_CLASS(klass); 1606 1607 k->realize = virtio_ccw_crypto_realize; 1608 k->exit = virtio_ccw_exit; 1609 dc->reset = virtio_ccw_reset; 1610 dc->props = virtio_ccw_crypto_properties; 1611 set_bit(DEVICE_CATEGORY_MISC, dc->categories); 1612 } 1613 1614 static const TypeInfo virtio_ccw_crypto = { 1615 .name = TYPE_VIRTIO_CRYPTO_CCW, 1616 .parent = TYPE_VIRTIO_CCW_DEVICE, 1617 .instance_size = sizeof(VirtIOCryptoCcw), 1618 .instance_init = virtio_ccw_crypto_instance_init, 1619 .class_init = virtio_ccw_crypto_class_init, 1620 }; 1621 1622 static void virtio_ccw_busdev_realize(DeviceState *dev, Error **errp) 1623 { 1624 VirtioCcwDevice *_dev = (VirtioCcwDevice *)dev; 1625 1626 virtio_ccw_bus_new(&_dev->bus, sizeof(_dev->bus), _dev); 1627 virtio_ccw_device_realize(_dev, errp); 1628 } 1629 1630 static int virtio_ccw_busdev_exit(DeviceState *dev) 1631 { 1632 VirtioCcwDevice *_dev = (VirtioCcwDevice *)dev; 1633 VirtIOCCWDeviceClass *_info = VIRTIO_CCW_DEVICE_GET_CLASS(dev); 1634 1635 return _info->exit(_dev); 1636 } 1637 1638 static void virtio_ccw_busdev_unplug(HotplugHandler *hotplug_dev, 1639 DeviceState *dev, Error **errp) 1640 { 1641 VirtioCcwDevice *_dev = to_virtio_ccw_dev_fast(dev); 1642 1643 virtio_ccw_stop_ioeventfd(_dev); 1644 } 1645 1646 static void virtio_ccw_device_class_init(ObjectClass *klass, void *data) 1647 { 1648 DeviceClass *dc = DEVICE_CLASS(klass); 1649 CCWDeviceClass *k = CCW_DEVICE_CLASS(dc); 1650 1651 k->unplug = virtio_ccw_busdev_unplug; 1652 dc->realize = virtio_ccw_busdev_realize; 1653 dc->exit = virtio_ccw_busdev_exit; 1654 dc->bus_type = TYPE_VIRTUAL_CSS_BUS; 1655 } 1656 1657 static const TypeInfo virtio_ccw_device_info = { 1658 .name = TYPE_VIRTIO_CCW_DEVICE, 1659 .parent = TYPE_CCW_DEVICE, 1660 .instance_size = sizeof(VirtioCcwDevice), 1661 .class_init = virtio_ccw_device_class_init, 1662 .class_size = sizeof(VirtIOCCWDeviceClass), 1663 .abstract = true, 1664 }; 1665 1666 /* virtio-ccw-bus */ 1667 1668 static void virtio_ccw_bus_new(VirtioBusState *bus, size_t bus_size, 1669 VirtioCcwDevice *dev) 1670 { 1671 DeviceState *qdev = DEVICE(dev); 1672 char virtio_bus_name[] = "virtio-bus"; 1673 1674 qbus_create_inplace(bus, bus_size, TYPE_VIRTIO_CCW_BUS, 1675 qdev, virtio_bus_name); 1676 } 1677 1678 static void virtio_ccw_bus_class_init(ObjectClass *klass, void *data) 1679 { 1680 VirtioBusClass *k = VIRTIO_BUS_CLASS(klass); 1681 BusClass *bus_class = BUS_CLASS(klass); 1682 1683 bus_class->max_dev = 1; 1684 k->notify = virtio_ccw_notify; 1685 k->vmstate_change = virtio_ccw_vmstate_change; 1686 k->query_guest_notifiers = virtio_ccw_query_guest_notifiers; 1687 k->set_guest_notifiers = virtio_ccw_set_guest_notifiers; 1688 k->save_queue = virtio_ccw_save_queue; 1689 k->load_queue = virtio_ccw_load_queue; 1690 k->save_config = virtio_ccw_save_config; 1691 k->load_config = virtio_ccw_load_config; 1692 k->pre_plugged = virtio_ccw_pre_plugged; 1693 k->device_plugged = virtio_ccw_device_plugged; 1694 k->device_unplugged = virtio_ccw_device_unplugged; 1695 k->ioeventfd_enabled = virtio_ccw_ioeventfd_enabled; 1696 k->ioeventfd_assign = virtio_ccw_ioeventfd_assign; 1697 } 1698 1699 static const TypeInfo virtio_ccw_bus_info = { 1700 .name = TYPE_VIRTIO_CCW_BUS, 1701 .parent = TYPE_VIRTIO_BUS, 1702 .instance_size = sizeof(VirtioCcwBusState), 1703 .class_init = virtio_ccw_bus_class_init, 1704 }; 1705 1706 #ifdef CONFIG_VIRTFS 1707 static Property virtio_ccw_9p_properties[] = { 1708 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice, flags, 1709 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT, true), 1710 DEFINE_PROP_UINT32("max_revision", VirtioCcwDevice, max_rev, 1711 VIRTIO_CCW_MAX_REV), 1712 DEFINE_PROP_END_OF_LIST(), 1713 }; 1714 1715 static void virtio_ccw_9p_realize(VirtioCcwDevice *ccw_dev, Error **errp) 1716 { 1717 V9fsCCWState *dev = VIRTIO_9P_CCW(ccw_dev); 1718 DeviceState *vdev = DEVICE(&dev->vdev); 1719 1720 qdev_set_parent_bus(vdev, BUS(&ccw_dev->bus)); 1721 object_property_set_bool(OBJECT(vdev), true, "realized", errp); 1722 } 1723 1724 static void virtio_ccw_9p_class_init(ObjectClass *klass, void *data) 1725 { 1726 DeviceClass *dc = DEVICE_CLASS(klass); 1727 VirtIOCCWDeviceClass *k = VIRTIO_CCW_DEVICE_CLASS(klass); 1728 1729 k->exit = virtio_ccw_exit; 1730 k->realize = virtio_ccw_9p_realize; 1731 dc->reset = virtio_ccw_reset; 1732 dc->props = virtio_ccw_9p_properties; 1733 set_bit(DEVICE_CATEGORY_STORAGE, dc->categories); 1734 } 1735 1736 static void virtio_ccw_9p_instance_init(Object *obj) 1737 { 1738 V9fsCCWState *dev = VIRTIO_9P_CCW(obj); 1739 1740 virtio_instance_init_common(obj, &dev->vdev, sizeof(dev->vdev), 1741 TYPE_VIRTIO_9P); 1742 } 1743 1744 static const TypeInfo virtio_ccw_9p_info = { 1745 .name = TYPE_VIRTIO_9P_CCW, 1746 .parent = TYPE_VIRTIO_CCW_DEVICE, 1747 .instance_size = sizeof(V9fsCCWState), 1748 .instance_init = virtio_ccw_9p_instance_init, 1749 .class_init = virtio_ccw_9p_class_init, 1750 }; 1751 #endif 1752 1753 #ifdef CONFIG_VHOST_VSOCK 1754 1755 static Property vhost_vsock_ccw_properties[] = { 1756 DEFINE_PROP_UINT32("max_revision", VirtioCcwDevice, max_rev, 1757 VIRTIO_CCW_MAX_REV), 1758 DEFINE_PROP_END_OF_LIST(), 1759 }; 1760 1761 static void vhost_vsock_ccw_realize(VirtioCcwDevice *ccw_dev, Error **errp) 1762 { 1763 VHostVSockCCWState *dev = VHOST_VSOCK_CCW(ccw_dev); 1764 DeviceState *vdev = DEVICE(&dev->vdev); 1765 Error *err = NULL; 1766 1767 qdev_set_parent_bus(vdev, BUS(&ccw_dev->bus)); 1768 object_property_set_bool(OBJECT(vdev), true, "realized", &err); 1769 error_propagate(errp, err); 1770 } 1771 1772 static void vhost_vsock_ccw_class_init(ObjectClass *klass, void *data) 1773 { 1774 DeviceClass *dc = DEVICE_CLASS(klass); 1775 VirtIOCCWDeviceClass *k = VIRTIO_CCW_DEVICE_CLASS(klass); 1776 1777 k->realize = vhost_vsock_ccw_realize; 1778 k->exit = virtio_ccw_exit; 1779 set_bit(DEVICE_CATEGORY_MISC, dc->categories); 1780 dc->props = vhost_vsock_ccw_properties; 1781 dc->reset = virtio_ccw_reset; 1782 } 1783 1784 static void vhost_vsock_ccw_instance_init(Object *obj) 1785 { 1786 VHostVSockCCWState *dev = VHOST_VSOCK_CCW(obj); 1787 1788 virtio_instance_init_common(obj, &dev->vdev, sizeof(dev->vdev), 1789 TYPE_VHOST_VSOCK); 1790 } 1791 1792 static const TypeInfo vhost_vsock_ccw_info = { 1793 .name = TYPE_VHOST_VSOCK_CCW, 1794 .parent = TYPE_VIRTIO_CCW_DEVICE, 1795 .instance_size = sizeof(VHostVSockCCWState), 1796 .instance_init = vhost_vsock_ccw_instance_init, 1797 .class_init = vhost_vsock_ccw_class_init, 1798 }; 1799 #endif 1800 1801 static void virtio_ccw_register(void) 1802 { 1803 type_register_static(&virtio_ccw_bus_info); 1804 type_register_static(&virtio_ccw_device_info); 1805 type_register_static(&virtio_ccw_serial); 1806 type_register_static(&virtio_ccw_blk); 1807 type_register_static(&virtio_ccw_net); 1808 type_register_static(&virtio_ccw_balloon); 1809 type_register_static(&virtio_ccw_scsi); 1810 #ifdef CONFIG_VHOST_SCSI 1811 type_register_static(&vhost_ccw_scsi); 1812 #endif 1813 type_register_static(&virtio_ccw_rng); 1814 #ifdef CONFIG_VIRTFS 1815 type_register_static(&virtio_ccw_9p_info); 1816 #endif 1817 #ifdef CONFIG_VHOST_VSOCK 1818 type_register_static(&vhost_vsock_ccw_info); 1819 #endif 1820 type_register_static(&virtio_ccw_crypto); 1821 } 1822 1823 type_init(virtio_ccw_register) 1824