2 * virtio ccw target implementation
4 * Copyright 2012,2015 IBM Corp.
5 * Author(s): Cornelia Huck <cornelia.huck@de.ibm.com>
6 * Pierre Morel <pmorel@linux.vnet.ibm.com>
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
13 #include "qemu/osdep.h"
14 #include "qapi/error.h"
16 #include "sysemu/sysemu.h"
17 #include "sysemu/kvm.h"
19 #include "hw/virtio/virtio.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"
29 #include "hw/s390x/ioinst.h"
30 #include "hw/s390x/css.h"
31 #include "virtio-ccw.h"
33 #include "hw/s390x/css-bridge.h"
34 #include "hw/s390x/s390-virtio-ccw.h"
36 #define NR_CLASSIC_INDICATOR_BITS 64
38 static int virtio_ccw_dev_post_load(void *opaque
, int version_id
)
40 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(opaque
);
41 CcwDevice
*ccw_dev
= CCW_DEVICE(dev
);
42 CCWDeviceClass
*ck
= CCW_DEVICE_GET_CLASS(ccw_dev
);
44 ccw_dev
->sch
->driver_data
= dev
;
45 if (ccw_dev
->sch
->thinint_active
) {
46 dev
->routes
.adapter
.adapter_id
= css_get_adapter_id(
47 CSS_IO_ADAPTER_VIRTIO
,
50 /* Re-fill subch_id after loading the subchannel states.*/
52 ck
->refill_ids(ccw_dev
);
57 typedef struct VirtioCcwDeviceTmp
{
58 VirtioCcwDevice
*parent
;
59 uint16_t config_vector
;
62 static int virtio_ccw_dev_tmp_pre_save(void *opaque
)
64 VirtioCcwDeviceTmp
*tmp
= opaque
;
65 VirtioCcwDevice
*dev
= tmp
->parent
;
66 VirtIODevice
*vdev
= virtio_bus_get_device(&dev
->bus
);
68 tmp
->config_vector
= vdev
->config_vector
;
73 static int virtio_ccw_dev_tmp_post_load(void *opaque
, int version_id
)
75 VirtioCcwDeviceTmp
*tmp
= opaque
;
76 VirtioCcwDevice
*dev
= tmp
->parent
;
77 VirtIODevice
*vdev
= virtio_bus_get_device(&dev
->bus
);
79 vdev
->config_vector
= tmp
->config_vector
;
83 const VMStateDescription vmstate_virtio_ccw_dev_tmp
= {
84 .name
= "s390_virtio_ccw_dev_tmp",
85 .pre_save
= virtio_ccw_dev_tmp_pre_save
,
86 .post_load
= virtio_ccw_dev_tmp_post_load
,
87 .fields
= (VMStateField
[]) {
88 VMSTATE_UINT16(config_vector
, VirtioCcwDeviceTmp
),
93 const VMStateDescription vmstate_virtio_ccw_dev
= {
94 .name
= "s390_virtio_ccw_dev",
96 .minimum_version_id
= 1,
97 .post_load
= virtio_ccw_dev_post_load
,
98 .fields
= (VMStateField
[]) {
99 VMSTATE_CCW_DEVICE(parent_obj
, VirtioCcwDevice
),
100 VMSTATE_PTR_TO_IND_ADDR(indicators
, VirtioCcwDevice
),
101 VMSTATE_PTR_TO_IND_ADDR(indicators2
, VirtioCcwDevice
),
102 VMSTATE_PTR_TO_IND_ADDR(summary_indicator
, VirtioCcwDevice
),
104 * Ugly hack because VirtIODevice does not migrate itself.
105 * This also makes legacy via vmstate_save_state possible.
107 VMSTATE_WITH_TMP(VirtioCcwDevice
, VirtioCcwDeviceTmp
,
108 vmstate_virtio_ccw_dev_tmp
),
109 VMSTATE_STRUCT(routes
, VirtioCcwDevice
, 1, vmstate_adapter_routes
,
111 VMSTATE_UINT8(thinint_isc
, VirtioCcwDevice
),
112 VMSTATE_INT32(revision
, VirtioCcwDevice
),
113 VMSTATE_END_OF_LIST()
117 static void virtio_ccw_bus_new(VirtioBusState
*bus
, size_t bus_size
,
118 VirtioCcwDevice
*dev
);
120 VirtIODevice
*virtio_ccw_get_vdev(SubchDev
*sch
)
122 VirtIODevice
*vdev
= NULL
;
123 VirtioCcwDevice
*dev
= sch
->driver_data
;
126 vdev
= virtio_bus_get_device(&dev
->bus
);
131 static void virtio_ccw_start_ioeventfd(VirtioCcwDevice
*dev
)
133 virtio_bus_start_ioeventfd(&dev
->bus
);
136 static void virtio_ccw_stop_ioeventfd(VirtioCcwDevice
*dev
)
138 virtio_bus_stop_ioeventfd(&dev
->bus
);
141 static bool virtio_ccw_ioeventfd_enabled(DeviceState
*d
)
143 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
145 return (dev
->flags
& VIRTIO_CCW_FLAG_USE_IOEVENTFD
) != 0;
148 static int virtio_ccw_ioeventfd_assign(DeviceState
*d
, EventNotifier
*notifier
,
151 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
152 CcwDevice
*ccw_dev
= CCW_DEVICE(dev
);
153 SubchDev
*sch
= ccw_dev
->sch
;
154 uint32_t sch_id
= (css_build_subchannel_id(sch
) << 16) | sch
->schid
;
156 return s390_assign_subch_ioeventfd(notifier
, sch_id
, n
, assign
);
159 /* Communication blocks used by several channel commands. */
160 typedef struct VqInfoBlockLegacy
{
165 } QEMU_PACKED VqInfoBlockLegacy
;
167 typedef struct VqInfoBlock
{
174 } QEMU_PACKED VqInfoBlock
;
176 typedef struct VqConfigBlock
{
179 } QEMU_PACKED VqConfigBlock
;
181 typedef struct VirtioFeatDesc
{
184 } QEMU_PACKED VirtioFeatDesc
;
186 typedef struct VirtioThinintInfo
{
187 hwaddr summary_indicator
;
188 hwaddr device_indicator
;
191 } QEMU_PACKED VirtioThinintInfo
;
193 typedef struct VirtioRevInfo
{
197 } QEMU_PACKED VirtioRevInfo
;
199 /* Specify where the virtqueues for the subchannel are in guest memory. */
200 static int virtio_ccw_set_vqs(SubchDev
*sch
, VqInfoBlock
*info
,
201 VqInfoBlockLegacy
*linfo
)
203 VirtIODevice
*vdev
= virtio_ccw_get_vdev(sch
);
204 uint16_t index
= info
? info
->index
: linfo
->index
;
205 uint16_t num
= info
? info
->num
: linfo
->num
;
206 uint64_t desc
= info
? info
->desc
: linfo
->queue
;
208 if (index
>= VIRTIO_QUEUE_MAX
) {
212 /* Current code in virtio.c relies on 4K alignment. */
213 if (linfo
&& desc
&& (linfo
->align
!= 4096)) {
222 virtio_queue_set_rings(vdev
, index
, desc
, info
->avail
, info
->used
);
224 virtio_queue_set_addr(vdev
, index
, desc
);
227 virtio_queue_set_vector(vdev
, index
, VIRTIO_NO_VECTOR
);
230 /* virtio-1 allows changing the ring size. */
231 if (virtio_queue_get_max_num(vdev
, index
) < num
) {
232 /* Fail if we exceed the maximum number. */
235 virtio_queue_set_num(vdev
, index
, num
);
236 } else if (virtio_queue_get_num(vdev
, index
) > num
) {
237 /* Fail if we don't have a big enough queue. */
240 /* We ignore possible increased num for legacy for compatibility. */
241 virtio_queue_set_vector(vdev
, index
, index
);
243 /* tell notify handler in case of config change */
244 vdev
->config_vector
= VIRTIO_QUEUE_MAX
;
248 static void virtio_ccw_reset_virtio(VirtioCcwDevice
*dev
, VirtIODevice
*vdev
)
250 CcwDevice
*ccw_dev
= CCW_DEVICE(dev
);
252 virtio_ccw_stop_ioeventfd(dev
);
254 if (dev
->indicators
) {
255 release_indicator(&dev
->routes
.adapter
, dev
->indicators
);
256 dev
->indicators
= NULL
;
258 if (dev
->indicators2
) {
259 release_indicator(&dev
->routes
.adapter
, dev
->indicators2
);
260 dev
->indicators2
= NULL
;
262 if (dev
->summary_indicator
) {
263 release_indicator(&dev
->routes
.adapter
, dev
->summary_indicator
);
264 dev
->summary_indicator
= NULL
;
266 ccw_dev
->sch
->thinint_active
= false;
269 static int virtio_ccw_handle_set_vq(SubchDev
*sch
, CCW1 ccw
, bool check_len
,
274 VqInfoBlockLegacy linfo
;
275 size_t info_len
= is_legacy
? sizeof(linfo
) : sizeof(info
);
278 if (ccw
.count
!= info_len
) {
281 } else if (ccw
.count
< info_len
) {
282 /* Can't execute command. */
289 ccw_dstream_read(&sch
->cds
, linfo
);
290 be64_to_cpus(&linfo
.queue
);
291 be32_to_cpus(&linfo
.align
);
292 be16_to_cpus(&linfo
.index
);
293 be16_to_cpus(&linfo
.num
);
294 ret
= virtio_ccw_set_vqs(sch
, NULL
, &linfo
);
296 ccw_dstream_read(&sch
->cds
, info
);
297 be64_to_cpus(&info
.desc
);
298 be16_to_cpus(&info
.index
);
299 be16_to_cpus(&info
.num
);
300 be64_to_cpus(&info
.avail
);
301 be64_to_cpus(&info
.used
);
302 ret
= virtio_ccw_set_vqs(sch
, &info
, NULL
);
304 sch
->curr_status
.scsw
.count
= 0;
308 static int virtio_ccw_cb(SubchDev
*sch
, CCW1 ccw
)
311 VirtioRevInfo revinfo
;
313 VirtioFeatDesc features
;
315 VqConfigBlock vq_config
;
316 VirtioCcwDevice
*dev
= sch
->driver_data
;
317 VirtIODevice
*vdev
= virtio_ccw_get_vdev(sch
);
320 VirtioThinintInfo thinint
;
326 trace_virtio_ccw_interpret_ccw(sch
->cssid
, sch
->ssid
, sch
->schid
,
328 check_len
= !((ccw
.flags
& CCW_FLAG_SLI
) && !(ccw
.flags
& CCW_FLAG_DC
));
330 if (dev
->force_revision_1
&& dev
->revision
< 0 &&
331 ccw
.cmd_code
!= CCW_CMD_SET_VIRTIO_REV
) {
333 * virtio-1 drivers must start with negotiating to a revision >= 1,
334 * so post a command reject for all other commands
339 /* Look at the command. */
340 switch (ccw
.cmd_code
) {
342 ret
= virtio_ccw_handle_set_vq(sch
, ccw
, check_len
, dev
->revision
< 1);
344 case CCW_CMD_VDEV_RESET
:
345 virtio_ccw_reset_virtio(dev
, vdev
);
348 case CCW_CMD_READ_FEAT
:
350 if (ccw
.count
!= sizeof(features
)) {
354 } else if (ccw
.count
< sizeof(features
)) {
355 /* Can't execute command. */
362 VirtioDeviceClass
*vdc
= VIRTIO_DEVICE_GET_CLASS(vdev
);
364 ccw_dstream_advance(&sch
->cds
, sizeof(features
.features
));
365 ccw_dstream_read(&sch
->cds
, features
.index
);
366 if (features
.index
== 0) {
367 if (dev
->revision
>= 1) {
368 /* Don't offer legacy features for modern devices. */
369 features
.features
= (uint32_t)
370 (vdev
->host_features
& ~vdc
->legacy_features
);
372 features
.features
= (uint32_t)vdev
->host_features
;
374 } else if ((features
.index
== 1) && (dev
->revision
>= 1)) {
376 * Only offer feature bits beyond 31 if the guest has
377 * negotiated at least revision 1.
379 features
.features
= (uint32_t)(vdev
->host_features
>> 32);
381 /* Return zeroes if the guest supports more feature bits. */
382 features
.features
= 0;
384 ccw_dstream_rewind(&sch
->cds
);
385 cpu_to_le32s(&features
.features
);
386 ccw_dstream_write(&sch
->cds
, features
.features
);
387 sch
->curr_status
.scsw
.count
= ccw
.count
- sizeof(features
);
391 case CCW_CMD_WRITE_FEAT
:
393 if (ccw
.count
!= sizeof(features
)) {
397 } else if (ccw
.count
< sizeof(features
)) {
398 /* Can't execute command. */
405 ccw_dstream_read(&sch
->cds
, features
);
406 le32_to_cpus(&features
.features
);
407 if (features
.index
== 0) {
408 virtio_set_features(vdev
,
409 (vdev
->guest_features
& 0xffffffff00000000ULL
) |
411 } else if ((features
.index
== 1) && (dev
->revision
>= 1)) {
413 * If the guest did not negotiate at least revision 1,
414 * we did not offer it any feature bits beyond 31. Such a
415 * guest passing us any bit here is therefore buggy.
417 virtio_set_features(vdev
,
418 (vdev
->guest_features
& 0x00000000ffffffffULL
) |
419 ((uint64_t)features
.features
<< 32));
422 * If the guest supports more feature bits, assert that it
423 * passes us zeroes for those we don't support.
425 if (features
.features
) {
426 qemu_log_mask(LOG_GUEST_ERROR
,
427 "Guest bug: features[%i]=%x (expected 0)",
428 features
.index
, features
.features
);
429 /* XXX: do a unit check here? */
432 sch
->curr_status
.scsw
.count
= ccw
.count
- sizeof(features
);
436 case CCW_CMD_READ_CONF
:
438 if (ccw
.count
> vdev
->config_len
) {
443 len
= MIN(ccw
.count
, vdev
->config_len
);
447 virtio_bus_get_vdev_config(&dev
->bus
, vdev
->config
);
448 ccw_dstream_write_buf(&sch
->cds
, vdev
->config
, len
);
449 sch
->curr_status
.scsw
.count
= ccw
.count
- len
;
453 case CCW_CMD_WRITE_CONF
:
455 if (ccw
.count
> vdev
->config_len
) {
460 len
= MIN(ccw
.count
, vdev
->config_len
);
464 ret
= ccw_dstream_read_buf(&sch
->cds
, vdev
->config
, len
);
466 virtio_bus_set_vdev_config(&dev
->bus
, vdev
->config
);
467 sch
->curr_status
.scsw
.count
= ccw
.count
- len
;
471 case CCW_CMD_READ_STATUS
:
473 if (ccw
.count
!= sizeof(status
)) {
477 } else if (ccw
.count
< sizeof(status
)) {
478 /* Can't execute command. */
485 address_space_stb(&address_space_memory
, ccw
.cda
, vdev
->status
,
486 MEMTXATTRS_UNSPECIFIED
, NULL
);
487 sch
->curr_status
.scsw
.count
= ccw
.count
- sizeof(vdev
->status
);
491 case CCW_CMD_WRITE_STATUS
:
493 if (ccw
.count
!= sizeof(status
)) {
497 } else if (ccw
.count
< sizeof(status
)) {
498 /* Can't execute command. */
505 ccw_dstream_read(&sch
->cds
, status
);
506 if (!(status
& VIRTIO_CONFIG_S_DRIVER_OK
)) {
507 virtio_ccw_stop_ioeventfd(dev
);
509 if (virtio_set_status(vdev
, status
) == 0) {
510 if (vdev
->status
== 0) {
511 virtio_ccw_reset_virtio(dev
, vdev
);
513 if (status
& VIRTIO_CONFIG_S_DRIVER_OK
) {
514 virtio_ccw_start_ioeventfd(dev
);
516 sch
->curr_status
.scsw
.count
= ccw
.count
- sizeof(status
);
519 /* Trigger a command reject. */
524 case CCW_CMD_SET_IND
:
526 if (ccw
.count
!= sizeof(indicators
)) {
530 } else if (ccw
.count
< sizeof(indicators
)) {
531 /* Can't execute command. */
535 if (sch
->thinint_active
) {
536 /* Trigger a command reject. */
540 if (virtio_get_num_queues(vdev
) > NR_CLASSIC_INDICATOR_BITS
) {
541 /* More queues than indicator bits --> trigger a reject */
548 ccw_dstream_read(&sch
->cds
, indicators
);
549 be64_to_cpus(&indicators
);
550 dev
->indicators
= get_indicator(indicators
, sizeof(uint64_t));
551 sch
->curr_status
.scsw
.count
= ccw
.count
- sizeof(indicators
);
555 case CCW_CMD_SET_CONF_IND
:
557 if (ccw
.count
!= sizeof(indicators
)) {
561 } else if (ccw
.count
< sizeof(indicators
)) {
562 /* Can't execute command. */
569 ccw_dstream_read(&sch
->cds
, indicators
);
570 be64_to_cpus(&indicators
);
571 dev
->indicators2
= get_indicator(indicators
, sizeof(uint64_t));
572 sch
->curr_status
.scsw
.count
= ccw
.count
- sizeof(indicators
);
576 case CCW_CMD_READ_VQ_CONF
:
578 if (ccw
.count
!= sizeof(vq_config
)) {
582 } else if (ccw
.count
< sizeof(vq_config
)) {
583 /* Can't execute command. */
590 ccw_dstream_read(&sch
->cds
, vq_config
.index
);
591 be16_to_cpus(&vq_config
.index
);
592 if (vq_config
.index
>= VIRTIO_QUEUE_MAX
) {
596 vq_config
.num_max
= virtio_queue_get_num(vdev
,
598 cpu_to_be16s(&vq_config
.num_max
);
599 ccw_dstream_write(&sch
->cds
, vq_config
.num_max
);
600 sch
->curr_status
.scsw
.count
= ccw
.count
- sizeof(vq_config
);
604 case CCW_CMD_SET_IND_ADAPTER
:
606 if (ccw
.count
!= sizeof(thinint
)) {
610 } else if (ccw
.count
< sizeof(thinint
)) {
611 /* Can't execute command. */
617 } else if (dev
->indicators
&& !sch
->thinint_active
) {
618 /* Trigger a command reject. */
621 if (ccw_dstream_read(&sch
->cds
, thinint
)) {
624 be64_to_cpus(&thinint
.ind_bit
);
625 be64_to_cpus(&thinint
.summary_indicator
);
626 be64_to_cpus(&thinint
.device_indicator
);
628 dev
->summary_indicator
=
629 get_indicator(thinint
.summary_indicator
, sizeof(uint8_t));
631 get_indicator(thinint
.device_indicator
,
632 thinint
.ind_bit
/ 8 + 1);
633 dev
->thinint_isc
= thinint
.isc
;
634 dev
->routes
.adapter
.ind_offset
= thinint
.ind_bit
;
635 dev
->routes
.adapter
.summary_offset
= 7;
636 dev
->routes
.adapter
.adapter_id
= css_get_adapter_id(
637 CSS_IO_ADAPTER_VIRTIO
,
639 sch
->thinint_active
= ((dev
->indicators
!= NULL
) &&
640 (dev
->summary_indicator
!= NULL
));
641 sch
->curr_status
.scsw
.count
= ccw
.count
- sizeof(thinint
);
646 case CCW_CMD_SET_VIRTIO_REV
:
647 len
= sizeof(revinfo
);
648 if (ccw
.count
< len
) {
656 ccw_dstream_read_buf(&sch
->cds
, &revinfo
, 4);
657 be16_to_cpus(&revinfo
.revision
);
658 be16_to_cpus(&revinfo
.length
);
659 if (ccw
.count
< len
+ revinfo
.length
||
660 (check_len
&& ccw
.count
> len
+ revinfo
.length
)) {
665 * Once we start to support revisions with additional data, we'll
666 * need to fetch it here. Nothing to do for now, though.
668 if (dev
->revision
>= 0 ||
669 revinfo
.revision
> virtio_ccw_rev_max(dev
) ||
670 (dev
->force_revision_1
&& !revinfo
.revision
)) {
675 dev
->revision
= revinfo
.revision
;
684 static void virtio_sch_disable_cb(SubchDev
*sch
)
686 VirtioCcwDevice
*dev
= sch
->driver_data
;
691 static void virtio_ccw_device_realize(VirtioCcwDevice
*dev
, Error
**errp
)
693 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_GET_CLASS(dev
);
694 CcwDevice
*ccw_dev
= CCW_DEVICE(dev
);
695 CCWDeviceClass
*ck
= CCW_DEVICE_GET_CLASS(ccw_dev
);
699 sch
= css_create_sch(ccw_dev
->devno
, errp
);
703 if (!virtio_ccw_rev_max(dev
) && dev
->force_revision_1
) {
704 error_setg(&err
, "Invalid value of property max_rev "
705 "(is %d expected >= 1)", virtio_ccw_rev_max(dev
));
709 sch
->driver_data
= dev
;
710 sch
->ccw_cb
= virtio_ccw_cb
;
711 sch
->disable_cb
= virtio_sch_disable_cb
;
712 sch
->id
.reserved
= 0xff;
713 sch
->id
.cu_type
= VIRTIO_CCW_CU_TYPE
;
714 sch
->do_subchannel_work
= do_subchannel_work_virtual
;
716 dev
->indicators
= NULL
;
718 css_sch_build_virtual_schib(sch
, 0, VIRTIO_CCW_CHPID_TYPE
);
720 trace_virtio_ccw_new_device(
721 sch
->cssid
, sch
->ssid
, sch
->schid
, sch
->devno
,
722 ccw_dev
->devno
.valid
? "user-configured" : "auto-configured");
724 if (kvm_enabled() && !kvm_eventfds_enabled()) {
725 dev
->flags
&= ~VIRTIO_CCW_FLAG_USE_IOEVENTFD
;
729 k
->realize(dev
, &err
);
735 ck
->realize(ccw_dev
, &err
);
743 error_propagate(errp
, err
);
744 css_subch_assign(sch
->cssid
, sch
->ssid
, sch
->schid
, sch
->devno
, NULL
);
749 static void virtio_ccw_device_unrealize(VirtioCcwDevice
*dev
, Error
**errp
)
751 VirtIOCCWDeviceClass
*dc
= VIRTIO_CCW_DEVICE_GET_CLASS(dev
);
752 CcwDevice
*ccw_dev
= CCW_DEVICE(dev
);
753 SubchDev
*sch
= ccw_dev
->sch
;
756 dc
->unrealize(dev
, errp
);
760 css_subch_assign(sch
->cssid
, sch
->ssid
, sch
->schid
, sch
->devno
, NULL
);
764 if (dev
->indicators
) {
765 release_indicator(&dev
->routes
.adapter
, dev
->indicators
);
766 dev
->indicators
= NULL
;
770 static void virtio_ccw_net_realize(VirtioCcwDevice
*ccw_dev
, Error
**errp
)
772 DeviceState
*qdev
= DEVICE(ccw_dev
);
773 VirtIONetCcw
*dev
= VIRTIO_NET_CCW(ccw_dev
);
774 DeviceState
*vdev
= DEVICE(&dev
->vdev
);
776 virtio_net_set_netclient_name(&dev
->vdev
, qdev
->id
,
777 object_get_typename(OBJECT(qdev
)));
778 qdev_set_parent_bus(vdev
, BUS(&ccw_dev
->bus
));
779 object_property_set_bool(OBJECT(vdev
), true, "realized", errp
);
782 static void virtio_ccw_net_instance_init(Object
*obj
)
784 VirtIONetCcw
*dev
= VIRTIO_NET_CCW(obj
);
786 virtio_instance_init_common(obj
, &dev
->vdev
, sizeof(dev
->vdev
),
788 object_property_add_alias(obj
, "bootindex", OBJECT(&dev
->vdev
),
789 "bootindex", &error_abort
);
792 static void virtio_ccw_blk_realize(VirtioCcwDevice
*ccw_dev
, Error
**errp
)
794 VirtIOBlkCcw
*dev
= VIRTIO_BLK_CCW(ccw_dev
);
795 DeviceState
*vdev
= DEVICE(&dev
->vdev
);
797 qdev_set_parent_bus(vdev
, BUS(&ccw_dev
->bus
));
798 object_property_set_bool(OBJECT(vdev
), true, "realized", errp
);
801 static void virtio_ccw_blk_instance_init(Object
*obj
)
803 VirtIOBlkCcw
*dev
= VIRTIO_BLK_CCW(obj
);
805 virtio_instance_init_common(obj
, &dev
->vdev
, sizeof(dev
->vdev
),
807 object_property_add_alias(obj
, "bootindex", OBJECT(&dev
->vdev
),
808 "bootindex", &error_abort
);
811 static void virtio_ccw_scsi_realize(VirtioCcwDevice
*ccw_dev
, Error
**errp
)
813 VirtIOSCSICcw
*dev
= VIRTIO_SCSI_CCW(ccw_dev
);
814 DeviceState
*vdev
= DEVICE(&dev
->vdev
);
815 DeviceState
*qdev
= DEVICE(ccw_dev
);
819 * For command line compatibility, this sets the virtio-scsi-device bus
823 bus_name
= g_strdup_printf("%s.0", qdev
->id
);
824 virtio_device_set_child_bus_name(VIRTIO_DEVICE(vdev
), bus_name
);
828 qdev_set_parent_bus(vdev
, BUS(&ccw_dev
->bus
));
829 object_property_set_bool(OBJECT(vdev
), true, "realized", errp
);
832 static void virtio_ccw_scsi_instance_init(Object
*obj
)
834 VirtIOSCSICcw
*dev
= VIRTIO_SCSI_CCW(obj
);
836 virtio_instance_init_common(obj
, &dev
->vdev
, sizeof(dev
->vdev
),
840 #ifdef CONFIG_VHOST_SCSI
841 static void vhost_ccw_scsi_realize(VirtioCcwDevice
*ccw_dev
, Error
**errp
)
843 VHostSCSICcw
*dev
= VHOST_SCSI_CCW(ccw_dev
);
844 DeviceState
*vdev
= DEVICE(&dev
->vdev
);
846 qdev_set_parent_bus(vdev
, BUS(&ccw_dev
->bus
));
847 object_property_set_bool(OBJECT(vdev
), true, "realized", errp
);
850 static void vhost_ccw_scsi_instance_init(Object
*obj
)
852 VHostSCSICcw
*dev
= VHOST_SCSI_CCW(obj
);
854 virtio_instance_init_common(obj
, &dev
->vdev
, sizeof(dev
->vdev
),
859 static void virtio_ccw_rng_realize(VirtioCcwDevice
*ccw_dev
, Error
**errp
)
861 VirtIORNGCcw
*dev
= VIRTIO_RNG_CCW(ccw_dev
);
862 DeviceState
*vdev
= DEVICE(&dev
->vdev
);
865 qdev_set_parent_bus(vdev
, BUS(&ccw_dev
->bus
));
866 object_property_set_bool(OBJECT(vdev
), true, "realized", &err
);
868 error_propagate(errp
, err
);
872 object_property_set_link(OBJECT(dev
),
873 OBJECT(dev
->vdev
.conf
.rng
), "rng",
877 static void virtio_ccw_crypto_realize(VirtioCcwDevice
*ccw_dev
, Error
**errp
)
879 VirtIOCryptoCcw
*dev
= VIRTIO_CRYPTO_CCW(ccw_dev
);
880 DeviceState
*vdev
= DEVICE(&dev
->vdev
);
883 qdev_set_parent_bus(vdev
, BUS(&ccw_dev
->bus
));
884 object_property_set_bool(OBJECT(vdev
), true, "realized", &err
);
886 error_propagate(errp
, err
);
890 object_property_set_link(OBJECT(vdev
),
891 OBJECT(dev
->vdev
.conf
.cryptodev
), "cryptodev",
895 static void virtio_ccw_gpu_realize(VirtioCcwDevice
*ccw_dev
, Error
**errp
)
897 VirtIOGPUCcw
*dev
= VIRTIO_GPU_CCW(ccw_dev
);
898 DeviceState
*vdev
= DEVICE(&dev
->vdev
);
900 qdev_set_parent_bus(vdev
, BUS(&ccw_dev
->bus
));
901 object_property_set_bool(OBJECT(vdev
), true, "realized", errp
);
904 static void virtio_ccw_input_realize(VirtioCcwDevice
*ccw_dev
, Error
**errp
)
906 VirtIOInputCcw
*dev
= VIRTIO_INPUT_CCW(ccw_dev
);
907 DeviceState
*vdev
= DEVICE(&dev
->vdev
);
909 qdev_set_parent_bus(vdev
, BUS(&ccw_dev
->bus
));
910 object_property_set_bool(OBJECT(vdev
), true, "realized", errp
);
913 /* DeviceState to VirtioCcwDevice. Note: used on datapath,
914 * be careful and test performance if you change this.
916 static inline VirtioCcwDevice
*to_virtio_ccw_dev_fast(DeviceState
*d
)
918 CcwDevice
*ccw_dev
= to_ccw_dev_fast(d
);
920 return container_of(ccw_dev
, VirtioCcwDevice
, parent_obj
);
923 static uint8_t virtio_set_ind_atomic(SubchDev
*sch
, uint64_t ind_loc
,
926 uint8_t ind_old
, ind_new
;
930 ind_addr
= cpu_physical_memory_map(ind_loc
, &len
, 1);
932 error_report("%s(%x.%x.%04x): unable to access indicator",
933 __func__
, sch
->cssid
, sch
->ssid
, sch
->schid
);
938 ind_new
= ind_old
| to_be_set
;
939 } while (atomic_cmpxchg(ind_addr
, ind_old
, ind_new
) != ind_old
);
940 trace_virtio_ccw_set_ind(ind_loc
, ind_old
, ind_new
);
941 cpu_physical_memory_unmap(ind_addr
, len
, 1, len
);
946 static void virtio_ccw_notify(DeviceState
*d
, uint16_t vector
)
948 VirtioCcwDevice
*dev
= to_virtio_ccw_dev_fast(d
);
949 CcwDevice
*ccw_dev
= to_ccw_dev_fast(d
);
950 SubchDev
*sch
= ccw_dev
->sch
;
953 if (vector
== VIRTIO_NO_VECTOR
) {
957 * vector < VIRTIO_QUEUE_MAX: notification for a virtqueue
958 * vector == VIRTIO_QUEUE_MAX: configuration change notification
959 * bits beyond that are unused and should never be notified for
961 assert(vector
<= VIRTIO_QUEUE_MAX
);
963 if (vector
< VIRTIO_QUEUE_MAX
) {
964 if (!dev
->indicators
) {
967 if (sch
->thinint_active
) {
969 * In the adapter interrupt case, indicators points to a
970 * memory area that may be (way) larger than 64 bit and
971 * ind_bit indicates the start of the indicators in a big
974 uint64_t ind_bit
= dev
->routes
.adapter
.ind_offset
;
976 virtio_set_ind_atomic(sch
, dev
->indicators
->addr
+
977 (ind_bit
+ vector
) / 8,
978 0x80 >> ((ind_bit
+ vector
) % 8));
979 if (!virtio_set_ind_atomic(sch
, dev
->summary_indicator
->addr
,
981 css_adapter_interrupt(CSS_IO_ADAPTER_VIRTIO
, dev
->thinint_isc
);
984 assert(vector
< NR_CLASSIC_INDICATOR_BITS
);
985 indicators
= address_space_ldq(&address_space_memory
,
986 dev
->indicators
->addr
,
987 MEMTXATTRS_UNSPECIFIED
,
989 indicators
|= 1ULL << vector
;
990 address_space_stq(&address_space_memory
, dev
->indicators
->addr
,
991 indicators
, MEMTXATTRS_UNSPECIFIED
, NULL
);
992 css_conditional_io_interrupt(sch
);
995 if (!dev
->indicators2
) {
998 indicators
= address_space_ldq(&address_space_memory
,
999 dev
->indicators2
->addr
,
1000 MEMTXATTRS_UNSPECIFIED
,
1003 address_space_stq(&address_space_memory
, dev
->indicators2
->addr
,
1004 indicators
, MEMTXATTRS_UNSPECIFIED
, NULL
);
1005 css_conditional_io_interrupt(sch
);
1009 static void virtio_ccw_reset(DeviceState
*d
)
1011 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
1012 VirtIODevice
*vdev
= virtio_bus_get_device(&dev
->bus
);
1013 VirtIOCCWDeviceClass
*vdc
= VIRTIO_CCW_DEVICE_GET_CLASS(dev
);
1015 virtio_ccw_reset_virtio(dev
, vdev
);
1016 if (vdc
->parent_reset
) {
1017 vdc
->parent_reset(d
);
1021 static void virtio_ccw_vmstate_change(DeviceState
*d
, bool running
)
1023 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
1026 virtio_ccw_start_ioeventfd(dev
);
1028 virtio_ccw_stop_ioeventfd(dev
);
1032 static bool virtio_ccw_query_guest_notifiers(DeviceState
*d
)
1034 CcwDevice
*dev
= CCW_DEVICE(d
);
1036 return !!(dev
->sch
->curr_status
.pmcw
.flags
& PMCW_FLAGS_MASK_ENA
);
1039 static int virtio_ccw_get_mappings(VirtioCcwDevice
*dev
)
1042 CcwDevice
*ccw_dev
= CCW_DEVICE(dev
);
1044 if (!ccw_dev
->sch
->thinint_active
) {
1048 r
= map_indicator(&dev
->routes
.adapter
, dev
->summary_indicator
);
1052 r
= map_indicator(&dev
->routes
.adapter
, dev
->indicators
);
1056 dev
->routes
.adapter
.summary_addr
= dev
->summary_indicator
->map
;
1057 dev
->routes
.adapter
.ind_addr
= dev
->indicators
->map
;
1062 static int virtio_ccw_setup_irqroutes(VirtioCcwDevice
*dev
, int nvqs
)
1065 VirtIODevice
*vdev
= virtio_bus_get_device(&dev
->bus
);
1067 S390FLICState
*fs
= s390_get_flic();
1068 S390FLICStateClass
*fsc
= s390_get_flic_class(fs
);
1070 ret
= virtio_ccw_get_mappings(dev
);
1074 for (i
= 0; i
< nvqs
; i
++) {
1075 if (!virtio_queue_get_num(vdev
, i
)) {
1079 dev
->routes
.num_routes
= i
;
1080 return fsc
->add_adapter_routes(fs
, &dev
->routes
);
1083 static void virtio_ccw_release_irqroutes(VirtioCcwDevice
*dev
, int nvqs
)
1085 S390FLICState
*fs
= s390_get_flic();
1086 S390FLICStateClass
*fsc
= s390_get_flic_class(fs
);
1088 fsc
->release_adapter_routes(fs
, &dev
->routes
);
1091 static int virtio_ccw_add_irqfd(VirtioCcwDevice
*dev
, int n
)
1093 VirtIODevice
*vdev
= virtio_bus_get_device(&dev
->bus
);
1094 VirtQueue
*vq
= virtio_get_queue(vdev
, n
);
1095 EventNotifier
*notifier
= virtio_queue_get_guest_notifier(vq
);
1097 return kvm_irqchip_add_irqfd_notifier_gsi(kvm_state
, notifier
, NULL
,
1098 dev
->routes
.gsi
[n
]);
1101 static void virtio_ccw_remove_irqfd(VirtioCcwDevice
*dev
, int n
)
1103 VirtIODevice
*vdev
= virtio_bus_get_device(&dev
->bus
);
1104 VirtQueue
*vq
= virtio_get_queue(vdev
, n
);
1105 EventNotifier
*notifier
= virtio_queue_get_guest_notifier(vq
);
1108 ret
= kvm_irqchip_remove_irqfd_notifier_gsi(kvm_state
, notifier
,
1109 dev
->routes
.gsi
[n
]);
1113 static int virtio_ccw_set_guest_notifier(VirtioCcwDevice
*dev
, int n
,
1114 bool assign
, bool with_irqfd
)
1116 VirtIODevice
*vdev
= virtio_bus_get_device(&dev
->bus
);
1117 VirtQueue
*vq
= virtio_get_queue(vdev
, n
);
1118 EventNotifier
*notifier
= virtio_queue_get_guest_notifier(vq
);
1119 VirtioDeviceClass
*k
= VIRTIO_DEVICE_GET_CLASS(vdev
);
1122 int r
= event_notifier_init(notifier
, 0);
1127 virtio_queue_set_guest_notifier_fd_handler(vq
, true, with_irqfd
);
1129 r
= virtio_ccw_add_irqfd(dev
, n
);
1131 virtio_queue_set_guest_notifier_fd_handler(vq
, false,
1137 * We do not support individual masking for channel devices, so we
1138 * need to manually trigger any guest masking callbacks here.
1140 if (k
->guest_notifier_mask
&& vdev
->use_guest_notifier_mask
) {
1141 k
->guest_notifier_mask(vdev
, n
, false);
1143 /* get lost events and re-inject */
1144 if (k
->guest_notifier_pending
&&
1145 k
->guest_notifier_pending(vdev
, n
)) {
1146 event_notifier_set(notifier
);
1149 if (k
->guest_notifier_mask
&& vdev
->use_guest_notifier_mask
) {
1150 k
->guest_notifier_mask(vdev
, n
, true);
1153 virtio_ccw_remove_irqfd(dev
, n
);
1155 virtio_queue_set_guest_notifier_fd_handler(vq
, false, with_irqfd
);
1156 event_notifier_cleanup(notifier
);
1161 static int virtio_ccw_set_guest_notifiers(DeviceState
*d
, int nvqs
,
1164 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
1165 VirtIODevice
*vdev
= virtio_bus_get_device(&dev
->bus
);
1166 CcwDevice
*ccw_dev
= CCW_DEVICE(d
);
1167 bool with_irqfd
= ccw_dev
->sch
->thinint_active
&& kvm_irqfds_enabled();
1170 if (with_irqfd
&& assigned
) {
1171 /* irq routes need to be set up before assigning irqfds */
1172 r
= virtio_ccw_setup_irqroutes(dev
, nvqs
);
1174 goto irqroute_error
;
1177 for (n
= 0; n
< nvqs
; n
++) {
1178 if (!virtio_queue_get_num(vdev
, n
)) {
1181 r
= virtio_ccw_set_guest_notifier(dev
, n
, assigned
, with_irqfd
);
1186 if (with_irqfd
&& !assigned
) {
1187 /* release irq routes after irqfds have been released */
1188 virtio_ccw_release_irqroutes(dev
, nvqs
);
1194 virtio_ccw_set_guest_notifier(dev
, n
, !assigned
, false);
1197 if (with_irqfd
&& assigned
) {
1198 virtio_ccw_release_irqroutes(dev
, nvqs
);
1203 static void virtio_ccw_save_queue(DeviceState
*d
, int n
, QEMUFile
*f
)
1205 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
1206 VirtIODevice
*vdev
= virtio_bus_get_device(&dev
->bus
);
1208 qemu_put_be16(f
, virtio_queue_vector(vdev
, n
));
1211 static int virtio_ccw_load_queue(DeviceState
*d
, int n
, QEMUFile
*f
)
1213 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
1214 VirtIODevice
*vdev
= virtio_bus_get_device(&dev
->bus
);
1217 qemu_get_be16s(f
, &vector
);
1218 virtio_queue_set_vector(vdev
, n
, vector
);
1223 static void virtio_ccw_save_config(DeviceState
*d
, QEMUFile
*f
)
1225 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
1226 vmstate_save_state(f
, &vmstate_virtio_ccw_dev
, dev
, NULL
);
1229 static int virtio_ccw_load_config(DeviceState
*d
, QEMUFile
*f
)
1231 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
1232 return vmstate_load_state(f
, &vmstate_virtio_ccw_dev
, dev
, 1);
1235 static void virtio_ccw_pre_plugged(DeviceState
*d
, Error
**errp
)
1237 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
1238 VirtIODevice
*vdev
= virtio_bus_get_device(&dev
->bus
);
1240 if (dev
->max_rev
>= 1) {
1241 virtio_add_feature(&vdev
->host_features
, VIRTIO_F_VERSION_1
);
1245 /* This is called by virtio-bus just after the device is plugged. */
1246 static void virtio_ccw_device_plugged(DeviceState
*d
, Error
**errp
)
1248 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
1249 VirtIODevice
*vdev
= virtio_bus_get_device(&dev
->bus
);
1250 CcwDevice
*ccw_dev
= CCW_DEVICE(d
);
1251 SubchDev
*sch
= ccw_dev
->sch
;
1252 int n
= virtio_get_num_queues(vdev
);
1253 S390FLICState
*flic
= s390_get_flic();
1255 if (!virtio_has_feature(vdev
->host_features
, VIRTIO_F_VERSION_1
)) {
1259 if (virtio_get_num_queues(vdev
) > VIRTIO_QUEUE_MAX
) {
1260 error_setg(errp
, "The number of virtqueues %d "
1261 "exceeds virtio limit %d", n
,
1265 if (virtio_get_num_queues(vdev
) > flic
->adapter_routes_max_batch
) {
1266 error_setg(errp
, "The number of virtqueues %d "
1267 "exceeds flic adapter route limit %d", n
,
1268 flic
->adapter_routes_max_batch
);
1272 sch
->id
.cu_model
= virtio_bus_get_vdev_id(&dev
->bus
);
1275 css_generate_sch_crws(sch
->cssid
, sch
->ssid
, sch
->schid
,
1279 static void virtio_ccw_device_unplugged(DeviceState
*d
)
1281 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
1283 virtio_ccw_stop_ioeventfd(dev
);
1285 /**************** Virtio-ccw Bus Device Descriptions *******************/
1287 static Property virtio_ccw_net_properties
[] = {
1288 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice
, flags
,
1289 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT
, true),
1290 DEFINE_PROP_UINT32("max_revision", VirtioCcwDevice
, max_rev
,
1291 VIRTIO_CCW_MAX_REV
),
1292 DEFINE_PROP_END_OF_LIST(),
1295 static void virtio_ccw_net_class_init(ObjectClass
*klass
, void *data
)
1297 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1298 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_CLASS(klass
);
1300 k
->realize
= virtio_ccw_net_realize
;
1301 dc
->props
= virtio_ccw_net_properties
;
1302 set_bit(DEVICE_CATEGORY_NETWORK
, dc
->categories
);
1305 static const TypeInfo virtio_ccw_net
= {
1306 .name
= TYPE_VIRTIO_NET_CCW
,
1307 .parent
= TYPE_VIRTIO_CCW_DEVICE
,
1308 .instance_size
= sizeof(VirtIONetCcw
),
1309 .instance_init
= virtio_ccw_net_instance_init
,
1310 .class_init
= virtio_ccw_net_class_init
,
1313 static Property virtio_ccw_blk_properties
[] = {
1314 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice
, flags
,
1315 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT
, true),
1316 DEFINE_PROP_UINT32("max_revision", VirtioCcwDevice
, max_rev
,
1317 VIRTIO_CCW_MAX_REV
),
1318 DEFINE_PROP_END_OF_LIST(),
1321 static void virtio_ccw_blk_class_init(ObjectClass
*klass
, void *data
)
1323 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1324 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_CLASS(klass
);
1326 k
->realize
= virtio_ccw_blk_realize
;
1327 dc
->props
= virtio_ccw_blk_properties
;
1328 set_bit(DEVICE_CATEGORY_STORAGE
, dc
->categories
);
1331 static const TypeInfo virtio_ccw_blk
= {
1332 .name
= TYPE_VIRTIO_BLK_CCW
,
1333 .parent
= TYPE_VIRTIO_CCW_DEVICE
,
1334 .instance_size
= sizeof(VirtIOBlkCcw
),
1335 .instance_init
= virtio_ccw_blk_instance_init
,
1336 .class_init
= virtio_ccw_blk_class_init
,
1339 static Property virtio_ccw_scsi_properties
[] = {
1340 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice
, flags
,
1341 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT
, true),
1342 DEFINE_PROP_UINT32("max_revision", VirtioCcwDevice
, max_rev
,
1343 VIRTIO_CCW_MAX_REV
),
1344 DEFINE_PROP_END_OF_LIST(),
1347 static void virtio_ccw_scsi_class_init(ObjectClass
*klass
, void *data
)
1349 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1350 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_CLASS(klass
);
1352 k
->realize
= virtio_ccw_scsi_realize
;
1353 dc
->props
= virtio_ccw_scsi_properties
;
1354 set_bit(DEVICE_CATEGORY_STORAGE
, dc
->categories
);
1357 static const TypeInfo virtio_ccw_scsi
= {
1358 .name
= TYPE_VIRTIO_SCSI_CCW
,
1359 .parent
= TYPE_VIRTIO_CCW_DEVICE
,
1360 .instance_size
= sizeof(VirtIOSCSICcw
),
1361 .instance_init
= virtio_ccw_scsi_instance_init
,
1362 .class_init
= virtio_ccw_scsi_class_init
,
1365 #ifdef CONFIG_VHOST_SCSI
1366 static Property vhost_ccw_scsi_properties
[] = {
1367 DEFINE_PROP_UINT32("max_revision", VirtioCcwDevice
, max_rev
,
1368 VIRTIO_CCW_MAX_REV
),
1369 DEFINE_PROP_END_OF_LIST(),
1372 static void vhost_ccw_scsi_class_init(ObjectClass
*klass
, void *data
)
1374 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1375 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_CLASS(klass
);
1377 k
->realize
= vhost_ccw_scsi_realize
;
1378 dc
->props
= vhost_ccw_scsi_properties
;
1379 set_bit(DEVICE_CATEGORY_STORAGE
, dc
->categories
);
1382 static const TypeInfo vhost_ccw_scsi
= {
1383 .name
= TYPE_VHOST_SCSI_CCW
,
1384 .parent
= TYPE_VIRTIO_CCW_DEVICE
,
1385 .instance_size
= sizeof(VHostSCSICcw
),
1386 .instance_init
= vhost_ccw_scsi_instance_init
,
1387 .class_init
= vhost_ccw_scsi_class_init
,
1391 static void virtio_ccw_rng_instance_init(Object
*obj
)
1393 VirtIORNGCcw
*dev
= VIRTIO_RNG_CCW(obj
);
1395 virtio_instance_init_common(obj
, &dev
->vdev
, sizeof(dev
->vdev
),
1399 static Property virtio_ccw_rng_properties
[] = {
1400 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice
, flags
,
1401 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT
, true),
1402 DEFINE_PROP_UINT32("max_revision", VirtioCcwDevice
, max_rev
,
1403 VIRTIO_CCW_MAX_REV
),
1404 DEFINE_PROP_END_OF_LIST(),
1407 static void virtio_ccw_rng_class_init(ObjectClass
*klass
, void *data
)
1409 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1410 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_CLASS(klass
);
1412 k
->realize
= virtio_ccw_rng_realize
;
1413 dc
->props
= virtio_ccw_rng_properties
;
1414 set_bit(DEVICE_CATEGORY_MISC
, dc
->categories
);
1417 static const TypeInfo virtio_ccw_rng
= {
1418 .name
= TYPE_VIRTIO_RNG_CCW
,
1419 .parent
= TYPE_VIRTIO_CCW_DEVICE
,
1420 .instance_size
= sizeof(VirtIORNGCcw
),
1421 .instance_init
= virtio_ccw_rng_instance_init
,
1422 .class_init
= virtio_ccw_rng_class_init
,
1425 static Property virtio_ccw_crypto_properties
[] = {
1426 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice
, flags
,
1427 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT
, true),
1428 DEFINE_PROP_UINT32("max_revision", VirtioCcwDevice
, max_rev
,
1429 VIRTIO_CCW_MAX_REV
),
1430 DEFINE_PROP_END_OF_LIST(),
1433 static void virtio_ccw_crypto_instance_init(Object
*obj
)
1435 VirtIOCryptoCcw
*dev
= VIRTIO_CRYPTO_CCW(obj
);
1436 VirtioCcwDevice
*ccw_dev
= VIRTIO_CCW_DEVICE(obj
);
1438 ccw_dev
->force_revision_1
= true;
1439 virtio_instance_init_common(obj
, &dev
->vdev
, sizeof(dev
->vdev
),
1440 TYPE_VIRTIO_CRYPTO
);
1443 static void virtio_ccw_crypto_class_init(ObjectClass
*klass
, void *data
)
1445 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1446 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_CLASS(klass
);
1448 k
->realize
= virtio_ccw_crypto_realize
;
1449 dc
->props
= virtio_ccw_crypto_properties
;
1450 set_bit(DEVICE_CATEGORY_MISC
, dc
->categories
);
1453 static const TypeInfo virtio_ccw_crypto
= {
1454 .name
= TYPE_VIRTIO_CRYPTO_CCW
,
1455 .parent
= TYPE_VIRTIO_CCW_DEVICE
,
1456 .instance_size
= sizeof(VirtIOCryptoCcw
),
1457 .instance_init
= virtio_ccw_crypto_instance_init
,
1458 .class_init
= virtio_ccw_crypto_class_init
,
1461 static Property virtio_ccw_gpu_properties
[] = {
1462 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice
, flags
,
1463 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT
, true),
1464 DEFINE_PROP_UINT32("max_revision", VirtioCcwDevice
, max_rev
,
1465 VIRTIO_CCW_MAX_REV
),
1466 DEFINE_PROP_END_OF_LIST(),
1469 static void virtio_ccw_gpu_instance_init(Object
*obj
)
1471 VirtIOGPUCcw
*dev
= VIRTIO_GPU_CCW(obj
);
1472 VirtioCcwDevice
*ccw_dev
= VIRTIO_CCW_DEVICE(obj
);
1474 ccw_dev
->force_revision_1
= true;
1475 virtio_instance_init_common(obj
, &dev
->vdev
, sizeof(dev
->vdev
),
1479 static void virtio_ccw_gpu_class_init(ObjectClass
*klass
, void *data
)
1481 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1482 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_CLASS(klass
);
1484 k
->realize
= virtio_ccw_gpu_realize
;
1485 dc
->props
= virtio_ccw_gpu_properties
;
1486 dc
->hotpluggable
= false;
1487 set_bit(DEVICE_CATEGORY_DISPLAY
, dc
->categories
);
1490 static const TypeInfo virtio_ccw_gpu
= {
1491 .name
= TYPE_VIRTIO_GPU_CCW
,
1492 .parent
= TYPE_VIRTIO_CCW_DEVICE
,
1493 .instance_size
= sizeof(VirtIOGPUCcw
),
1494 .instance_init
= virtio_ccw_gpu_instance_init
,
1495 .class_init
= virtio_ccw_gpu_class_init
,
1498 static Property virtio_ccw_input_properties
[] = {
1499 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice
, flags
,
1500 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT
, true),
1501 DEFINE_PROP_UINT32("max_revision", VirtioCcwDevice
, max_rev
,
1502 VIRTIO_CCW_MAX_REV
),
1503 DEFINE_PROP_END_OF_LIST(),
1506 static void virtio_ccw_input_class_init(ObjectClass
*klass
, void *data
)
1508 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1509 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_CLASS(klass
);
1511 k
->realize
= virtio_ccw_input_realize
;
1512 dc
->props
= virtio_ccw_input_properties
;
1513 set_bit(DEVICE_CATEGORY_INPUT
, dc
->categories
);
1516 static void virtio_ccw_keyboard_instance_init(Object
*obj
)
1518 VirtIOInputHIDCcw
*dev
= VIRTIO_INPUT_HID_CCW(obj
);
1519 VirtioCcwDevice
*ccw_dev
= VIRTIO_CCW_DEVICE(obj
);
1521 ccw_dev
->force_revision_1
= true;
1522 virtio_instance_init_common(obj
, &dev
->vdev
, sizeof(dev
->vdev
),
1523 TYPE_VIRTIO_KEYBOARD
);
1526 static void virtio_ccw_mouse_instance_init(Object
*obj
)
1528 VirtIOInputHIDCcw
*dev
= VIRTIO_INPUT_HID_CCW(obj
);
1529 VirtioCcwDevice
*ccw_dev
= VIRTIO_CCW_DEVICE(obj
);
1531 ccw_dev
->force_revision_1
= true;
1532 virtio_instance_init_common(obj
, &dev
->vdev
, sizeof(dev
->vdev
),
1536 static void virtio_ccw_tablet_instance_init(Object
*obj
)
1538 VirtIOInputHIDCcw
*dev
= VIRTIO_INPUT_HID_CCW(obj
);
1539 VirtioCcwDevice
*ccw_dev
= VIRTIO_CCW_DEVICE(obj
);
1541 ccw_dev
->force_revision_1
= true;
1542 virtio_instance_init_common(obj
, &dev
->vdev
, sizeof(dev
->vdev
),
1543 TYPE_VIRTIO_TABLET
);
1546 static const TypeInfo virtio_ccw_input
= {
1547 .name
= TYPE_VIRTIO_INPUT_CCW
,
1548 .parent
= TYPE_VIRTIO_CCW_DEVICE
,
1549 .instance_size
= sizeof(VirtIOInputCcw
),
1550 .class_init
= virtio_ccw_input_class_init
,
1554 static const TypeInfo virtio_ccw_input_hid
= {
1555 .name
= TYPE_VIRTIO_INPUT_HID_CCW
,
1556 .parent
= TYPE_VIRTIO_INPUT_CCW
,
1557 .instance_size
= sizeof(VirtIOInputHIDCcw
),
1561 static const TypeInfo virtio_ccw_keyboard
= {
1562 .name
= TYPE_VIRTIO_KEYBOARD_CCW
,
1563 .parent
= TYPE_VIRTIO_INPUT_HID_CCW
,
1564 .instance_size
= sizeof(VirtIOInputHIDCcw
),
1565 .instance_init
= virtio_ccw_keyboard_instance_init
,
1568 static const TypeInfo virtio_ccw_mouse
= {
1569 .name
= TYPE_VIRTIO_MOUSE_CCW
,
1570 .parent
= TYPE_VIRTIO_INPUT_HID_CCW
,
1571 .instance_size
= sizeof(VirtIOInputHIDCcw
),
1572 .instance_init
= virtio_ccw_mouse_instance_init
,
1575 static const TypeInfo virtio_ccw_tablet
= {
1576 .name
= TYPE_VIRTIO_TABLET_CCW
,
1577 .parent
= TYPE_VIRTIO_INPUT_HID_CCW
,
1578 .instance_size
= sizeof(VirtIOInputHIDCcw
),
1579 .instance_init
= virtio_ccw_tablet_instance_init
,
1582 static void virtio_ccw_busdev_realize(DeviceState
*dev
, Error
**errp
)
1584 VirtioCcwDevice
*_dev
= (VirtioCcwDevice
*)dev
;
1586 virtio_ccw_bus_new(&_dev
->bus
, sizeof(_dev
->bus
), _dev
);
1587 virtio_ccw_device_realize(_dev
, errp
);
1590 static void virtio_ccw_busdev_unrealize(DeviceState
*dev
, Error
**errp
)
1592 VirtioCcwDevice
*_dev
= (VirtioCcwDevice
*)dev
;
1594 virtio_ccw_device_unrealize(_dev
, errp
);
1597 static void virtio_ccw_busdev_unplug(HotplugHandler
*hotplug_dev
,
1598 DeviceState
*dev
, Error
**errp
)
1600 VirtioCcwDevice
*_dev
= to_virtio_ccw_dev_fast(dev
);
1602 virtio_ccw_stop_ioeventfd(_dev
);
1605 static void virtio_ccw_device_class_init(ObjectClass
*klass
, void *data
)
1607 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1608 CCWDeviceClass
*k
= CCW_DEVICE_CLASS(dc
);
1609 VirtIOCCWDeviceClass
*vdc
= VIRTIO_CCW_DEVICE_CLASS(klass
);
1611 k
->unplug
= virtio_ccw_busdev_unplug
;
1612 dc
->realize
= virtio_ccw_busdev_realize
;
1613 dc
->unrealize
= virtio_ccw_busdev_unrealize
;
1614 dc
->bus_type
= TYPE_VIRTUAL_CSS_BUS
;
1615 device_class_set_parent_reset(dc
, virtio_ccw_reset
, &vdc
->parent_reset
);
1618 static const TypeInfo virtio_ccw_device_info
= {
1619 .name
= TYPE_VIRTIO_CCW_DEVICE
,
1620 .parent
= TYPE_CCW_DEVICE
,
1621 .instance_size
= sizeof(VirtioCcwDevice
),
1622 .class_init
= virtio_ccw_device_class_init
,
1623 .class_size
= sizeof(VirtIOCCWDeviceClass
),
1627 /* virtio-ccw-bus */
1629 static void virtio_ccw_bus_new(VirtioBusState
*bus
, size_t bus_size
,
1630 VirtioCcwDevice
*dev
)
1632 DeviceState
*qdev
= DEVICE(dev
);
1633 char virtio_bus_name
[] = "virtio-bus";
1635 qbus_create_inplace(bus
, bus_size
, TYPE_VIRTIO_CCW_BUS
,
1636 qdev
, virtio_bus_name
);
1639 static void virtio_ccw_bus_class_init(ObjectClass
*klass
, void *data
)
1641 VirtioBusClass
*k
= VIRTIO_BUS_CLASS(klass
);
1642 BusClass
*bus_class
= BUS_CLASS(klass
);
1644 bus_class
->max_dev
= 1;
1645 k
->notify
= virtio_ccw_notify
;
1646 k
->vmstate_change
= virtio_ccw_vmstate_change
;
1647 k
->query_guest_notifiers
= virtio_ccw_query_guest_notifiers
;
1648 k
->set_guest_notifiers
= virtio_ccw_set_guest_notifiers
;
1649 k
->save_queue
= virtio_ccw_save_queue
;
1650 k
->load_queue
= virtio_ccw_load_queue
;
1651 k
->save_config
= virtio_ccw_save_config
;
1652 k
->load_config
= virtio_ccw_load_config
;
1653 k
->pre_plugged
= virtio_ccw_pre_plugged
;
1654 k
->device_plugged
= virtio_ccw_device_plugged
;
1655 k
->device_unplugged
= virtio_ccw_device_unplugged
;
1656 k
->ioeventfd_enabled
= virtio_ccw_ioeventfd_enabled
;
1657 k
->ioeventfd_assign
= virtio_ccw_ioeventfd_assign
;
1660 static const TypeInfo virtio_ccw_bus_info
= {
1661 .name
= TYPE_VIRTIO_CCW_BUS
,
1662 .parent
= TYPE_VIRTIO_BUS
,
1663 .instance_size
= sizeof(VirtioCcwBusState
),
1664 .class_init
= virtio_ccw_bus_class_init
,
1667 #ifdef CONFIG_VIRTFS
1668 static Property virtio_ccw_9p_properties
[] = {
1669 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice
, flags
,
1670 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT
, true),
1671 DEFINE_PROP_UINT32("max_revision", VirtioCcwDevice
, max_rev
,
1672 VIRTIO_CCW_MAX_REV
),
1673 DEFINE_PROP_END_OF_LIST(),
1676 static void virtio_ccw_9p_realize(VirtioCcwDevice
*ccw_dev
, Error
**errp
)
1678 V9fsCCWState
*dev
= VIRTIO_9P_CCW(ccw_dev
);
1679 DeviceState
*vdev
= DEVICE(&dev
->vdev
);
1681 qdev_set_parent_bus(vdev
, BUS(&ccw_dev
->bus
));
1682 object_property_set_bool(OBJECT(vdev
), true, "realized", errp
);
1685 static void virtio_ccw_9p_class_init(ObjectClass
*klass
, void *data
)
1687 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1688 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_CLASS(klass
);
1690 k
->realize
= virtio_ccw_9p_realize
;
1691 dc
->props
= virtio_ccw_9p_properties
;
1692 set_bit(DEVICE_CATEGORY_STORAGE
, dc
->categories
);
1695 static void virtio_ccw_9p_instance_init(Object
*obj
)
1697 V9fsCCWState
*dev
= VIRTIO_9P_CCW(obj
);
1699 virtio_instance_init_common(obj
, &dev
->vdev
, sizeof(dev
->vdev
),
1703 static const TypeInfo virtio_ccw_9p_info
= {
1704 .name
= TYPE_VIRTIO_9P_CCW
,
1705 .parent
= TYPE_VIRTIO_CCW_DEVICE
,
1706 .instance_size
= sizeof(V9fsCCWState
),
1707 .instance_init
= virtio_ccw_9p_instance_init
,
1708 .class_init
= virtio_ccw_9p_class_init
,
1712 #ifdef CONFIG_VHOST_VSOCK
1714 static Property vhost_vsock_ccw_properties
[] = {
1715 DEFINE_PROP_UINT32("max_revision", VirtioCcwDevice
, max_rev
,
1716 VIRTIO_CCW_MAX_REV
),
1717 DEFINE_PROP_END_OF_LIST(),
1720 static void vhost_vsock_ccw_realize(VirtioCcwDevice
*ccw_dev
, Error
**errp
)
1722 VHostVSockCCWState
*dev
= VHOST_VSOCK_CCW(ccw_dev
);
1723 DeviceState
*vdev
= DEVICE(&dev
->vdev
);
1725 qdev_set_parent_bus(vdev
, BUS(&ccw_dev
->bus
));
1726 object_property_set_bool(OBJECT(vdev
), true, "realized", errp
);
1729 static void vhost_vsock_ccw_class_init(ObjectClass
*klass
, void *data
)
1731 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1732 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_CLASS(klass
);
1734 k
->realize
= vhost_vsock_ccw_realize
;
1735 set_bit(DEVICE_CATEGORY_MISC
, dc
->categories
);
1736 dc
->props
= vhost_vsock_ccw_properties
;
1739 static void vhost_vsock_ccw_instance_init(Object
*obj
)
1741 VHostVSockCCWState
*dev
= VHOST_VSOCK_CCW(obj
);
1743 virtio_instance_init_common(obj
, &dev
->vdev
, sizeof(dev
->vdev
),
1747 static const TypeInfo vhost_vsock_ccw_info
= {
1748 .name
= TYPE_VHOST_VSOCK_CCW
,
1749 .parent
= TYPE_VIRTIO_CCW_DEVICE
,
1750 .instance_size
= sizeof(VHostVSockCCWState
),
1751 .instance_init
= vhost_vsock_ccw_instance_init
,
1752 .class_init
= vhost_vsock_ccw_class_init
,
1756 static void virtio_ccw_register(void)
1758 type_register_static(&virtio_ccw_bus_info
);
1759 type_register_static(&virtio_ccw_device_info
);
1760 type_register_static(&virtio_ccw_blk
);
1761 type_register_static(&virtio_ccw_net
);
1762 type_register_static(&virtio_ccw_scsi
);
1763 #ifdef CONFIG_VHOST_SCSI
1764 type_register_static(&vhost_ccw_scsi
);
1766 type_register_static(&virtio_ccw_rng
);
1767 #ifdef CONFIG_VIRTFS
1768 type_register_static(&virtio_ccw_9p_info
);
1770 #ifdef CONFIG_VHOST_VSOCK
1771 type_register_static(&vhost_vsock_ccw_info
);
1773 type_register_static(&virtio_ccw_crypto
);
1774 type_register_static(&virtio_ccw_gpu
);
1775 type_register_static(&virtio_ccw_input
);
1776 type_register_static(&virtio_ccw_input_hid
);
1777 type_register_static(&virtio_ccw_keyboard
);
1778 type_register_static(&virtio_ccw_mouse
);
1779 type_register_static(&virtio_ccw_tablet
);
1782 type_init(virtio_ccw_register
)