hw/s390x/virtio-ccw.c

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