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 sch->thinint_active = ((dev->indicators != 0) && 526 (dev->summary_indicator != 0)); 527 sch->curr_status.scsw.count = ccw.count - len; 528 ret = 0; 529 } 530 } 531 break; 532 default: 533 ret = -ENOSYS; 534 break; 535 } 536 return ret; 537 } 538 539 static int virtio_ccw_device_init(VirtioCcwDevice *dev, VirtIODevice *vdev) 540 { 541 unsigned int cssid = 0; 542 unsigned int ssid = 0; 543 unsigned int schid; 544 unsigned int devno; 545 bool have_devno = false; 546 bool found = false; 547 SubchDev *sch; 548 int ret; 549 int num; 550 DeviceState *parent = DEVICE(dev); 551 552 sch = g_malloc0(sizeof(SubchDev)); 553 554 sch->driver_data = dev; 555 dev->sch = sch; 556 557 dev->indicators = 0; 558 559 /* Initialize subchannel structure. */ 560 sch->channel_prog = 0x0; 561 sch->last_cmd_valid = false; 562 sch->orb = NULL; 563 sch->thinint_active = false; 564 /* 565 * Use a device number if provided. Otherwise, fall back to subchannel 566 * number. 567 */ 568 if (dev->bus_id) { 569 num = sscanf(dev->bus_id, "%x.%x.%04x", &cssid, &ssid, &devno); 570 if (num == 3) { 571 if ((cssid > MAX_CSSID) || (ssid > MAX_SSID)) { 572 ret = -EINVAL; 573 error_report("Invalid cssid or ssid: cssid %x, ssid %x", 574 cssid, ssid); 575 goto out_err; 576 } 577 /* Enforce use of virtual cssid. */ 578 if (cssid != VIRTUAL_CSSID) { 579 ret = -EINVAL; 580 error_report("cssid %x not valid for virtio devices", cssid); 581 goto out_err; 582 } 583 if (css_devno_used(cssid, ssid, devno)) { 584 ret = -EEXIST; 585 error_report("Device %x.%x.%04x already exists", cssid, ssid, 586 devno); 587 goto out_err; 588 } 589 sch->cssid = cssid; 590 sch->ssid = ssid; 591 sch->devno = devno; 592 have_devno = true; 593 } else { 594 ret = -EINVAL; 595 error_report("Malformed devno parameter '%s'", dev->bus_id); 596 goto out_err; 597 } 598 } 599 600 /* Find the next free id. */ 601 if (have_devno) { 602 for (schid = 0; schid <= MAX_SCHID; schid++) { 603 if (!css_find_subch(1, cssid, ssid, schid)) { 604 sch->schid = schid; 605 css_subch_assign(cssid, ssid, schid, devno, sch); 606 found = true; 607 break; 608 } 609 } 610 if (!found) { 611 ret = -ENODEV; 612 error_report("No free subchannel found for %x.%x.%04x", cssid, ssid, 613 devno); 614 goto out_err; 615 } 616 trace_virtio_ccw_new_device(cssid, ssid, schid, devno, 617 "user-configured"); 618 } else { 619 cssid = VIRTUAL_CSSID; 620 for (ssid = 0; ssid <= MAX_SSID; ssid++) { 621 for (schid = 0; schid <= MAX_SCHID; schid++) { 622 if (!css_find_subch(1, cssid, ssid, schid)) { 623 sch->cssid = cssid; 624 sch->ssid = ssid; 625 sch->schid = schid; 626 devno = schid; 627 /* 628 * If the devno is already taken, look further in this 629 * subchannel set. 630 */ 631 while (css_devno_used(cssid, ssid, devno)) { 632 if (devno == MAX_SCHID) { 633 devno = 0; 634 } else if (devno == schid - 1) { 635 ret = -ENODEV; 636 error_report("No free devno found"); 637 goto out_err; 638 } else { 639 devno++; 640 } 641 } 642 sch->devno = devno; 643 css_subch_assign(cssid, ssid, schid, devno, sch); 644 found = true; 645 break; 646 } 647 } 648 if (found) { 649 break; 650 } 651 } 652 if (!found) { 653 ret = -ENODEV; 654 error_report("Virtual channel subsystem is full!"); 655 goto out_err; 656 } 657 trace_virtio_ccw_new_device(cssid, ssid, schid, devno, 658 "auto-configured"); 659 } 660 661 /* Build initial schib. */ 662 css_sch_build_virtual_schib(sch, 0, VIRTIO_CCW_CHPID_TYPE); 663 664 sch->ccw_cb = virtio_ccw_cb; 665 666 /* Build senseid data. */ 667 memset(&sch->id, 0, sizeof(SenseId)); 668 sch->id.reserved = 0xff; 669 sch->id.cu_type = VIRTIO_CCW_CU_TYPE; 670 sch->id.cu_model = vdev->device_id; 671 672 /* Only the first 32 feature bits are used. */ 673 dev->host_features[0] = virtio_bus_get_vdev_features(&dev->bus, 674 dev->host_features[0]); 675 676 dev->host_features[0] |= 0x1 << VIRTIO_F_NOTIFY_ON_EMPTY; 677 dev->host_features[0] |= 0x1 << VIRTIO_F_BAD_FEATURE; 678 679 css_generate_sch_crws(sch->cssid, sch->ssid, sch->schid, 680 parent->hotplugged, 1); 681 return 0; 682 683 out_err: 684 dev->sch = NULL; 685 g_free(sch); 686 return ret; 687 } 688 689 static int virtio_ccw_exit(VirtioCcwDevice *dev) 690 { 691 SubchDev *sch = dev->sch; 692 693 if (sch) { 694 css_subch_assign(sch->cssid, sch->ssid, sch->schid, sch->devno, NULL); 695 g_free(sch); 696 } 697 dev->indicators = 0; 698 return 0; 699 } 700 701 static int virtio_ccw_net_init(VirtioCcwDevice *ccw_dev) 702 { 703 DeviceState *qdev = DEVICE(ccw_dev); 704 VirtIONetCcw *dev = VIRTIO_NET_CCW(ccw_dev); 705 DeviceState *vdev = DEVICE(&dev->vdev); 706 707 virtio_net_set_config_size(&dev->vdev, ccw_dev->host_features[0]); 708 virtio_net_set_netclient_name(&dev->vdev, qdev->id, 709 object_get_typename(OBJECT(qdev))); 710 qdev_set_parent_bus(vdev, BUS(&ccw_dev->bus)); 711 if (qdev_init(vdev) < 0) { 712 return -1; 713 } 714 715 return virtio_ccw_device_init(ccw_dev, VIRTIO_DEVICE(vdev)); 716 } 717 718 static void virtio_ccw_net_instance_init(Object *obj) 719 { 720 VirtIONetCcw *dev = VIRTIO_NET_CCW(obj); 721 object_initialize(&dev->vdev, sizeof(dev->vdev), TYPE_VIRTIO_NET); 722 object_property_add_child(obj, "virtio-backend", OBJECT(&dev->vdev), NULL); 723 } 724 725 static int virtio_ccw_blk_init(VirtioCcwDevice *ccw_dev) 726 { 727 VirtIOBlkCcw *dev = VIRTIO_BLK_CCW(ccw_dev); 728 DeviceState *vdev = DEVICE(&dev->vdev); 729 virtio_blk_set_conf(vdev, &(dev->blk)); 730 qdev_set_parent_bus(vdev, BUS(&ccw_dev->bus)); 731 if (qdev_init(vdev) < 0) { 732 return -1; 733 } 734 735 return virtio_ccw_device_init(ccw_dev, VIRTIO_DEVICE(vdev)); 736 } 737 738 static void virtio_ccw_blk_instance_init(Object *obj) 739 { 740 VirtIOBlkCcw *dev = VIRTIO_BLK_CCW(obj); 741 object_initialize(&dev->vdev, sizeof(dev->vdev), TYPE_VIRTIO_BLK); 742 object_property_add_child(obj, "virtio-backend", OBJECT(&dev->vdev), NULL); 743 } 744 745 static int virtio_ccw_serial_init(VirtioCcwDevice *ccw_dev) 746 { 747 VirtioSerialCcw *dev = VIRTIO_SERIAL_CCW(ccw_dev); 748 DeviceState *vdev = DEVICE(&dev->vdev); 749 DeviceState *proxy = DEVICE(ccw_dev); 750 char *bus_name; 751 752 /* 753 * For command line compatibility, this sets the virtio-serial-device bus 754 * name as before. 755 */ 756 if (proxy->id) { 757 bus_name = g_strdup_printf("%s.0", proxy->id); 758 virtio_device_set_child_bus_name(VIRTIO_DEVICE(vdev), bus_name); 759 g_free(bus_name); 760 } 761 762 qdev_set_parent_bus(vdev, BUS(&ccw_dev->bus)); 763 if (qdev_init(vdev) < 0) { 764 return -1; 765 } 766 767 return virtio_ccw_device_init(ccw_dev, VIRTIO_DEVICE(vdev)); 768 } 769 770 771 static void virtio_ccw_serial_instance_init(Object *obj) 772 { 773 VirtioSerialCcw *dev = VIRTIO_SERIAL_CCW(obj); 774 object_initialize(&dev->vdev, sizeof(dev->vdev), TYPE_VIRTIO_SERIAL); 775 object_property_add_child(obj, "virtio-backend", OBJECT(&dev->vdev), NULL); 776 } 777 778 static int virtio_ccw_balloon_init(VirtioCcwDevice *ccw_dev) 779 { 780 VirtIOBalloonCcw *dev = VIRTIO_BALLOON_CCW(ccw_dev); 781 DeviceState *vdev = DEVICE(&dev->vdev); 782 783 qdev_set_parent_bus(vdev, BUS(&ccw_dev->bus)); 784 if (qdev_init(vdev) < 0) { 785 return -1; 786 } 787 788 return virtio_ccw_device_init(ccw_dev, VIRTIO_DEVICE(vdev)); 789 } 790 791 static void balloon_ccw_stats_get_all(Object *obj, struct Visitor *v, 792 void *opaque, const char *name, 793 Error **errp) 794 { 795 VirtIOBalloonCcw *dev = opaque; 796 object_property_get(OBJECT(&dev->vdev), v, "guest-stats", errp); 797 } 798 799 static void balloon_ccw_stats_get_poll_interval(Object *obj, struct Visitor *v, 800 void *opaque, const char *name, 801 Error **errp) 802 { 803 VirtIOBalloonCcw *dev = opaque; 804 object_property_get(OBJECT(&dev->vdev), v, "guest-stats-polling-interval", 805 errp); 806 } 807 808 static void balloon_ccw_stats_set_poll_interval(Object *obj, struct Visitor *v, 809 void *opaque, const char *name, 810 Error **errp) 811 { 812 VirtIOBalloonCcw *dev = opaque; 813 object_property_set(OBJECT(&dev->vdev), v, "guest-stats-polling-interval", 814 errp); 815 } 816 817 static void virtio_ccw_balloon_instance_init(Object *obj) 818 { 819 VirtIOBalloonCcw *dev = VIRTIO_BALLOON_CCW(obj); 820 object_initialize(&dev->vdev, sizeof(dev->vdev), TYPE_VIRTIO_BALLOON); 821 object_property_add_child(obj, "virtio-backend", OBJECT(&dev->vdev), NULL); 822 823 object_property_add(obj, "guest-stats", "guest statistics", 824 balloon_ccw_stats_get_all, NULL, NULL, dev, NULL); 825 826 object_property_add(obj, "guest-stats-polling-interval", "int", 827 balloon_ccw_stats_get_poll_interval, 828 balloon_ccw_stats_set_poll_interval, 829 NULL, dev, NULL); 830 } 831 832 static int virtio_ccw_scsi_init(VirtioCcwDevice *ccw_dev) 833 { 834 VirtIOSCSICcw *dev = VIRTIO_SCSI_CCW(ccw_dev); 835 DeviceState *vdev = DEVICE(&dev->vdev); 836 DeviceState *qdev = DEVICE(ccw_dev); 837 char *bus_name; 838 839 /* 840 * For command line compatibility, this sets the virtio-scsi-device bus 841 * name as before. 842 */ 843 if (qdev->id) { 844 bus_name = g_strdup_printf("%s.0", qdev->id); 845 virtio_device_set_child_bus_name(VIRTIO_DEVICE(vdev), bus_name); 846 g_free(bus_name); 847 } 848 849 qdev_set_parent_bus(vdev, BUS(&ccw_dev->bus)); 850 if (qdev_init(vdev) < 0) { 851 return -1; 852 } 853 854 return virtio_ccw_device_init(ccw_dev, VIRTIO_DEVICE(vdev)); 855 } 856 857 static void virtio_ccw_scsi_instance_init(Object *obj) 858 { 859 VirtIOSCSICcw *dev = VIRTIO_SCSI_CCW(obj); 860 object_initialize(&dev->vdev, sizeof(dev->vdev), TYPE_VIRTIO_SCSI); 861 object_property_add_child(obj, "virtio-backend", OBJECT(&dev->vdev), NULL); 862 } 863 864 #ifdef CONFIG_VHOST_SCSI 865 static int vhost_ccw_scsi_init(VirtioCcwDevice *ccw_dev) 866 { 867 VHostSCSICcw *dev = VHOST_SCSI_CCW(ccw_dev); 868 DeviceState *vdev = DEVICE(&dev->vdev); 869 870 qdev_set_parent_bus(vdev, BUS(&ccw_dev->bus)); 871 if (qdev_init(vdev) < 0) { 872 return -1; 873 } 874 875 return virtio_ccw_device_init(ccw_dev, VIRTIO_DEVICE(vdev)); 876 } 877 878 static void vhost_ccw_scsi_instance_init(Object *obj) 879 { 880 VHostSCSICcw *dev = VHOST_SCSI_CCW(obj); 881 object_initialize(&dev->vdev, sizeof(dev->vdev), TYPE_VHOST_SCSI); 882 object_property_add_child(obj, "virtio-backend", OBJECT(&dev->vdev), NULL); 883 } 884 #endif 885 886 static int virtio_ccw_rng_init(VirtioCcwDevice *ccw_dev) 887 { 888 VirtIORNGCcw *dev = VIRTIO_RNG_CCW(ccw_dev); 889 DeviceState *vdev = DEVICE(&dev->vdev); 890 891 qdev_set_parent_bus(vdev, BUS(&ccw_dev->bus)); 892 if (qdev_init(vdev) < 0) { 893 return -1; 894 } 895 896 object_property_set_link(OBJECT(dev), 897 OBJECT(dev->vdev.conf.rng), "rng", 898 NULL); 899 900 return virtio_ccw_device_init(ccw_dev, VIRTIO_DEVICE(vdev)); 901 } 902 903 /* DeviceState to VirtioCcwDevice. Note: used on datapath, 904 * be careful and test performance if you change this. 905 */ 906 static inline VirtioCcwDevice *to_virtio_ccw_dev_fast(DeviceState *d) 907 { 908 return container_of(d, VirtioCcwDevice, parent_obj); 909 } 910 911 static uint8_t virtio_set_ind_atomic(SubchDev *sch, uint64_t ind_loc, 912 uint8_t to_be_set) 913 { 914 uint8_t ind_old, ind_new; 915 hwaddr len = 1; 916 uint8_t *ind_addr; 917 918 ind_addr = cpu_physical_memory_map(ind_loc, &len, 1); 919 if (!ind_addr) { 920 error_report("%s(%x.%x.%04x): unable to access indicator", 921 __func__, sch->cssid, sch->ssid, sch->schid); 922 return -1; 923 } 924 do { 925 ind_old = *ind_addr; 926 ind_new = ind_old | to_be_set; 927 } while (atomic_cmpxchg(ind_addr, ind_old, ind_new) != ind_old); 928 cpu_physical_memory_unmap(ind_addr, len, 1, len); 929 930 return ind_old; 931 } 932 933 static void virtio_ccw_notify(DeviceState *d, uint16_t vector) 934 { 935 VirtioCcwDevice *dev = to_virtio_ccw_dev_fast(d); 936 SubchDev *sch = dev->sch; 937 uint64_t indicators; 938 939 if (vector >= 128) { 940 return; 941 } 942 943 if (vector < VIRTIO_PCI_QUEUE_MAX) { 944 if (!dev->indicators) { 945 return; 946 } 947 if (sch->thinint_active) { 948 /* 949 * In the adapter interrupt case, indicators points to a 950 * memory area that may be (way) larger than 64 bit and 951 * ind_bit indicates the start of the indicators in a big 952 * endian notation. 953 */ 954 virtio_set_ind_atomic(sch, dev->indicators + 955 (dev->ind_bit + vector) / 8, 956 0x80 >> ((dev->ind_bit + vector) % 8)); 957 if (!virtio_set_ind_atomic(sch, dev->summary_indicator, 958 0x01)) { 959 css_adapter_interrupt(dev->thinint_isc); 960 } 961 } else { 962 indicators = ldq_phys(&address_space_memory, dev->indicators); 963 indicators |= 1ULL << vector; 964 stq_phys(&address_space_memory, dev->indicators, indicators); 965 css_conditional_io_interrupt(sch); 966 } 967 } else { 968 if (!dev->indicators2) { 969 return; 970 } 971 vector = 0; 972 indicators = ldq_phys(&address_space_memory, dev->indicators2); 973 indicators |= 1ULL << vector; 974 stq_phys(&address_space_memory, dev->indicators2, indicators); 975 css_conditional_io_interrupt(sch); 976 } 977 } 978 979 static unsigned virtio_ccw_get_features(DeviceState *d) 980 { 981 VirtioCcwDevice *dev = VIRTIO_CCW_DEVICE(d); 982 983 /* Only the first 32 feature bits are used. */ 984 return dev->host_features[0]; 985 } 986 987 static void virtio_ccw_reset(DeviceState *d) 988 { 989 VirtioCcwDevice *dev = VIRTIO_CCW_DEVICE(d); 990 VirtIODevice *vdev = virtio_bus_get_device(&dev->bus); 991 992 virtio_ccw_stop_ioeventfd(dev); 993 virtio_reset(vdev); 994 css_reset_sch(dev->sch); 995 dev->indicators = 0; 996 dev->indicators2 = 0; 997 dev->summary_indicator = 0; 998 } 999 1000 static void virtio_ccw_vmstate_change(DeviceState *d, bool running) 1001 { 1002 VirtioCcwDevice *dev = VIRTIO_CCW_DEVICE(d); 1003 1004 if (running) { 1005 virtio_ccw_start_ioeventfd(dev); 1006 } else { 1007 virtio_ccw_stop_ioeventfd(dev); 1008 } 1009 } 1010 1011 static bool virtio_ccw_query_guest_notifiers(DeviceState *d) 1012 { 1013 VirtioCcwDevice *dev = VIRTIO_CCW_DEVICE(d); 1014 1015 return !!(dev->sch->curr_status.pmcw.flags & PMCW_FLAGS_MASK_ENA); 1016 } 1017 1018 static int virtio_ccw_set_host_notifier(DeviceState *d, int n, bool assign) 1019 { 1020 VirtioCcwDevice *dev = VIRTIO_CCW_DEVICE(d); 1021 1022 /* Stop using the generic ioeventfd, we are doing eventfd handling 1023 * ourselves below */ 1024 dev->ioeventfd_disabled = assign; 1025 if (assign) { 1026 virtio_ccw_stop_ioeventfd(dev); 1027 } 1028 return virtio_ccw_set_guest2host_notifier(dev, n, assign, false); 1029 } 1030 1031 static int virtio_ccw_set_guest_notifier(VirtioCcwDevice *dev, int n, 1032 bool assign, bool with_irqfd) 1033 { 1034 VirtIODevice *vdev = virtio_bus_get_device(&dev->bus); 1035 VirtQueue *vq = virtio_get_queue(vdev, n); 1036 EventNotifier *notifier = virtio_queue_get_guest_notifier(vq); 1037 VirtioDeviceClass *k = VIRTIO_DEVICE_GET_CLASS(vdev); 1038 1039 if (assign) { 1040 int r = event_notifier_init(notifier, 0); 1041 1042 if (r < 0) { 1043 return r; 1044 } 1045 virtio_queue_set_guest_notifier_fd_handler(vq, true, with_irqfd); 1046 /* We do not support irqfd for classic I/O interrupts, because the 1047 * classic interrupts are intermixed with the subchannel status, that 1048 * is queried with test subchannel. We want to use vhost, though. 1049 * Lets make sure to have vhost running and wire up the irq fd to 1050 * land in qemu (and only the irq fd) in this code. 1051 */ 1052 if (k->guest_notifier_mask) { 1053 k->guest_notifier_mask(vdev, n, false); 1054 } 1055 /* get lost events and re-inject */ 1056 if (k->guest_notifier_pending && 1057 k->guest_notifier_pending(vdev, n)) { 1058 event_notifier_set(notifier); 1059 } 1060 } else { 1061 if (k->guest_notifier_mask) { 1062 k->guest_notifier_mask(vdev, n, true); 1063 } 1064 virtio_queue_set_guest_notifier_fd_handler(vq, false, with_irqfd); 1065 event_notifier_cleanup(notifier); 1066 } 1067 return 0; 1068 } 1069 1070 static int virtio_ccw_set_guest_notifiers(DeviceState *d, int nvqs, 1071 bool assigned) 1072 { 1073 VirtioCcwDevice *dev = VIRTIO_CCW_DEVICE(d); 1074 VirtIODevice *vdev = virtio_bus_get_device(&dev->bus); 1075 int r, n; 1076 1077 for (n = 0; n < nvqs; n++) { 1078 if (!virtio_queue_get_num(vdev, n)) { 1079 break; 1080 } 1081 /* false -> true, as soon as irqfd works */ 1082 r = virtio_ccw_set_guest_notifier(dev, n, assigned, false); 1083 if (r < 0) { 1084 goto assign_error; 1085 } 1086 } 1087 return 0; 1088 1089 assign_error: 1090 while (--n >= 0) { 1091 virtio_ccw_set_guest_notifier(dev, n, !assigned, false); 1092 } 1093 return r; 1094 } 1095 1096 /**************** Virtio-ccw Bus Device Descriptions *******************/ 1097 1098 static Property virtio_ccw_net_properties[] = { 1099 DEFINE_PROP_STRING("devno", VirtioCcwDevice, bus_id), 1100 DEFINE_VIRTIO_NET_FEATURES(VirtioCcwDevice, host_features[0]), 1101 DEFINE_VIRTIO_NET_PROPERTIES(VirtIONetCcw, vdev.net_conf), 1102 DEFINE_NIC_PROPERTIES(VirtIONetCcw, vdev.nic_conf), 1103 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice, flags, 1104 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT, true), 1105 DEFINE_PROP_END_OF_LIST(), 1106 }; 1107 1108 static void virtio_ccw_net_class_init(ObjectClass *klass, void *data) 1109 { 1110 DeviceClass *dc = DEVICE_CLASS(klass); 1111 VirtIOCCWDeviceClass *k = VIRTIO_CCW_DEVICE_CLASS(klass); 1112 1113 k->init = virtio_ccw_net_init; 1114 k->exit = virtio_ccw_exit; 1115 dc->reset = virtio_ccw_reset; 1116 dc->props = virtio_ccw_net_properties; 1117 } 1118 1119 static const TypeInfo virtio_ccw_net = { 1120 .name = TYPE_VIRTIO_NET_CCW, 1121 .parent = TYPE_VIRTIO_CCW_DEVICE, 1122 .instance_size = sizeof(VirtIONetCcw), 1123 .instance_init = virtio_ccw_net_instance_init, 1124 .class_init = virtio_ccw_net_class_init, 1125 }; 1126 1127 static Property virtio_ccw_blk_properties[] = { 1128 DEFINE_PROP_STRING("devno", VirtioCcwDevice, bus_id), 1129 DEFINE_VIRTIO_BLK_FEATURES(VirtioCcwDevice, host_features[0]), 1130 DEFINE_VIRTIO_BLK_PROPERTIES(VirtIOBlkCcw, blk), 1131 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice, flags, 1132 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT, true), 1133 #ifdef CONFIG_VIRTIO_BLK_DATA_PLANE 1134 DEFINE_PROP_BIT("x-data-plane", VirtIOBlkCcw, blk.data_plane, 0, false), 1135 #endif 1136 DEFINE_PROP_END_OF_LIST(), 1137 }; 1138 1139 static void virtio_ccw_blk_class_init(ObjectClass *klass, void *data) 1140 { 1141 DeviceClass *dc = DEVICE_CLASS(klass); 1142 VirtIOCCWDeviceClass *k = VIRTIO_CCW_DEVICE_CLASS(klass); 1143 1144 k->init = virtio_ccw_blk_init; 1145 k->exit = virtio_ccw_exit; 1146 dc->reset = virtio_ccw_reset; 1147 dc->props = virtio_ccw_blk_properties; 1148 } 1149 1150 static const TypeInfo virtio_ccw_blk = { 1151 .name = TYPE_VIRTIO_BLK_CCW, 1152 .parent = TYPE_VIRTIO_CCW_DEVICE, 1153 .instance_size = sizeof(VirtIOBlkCcw), 1154 .instance_init = virtio_ccw_blk_instance_init, 1155 .class_init = virtio_ccw_blk_class_init, 1156 }; 1157 1158 static Property virtio_ccw_serial_properties[] = { 1159 DEFINE_PROP_STRING("devno", VirtioCcwDevice, bus_id), 1160 DEFINE_VIRTIO_SERIAL_PROPERTIES(VirtioSerialCcw, vdev.serial), 1161 DEFINE_VIRTIO_COMMON_FEATURES(VirtioCcwDevice, host_features[0]), 1162 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice, flags, 1163 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT, true), 1164 DEFINE_PROP_END_OF_LIST(), 1165 }; 1166 1167 static void virtio_ccw_serial_class_init(ObjectClass *klass, void *data) 1168 { 1169 DeviceClass *dc = DEVICE_CLASS(klass); 1170 VirtIOCCWDeviceClass *k = VIRTIO_CCW_DEVICE_CLASS(klass); 1171 1172 k->init = virtio_ccw_serial_init; 1173 k->exit = virtio_ccw_exit; 1174 dc->reset = virtio_ccw_reset; 1175 dc->props = virtio_ccw_serial_properties; 1176 } 1177 1178 static const TypeInfo virtio_ccw_serial = { 1179 .name = TYPE_VIRTIO_SERIAL_CCW, 1180 .parent = TYPE_VIRTIO_CCW_DEVICE, 1181 .instance_size = sizeof(VirtioSerialCcw), 1182 .instance_init = virtio_ccw_serial_instance_init, 1183 .class_init = virtio_ccw_serial_class_init, 1184 }; 1185 1186 static Property virtio_ccw_balloon_properties[] = { 1187 DEFINE_PROP_STRING("devno", VirtioCcwDevice, bus_id), 1188 DEFINE_VIRTIO_COMMON_FEATURES(VirtioCcwDevice, host_features[0]), 1189 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice, flags, 1190 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT, true), 1191 DEFINE_PROP_END_OF_LIST(), 1192 }; 1193 1194 static void virtio_ccw_balloon_class_init(ObjectClass *klass, void *data) 1195 { 1196 DeviceClass *dc = DEVICE_CLASS(klass); 1197 VirtIOCCWDeviceClass *k = VIRTIO_CCW_DEVICE_CLASS(klass); 1198 1199 k->init = virtio_ccw_balloon_init; 1200 k->exit = virtio_ccw_exit; 1201 dc->reset = virtio_ccw_reset; 1202 dc->props = virtio_ccw_balloon_properties; 1203 } 1204 1205 static const TypeInfo virtio_ccw_balloon = { 1206 .name = TYPE_VIRTIO_BALLOON_CCW, 1207 .parent = TYPE_VIRTIO_CCW_DEVICE, 1208 .instance_size = sizeof(VirtIOBalloonCcw), 1209 .instance_init = virtio_ccw_balloon_instance_init, 1210 .class_init = virtio_ccw_balloon_class_init, 1211 }; 1212 1213 static Property virtio_ccw_scsi_properties[] = { 1214 DEFINE_PROP_STRING("devno", VirtioCcwDevice, bus_id), 1215 DEFINE_VIRTIO_SCSI_PROPERTIES(VirtIOSCSICcw, vdev.parent_obj.conf), 1216 DEFINE_VIRTIO_SCSI_FEATURES(VirtioCcwDevice, host_features[0]), 1217 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice, flags, 1218 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT, true), 1219 DEFINE_PROP_END_OF_LIST(), 1220 }; 1221 1222 static void virtio_ccw_scsi_class_init(ObjectClass *klass, void *data) 1223 { 1224 DeviceClass *dc = DEVICE_CLASS(klass); 1225 VirtIOCCWDeviceClass *k = VIRTIO_CCW_DEVICE_CLASS(klass); 1226 1227 k->init = virtio_ccw_scsi_init; 1228 k->exit = virtio_ccw_exit; 1229 dc->reset = virtio_ccw_reset; 1230 dc->props = virtio_ccw_scsi_properties; 1231 } 1232 1233 static const TypeInfo virtio_ccw_scsi = { 1234 .name = TYPE_VIRTIO_SCSI_CCW, 1235 .parent = TYPE_VIRTIO_CCW_DEVICE, 1236 .instance_size = sizeof(VirtIOSCSICcw), 1237 .instance_init = virtio_ccw_scsi_instance_init, 1238 .class_init = virtio_ccw_scsi_class_init, 1239 }; 1240 1241 #ifdef CONFIG_VHOST_SCSI 1242 static Property vhost_ccw_scsi_properties[] = { 1243 DEFINE_PROP_STRING("devno", VirtioCcwDevice, bus_id), 1244 DEFINE_VHOST_SCSI_PROPERTIES(VirtIOSCSICcw, vdev.parent_obj.conf), 1245 DEFINE_VIRTIO_COMMON_FEATURES(VirtioCcwDevice, host_features[0]), 1246 DEFINE_PROP_END_OF_LIST(), 1247 }; 1248 1249 static void vhost_ccw_scsi_class_init(ObjectClass *klass, void *data) 1250 { 1251 DeviceClass *dc = DEVICE_CLASS(klass); 1252 VirtIOCCWDeviceClass *k = VIRTIO_CCW_DEVICE_CLASS(klass); 1253 1254 k->init = vhost_ccw_scsi_init; 1255 k->exit = virtio_ccw_exit; 1256 dc->reset = virtio_ccw_reset; 1257 dc->props = vhost_ccw_scsi_properties; 1258 } 1259 1260 static const TypeInfo vhost_ccw_scsi = { 1261 .name = TYPE_VHOST_SCSI_CCW, 1262 .parent = TYPE_VIRTIO_CCW_DEVICE, 1263 .instance_size = sizeof(VirtIOSCSICcw), 1264 .instance_init = vhost_ccw_scsi_instance_init, 1265 .class_init = vhost_ccw_scsi_class_init, 1266 }; 1267 #endif 1268 1269 static void virtio_ccw_rng_instance_init(Object *obj) 1270 { 1271 VirtIORNGCcw *dev = VIRTIO_RNG_CCW(obj); 1272 object_initialize(&dev->vdev, sizeof(dev->vdev), TYPE_VIRTIO_RNG); 1273 object_property_add_child(obj, "virtio-backend", OBJECT(&dev->vdev), NULL); 1274 object_property_add_link(obj, "rng", TYPE_RNG_BACKEND, 1275 (Object **)&dev->vdev.conf.rng, 1276 qdev_prop_allow_set_link_before_realize, 1277 OBJ_PROP_LINK_UNREF_ON_RELEASE, NULL); 1278 } 1279 1280 static Property virtio_ccw_rng_properties[] = { 1281 DEFINE_PROP_STRING("devno", VirtioCcwDevice, bus_id), 1282 DEFINE_VIRTIO_COMMON_FEATURES(VirtioCcwDevice, host_features[0]), 1283 DEFINE_VIRTIO_RNG_PROPERTIES(VirtIORNGCcw, vdev.conf), 1284 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice, flags, 1285 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT, true), 1286 DEFINE_PROP_END_OF_LIST(), 1287 }; 1288 1289 static void virtio_ccw_rng_class_init(ObjectClass *klass, void *data) 1290 { 1291 DeviceClass *dc = DEVICE_CLASS(klass); 1292 VirtIOCCWDeviceClass *k = VIRTIO_CCW_DEVICE_CLASS(klass); 1293 1294 k->init = virtio_ccw_rng_init; 1295 k->exit = virtio_ccw_exit; 1296 dc->reset = virtio_ccw_reset; 1297 dc->props = virtio_ccw_rng_properties; 1298 } 1299 1300 static const TypeInfo virtio_ccw_rng = { 1301 .name = TYPE_VIRTIO_RNG_CCW, 1302 .parent = TYPE_VIRTIO_CCW_DEVICE, 1303 .instance_size = sizeof(VirtIORNGCcw), 1304 .instance_init = virtio_ccw_rng_instance_init, 1305 .class_init = virtio_ccw_rng_class_init, 1306 }; 1307 1308 static int virtio_ccw_busdev_init(DeviceState *dev) 1309 { 1310 VirtioCcwDevice *_dev = (VirtioCcwDevice *)dev; 1311 VirtIOCCWDeviceClass *_info = VIRTIO_CCW_DEVICE_GET_CLASS(dev); 1312 1313 virtio_ccw_bus_new(&_dev->bus, sizeof(_dev->bus), _dev); 1314 1315 return _info->init(_dev); 1316 } 1317 1318 static int virtio_ccw_busdev_exit(DeviceState *dev) 1319 { 1320 VirtioCcwDevice *_dev = (VirtioCcwDevice *)dev; 1321 VirtIOCCWDeviceClass *_info = VIRTIO_CCW_DEVICE_GET_CLASS(dev); 1322 1323 return _info->exit(_dev); 1324 } 1325 1326 static int virtio_ccw_busdev_unplug(DeviceState *dev) 1327 { 1328 VirtioCcwDevice *_dev = (VirtioCcwDevice *)dev; 1329 SubchDev *sch = _dev->sch; 1330 1331 virtio_ccw_stop_ioeventfd(_dev); 1332 1333 /* 1334 * We should arrive here only for device_del, since we don't support 1335 * direct hot(un)plug of channels, but only through virtio. 1336 */ 1337 assert(sch != NULL); 1338 /* Subchannel is now disabled and no longer valid. */ 1339 sch->curr_status.pmcw.flags &= ~(PMCW_FLAGS_MASK_ENA | 1340 PMCW_FLAGS_MASK_DNV); 1341 1342 css_generate_sch_crws(sch->cssid, sch->ssid, sch->schid, 1, 0); 1343 1344 object_unparent(OBJECT(dev)); 1345 return 0; 1346 } 1347 1348 static void virtio_ccw_device_class_init(ObjectClass *klass, void *data) 1349 { 1350 DeviceClass *dc = DEVICE_CLASS(klass); 1351 1352 dc->init = virtio_ccw_busdev_init; 1353 dc->exit = virtio_ccw_busdev_exit; 1354 dc->unplug = virtio_ccw_busdev_unplug; 1355 dc->bus_type = TYPE_VIRTUAL_CSS_BUS; 1356 1357 } 1358 1359 static const TypeInfo virtio_ccw_device_info = { 1360 .name = TYPE_VIRTIO_CCW_DEVICE, 1361 .parent = TYPE_DEVICE, 1362 .instance_size = sizeof(VirtioCcwDevice), 1363 .class_init = virtio_ccw_device_class_init, 1364 .class_size = sizeof(VirtIOCCWDeviceClass), 1365 .abstract = true, 1366 }; 1367 1368 /***************** Virtual-css Bus Bridge Device ********************/ 1369 /* Only required to have the virtio bus as child in the system bus */ 1370 1371 static int virtual_css_bridge_init(SysBusDevice *dev) 1372 { 1373 /* nothing */ 1374 return 0; 1375 } 1376 1377 static void virtual_css_bridge_class_init(ObjectClass *klass, void *data) 1378 { 1379 SysBusDeviceClass *k = SYS_BUS_DEVICE_CLASS(klass); 1380 1381 k->init = virtual_css_bridge_init; 1382 } 1383 1384 static const TypeInfo virtual_css_bridge_info = { 1385 .name = "virtual-css-bridge", 1386 .parent = TYPE_SYS_BUS_DEVICE, 1387 .instance_size = sizeof(SysBusDevice), 1388 .class_init = virtual_css_bridge_class_init, 1389 }; 1390 1391 /* virtio-ccw-bus */ 1392 1393 static void virtio_ccw_bus_new(VirtioBusState *bus, size_t bus_size, 1394 VirtioCcwDevice *dev) 1395 { 1396 DeviceState *qdev = DEVICE(dev); 1397 BusState *qbus; 1398 char virtio_bus_name[] = "virtio-bus"; 1399 1400 qbus_create_inplace(bus, bus_size, TYPE_VIRTIO_CCW_BUS, 1401 qdev, virtio_bus_name); 1402 qbus = BUS(bus); 1403 qbus->allow_hotplug = 1; 1404 } 1405 1406 static void virtio_ccw_bus_class_init(ObjectClass *klass, void *data) 1407 { 1408 VirtioBusClass *k = VIRTIO_BUS_CLASS(klass); 1409 BusClass *bus_class = BUS_CLASS(klass); 1410 1411 bus_class->max_dev = 1; 1412 k->notify = virtio_ccw_notify; 1413 k->get_features = virtio_ccw_get_features; 1414 k->vmstate_change = virtio_ccw_vmstate_change; 1415 k->query_guest_notifiers = virtio_ccw_query_guest_notifiers; 1416 k->set_host_notifier = virtio_ccw_set_host_notifier; 1417 k->set_guest_notifiers = virtio_ccw_set_guest_notifiers; 1418 } 1419 1420 static const TypeInfo virtio_ccw_bus_info = { 1421 .name = TYPE_VIRTIO_CCW_BUS, 1422 .parent = TYPE_VIRTIO_BUS, 1423 .instance_size = sizeof(VirtioCcwBusState), 1424 .class_init = virtio_ccw_bus_class_init, 1425 }; 1426 1427 static void virtio_ccw_register(void) 1428 { 1429 type_register_static(&virtio_ccw_bus_info); 1430 type_register_static(&virtual_css_bus_info); 1431 type_register_static(&virtio_ccw_device_info); 1432 type_register_static(&virtio_ccw_serial); 1433 type_register_static(&virtio_ccw_blk); 1434 type_register_static(&virtio_ccw_net); 1435 type_register_static(&virtio_ccw_balloon); 1436 type_register_static(&virtio_ccw_scsi); 1437 #ifdef CONFIG_VHOST_SCSI 1438 type_register_static(&vhost_ccw_scsi); 1439 #endif 1440 type_register_static(&virtio_ccw_rng); 1441 type_register_static(&virtual_css_bridge_info); 1442 } 1443 1444 type_init(virtio_ccw_register) 1445