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