hw/s390x/virtio-ccw.c

   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)