1 /* 2 * virtio ccw target implementation 3 * 4 * Copyright 2012,2014 IBM Corp. 5 * Author(s): Cornelia Huck <cornelia.huck@de.ibm.com> 6 * 7 * This work is licensed under the terms of the GNU GPL, version 2 or (at 8 * your option) any later version. See the COPYING file in the top-level 9 * directory. 10 */ 11 12 #include "hw/hw.h" 13 #include "block/block.h" 14 #include "sysemu/blockdev.h" 15 #include "sysemu/sysemu.h" 16 #include "net/net.h" 17 #include "monitor/monitor.h" 18 #include "hw/virtio/virtio.h" 19 #include "hw/virtio/virtio-serial.h" 20 #include "hw/virtio/virtio-net.h" 21 #include "hw/sysbus.h" 22 #include "qemu/bitops.h" 23 #include "hw/virtio/virtio-bus.h" 24 25 #include "ioinst.h" 26 #include "css.h" 27 #include "virtio-ccw.h" 28 #include "trace.h" 29 30 static void virtio_ccw_bus_new(VirtioBusState *bus, size_t bus_size, 31 VirtioCcwDevice *dev); 32 33 static void virtual_css_bus_reset(BusState *qbus) 34 { 35 /* This should actually be modelled via the generic css */ 36 css_reset(); 37 } 38 39 40 static void virtual_css_bus_class_init(ObjectClass *klass, void *data) 41 { 42 BusClass *k = BUS_CLASS(klass); 43 44 k->reset = virtual_css_bus_reset; 45 } 46 47 static const TypeInfo virtual_css_bus_info = { 48 .name = TYPE_VIRTUAL_CSS_BUS, 49 .parent = TYPE_BUS, 50 .instance_size = sizeof(VirtualCssBus), 51 .class_init = virtual_css_bus_class_init, 52 }; 53 54 VirtIODevice *virtio_ccw_get_vdev(SubchDev *sch) 55 { 56 VirtIODevice *vdev = NULL; 57 VirtioCcwDevice *dev = sch->driver_data; 58 59 if (dev) { 60 vdev = virtio_bus_get_device(&dev->bus); 61 } 62 return vdev; 63 } 64 65 static int virtio_ccw_set_guest2host_notifier(VirtioCcwDevice *dev, int n, 66 bool assign, bool set_handler) 67 { 68 VirtIODevice *vdev = virtio_bus_get_device(&dev->bus); 69 VirtQueue *vq = virtio_get_queue(vdev, n); 70 EventNotifier *notifier = virtio_queue_get_host_notifier(vq); 71 int r = 0; 72 SubchDev *sch = dev->sch; 73 uint32_t sch_id = (css_build_subchannel_id(sch) << 16) | sch->schid; 74 75 if (assign) { 76 r = event_notifier_init(notifier, 1); 77 if (r < 0) { 78 error_report("%s: unable to init event notifier: %d", __func__, r); 79 return r; 80 } 81 virtio_queue_set_host_notifier_fd_handler(vq, true, set_handler); 82 r = s390_assign_subch_ioeventfd(notifier, sch_id, n, assign); 83 if (r < 0) { 84 error_report("%s: unable to assign ioeventfd: %d", __func__, r); 85 virtio_queue_set_host_notifier_fd_handler(vq, false, false); 86 event_notifier_cleanup(notifier); 87 return r; 88 } 89 } else { 90 virtio_queue_set_host_notifier_fd_handler(vq, false, false); 91 s390_assign_subch_ioeventfd(notifier, sch_id, n, assign); 92 event_notifier_cleanup(notifier); 93 } 94 return r; 95 } 96 97 static void virtio_ccw_start_ioeventfd(VirtioCcwDevice *dev) 98 { 99 VirtIODevice *vdev; 100 int n, r; 101 102 if (!(dev->flags & VIRTIO_CCW_FLAG_USE_IOEVENTFD) || 103 dev->ioeventfd_disabled || 104 dev->ioeventfd_started) { 105 return; 106 } 107 vdev = virtio_bus_get_device(&dev->bus); 108 for (n = 0; n < VIRTIO_PCI_QUEUE_MAX; n++) { 109 if (!virtio_queue_get_num(vdev, n)) { 110 continue; 111 } 112 r = virtio_ccw_set_guest2host_notifier(dev, n, true, true); 113 if (r < 0) { 114 goto assign_error; 115 } 116 } 117 dev->ioeventfd_started = true; 118 return; 119 120 assign_error: 121 while (--n >= 0) { 122 if (!virtio_queue_get_num(vdev, n)) { 123 continue; 124 } 125 r = virtio_ccw_set_guest2host_notifier(dev, n, false, false); 126 assert(r >= 0); 127 } 128 dev->ioeventfd_started = false; 129 /* Disable ioeventfd for this device. */ 130 dev->flags &= ~VIRTIO_CCW_FLAG_USE_IOEVENTFD; 131 error_report("%s: failed. Fallback to userspace (slower).", __func__); 132 } 133 134 static void virtio_ccw_stop_ioeventfd(VirtioCcwDevice *dev) 135 { 136 VirtIODevice *vdev; 137 int n, r; 138 139 if (!dev->ioeventfd_started) { 140 return; 141 } 142 vdev = virtio_bus_get_device(&dev->bus); 143 for (n = 0; n < VIRTIO_PCI_QUEUE_MAX; n++) { 144 if (!virtio_queue_get_num(vdev, n)) { 145 continue; 146 } 147 r = virtio_ccw_set_guest2host_notifier(dev, n, false, false); 148 assert(r >= 0); 149 } 150 dev->ioeventfd_started = false; 151 } 152 153 VirtualCssBus *virtual_css_bus_init(void) 154 { 155 VirtualCssBus *cbus; 156 BusState *bus; 157 DeviceState *dev; 158 159 /* Create bridge device */ 160 dev = qdev_create(NULL, "virtual-css-bridge"); 161 qdev_init_nofail(dev); 162 163 /* Create bus on bridge device */ 164 bus = qbus_create(TYPE_VIRTUAL_CSS_BUS, dev, "virtual-css"); 165 cbus = VIRTUAL_CSS_BUS(bus); 166 167 /* Enable hotplugging */ 168 bus->allow_hotplug = 1; 169 170 return cbus; 171 } 172 173 /* Communication blocks used by several channel commands. */ 174 typedef struct VqInfoBlock { 175 uint64_t queue; 176 uint32_t align; 177 uint16_t index; 178 uint16_t num; 179 } QEMU_PACKED VqInfoBlock; 180 181 typedef struct VqConfigBlock { 182 uint16_t index; 183 uint16_t num_max; 184 } QEMU_PACKED VqConfigBlock; 185 186 typedef struct VirtioFeatDesc { 187 uint32_t features; 188 uint8_t index; 189 } QEMU_PACKED VirtioFeatDesc; 190 191 typedef struct VirtioThinintInfo { 192 hwaddr summary_indicator; 193 hwaddr device_indicator; 194 uint64_t ind_bit; 195 uint8_t isc; 196 } QEMU_PACKED VirtioThinintInfo; 197 198 /* Specify where the virtqueues for the subchannel are in guest memory. */ 199 static int virtio_ccw_set_vqs(SubchDev *sch, uint64_t addr, uint32_t align, 200 uint16_t index, uint16_t num) 201 { 202 VirtIODevice *vdev = virtio_ccw_get_vdev(sch); 203 204 if (index > VIRTIO_PCI_QUEUE_MAX) { 205 return -EINVAL; 206 } 207 208 /* Current code in virtio.c relies on 4K alignment. */ 209 if (addr && (align != 4096)) { 210 return -EINVAL; 211 } 212 213 if (!vdev) { 214 return -EINVAL; 215 } 216 217 virtio_queue_set_addr(vdev, index, addr); 218 if (!addr) { 219 virtio_queue_set_vector(vdev, index, 0); 220 } else { 221 /* Fail if we don't have a big enough queue. */ 222 /* TODO: Add interface to handle vring.num changing */ 223 if (virtio_queue_get_num(vdev, index) > num) { 224 return -EINVAL; 225 } 226 virtio_queue_set_vector(vdev, index, index); 227 } 228 /* tell notify handler in case of config change */ 229 vdev->config_vector = VIRTIO_PCI_QUEUE_MAX; 230 return 0; 231 } 232 233 static int virtio_ccw_cb(SubchDev *sch, CCW1 ccw) 234 { 235 int ret; 236 VqInfoBlock info; 237 uint8_t status; 238 VirtioFeatDesc features; 239 void *config; 240 hwaddr indicators; 241 VqConfigBlock vq_config; 242 VirtioCcwDevice *dev = sch->driver_data; 243 VirtIODevice *vdev = virtio_ccw_get_vdev(sch); 244 bool check_len; 245 int len; 246 hwaddr hw_len; 247 VirtioThinintInfo *thinint; 248 249 if (!dev) { 250 return -EINVAL; 251 } 252 253 trace_virtio_ccw_interpret_ccw(sch->cssid, sch->ssid, sch->schid, 254 ccw.cmd_code); 255 check_len = !((ccw.flags & CCW_FLAG_SLI) && !(ccw.flags & CCW_FLAG_DC)); 256 257 /* Look at the command. */ 258 switch (ccw.cmd_code) { 259 case CCW_CMD_SET_VQ: 260 if (check_len) { 261 if (ccw.count != sizeof(info)) { 262 ret = -EINVAL; 263 break; 264 } 265 } else if (ccw.count < sizeof(info)) { 266 /* Can't execute command. */ 267 ret = -EINVAL; 268 break; 269 } 270 if (!ccw.cda) { 271 ret = -EFAULT; 272 } else { 273 info.queue = ldq_phys(&address_space_memory, ccw.cda); 274 info.align = ldl_phys(&address_space_memory, 275 ccw.cda + sizeof(info.queue)); 276 info.index = lduw_phys(&address_space_memory, 277 ccw.cda + sizeof(info.queue) 278 + sizeof(info.align)); 279 info.num = lduw_phys(&address_space_memory, 280 ccw.cda + sizeof(info.queue) 281 + sizeof(info.align) 282 + sizeof(info.index)); 283 ret = virtio_ccw_set_vqs(sch, info.queue, info.align, info.index, 284 info.num); 285 sch->curr_status.scsw.count = 0; 286 } 287 break; 288 case CCW_CMD_VDEV_RESET: 289 virtio_ccw_stop_ioeventfd(dev); 290 virtio_reset(vdev); 291 ret = 0; 292 break; 293 case CCW_CMD_READ_FEAT: 294 if (check_len) { 295 if (ccw.count != sizeof(features)) { 296 ret = -EINVAL; 297 break; 298 } 299 } else if (ccw.count < sizeof(features)) { 300 /* Can't execute command. */ 301 ret = -EINVAL; 302 break; 303 } 304 if (!ccw.cda) { 305 ret = -EFAULT; 306 } else { 307 features.index = ldub_phys(&address_space_memory, 308 ccw.cda + sizeof(features.features)); 309 if (features.index < ARRAY_SIZE(dev->host_features)) { 310 features.features = dev->host_features[features.index]; 311 } else { 312 /* Return zeroes if the guest supports more feature bits. */ 313 features.features = 0; 314 } 315 stl_le_phys(&address_space_memory, ccw.cda, features.features); 316 sch->curr_status.scsw.count = ccw.count - sizeof(features); 317 ret = 0; 318 } 319 break; 320 case CCW_CMD_WRITE_FEAT: 321 if (check_len) { 322 if (ccw.count != sizeof(features)) { 323 ret = -EINVAL; 324 break; 325 } 326 } else if (ccw.count < sizeof(features)) { 327 /* Can't execute command. */ 328 ret = -EINVAL; 329 break; 330 } 331 if (!ccw.cda) { 332 ret = -EFAULT; 333 } else { 334 features.index = ldub_phys(&address_space_memory, 335 ccw.cda + sizeof(features.features)); 336 features.features = ldl_le_phys(&address_space_memory, ccw.cda); 337 if (features.index < ARRAY_SIZE(dev->host_features)) { 338 virtio_bus_set_vdev_features(&dev->bus, features.features); 339 vdev->guest_features = features.features; 340 } else { 341 /* 342 * If the guest supports more feature bits, assert that it 343 * passes us zeroes for those we don't support. 344 */ 345 if (features.features) { 346 fprintf(stderr, "Guest bug: features[%i]=%x (expected 0)\n", 347 features.index, features.features); 348 /* XXX: do a unit check here? */ 349 } 350 } 351 sch->curr_status.scsw.count = ccw.count - sizeof(features); 352 ret = 0; 353 } 354 break; 355 case CCW_CMD_READ_CONF: 356 if (check_len) { 357 if (ccw.count > vdev->config_len) { 358 ret = -EINVAL; 359 break; 360 } 361 } 362 len = MIN(ccw.count, vdev->config_len); 363 if (!ccw.cda) { 364 ret = -EFAULT; 365 } else { 366 virtio_bus_get_vdev_config(&dev->bus, vdev->config); 367 /* XXX config space endianness */ 368 cpu_physical_memory_write(ccw.cda, vdev->config, len); 369 sch->curr_status.scsw.count = ccw.count - len; 370 ret = 0; 371 } 372 break; 373 case CCW_CMD_WRITE_CONF: 374 if (check_len) { 375 if (ccw.count > vdev->config_len) { 376 ret = -EINVAL; 377 break; 378 } 379 } 380 len = MIN(ccw.count, vdev->config_len); 381 hw_len = len; 382 if (!ccw.cda) { 383 ret = -EFAULT; 384 } else { 385 config = cpu_physical_memory_map(ccw.cda, &hw_len, 0); 386 if (!config) { 387 ret = -EFAULT; 388 } else { 389 len = hw_len; 390 /* XXX config space endianness */ 391 memcpy(vdev->config, config, len); 392 cpu_physical_memory_unmap(config, hw_len, 0, hw_len); 393 virtio_bus_set_vdev_config(&dev->bus, vdev->config); 394 sch->curr_status.scsw.count = ccw.count - len; 395 ret = 0; 396 } 397 } 398 break; 399 case CCW_CMD_WRITE_STATUS: 400 if (check_len) { 401 if (ccw.count != sizeof(status)) { 402 ret = -EINVAL; 403 break; 404 } 405 } else if (ccw.count < sizeof(status)) { 406 /* Can't execute command. */ 407 ret = -EINVAL; 408 break; 409 } 410 if (!ccw.cda) { 411 ret = -EFAULT; 412 } else { 413 status = ldub_phys(&address_space_memory, ccw.cda); 414 if (!(status & VIRTIO_CONFIG_S_DRIVER_OK)) { 415 virtio_ccw_stop_ioeventfd(dev); 416 } 417 virtio_set_status(vdev, status); 418 if (vdev->status == 0) { 419 virtio_reset(vdev); 420 } 421 if (status & VIRTIO_CONFIG_S_DRIVER_OK) { 422 virtio_ccw_start_ioeventfd(dev); 423 } 424 sch->curr_status.scsw.count = ccw.count - sizeof(status); 425 ret = 0; 426 } 427 break; 428 case CCW_CMD_SET_IND: 429 if (check_len) { 430 if (ccw.count != sizeof(indicators)) { 431 ret = -EINVAL; 432 break; 433 } 434 } else if (ccw.count < sizeof(indicators)) { 435 /* Can't execute command. */ 436 ret = -EINVAL; 437 break; 438 } 439 if (sch->thinint_active) { 440 /* Trigger a command reject. */ 441 ret = -ENOSYS; 442 break; 443 } 444 if (!ccw.cda) { 445 ret = -EFAULT; 446 } else { 447 indicators = ldq_phys(&address_space_memory, ccw.cda); 448 dev->indicators = indicators; 449 sch->curr_status.scsw.count = ccw.count - sizeof(indicators); 450 ret = 0; 451 } 452 break; 453 case CCW_CMD_SET_CONF_IND: 454 if (check_len) { 455 if (ccw.count != sizeof(indicators)) { 456 ret = -EINVAL; 457 break; 458 } 459 } else if (ccw.count < sizeof(indicators)) { 460 /* Can't execute command. */ 461 ret = -EINVAL; 462 break; 463 } 464 if (!ccw.cda) { 465 ret = -EFAULT; 466 } else { 467 indicators = ldq_phys(&address_space_memory, ccw.cda); 468 dev->indicators2 = indicators; 469 sch->curr_status.scsw.count = ccw.count - sizeof(indicators); 470 ret = 0; 471 } 472 break; 473 case CCW_CMD_READ_VQ_CONF: 474 if (check_len) { 475 if (ccw.count != sizeof(vq_config)) { 476 ret = -EINVAL; 477 break; 478 } 479 } else if (ccw.count < sizeof(vq_config)) { 480 /* Can't execute command. */ 481 ret = -EINVAL; 482 break; 483 } 484 if (!ccw.cda) { 485 ret = -EFAULT; 486 } else { 487 vq_config.index = lduw_phys(&address_space_memory, ccw.cda); 488 vq_config.num_max = virtio_queue_get_num(vdev, 489 vq_config.index); 490 stw_phys(&address_space_memory, 491 ccw.cda + sizeof(vq_config.index), vq_config.num_max); 492 sch->curr_status.scsw.count = ccw.count - sizeof(vq_config); 493 ret = 0; 494 } 495 break; 496 case CCW_CMD_SET_IND_ADAPTER: 497 if (check_len) { 498 if (ccw.count != sizeof(*thinint)) { 499 ret = -EINVAL; 500 break; 501 } 502 } else if (ccw.count < sizeof(*thinint)) { 503 /* Can't execute command. */ 504 ret = -EINVAL; 505 break; 506 } 507 len = sizeof(*thinint); 508 hw_len = len; 509 if (!ccw.cda) { 510 ret = -EFAULT; 511 } else if (dev->indicators && !sch->thinint_active) { 512 /* Trigger a command reject. */ 513 ret = -ENOSYS; 514 } else { 515 thinint = cpu_physical_memory_map(ccw.cda, &hw_len, 0); 516 if (!thinint) { 517 ret = -EFAULT; 518 } else { 519 len = hw_len; 520 dev->summary_indicator = thinint->summary_indicator; 521 dev->indicators = thinint->device_indicator; 522 dev->thinint_isc = thinint->isc; 523 dev->ind_bit = thinint->ind_bit; 524 cpu_physical_memory_unmap(thinint, hw_len, 0, hw_len); 525 ret = css_register_io_adapter(CSS_IO_ADAPTER_VIRTIO, 526 dev->thinint_isc, true, false, 527 &dev->adapter_id); 528 assert(ret == 0); 529 sch->thinint_active = ((dev->indicators != 0) && 530 (dev->summary_indicator != 0)); 531 sch->curr_status.scsw.count = ccw.count - len; 532 ret = 0; 533 } 534 } 535 break; 536 default: 537 ret = -ENOSYS; 538 break; 539 } 540 return ret; 541 } 542 543 static int virtio_ccw_device_init(VirtioCcwDevice *dev, VirtIODevice *vdev) 544 { 545 unsigned int cssid = 0; 546 unsigned int ssid = 0; 547 unsigned int schid; 548 unsigned int devno; 549 bool have_devno = false; 550 bool found = false; 551 SubchDev *sch; 552 int ret; 553 int num; 554 DeviceState *parent = DEVICE(dev); 555 556 sch = g_malloc0(sizeof(SubchDev)); 557 558 sch->driver_data = dev; 559 dev->sch = sch; 560 561 dev->indicators = 0; 562 563 /* Initialize subchannel structure. */ 564 sch->channel_prog = 0x0; 565 sch->last_cmd_valid = false; 566 sch->thinint_active = false; 567 /* 568 * Use a device number if provided. Otherwise, fall back to subchannel 569 * number. 570 */ 571 if (dev->bus_id) { 572 num = sscanf(dev->bus_id, "%x.%x.%04x", &cssid, &ssid, &devno); 573 if (num == 3) { 574 if ((cssid > MAX_CSSID) || (ssid > MAX_SSID)) { 575 ret = -EINVAL; 576 error_report("Invalid cssid or ssid: cssid %x, ssid %x", 577 cssid, ssid); 578 goto out_err; 579 } 580 /* Enforce use of virtual cssid. */ 581 if (cssid != VIRTUAL_CSSID) { 582 ret = -EINVAL; 583 error_report("cssid %x not valid for virtio devices", cssid); 584 goto out_err; 585 } 586 if (css_devno_used(cssid, ssid, devno)) { 587 ret = -EEXIST; 588 error_report("Device %x.%x.%04x already exists", cssid, ssid, 589 devno); 590 goto out_err; 591 } 592 sch->cssid = cssid; 593 sch->ssid = ssid; 594 sch->devno = devno; 595 have_devno = true; 596 } else { 597 ret = -EINVAL; 598 error_report("Malformed devno parameter '%s'", dev->bus_id); 599 goto out_err; 600 } 601 } 602 603 /* Find the next free id. */ 604 if (have_devno) { 605 for (schid = 0; schid <= MAX_SCHID; schid++) { 606 if (!css_find_subch(1, cssid, ssid, schid)) { 607 sch->schid = schid; 608 css_subch_assign(cssid, ssid, schid, devno, sch); 609 found = true; 610 break; 611 } 612 } 613 if (!found) { 614 ret = -ENODEV; 615 error_report("No free subchannel found for %x.%x.%04x", cssid, ssid, 616 devno); 617 goto out_err; 618 } 619 trace_virtio_ccw_new_device(cssid, ssid, schid, devno, 620 "user-configured"); 621 } else { 622 cssid = VIRTUAL_CSSID; 623 for (ssid = 0; ssid <= MAX_SSID; ssid++) { 624 for (schid = 0; schid <= MAX_SCHID; schid++) { 625 if (!css_find_subch(1, cssid, ssid, schid)) { 626 sch->cssid = cssid; 627 sch->ssid = ssid; 628 sch->schid = schid; 629 devno = schid; 630 /* 631 * If the devno is already taken, look further in this 632 * subchannel set. 633 */ 634 while (css_devno_used(cssid, ssid, devno)) { 635 if (devno == MAX_SCHID) { 636 devno = 0; 637 } else if (devno == schid - 1) { 638 ret = -ENODEV; 639 error_report("No free devno found"); 640 goto out_err; 641 } else { 642 devno++; 643 } 644 } 645 sch->devno = devno; 646 css_subch_assign(cssid, ssid, schid, devno, sch); 647 found = true; 648 break; 649 } 650 } 651 if (found) { 652 break; 653 } 654 } 655 if (!found) { 656 ret = -ENODEV; 657 error_report("Virtual channel subsystem is full!"); 658 goto out_err; 659 } 660 trace_virtio_ccw_new_device(cssid, ssid, schid, devno, 661 "auto-configured"); 662 } 663 664 /* Build initial schib. */ 665 css_sch_build_virtual_schib(sch, 0, VIRTIO_CCW_CHPID_TYPE); 666 667 sch->ccw_cb = virtio_ccw_cb; 668 669 /* Build senseid data. */ 670 memset(&sch->id, 0, sizeof(SenseId)); 671 sch->id.reserved = 0xff; 672 sch->id.cu_type = VIRTIO_CCW_CU_TYPE; 673 sch->id.cu_model = vdev->device_id; 674 675 /* Only the first 32 feature bits are used. */ 676 dev->host_features[0] = virtio_bus_get_vdev_features(&dev->bus, 677 dev->host_features[0]); 678 679 dev->host_features[0] |= 0x1 << VIRTIO_F_NOTIFY_ON_EMPTY; 680 dev->host_features[0] |= 0x1 << VIRTIO_F_BAD_FEATURE; 681 682 css_generate_sch_crws(sch->cssid, sch->ssid, sch->schid, 683 parent->hotplugged, 1); 684 return 0; 685 686 out_err: 687 dev->sch = NULL; 688 g_free(sch); 689 return ret; 690 } 691 692 static int virtio_ccw_exit(VirtioCcwDevice *dev) 693 { 694 SubchDev *sch = dev->sch; 695 696 if (sch) { 697 css_subch_assign(sch->cssid, sch->ssid, sch->schid, sch->devno, NULL); 698 g_free(sch); 699 } 700 dev->indicators = 0; 701 return 0; 702 } 703 704 static int virtio_ccw_net_init(VirtioCcwDevice *ccw_dev) 705 { 706 DeviceState *qdev = DEVICE(ccw_dev); 707 VirtIONetCcw *dev = VIRTIO_NET_CCW(ccw_dev); 708 DeviceState *vdev = DEVICE(&dev->vdev); 709 710 virtio_net_set_config_size(&dev->vdev, ccw_dev->host_features[0]); 711 virtio_net_set_netclient_name(&dev->vdev, qdev->id, 712 object_get_typename(OBJECT(qdev))); 713 qdev_set_parent_bus(vdev, BUS(&ccw_dev->bus)); 714 if (qdev_init(vdev) < 0) { 715 return -1; 716 } 717 718 return virtio_ccw_device_init(ccw_dev, VIRTIO_DEVICE(vdev)); 719 } 720 721 static void virtio_ccw_net_instance_init(Object *obj) 722 { 723 VirtIONetCcw *dev = VIRTIO_NET_CCW(obj); 724 object_initialize(&dev->vdev, sizeof(dev->vdev), TYPE_VIRTIO_NET); 725 object_property_add_child(obj, "virtio-backend", OBJECT(&dev->vdev), NULL); 726 } 727 728 static int virtio_ccw_blk_init(VirtioCcwDevice *ccw_dev) 729 { 730 VirtIOBlkCcw *dev = VIRTIO_BLK_CCW(ccw_dev); 731 DeviceState *vdev = DEVICE(&dev->vdev); 732 virtio_blk_set_conf(vdev, &(dev->blk)); 733 qdev_set_parent_bus(vdev, BUS(&ccw_dev->bus)); 734 if (qdev_init(vdev) < 0) { 735 return -1; 736 } 737 738 return virtio_ccw_device_init(ccw_dev, VIRTIO_DEVICE(vdev)); 739 } 740 741 static void virtio_ccw_blk_instance_init(Object *obj) 742 { 743 VirtIOBlkCcw *dev = VIRTIO_BLK_CCW(obj); 744 object_initialize(&dev->vdev, sizeof(dev->vdev), TYPE_VIRTIO_BLK); 745 object_property_add_child(obj, "virtio-backend", OBJECT(&dev->vdev), NULL); 746 } 747 748 static int virtio_ccw_serial_init(VirtioCcwDevice *ccw_dev) 749 { 750 VirtioSerialCcw *dev = VIRTIO_SERIAL_CCW(ccw_dev); 751 DeviceState *vdev = DEVICE(&dev->vdev); 752 DeviceState *proxy = DEVICE(ccw_dev); 753 char *bus_name; 754 755 /* 756 * For command line compatibility, this sets the virtio-serial-device bus 757 * name as before. 758 */ 759 if (proxy->id) { 760 bus_name = g_strdup_printf("%s.0", proxy->id); 761 virtio_device_set_child_bus_name(VIRTIO_DEVICE(vdev), bus_name); 762 g_free(bus_name); 763 } 764 765 qdev_set_parent_bus(vdev, BUS(&ccw_dev->bus)); 766 if (qdev_init(vdev) < 0) { 767 return -1; 768 } 769 770 return virtio_ccw_device_init(ccw_dev, VIRTIO_DEVICE(vdev)); 771 } 772 773 774 static void virtio_ccw_serial_instance_init(Object *obj) 775 { 776 VirtioSerialCcw *dev = VIRTIO_SERIAL_CCW(obj); 777 object_initialize(&dev->vdev, sizeof(dev->vdev), TYPE_VIRTIO_SERIAL); 778 object_property_add_child(obj, "virtio-backend", OBJECT(&dev->vdev), NULL); 779 } 780 781 static int virtio_ccw_balloon_init(VirtioCcwDevice *ccw_dev) 782 { 783 VirtIOBalloonCcw *dev = VIRTIO_BALLOON_CCW(ccw_dev); 784 DeviceState *vdev = DEVICE(&dev->vdev); 785 786 qdev_set_parent_bus(vdev, BUS(&ccw_dev->bus)); 787 if (qdev_init(vdev) < 0) { 788 return -1; 789 } 790 791 return virtio_ccw_device_init(ccw_dev, VIRTIO_DEVICE(vdev)); 792 } 793 794 static void balloon_ccw_stats_get_all(Object *obj, struct Visitor *v, 795 void *opaque, const char *name, 796 Error **errp) 797 { 798 VirtIOBalloonCcw *dev = opaque; 799 object_property_get(OBJECT(&dev->vdev), v, "guest-stats", errp); 800 } 801 802 static void balloon_ccw_stats_get_poll_interval(Object *obj, struct Visitor *v, 803 void *opaque, const char *name, 804 Error **errp) 805 { 806 VirtIOBalloonCcw *dev = opaque; 807 object_property_get(OBJECT(&dev->vdev), v, "guest-stats-polling-interval", 808 errp); 809 } 810 811 static void balloon_ccw_stats_set_poll_interval(Object *obj, struct Visitor *v, 812 void *opaque, const char *name, 813 Error **errp) 814 { 815 VirtIOBalloonCcw *dev = opaque; 816 object_property_set(OBJECT(&dev->vdev), v, "guest-stats-polling-interval", 817 errp); 818 } 819 820 static void virtio_ccw_balloon_instance_init(Object *obj) 821 { 822 VirtIOBalloonCcw *dev = VIRTIO_BALLOON_CCW(obj); 823 object_initialize(&dev->vdev, sizeof(dev->vdev), TYPE_VIRTIO_BALLOON); 824 object_property_add_child(obj, "virtio-backend", OBJECT(&dev->vdev), NULL); 825 826 object_property_add(obj, "guest-stats", "guest statistics", 827 balloon_ccw_stats_get_all, NULL, NULL, dev, NULL); 828 829 object_property_add(obj, "guest-stats-polling-interval", "int", 830 balloon_ccw_stats_get_poll_interval, 831 balloon_ccw_stats_set_poll_interval, 832 NULL, dev, NULL); 833 } 834 835 static int virtio_ccw_scsi_init(VirtioCcwDevice *ccw_dev) 836 { 837 VirtIOSCSICcw *dev = VIRTIO_SCSI_CCW(ccw_dev); 838 DeviceState *vdev = DEVICE(&dev->vdev); 839 DeviceState *qdev = DEVICE(ccw_dev); 840 char *bus_name; 841 842 /* 843 * For command line compatibility, this sets the virtio-scsi-device bus 844 * name as before. 845 */ 846 if (qdev->id) { 847 bus_name = g_strdup_printf("%s.0", qdev->id); 848 virtio_device_set_child_bus_name(VIRTIO_DEVICE(vdev), bus_name); 849 g_free(bus_name); 850 } 851 852 qdev_set_parent_bus(vdev, BUS(&ccw_dev->bus)); 853 if (qdev_init(vdev) < 0) { 854 return -1; 855 } 856 857 return virtio_ccw_device_init(ccw_dev, VIRTIO_DEVICE(vdev)); 858 } 859 860 static void virtio_ccw_scsi_instance_init(Object *obj) 861 { 862 VirtIOSCSICcw *dev = VIRTIO_SCSI_CCW(obj); 863 object_initialize(&dev->vdev, sizeof(dev->vdev), TYPE_VIRTIO_SCSI); 864 object_property_add_child(obj, "virtio-backend", OBJECT(&dev->vdev), NULL); 865 } 866 867 #ifdef CONFIG_VHOST_SCSI 868 static int vhost_ccw_scsi_init(VirtioCcwDevice *ccw_dev) 869 { 870 VHostSCSICcw *dev = VHOST_SCSI_CCW(ccw_dev); 871 DeviceState *vdev = DEVICE(&dev->vdev); 872 873 qdev_set_parent_bus(vdev, BUS(&ccw_dev->bus)); 874 if (qdev_init(vdev) < 0) { 875 return -1; 876 } 877 878 return virtio_ccw_device_init(ccw_dev, VIRTIO_DEVICE(vdev)); 879 } 880 881 static void vhost_ccw_scsi_instance_init(Object *obj) 882 { 883 VHostSCSICcw *dev = VHOST_SCSI_CCW(obj); 884 object_initialize(&dev->vdev, sizeof(dev->vdev), TYPE_VHOST_SCSI); 885 object_property_add_child(obj, "virtio-backend", OBJECT(&dev->vdev), NULL); 886 } 887 #endif 888 889 static int virtio_ccw_rng_init(VirtioCcwDevice *ccw_dev) 890 { 891 VirtIORNGCcw *dev = VIRTIO_RNG_CCW(ccw_dev); 892 DeviceState *vdev = DEVICE(&dev->vdev); 893 894 qdev_set_parent_bus(vdev, BUS(&ccw_dev->bus)); 895 if (qdev_init(vdev) < 0) { 896 return -1; 897 } 898 899 object_property_set_link(OBJECT(dev), 900 OBJECT(dev->vdev.conf.rng), "rng", 901 NULL); 902 903 return virtio_ccw_device_init(ccw_dev, VIRTIO_DEVICE(vdev)); 904 } 905 906 /* DeviceState to VirtioCcwDevice. Note: used on datapath, 907 * be careful and test performance if you change this. 908 */ 909 static inline VirtioCcwDevice *to_virtio_ccw_dev_fast(DeviceState *d) 910 { 911 return container_of(d, VirtioCcwDevice, parent_obj); 912 } 913 914 static uint8_t virtio_set_ind_atomic(SubchDev *sch, uint64_t ind_loc, 915 uint8_t to_be_set) 916 { 917 uint8_t ind_old, ind_new; 918 hwaddr len = 1; 919 uint8_t *ind_addr; 920 921 ind_addr = cpu_physical_memory_map(ind_loc, &len, 1); 922 if (!ind_addr) { 923 error_report("%s(%x.%x.%04x): unable to access indicator", 924 __func__, sch->cssid, sch->ssid, sch->schid); 925 return -1; 926 } 927 do { 928 ind_old = *ind_addr; 929 ind_new = ind_old | to_be_set; 930 } while (atomic_cmpxchg(ind_addr, ind_old, ind_new) != ind_old); 931 cpu_physical_memory_unmap(ind_addr, len, 1, len); 932 933 return ind_old; 934 } 935 936 static void virtio_ccw_notify(DeviceState *d, uint16_t vector) 937 { 938 VirtioCcwDevice *dev = to_virtio_ccw_dev_fast(d); 939 SubchDev *sch = dev->sch; 940 uint64_t indicators; 941 942 if (vector >= 128) { 943 return; 944 } 945 946 if (vector < VIRTIO_PCI_QUEUE_MAX) { 947 if (!dev->indicators) { 948 return; 949 } 950 if (sch->thinint_active) { 951 /* 952 * In the adapter interrupt case, indicators points to a 953 * memory area that may be (way) larger than 64 bit and 954 * ind_bit indicates the start of the indicators in a big 955 * endian notation. 956 */ 957 virtio_set_ind_atomic(sch, dev->indicators + 958 (dev->ind_bit + vector) / 8, 959 0x80 >> ((dev->ind_bit + vector) % 8)); 960 if (!virtio_set_ind_atomic(sch, dev->summary_indicator, 961 0x01)) { 962 css_adapter_interrupt(dev->thinint_isc); 963 } 964 } else { 965 indicators = ldq_phys(&address_space_memory, dev->indicators); 966 indicators |= 1ULL << vector; 967 stq_phys(&address_space_memory, dev->indicators, indicators); 968 css_conditional_io_interrupt(sch); 969 } 970 } else { 971 if (!dev->indicators2) { 972 return; 973 } 974 vector = 0; 975 indicators = ldq_phys(&address_space_memory, dev->indicators2); 976 indicators |= 1ULL << vector; 977 stq_phys(&address_space_memory, dev->indicators2, indicators); 978 css_conditional_io_interrupt(sch); 979 } 980 } 981 982 static unsigned virtio_ccw_get_features(DeviceState *d) 983 { 984 VirtioCcwDevice *dev = VIRTIO_CCW_DEVICE(d); 985 986 /* Only the first 32 feature bits are used. */ 987 return dev->host_features[0]; 988 } 989 990 static void virtio_ccw_reset(DeviceState *d) 991 { 992 VirtioCcwDevice *dev = VIRTIO_CCW_DEVICE(d); 993 VirtIODevice *vdev = virtio_bus_get_device(&dev->bus); 994 995 virtio_ccw_stop_ioeventfd(dev); 996 virtio_reset(vdev); 997 css_reset_sch(dev->sch); 998 dev->indicators = 0; 999 dev->indicators2 = 0; 1000 dev->summary_indicator = 0; 1001 } 1002 1003 static void virtio_ccw_vmstate_change(DeviceState *d, bool running) 1004 { 1005 VirtioCcwDevice *dev = VIRTIO_CCW_DEVICE(d); 1006 1007 if (running) { 1008 virtio_ccw_start_ioeventfd(dev); 1009 } else { 1010 virtio_ccw_stop_ioeventfd(dev); 1011 } 1012 } 1013 1014 static bool virtio_ccw_query_guest_notifiers(DeviceState *d) 1015 { 1016 VirtioCcwDevice *dev = VIRTIO_CCW_DEVICE(d); 1017 1018 return !!(dev->sch->curr_status.pmcw.flags & PMCW_FLAGS_MASK_ENA); 1019 } 1020 1021 static int virtio_ccw_set_host_notifier(DeviceState *d, int n, bool assign) 1022 { 1023 VirtioCcwDevice *dev = VIRTIO_CCW_DEVICE(d); 1024 1025 /* Stop using the generic ioeventfd, we are doing eventfd handling 1026 * ourselves below */ 1027 dev->ioeventfd_disabled = assign; 1028 if (assign) { 1029 virtio_ccw_stop_ioeventfd(dev); 1030 } 1031 return virtio_ccw_set_guest2host_notifier(dev, n, assign, false); 1032 } 1033 1034 static int virtio_ccw_set_guest_notifier(VirtioCcwDevice *dev, int n, 1035 bool assign, bool with_irqfd) 1036 { 1037 VirtIODevice *vdev = virtio_bus_get_device(&dev->bus); 1038 VirtQueue *vq = virtio_get_queue(vdev, n); 1039 EventNotifier *notifier = virtio_queue_get_guest_notifier(vq); 1040 VirtioDeviceClass *k = VIRTIO_DEVICE_GET_CLASS(vdev); 1041 1042 if (assign) { 1043 int r = event_notifier_init(notifier, 0); 1044 1045 if (r < 0) { 1046 return r; 1047 } 1048 virtio_queue_set_guest_notifier_fd_handler(vq, true, with_irqfd); 1049 /* We do not support irqfd for classic I/O interrupts, because the 1050 * classic interrupts are intermixed with the subchannel status, that 1051 * is queried with test subchannel. We want to use vhost, though. 1052 * Lets make sure to have vhost running and wire up the irq fd to 1053 * land in qemu (and only the irq fd) in this code. 1054 */ 1055 if (k->guest_notifier_mask) { 1056 k->guest_notifier_mask(vdev, n, false); 1057 } 1058 /* get lost events and re-inject */ 1059 if (k->guest_notifier_pending && 1060 k->guest_notifier_pending(vdev, n)) { 1061 event_notifier_set(notifier); 1062 } 1063 } else { 1064 if (k->guest_notifier_mask) { 1065 k->guest_notifier_mask(vdev, n, true); 1066 } 1067 virtio_queue_set_guest_notifier_fd_handler(vq, false, with_irqfd); 1068 event_notifier_cleanup(notifier); 1069 } 1070 return 0; 1071 } 1072 1073 static int virtio_ccw_set_guest_notifiers(DeviceState *d, int nvqs, 1074 bool assigned) 1075 { 1076 VirtioCcwDevice *dev = VIRTIO_CCW_DEVICE(d); 1077 VirtIODevice *vdev = virtio_bus_get_device(&dev->bus); 1078 int r, n; 1079 1080 for (n = 0; n < nvqs; n++) { 1081 if (!virtio_queue_get_num(vdev, n)) { 1082 break; 1083 } 1084 /* false -> true, as soon as irqfd works */ 1085 r = virtio_ccw_set_guest_notifier(dev, n, assigned, false); 1086 if (r < 0) { 1087 goto assign_error; 1088 } 1089 } 1090 return 0; 1091 1092 assign_error: 1093 while (--n >= 0) { 1094 virtio_ccw_set_guest_notifier(dev, n, !assigned, false); 1095 } 1096 return r; 1097 } 1098 1099 /**************** Virtio-ccw Bus Device Descriptions *******************/ 1100 1101 static Property virtio_ccw_net_properties[] = { 1102 DEFINE_PROP_STRING("devno", VirtioCcwDevice, bus_id), 1103 DEFINE_VIRTIO_NET_FEATURES(VirtioCcwDevice, host_features[0]), 1104 DEFINE_VIRTIO_NET_PROPERTIES(VirtIONetCcw, vdev.net_conf), 1105 DEFINE_NIC_PROPERTIES(VirtIONetCcw, vdev.nic_conf), 1106 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice, flags, 1107 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT, true), 1108 DEFINE_PROP_END_OF_LIST(), 1109 }; 1110 1111 static void virtio_ccw_net_class_init(ObjectClass *klass, void *data) 1112 { 1113 DeviceClass *dc = DEVICE_CLASS(klass); 1114 VirtIOCCWDeviceClass *k = VIRTIO_CCW_DEVICE_CLASS(klass); 1115 1116 k->init = virtio_ccw_net_init; 1117 k->exit = virtio_ccw_exit; 1118 dc->reset = virtio_ccw_reset; 1119 dc->props = virtio_ccw_net_properties; 1120 } 1121 1122 static const TypeInfo virtio_ccw_net = { 1123 .name = TYPE_VIRTIO_NET_CCW, 1124 .parent = TYPE_VIRTIO_CCW_DEVICE, 1125 .instance_size = sizeof(VirtIONetCcw), 1126 .instance_init = virtio_ccw_net_instance_init, 1127 .class_init = virtio_ccw_net_class_init, 1128 }; 1129 1130 static Property virtio_ccw_blk_properties[] = { 1131 DEFINE_PROP_STRING("devno", VirtioCcwDevice, bus_id), 1132 DEFINE_VIRTIO_BLK_FEATURES(VirtioCcwDevice, host_features[0]), 1133 DEFINE_VIRTIO_BLK_PROPERTIES(VirtIOBlkCcw, blk), 1134 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice, flags, 1135 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT, true), 1136 #ifdef CONFIG_VIRTIO_BLK_DATA_PLANE 1137 DEFINE_PROP_BIT("x-data-plane", VirtIOBlkCcw, blk.data_plane, 0, false), 1138 #endif 1139 DEFINE_PROP_END_OF_LIST(), 1140 }; 1141 1142 static void virtio_ccw_blk_class_init(ObjectClass *klass, void *data) 1143 { 1144 DeviceClass *dc = DEVICE_CLASS(klass); 1145 VirtIOCCWDeviceClass *k = VIRTIO_CCW_DEVICE_CLASS(klass); 1146 1147 k->init = virtio_ccw_blk_init; 1148 k->exit = virtio_ccw_exit; 1149 dc->reset = virtio_ccw_reset; 1150 dc->props = virtio_ccw_blk_properties; 1151 } 1152 1153 static const TypeInfo virtio_ccw_blk = { 1154 .name = TYPE_VIRTIO_BLK_CCW, 1155 .parent = TYPE_VIRTIO_CCW_DEVICE, 1156 .instance_size = sizeof(VirtIOBlkCcw), 1157 .instance_init = virtio_ccw_blk_instance_init, 1158 .class_init = virtio_ccw_blk_class_init, 1159 }; 1160 1161 static Property virtio_ccw_serial_properties[] = { 1162 DEFINE_PROP_STRING("devno", VirtioCcwDevice, bus_id), 1163 DEFINE_VIRTIO_SERIAL_PROPERTIES(VirtioSerialCcw, vdev.serial), 1164 DEFINE_VIRTIO_COMMON_FEATURES(VirtioCcwDevice, host_features[0]), 1165 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice, flags, 1166 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT, true), 1167 DEFINE_PROP_END_OF_LIST(), 1168 }; 1169 1170 static void virtio_ccw_serial_class_init(ObjectClass *klass, void *data) 1171 { 1172 DeviceClass *dc = DEVICE_CLASS(klass); 1173 VirtIOCCWDeviceClass *k = VIRTIO_CCW_DEVICE_CLASS(klass); 1174 1175 k->init = virtio_ccw_serial_init; 1176 k->exit = virtio_ccw_exit; 1177 dc->reset = virtio_ccw_reset; 1178 dc->props = virtio_ccw_serial_properties; 1179 } 1180 1181 static const TypeInfo virtio_ccw_serial = { 1182 .name = TYPE_VIRTIO_SERIAL_CCW, 1183 .parent = TYPE_VIRTIO_CCW_DEVICE, 1184 .instance_size = sizeof(VirtioSerialCcw), 1185 .instance_init = virtio_ccw_serial_instance_init, 1186 .class_init = virtio_ccw_serial_class_init, 1187 }; 1188 1189 static Property virtio_ccw_balloon_properties[] = { 1190 DEFINE_PROP_STRING("devno", VirtioCcwDevice, bus_id), 1191 DEFINE_VIRTIO_COMMON_FEATURES(VirtioCcwDevice, host_features[0]), 1192 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice, flags, 1193 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT, true), 1194 DEFINE_PROP_END_OF_LIST(), 1195 }; 1196 1197 static void virtio_ccw_balloon_class_init(ObjectClass *klass, void *data) 1198 { 1199 DeviceClass *dc = DEVICE_CLASS(klass); 1200 VirtIOCCWDeviceClass *k = VIRTIO_CCW_DEVICE_CLASS(klass); 1201 1202 k->init = virtio_ccw_balloon_init; 1203 k->exit = virtio_ccw_exit; 1204 dc->reset = virtio_ccw_reset; 1205 dc->props = virtio_ccw_balloon_properties; 1206 } 1207 1208 static const TypeInfo virtio_ccw_balloon = { 1209 .name = TYPE_VIRTIO_BALLOON_CCW, 1210 .parent = TYPE_VIRTIO_CCW_DEVICE, 1211 .instance_size = sizeof(VirtIOBalloonCcw), 1212 .instance_init = virtio_ccw_balloon_instance_init, 1213 .class_init = virtio_ccw_balloon_class_init, 1214 }; 1215 1216 static Property virtio_ccw_scsi_properties[] = { 1217 DEFINE_PROP_STRING("devno", VirtioCcwDevice, bus_id), 1218 DEFINE_VIRTIO_SCSI_PROPERTIES(VirtIOSCSICcw, vdev.parent_obj.conf), 1219 DEFINE_VIRTIO_SCSI_FEATURES(VirtioCcwDevice, host_features[0]), 1220 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice, flags, 1221 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT, true), 1222 DEFINE_PROP_END_OF_LIST(), 1223 }; 1224 1225 static void virtio_ccw_scsi_class_init(ObjectClass *klass, void *data) 1226 { 1227 DeviceClass *dc = DEVICE_CLASS(klass); 1228 VirtIOCCWDeviceClass *k = VIRTIO_CCW_DEVICE_CLASS(klass); 1229 1230 k->init = virtio_ccw_scsi_init; 1231 k->exit = virtio_ccw_exit; 1232 dc->reset = virtio_ccw_reset; 1233 dc->props = virtio_ccw_scsi_properties; 1234 } 1235 1236 static const TypeInfo virtio_ccw_scsi = { 1237 .name = TYPE_VIRTIO_SCSI_CCW, 1238 .parent = TYPE_VIRTIO_CCW_DEVICE, 1239 .instance_size = sizeof(VirtIOSCSICcw), 1240 .instance_init = virtio_ccw_scsi_instance_init, 1241 .class_init = virtio_ccw_scsi_class_init, 1242 }; 1243 1244 #ifdef CONFIG_VHOST_SCSI 1245 static Property vhost_ccw_scsi_properties[] = { 1246 DEFINE_PROP_STRING("devno", VirtioCcwDevice, bus_id), 1247 DEFINE_VHOST_SCSI_PROPERTIES(VirtIOSCSICcw, vdev.parent_obj.conf), 1248 DEFINE_VIRTIO_COMMON_FEATURES(VirtioCcwDevice, host_features[0]), 1249 DEFINE_PROP_END_OF_LIST(), 1250 }; 1251 1252 static void vhost_ccw_scsi_class_init(ObjectClass *klass, void *data) 1253 { 1254 DeviceClass *dc = DEVICE_CLASS(klass); 1255 VirtIOCCWDeviceClass *k = VIRTIO_CCW_DEVICE_CLASS(klass); 1256 1257 k->init = vhost_ccw_scsi_init; 1258 k->exit = virtio_ccw_exit; 1259 dc->reset = virtio_ccw_reset; 1260 dc->props = vhost_ccw_scsi_properties; 1261 } 1262 1263 static const TypeInfo vhost_ccw_scsi = { 1264 .name = TYPE_VHOST_SCSI_CCW, 1265 .parent = TYPE_VIRTIO_CCW_DEVICE, 1266 .instance_size = sizeof(VirtIOSCSICcw), 1267 .instance_init = vhost_ccw_scsi_instance_init, 1268 .class_init = vhost_ccw_scsi_class_init, 1269 }; 1270 #endif 1271 1272 static void virtio_ccw_rng_instance_init(Object *obj) 1273 { 1274 VirtIORNGCcw *dev = VIRTIO_RNG_CCW(obj); 1275 object_initialize(&dev->vdev, sizeof(dev->vdev), TYPE_VIRTIO_RNG); 1276 object_property_add_child(obj, "virtio-backend", OBJECT(&dev->vdev), NULL); 1277 object_property_add_link(obj, "rng", TYPE_RNG_BACKEND, 1278 (Object **)&dev->vdev.conf.rng, 1279 qdev_prop_allow_set_link_before_realize, 1280 OBJ_PROP_LINK_UNREF_ON_RELEASE, NULL); 1281 } 1282 1283 static Property virtio_ccw_rng_properties[] = { 1284 DEFINE_PROP_STRING("devno", VirtioCcwDevice, bus_id), 1285 DEFINE_VIRTIO_COMMON_FEATURES(VirtioCcwDevice, host_features[0]), 1286 DEFINE_VIRTIO_RNG_PROPERTIES(VirtIORNGCcw, vdev.conf), 1287 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice, flags, 1288 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT, true), 1289 DEFINE_PROP_END_OF_LIST(), 1290 }; 1291 1292 static void virtio_ccw_rng_class_init(ObjectClass *klass, void *data) 1293 { 1294 DeviceClass *dc = DEVICE_CLASS(klass); 1295 VirtIOCCWDeviceClass *k = VIRTIO_CCW_DEVICE_CLASS(klass); 1296 1297 k->init = virtio_ccw_rng_init; 1298 k->exit = virtio_ccw_exit; 1299 dc->reset = virtio_ccw_reset; 1300 dc->props = virtio_ccw_rng_properties; 1301 } 1302 1303 static const TypeInfo virtio_ccw_rng = { 1304 .name = TYPE_VIRTIO_RNG_CCW, 1305 .parent = TYPE_VIRTIO_CCW_DEVICE, 1306 .instance_size = sizeof(VirtIORNGCcw), 1307 .instance_init = virtio_ccw_rng_instance_init, 1308 .class_init = virtio_ccw_rng_class_init, 1309 }; 1310 1311 static int virtio_ccw_busdev_init(DeviceState *dev) 1312 { 1313 VirtioCcwDevice *_dev = (VirtioCcwDevice *)dev; 1314 VirtIOCCWDeviceClass *_info = VIRTIO_CCW_DEVICE_GET_CLASS(dev); 1315 1316 virtio_ccw_bus_new(&_dev->bus, sizeof(_dev->bus), _dev); 1317 1318 return _info->init(_dev); 1319 } 1320 1321 static int virtio_ccw_busdev_exit(DeviceState *dev) 1322 { 1323 VirtioCcwDevice *_dev = (VirtioCcwDevice *)dev; 1324 VirtIOCCWDeviceClass *_info = VIRTIO_CCW_DEVICE_GET_CLASS(dev); 1325 1326 return _info->exit(_dev); 1327 } 1328 1329 static int virtio_ccw_busdev_unplug(DeviceState *dev) 1330 { 1331 VirtioCcwDevice *_dev = (VirtioCcwDevice *)dev; 1332 SubchDev *sch = _dev->sch; 1333 1334 virtio_ccw_stop_ioeventfd(_dev); 1335 1336 /* 1337 * We should arrive here only for device_del, since we don't support 1338 * direct hot(un)plug of channels, but only through virtio. 1339 */ 1340 assert(sch != NULL); 1341 /* Subchannel is now disabled and no longer valid. */ 1342 sch->curr_status.pmcw.flags &= ~(PMCW_FLAGS_MASK_ENA | 1343 PMCW_FLAGS_MASK_DNV); 1344 1345 css_generate_sch_crws(sch->cssid, sch->ssid, sch->schid, 1, 0); 1346 1347 object_unparent(OBJECT(dev)); 1348 return 0; 1349 } 1350 1351 static void virtio_ccw_device_class_init(ObjectClass *klass, void *data) 1352 { 1353 DeviceClass *dc = DEVICE_CLASS(klass); 1354 1355 dc->init = virtio_ccw_busdev_init; 1356 dc->exit = virtio_ccw_busdev_exit; 1357 dc->unplug = virtio_ccw_busdev_unplug; 1358 dc->bus_type = TYPE_VIRTUAL_CSS_BUS; 1359 1360 } 1361 1362 static const TypeInfo virtio_ccw_device_info = { 1363 .name = TYPE_VIRTIO_CCW_DEVICE, 1364 .parent = TYPE_DEVICE, 1365 .instance_size = sizeof(VirtioCcwDevice), 1366 .class_init = virtio_ccw_device_class_init, 1367 .class_size = sizeof(VirtIOCCWDeviceClass), 1368 .abstract = true, 1369 }; 1370 1371 /***************** Virtual-css Bus Bridge Device ********************/ 1372 /* Only required to have the virtio bus as child in the system bus */ 1373 1374 static int virtual_css_bridge_init(SysBusDevice *dev) 1375 { 1376 /* nothing */ 1377 return 0; 1378 } 1379 1380 static void virtual_css_bridge_class_init(ObjectClass *klass, void *data) 1381 { 1382 SysBusDeviceClass *k = SYS_BUS_DEVICE_CLASS(klass); 1383 1384 k->init = virtual_css_bridge_init; 1385 } 1386 1387 static const TypeInfo virtual_css_bridge_info = { 1388 .name = "virtual-css-bridge", 1389 .parent = TYPE_SYS_BUS_DEVICE, 1390 .instance_size = sizeof(SysBusDevice), 1391 .class_init = virtual_css_bridge_class_init, 1392 }; 1393 1394 /* virtio-ccw-bus */ 1395 1396 static void virtio_ccw_bus_new(VirtioBusState *bus, size_t bus_size, 1397 VirtioCcwDevice *dev) 1398 { 1399 DeviceState *qdev = DEVICE(dev); 1400 BusState *qbus; 1401 char virtio_bus_name[] = "virtio-bus"; 1402 1403 qbus_create_inplace(bus, bus_size, TYPE_VIRTIO_CCW_BUS, 1404 qdev, virtio_bus_name); 1405 qbus = BUS(bus); 1406 qbus->allow_hotplug = 1; 1407 } 1408 1409 static void virtio_ccw_bus_class_init(ObjectClass *klass, void *data) 1410 { 1411 VirtioBusClass *k = VIRTIO_BUS_CLASS(klass); 1412 BusClass *bus_class = BUS_CLASS(klass); 1413 1414 bus_class->max_dev = 1; 1415 k->notify = virtio_ccw_notify; 1416 k->get_features = virtio_ccw_get_features; 1417 k->vmstate_change = virtio_ccw_vmstate_change; 1418 k->query_guest_notifiers = virtio_ccw_query_guest_notifiers; 1419 k->set_host_notifier = virtio_ccw_set_host_notifier; 1420 k->set_guest_notifiers = virtio_ccw_set_guest_notifiers; 1421 } 1422 1423 static const TypeInfo virtio_ccw_bus_info = { 1424 .name = TYPE_VIRTIO_CCW_BUS, 1425 .parent = TYPE_VIRTIO_BUS, 1426 .instance_size = sizeof(VirtioCcwBusState), 1427 .class_init = virtio_ccw_bus_class_init, 1428 }; 1429 1430 static void virtio_ccw_register(void) 1431 { 1432 type_register_static(&virtio_ccw_bus_info); 1433 type_register_static(&virtual_css_bus_info); 1434 type_register_static(&virtio_ccw_device_info); 1435 type_register_static(&virtio_ccw_serial); 1436 type_register_static(&virtio_ccw_blk); 1437 type_register_static(&virtio_ccw_net); 1438 type_register_static(&virtio_ccw_balloon); 1439 type_register_static(&virtio_ccw_scsi); 1440 #ifdef CONFIG_VHOST_SCSI 1441 type_register_static(&vhost_ccw_scsi); 1442 #endif 1443 type_register_static(&virtio_ccw_rng); 1444 type_register_static(&virtual_css_bridge_info); 1445 } 1446 1447 type_init(virtio_ccw_register) 1448