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