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-serial.h"
21 #include "hw/virtio/virtio-net.h"
22 #include "hw/sysbus.h"
23 #include "qemu/bitops.h"
24 #include "qemu/error-report.h"
25 #include "hw/virtio/virtio-access.h"
26 #include "hw/virtio/virtio-bus.h"
27 #include "hw/s390x/adapter.h"
28 #include "hw/s390x/s390_flic.h"
30 #include "hw/s390x/ioinst.h"
31 #include "hw/s390x/css.h"
32 #include "virtio-ccw.h"
34 #include "hw/s390x/css-bridge.h"
35 #include "hw/s390x/s390-virtio-ccw.h"
37 #define NR_CLASSIC_INDICATOR_BITS 64
39 static int virtio_ccw_dev_post_load(void *opaque
, int version_id
)
41 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(opaque
);
42 CcwDevice
*ccw_dev
= CCW_DEVICE(dev
);
43 CCWDeviceClass
*ck
= CCW_DEVICE_GET_CLASS(ccw_dev
);
45 ccw_dev
->sch
->driver_data
= dev
;
46 if (ccw_dev
->sch
->thinint_active
) {
47 dev
->routes
.adapter
.adapter_id
= css_get_adapter_id(
48 CSS_IO_ADAPTER_VIRTIO
,
51 /* Re-fill subch_id after loading the subchannel states.*/
53 ck
->refill_ids(ccw_dev
);
58 typedef struct VirtioCcwDeviceTmp
{
59 VirtioCcwDevice
*parent
;
60 uint16_t config_vector
;
63 static int virtio_ccw_dev_tmp_pre_save(void *opaque
)
65 VirtioCcwDeviceTmp
*tmp
= opaque
;
66 VirtioCcwDevice
*dev
= tmp
->parent
;
67 VirtIODevice
*vdev
= virtio_bus_get_device(&dev
->bus
);
69 tmp
->config_vector
= vdev
->config_vector
;
74 static int virtio_ccw_dev_tmp_post_load(void *opaque
, int version_id
)
76 VirtioCcwDeviceTmp
*tmp
= opaque
;
77 VirtioCcwDevice
*dev
= tmp
->parent
;
78 VirtIODevice
*vdev
= virtio_bus_get_device(&dev
->bus
);
80 vdev
->config_vector
= tmp
->config_vector
;
84 const VMStateDescription vmstate_virtio_ccw_dev_tmp
= {
85 .name
= "s390_virtio_ccw_dev_tmp",
86 .pre_save
= virtio_ccw_dev_tmp_pre_save
,
87 .post_load
= virtio_ccw_dev_tmp_post_load
,
88 .fields
= (VMStateField
[]) {
89 VMSTATE_UINT16(config_vector
, VirtioCcwDeviceTmp
),
94 const VMStateDescription vmstate_virtio_ccw_dev
= {
95 .name
= "s390_virtio_ccw_dev",
97 .minimum_version_id
= 1,
98 .post_load
= virtio_ccw_dev_post_load
,
99 .fields
= (VMStateField
[]) {
100 VMSTATE_CCW_DEVICE(parent_obj
, VirtioCcwDevice
),
101 VMSTATE_PTR_TO_IND_ADDR(indicators
, VirtioCcwDevice
),
102 VMSTATE_PTR_TO_IND_ADDR(indicators2
, VirtioCcwDevice
),
103 VMSTATE_PTR_TO_IND_ADDR(summary_indicator
, VirtioCcwDevice
),
105 * Ugly hack because VirtIODevice does not migrate itself.
106 * This also makes legacy via vmstate_save_state possible.
108 VMSTATE_WITH_TMP(VirtioCcwDevice
, VirtioCcwDeviceTmp
,
109 vmstate_virtio_ccw_dev_tmp
),
110 VMSTATE_STRUCT(routes
, VirtioCcwDevice
, 1, vmstate_adapter_routes
,
112 VMSTATE_UINT8(thinint_isc
, VirtioCcwDevice
),
113 VMSTATE_INT32(revision
, VirtioCcwDevice
),
114 VMSTATE_END_OF_LIST()
118 static void virtio_ccw_bus_new(VirtioBusState
*bus
, size_t bus_size
,
119 VirtioCcwDevice
*dev
);
121 VirtIODevice
*virtio_ccw_get_vdev(SubchDev
*sch
)
123 VirtIODevice
*vdev
= NULL
;
124 VirtioCcwDevice
*dev
= sch
->driver_data
;
127 vdev
= virtio_bus_get_device(&dev
->bus
);
132 static void virtio_ccw_start_ioeventfd(VirtioCcwDevice
*dev
)
134 virtio_bus_start_ioeventfd(&dev
->bus
);
137 static void virtio_ccw_stop_ioeventfd(VirtioCcwDevice
*dev
)
139 virtio_bus_stop_ioeventfd(&dev
->bus
);
142 static bool virtio_ccw_ioeventfd_enabled(DeviceState
*d
)
144 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
146 return (dev
->flags
& VIRTIO_CCW_FLAG_USE_IOEVENTFD
) != 0;
149 static int virtio_ccw_ioeventfd_assign(DeviceState
*d
, EventNotifier
*notifier
,
152 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
153 CcwDevice
*ccw_dev
= CCW_DEVICE(dev
);
154 SubchDev
*sch
= ccw_dev
->sch
;
155 uint32_t sch_id
= (css_build_subchannel_id(sch
) << 16) | sch
->schid
;
157 return s390_assign_subch_ioeventfd(notifier
, sch_id
, n
, assign
);
160 /* Communication blocks used by several channel commands. */
161 typedef struct VqInfoBlockLegacy
{
166 } QEMU_PACKED VqInfoBlockLegacy
;
168 typedef struct VqInfoBlock
{
175 } QEMU_PACKED VqInfoBlock
;
177 typedef struct VqConfigBlock
{
180 } QEMU_PACKED VqConfigBlock
;
182 typedef struct VirtioFeatDesc
{
185 } QEMU_PACKED VirtioFeatDesc
;
187 typedef struct VirtioThinintInfo
{
188 hwaddr summary_indicator
;
189 hwaddr device_indicator
;
192 } QEMU_PACKED VirtioThinintInfo
;
194 typedef struct VirtioRevInfo
{
198 } QEMU_PACKED VirtioRevInfo
;
200 /* Specify where the virtqueues for the subchannel are in guest memory. */
201 static int virtio_ccw_set_vqs(SubchDev
*sch
, VqInfoBlock
*info
,
202 VqInfoBlockLegacy
*linfo
)
204 VirtIODevice
*vdev
= virtio_ccw_get_vdev(sch
);
205 uint16_t index
= info
? info
->index
: linfo
->index
;
206 uint16_t num
= info
? info
->num
: linfo
->num
;
207 uint64_t desc
= info
? info
->desc
: linfo
->queue
;
209 if (index
>= VIRTIO_QUEUE_MAX
) {
213 /* Current code in virtio.c relies on 4K alignment. */
214 if (linfo
&& desc
&& (linfo
->align
!= 4096)) {
223 virtio_queue_set_rings(vdev
, index
, desc
, info
->avail
, info
->used
);
225 virtio_queue_set_addr(vdev
, index
, desc
);
228 virtio_queue_set_vector(vdev
, index
, VIRTIO_NO_VECTOR
);
231 /* virtio-1 allows changing the ring size. */
232 if (virtio_queue_get_max_num(vdev
, index
) < num
) {
233 /* Fail if we exceed the maximum number. */
236 virtio_queue_set_num(vdev
, index
, num
);
237 } else if (virtio_queue_get_num(vdev
, index
) > num
) {
238 /* Fail if we don't have a big enough queue. */
241 /* We ignore possible increased num for legacy for compatibility. */
242 virtio_queue_set_vector(vdev
, index
, index
);
244 /* tell notify handler in case of config change */
245 vdev
->config_vector
= VIRTIO_QUEUE_MAX
;
249 static void virtio_ccw_reset_virtio(VirtioCcwDevice
*dev
, VirtIODevice
*vdev
)
251 CcwDevice
*ccw_dev
= CCW_DEVICE(dev
);
253 virtio_ccw_stop_ioeventfd(dev
);
255 if (dev
->indicators
) {
256 release_indicator(&dev
->routes
.adapter
, dev
->indicators
);
257 dev
->indicators
= NULL
;
259 if (dev
->indicators2
) {
260 release_indicator(&dev
->routes
.adapter
, dev
->indicators2
);
261 dev
->indicators2
= NULL
;
263 if (dev
->summary_indicator
) {
264 release_indicator(&dev
->routes
.adapter
, dev
->summary_indicator
);
265 dev
->summary_indicator
= NULL
;
267 ccw_dev
->sch
->thinint_active
= false;
270 static int virtio_ccw_handle_set_vq(SubchDev
*sch
, CCW1 ccw
, bool check_len
,
275 VqInfoBlockLegacy linfo
;
276 size_t info_len
= is_legacy
? sizeof(linfo
) : sizeof(info
);
279 if (ccw
.count
!= info_len
) {
282 } else if (ccw
.count
< info_len
) {
283 /* Can't execute command. */
290 ccw_dstream_read(&sch
->cds
, linfo
);
291 be64_to_cpus(&linfo
.queue
);
292 be32_to_cpus(&linfo
.align
);
293 be16_to_cpus(&linfo
.index
);
294 be16_to_cpus(&linfo
.num
);
295 ret
= virtio_ccw_set_vqs(sch
, NULL
, &linfo
);
297 ccw_dstream_read(&sch
->cds
, info
);
298 be64_to_cpus(&info
.desc
);
299 be16_to_cpus(&info
.index
);
300 be16_to_cpus(&info
.num
);
301 be64_to_cpus(&info
.avail
);
302 be64_to_cpus(&info
.used
);
303 ret
= virtio_ccw_set_vqs(sch
, &info
, NULL
);
305 sch
->curr_status
.scsw
.count
= 0;
309 static int virtio_ccw_cb(SubchDev
*sch
, CCW1 ccw
)
312 VirtioRevInfo revinfo
;
314 VirtioFeatDesc features
;
316 VqConfigBlock vq_config
;
317 VirtioCcwDevice
*dev
= sch
->driver_data
;
318 VirtIODevice
*vdev
= virtio_ccw_get_vdev(sch
);
321 VirtioThinintInfo thinint
;
327 trace_virtio_ccw_interpret_ccw(sch
->cssid
, sch
->ssid
, sch
->schid
,
329 check_len
= !((ccw
.flags
& CCW_FLAG_SLI
) && !(ccw
.flags
& CCW_FLAG_DC
));
331 if (dev
->force_revision_1
&& dev
->revision
< 0 &&
332 ccw
.cmd_code
!= CCW_CMD_SET_VIRTIO_REV
) {
334 * virtio-1 drivers must start with negotiating to a revision >= 1,
335 * so post a command reject for all other commands
340 /* Look at the command. */
341 switch (ccw
.cmd_code
) {
343 ret
= virtio_ccw_handle_set_vq(sch
, ccw
, check_len
, dev
->revision
< 1);
345 case CCW_CMD_VDEV_RESET
:
346 virtio_ccw_reset_virtio(dev
, vdev
);
349 case CCW_CMD_READ_FEAT
:
351 if (ccw
.count
!= sizeof(features
)) {
355 } else if (ccw
.count
< sizeof(features
)) {
356 /* Can't execute command. */
363 VirtioDeviceClass
*vdc
= VIRTIO_DEVICE_GET_CLASS(vdev
);
365 ccw_dstream_advance(&sch
->cds
, sizeof(features
.features
));
366 ccw_dstream_read(&sch
->cds
, features
.index
);
367 if (features
.index
== 0) {
368 if (dev
->revision
>= 1) {
369 /* Don't offer legacy features for modern devices. */
370 features
.features
= (uint32_t)
371 (vdev
->host_features
& ~vdc
->legacy_features
);
373 features
.features
= (uint32_t)vdev
->host_features
;
375 } else if ((features
.index
== 1) && (dev
->revision
>= 1)) {
377 * Only offer feature bits beyond 31 if the guest has
378 * negotiated at least revision 1.
380 features
.features
= (uint32_t)(vdev
->host_features
>> 32);
382 /* Return zeroes if the guest supports more feature bits. */
383 features
.features
= 0;
385 ccw_dstream_rewind(&sch
->cds
);
386 cpu_to_le32s(&features
.features
);
387 ccw_dstream_write(&sch
->cds
, features
.features
);
388 sch
->curr_status
.scsw
.count
= ccw
.count
- sizeof(features
);
392 case CCW_CMD_WRITE_FEAT
:
394 if (ccw
.count
!= sizeof(features
)) {
398 } else if (ccw
.count
< sizeof(features
)) {
399 /* Can't execute command. */
406 ccw_dstream_read(&sch
->cds
, features
);
407 le32_to_cpus(&features
.features
);
408 if (features
.index
== 0) {
409 virtio_set_features(vdev
,
410 (vdev
->guest_features
& 0xffffffff00000000ULL
) |
412 } else if ((features
.index
== 1) && (dev
->revision
>= 1)) {
414 * If the guest did not negotiate at least revision 1,
415 * we did not offer it any feature bits beyond 31. Such a
416 * guest passing us any bit here is therefore buggy.
418 virtio_set_features(vdev
,
419 (vdev
->guest_features
& 0x00000000ffffffffULL
) |
420 ((uint64_t)features
.features
<< 32));
423 * If the guest supports more feature bits, assert that it
424 * passes us zeroes for those we don't support.
426 if (features
.features
) {
427 qemu_log_mask(LOG_GUEST_ERROR
,
428 "Guest bug: features[%i]=%x (expected 0)",
429 features
.index
, features
.features
);
430 /* XXX: do a unit check here? */
433 sch
->curr_status
.scsw
.count
= ccw
.count
- sizeof(features
);
437 case CCW_CMD_READ_CONF
:
439 if (ccw
.count
> vdev
->config_len
) {
444 len
= MIN(ccw
.count
, vdev
->config_len
);
448 virtio_bus_get_vdev_config(&dev
->bus
, vdev
->config
);
449 ccw_dstream_write_buf(&sch
->cds
, vdev
->config
, len
);
450 sch
->curr_status
.scsw
.count
= ccw
.count
- len
;
454 case CCW_CMD_WRITE_CONF
:
456 if (ccw
.count
> vdev
->config_len
) {
461 len
= MIN(ccw
.count
, vdev
->config_len
);
465 ret
= ccw_dstream_read_buf(&sch
->cds
, vdev
->config
, len
);
467 virtio_bus_set_vdev_config(&dev
->bus
, vdev
->config
);
468 sch
->curr_status
.scsw
.count
= ccw
.count
- len
;
472 case CCW_CMD_READ_STATUS
:
474 if (ccw
.count
!= sizeof(status
)) {
478 } else if (ccw
.count
< sizeof(status
)) {
479 /* Can't execute command. */
486 address_space_stb(&address_space_memory
, ccw
.cda
, vdev
->status
,
487 MEMTXATTRS_UNSPECIFIED
, NULL
);
488 sch
->curr_status
.scsw
.count
= ccw
.count
- sizeof(vdev
->status
);
492 case CCW_CMD_WRITE_STATUS
:
494 if (ccw
.count
!= sizeof(status
)) {
498 } else if (ccw
.count
< sizeof(status
)) {
499 /* Can't execute command. */
506 ccw_dstream_read(&sch
->cds
, status
);
507 if (!(status
& VIRTIO_CONFIG_S_DRIVER_OK
)) {
508 virtio_ccw_stop_ioeventfd(dev
);
510 if (virtio_set_status(vdev
, status
) == 0) {
511 if (vdev
->status
== 0) {
512 virtio_ccw_reset_virtio(dev
, vdev
);
514 if (status
& VIRTIO_CONFIG_S_DRIVER_OK
) {
515 virtio_ccw_start_ioeventfd(dev
);
517 sch
->curr_status
.scsw
.count
= ccw
.count
- sizeof(status
);
520 /* Trigger a command reject. */
525 case CCW_CMD_SET_IND
:
527 if (ccw
.count
!= sizeof(indicators
)) {
531 } else if (ccw
.count
< sizeof(indicators
)) {
532 /* Can't execute command. */
536 if (sch
->thinint_active
) {
537 /* Trigger a command reject. */
541 if (virtio_get_num_queues(vdev
) > NR_CLASSIC_INDICATOR_BITS
) {
542 /* More queues than indicator bits --> trigger a reject */
549 ccw_dstream_read(&sch
->cds
, indicators
);
550 be64_to_cpus(&indicators
);
551 dev
->indicators
= get_indicator(indicators
, sizeof(uint64_t));
552 sch
->curr_status
.scsw
.count
= ccw
.count
- sizeof(indicators
);
556 case CCW_CMD_SET_CONF_IND
:
558 if (ccw
.count
!= sizeof(indicators
)) {
562 } else if (ccw
.count
< sizeof(indicators
)) {
563 /* Can't execute command. */
570 ccw_dstream_read(&sch
->cds
, indicators
);
571 be64_to_cpus(&indicators
);
572 dev
->indicators2
= get_indicator(indicators
, sizeof(uint64_t));
573 sch
->curr_status
.scsw
.count
= ccw
.count
- sizeof(indicators
);
577 case CCW_CMD_READ_VQ_CONF
:
579 if (ccw
.count
!= sizeof(vq_config
)) {
583 } else if (ccw
.count
< sizeof(vq_config
)) {
584 /* Can't execute command. */
591 ccw_dstream_read(&sch
->cds
, vq_config
.index
);
592 be16_to_cpus(&vq_config
.index
);
593 if (vq_config
.index
>= VIRTIO_QUEUE_MAX
) {
597 vq_config
.num_max
= virtio_queue_get_num(vdev
,
599 cpu_to_be16s(&vq_config
.num_max
);
600 ccw_dstream_write(&sch
->cds
, vq_config
.num_max
);
601 sch
->curr_status
.scsw
.count
= ccw
.count
- sizeof(vq_config
);
605 case CCW_CMD_SET_IND_ADAPTER
:
607 if (ccw
.count
!= sizeof(thinint
)) {
611 } else if (ccw
.count
< sizeof(thinint
)) {
612 /* Can't execute command. */
618 } else if (dev
->indicators
&& !sch
->thinint_active
) {
619 /* Trigger a command reject. */
622 if (ccw_dstream_read(&sch
->cds
, thinint
)) {
625 be64_to_cpus(&thinint
.ind_bit
);
626 be64_to_cpus(&thinint
.summary_indicator
);
627 be64_to_cpus(&thinint
.device_indicator
);
629 dev
->summary_indicator
=
630 get_indicator(thinint
.summary_indicator
, sizeof(uint8_t));
632 get_indicator(thinint
.device_indicator
,
633 thinint
.ind_bit
/ 8 + 1);
634 dev
->thinint_isc
= thinint
.isc
;
635 dev
->routes
.adapter
.ind_offset
= thinint
.ind_bit
;
636 dev
->routes
.adapter
.summary_offset
= 7;
637 dev
->routes
.adapter
.adapter_id
= css_get_adapter_id(
638 CSS_IO_ADAPTER_VIRTIO
,
640 sch
->thinint_active
= ((dev
->indicators
!= NULL
) &&
641 (dev
->summary_indicator
!= NULL
));
642 sch
->curr_status
.scsw
.count
= ccw
.count
- sizeof(thinint
);
647 case CCW_CMD_SET_VIRTIO_REV
:
648 len
= sizeof(revinfo
);
649 if (ccw
.count
< len
) {
657 ccw_dstream_read_buf(&sch
->cds
, &revinfo
, 4);
658 be16_to_cpus(&revinfo
.revision
);
659 be16_to_cpus(&revinfo
.length
);
660 if (ccw
.count
< len
+ revinfo
.length
||
661 (check_len
&& ccw
.count
> len
+ revinfo
.length
)) {
666 * Once we start to support revisions with additional data, we'll
667 * need to fetch it here. Nothing to do for now, though.
669 if (dev
->revision
>= 0 ||
670 revinfo
.revision
> virtio_ccw_rev_max(dev
) ||
671 (dev
->force_revision_1
&& !revinfo
.revision
)) {
676 dev
->revision
= revinfo
.revision
;
685 static void virtio_sch_disable_cb(SubchDev
*sch
)
687 VirtioCcwDevice
*dev
= sch
->driver_data
;
692 static void virtio_ccw_device_realize(VirtioCcwDevice
*dev
, Error
**errp
)
694 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_GET_CLASS(dev
);
695 CcwDevice
*ccw_dev
= CCW_DEVICE(dev
);
696 CCWDeviceClass
*ck
= CCW_DEVICE_GET_CLASS(ccw_dev
);
697 DeviceState
*parent
= DEVICE(ccw_dev
);
698 BusState
*qbus
= qdev_get_parent_bus(parent
);
699 VirtualCssBus
*cbus
= VIRTUAL_CSS_BUS(qbus
);
703 sch
= css_create_sch(ccw_dev
->devno
, cbus
->squash_mcss
, errp
);
707 if (!virtio_ccw_rev_max(dev
) && dev
->force_revision_1
) {
708 error_setg(&err
, "Invalid value of property max_rev "
709 "(is %d expected >= 1)", virtio_ccw_rev_max(dev
));
713 sch
->driver_data
= dev
;
714 sch
->ccw_cb
= virtio_ccw_cb
;
715 sch
->disable_cb
= virtio_sch_disable_cb
;
716 sch
->id
.reserved
= 0xff;
717 sch
->id
.cu_type
= VIRTIO_CCW_CU_TYPE
;
718 sch
->do_subchannel_work
= do_subchannel_work_virtual
;
720 dev
->indicators
= NULL
;
722 css_sch_build_virtual_schib(sch
, 0, VIRTIO_CCW_CHPID_TYPE
);
724 trace_virtio_ccw_new_device(
725 sch
->cssid
, sch
->ssid
, sch
->schid
, sch
->devno
,
726 ccw_dev
->devno
.valid
? "user-configured" : "auto-configured");
728 if (kvm_enabled() && !kvm_eventfds_enabled()) {
729 dev
->flags
&= ~VIRTIO_CCW_FLAG_USE_IOEVENTFD
;
733 k
->realize(dev
, &err
);
739 ck
->realize(ccw_dev
, &err
);
747 error_propagate(errp
, err
);
748 css_subch_assign(sch
->cssid
, sch
->ssid
, sch
->schid
, sch
->devno
, NULL
);
753 static void virtio_ccw_unrealize(VirtioCcwDevice
*dev
, Error
**errp
)
755 CcwDevice
*ccw_dev
= CCW_DEVICE(dev
);
756 SubchDev
*sch
= ccw_dev
->sch
;
759 css_subch_assign(sch
->cssid
, sch
->ssid
, sch
->schid
, sch
->devno
, NULL
);
763 if (dev
->indicators
) {
764 release_indicator(&dev
->routes
.adapter
, dev
->indicators
);
765 dev
->indicators
= NULL
;
769 static void virtio_ccw_net_realize(VirtioCcwDevice
*ccw_dev
, Error
**errp
)
771 DeviceState
*qdev
= DEVICE(ccw_dev
);
772 VirtIONetCcw
*dev
= VIRTIO_NET_CCW(ccw_dev
);
773 DeviceState
*vdev
= DEVICE(&dev
->vdev
);
775 virtio_net_set_netclient_name(&dev
->vdev
, qdev
->id
,
776 object_get_typename(OBJECT(qdev
)));
777 qdev_set_parent_bus(vdev
, BUS(&ccw_dev
->bus
));
778 object_property_set_bool(OBJECT(vdev
), true, "realized", errp
);
781 static void virtio_ccw_net_instance_init(Object
*obj
)
783 VirtIONetCcw
*dev
= VIRTIO_NET_CCW(obj
);
785 virtio_instance_init_common(obj
, &dev
->vdev
, sizeof(dev
->vdev
),
787 object_property_add_alias(obj
, "bootindex", OBJECT(&dev
->vdev
),
788 "bootindex", &error_abort
);
791 static void virtio_ccw_blk_realize(VirtioCcwDevice
*ccw_dev
, Error
**errp
)
793 VirtIOBlkCcw
*dev
= VIRTIO_BLK_CCW(ccw_dev
);
794 DeviceState
*vdev
= DEVICE(&dev
->vdev
);
796 qdev_set_parent_bus(vdev
, BUS(&ccw_dev
->bus
));
797 object_property_set_bool(OBJECT(vdev
), true, "realized", errp
);
800 static void virtio_ccw_blk_instance_init(Object
*obj
)
802 VirtIOBlkCcw
*dev
= VIRTIO_BLK_CCW(obj
);
804 virtio_instance_init_common(obj
, &dev
->vdev
, sizeof(dev
->vdev
),
806 object_property_add_alias(obj
, "bootindex", OBJECT(&dev
->vdev
),
807 "bootindex", &error_abort
);
810 static void virtio_ccw_serial_realize(VirtioCcwDevice
*ccw_dev
, Error
**errp
)
812 VirtioSerialCcw
*dev
= VIRTIO_SERIAL_CCW(ccw_dev
);
813 DeviceState
*vdev
= DEVICE(&dev
->vdev
);
814 DeviceState
*proxy
= DEVICE(ccw_dev
);
818 * For command line compatibility, this sets the virtio-serial-device bus
822 bus_name
= g_strdup_printf("%s.0", proxy
->id
);
823 virtio_device_set_child_bus_name(VIRTIO_DEVICE(vdev
), bus_name
);
827 qdev_set_parent_bus(vdev
, BUS(&ccw_dev
->bus
));
828 object_property_set_bool(OBJECT(vdev
), true, "realized", errp
);
832 static void virtio_ccw_serial_instance_init(Object
*obj
)
834 VirtioSerialCcw
*dev
= VIRTIO_SERIAL_CCW(obj
);
836 virtio_instance_init_common(obj
, &dev
->vdev
, sizeof(dev
->vdev
),
840 static void virtio_ccw_balloon_realize(VirtioCcwDevice
*ccw_dev
, Error
**errp
)
842 VirtIOBalloonCcw
*dev
= VIRTIO_BALLOON_CCW(ccw_dev
);
843 DeviceState
*vdev
= DEVICE(&dev
->vdev
);
845 qdev_set_parent_bus(vdev
, BUS(&ccw_dev
->bus
));
846 object_property_set_bool(OBJECT(vdev
), true, "realized", errp
);
849 static void virtio_ccw_balloon_instance_init(Object
*obj
)
851 VirtIOBalloonCcw
*dev
= VIRTIO_BALLOON_CCW(obj
);
853 virtio_instance_init_common(obj
, &dev
->vdev
, sizeof(dev
->vdev
),
854 TYPE_VIRTIO_BALLOON
);
855 object_property_add_alias(obj
, "guest-stats", OBJECT(&dev
->vdev
),
856 "guest-stats", &error_abort
);
857 object_property_add_alias(obj
, "guest-stats-polling-interval",
859 "guest-stats-polling-interval", &error_abort
);
862 static void virtio_ccw_scsi_realize(VirtioCcwDevice
*ccw_dev
, Error
**errp
)
864 VirtIOSCSICcw
*dev
= VIRTIO_SCSI_CCW(ccw_dev
);
865 DeviceState
*vdev
= DEVICE(&dev
->vdev
);
866 DeviceState
*qdev
= DEVICE(ccw_dev
);
870 * For command line compatibility, this sets the virtio-scsi-device bus
874 bus_name
= g_strdup_printf("%s.0", qdev
->id
);
875 virtio_device_set_child_bus_name(VIRTIO_DEVICE(vdev
), bus_name
);
879 qdev_set_parent_bus(vdev
, BUS(&ccw_dev
->bus
));
880 object_property_set_bool(OBJECT(vdev
), true, "realized", errp
);
883 static void virtio_ccw_scsi_instance_init(Object
*obj
)
885 VirtIOSCSICcw
*dev
= VIRTIO_SCSI_CCW(obj
);
887 virtio_instance_init_common(obj
, &dev
->vdev
, sizeof(dev
->vdev
),
891 #ifdef CONFIG_VHOST_SCSI
892 static void vhost_ccw_scsi_realize(VirtioCcwDevice
*ccw_dev
, Error
**errp
)
894 VHostSCSICcw
*dev
= VHOST_SCSI_CCW(ccw_dev
);
895 DeviceState
*vdev
= DEVICE(&dev
->vdev
);
897 qdev_set_parent_bus(vdev
, BUS(&ccw_dev
->bus
));
898 object_property_set_bool(OBJECT(vdev
), true, "realized", errp
);
901 static void vhost_ccw_scsi_instance_init(Object
*obj
)
903 VHostSCSICcw
*dev
= VHOST_SCSI_CCW(obj
);
905 virtio_instance_init_common(obj
, &dev
->vdev
, sizeof(dev
->vdev
),
910 static void virtio_ccw_rng_realize(VirtioCcwDevice
*ccw_dev
, Error
**errp
)
912 VirtIORNGCcw
*dev
= VIRTIO_RNG_CCW(ccw_dev
);
913 DeviceState
*vdev
= DEVICE(&dev
->vdev
);
916 qdev_set_parent_bus(vdev
, BUS(&ccw_dev
->bus
));
917 object_property_set_bool(OBJECT(vdev
), true, "realized", &err
);
919 error_propagate(errp
, err
);
923 object_property_set_link(OBJECT(dev
),
924 OBJECT(dev
->vdev
.conf
.rng
), "rng",
928 static void virtio_ccw_crypto_realize(VirtioCcwDevice
*ccw_dev
, Error
**errp
)
930 VirtIOCryptoCcw
*dev
= VIRTIO_CRYPTO_CCW(ccw_dev
);
931 DeviceState
*vdev
= DEVICE(&dev
->vdev
);
934 qdev_set_parent_bus(vdev
, BUS(&ccw_dev
->bus
));
935 object_property_set_bool(OBJECT(vdev
), true, "realized", &err
);
937 error_propagate(errp
, err
);
941 object_property_set_link(OBJECT(vdev
),
942 OBJECT(dev
->vdev
.conf
.cryptodev
), "cryptodev",
946 static void virtio_ccw_gpu_realize(VirtioCcwDevice
*ccw_dev
, Error
**errp
)
948 VirtIOGPUCcw
*dev
= VIRTIO_GPU_CCW(ccw_dev
);
949 DeviceState
*vdev
= DEVICE(&dev
->vdev
);
951 qdev_set_parent_bus(vdev
, BUS(&ccw_dev
->bus
));
952 object_property_set_bool(OBJECT(vdev
), true, "realized", errp
);
955 static void virtio_ccw_input_realize(VirtioCcwDevice
*ccw_dev
, Error
**errp
)
957 VirtIOInputCcw
*dev
= VIRTIO_INPUT_CCW(ccw_dev
);
958 DeviceState
*vdev
= DEVICE(&dev
->vdev
);
960 qdev_set_parent_bus(vdev
, BUS(&ccw_dev
->bus
));
961 object_property_set_bool(OBJECT(vdev
), true, "realized", errp
);
964 /* DeviceState to VirtioCcwDevice. Note: used on datapath,
965 * be careful and test performance if you change this.
967 static inline VirtioCcwDevice
*to_virtio_ccw_dev_fast(DeviceState
*d
)
969 CcwDevice
*ccw_dev
= to_ccw_dev_fast(d
);
971 return container_of(ccw_dev
, VirtioCcwDevice
, parent_obj
);
974 static uint8_t virtio_set_ind_atomic(SubchDev
*sch
, uint64_t ind_loc
,
977 uint8_t ind_old
, ind_new
;
981 ind_addr
= cpu_physical_memory_map(ind_loc
, &len
, 1);
983 error_report("%s(%x.%x.%04x): unable to access indicator",
984 __func__
, sch
->cssid
, sch
->ssid
, sch
->schid
);
989 ind_new
= ind_old
| to_be_set
;
990 } while (atomic_cmpxchg(ind_addr
, ind_old
, ind_new
) != ind_old
);
991 trace_virtio_ccw_set_ind(ind_loc
, ind_old
, ind_new
);
992 cpu_physical_memory_unmap(ind_addr
, len
, 1, len
);
997 static void virtio_ccw_notify(DeviceState
*d
, uint16_t vector
)
999 VirtioCcwDevice
*dev
= to_virtio_ccw_dev_fast(d
);
1000 CcwDevice
*ccw_dev
= to_ccw_dev_fast(d
);
1001 SubchDev
*sch
= ccw_dev
->sch
;
1002 uint64_t indicators
;
1004 if (vector
== VIRTIO_NO_VECTOR
) {
1008 * vector < VIRTIO_QUEUE_MAX: notification for a virtqueue
1009 * vector == VIRTIO_QUEUE_MAX: configuration change notification
1010 * bits beyond that are unused and should never be notified for
1012 assert(vector
<= VIRTIO_QUEUE_MAX
);
1014 if (vector
< VIRTIO_QUEUE_MAX
) {
1015 if (!dev
->indicators
) {
1018 if (sch
->thinint_active
) {
1020 * In the adapter interrupt case, indicators points to a
1021 * memory area that may be (way) larger than 64 bit and
1022 * ind_bit indicates the start of the indicators in a big
1025 uint64_t ind_bit
= dev
->routes
.adapter
.ind_offset
;
1027 virtio_set_ind_atomic(sch
, dev
->indicators
->addr
+
1028 (ind_bit
+ vector
) / 8,
1029 0x80 >> ((ind_bit
+ vector
) % 8));
1030 if (!virtio_set_ind_atomic(sch
, dev
->summary_indicator
->addr
,
1032 css_adapter_interrupt(CSS_IO_ADAPTER_VIRTIO
, dev
->thinint_isc
);
1035 assert(vector
< NR_CLASSIC_INDICATOR_BITS
);
1036 indicators
= address_space_ldq(&address_space_memory
,
1037 dev
->indicators
->addr
,
1038 MEMTXATTRS_UNSPECIFIED
,
1040 indicators
|= 1ULL << vector
;
1041 address_space_stq(&address_space_memory
, dev
->indicators
->addr
,
1042 indicators
, MEMTXATTRS_UNSPECIFIED
, NULL
);
1043 css_conditional_io_interrupt(sch
);
1046 if (!dev
->indicators2
) {
1049 indicators
= address_space_ldq(&address_space_memory
,
1050 dev
->indicators2
->addr
,
1051 MEMTXATTRS_UNSPECIFIED
,
1054 address_space_stq(&address_space_memory
, dev
->indicators2
->addr
,
1055 indicators
, MEMTXATTRS_UNSPECIFIED
, NULL
);
1056 css_conditional_io_interrupt(sch
);
1060 static void virtio_ccw_reset(DeviceState
*d
)
1062 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
1063 VirtIODevice
*vdev
= virtio_bus_get_device(&dev
->bus
);
1064 VirtIOCCWDeviceClass
*vdc
= VIRTIO_CCW_DEVICE_GET_CLASS(dev
);
1066 virtio_ccw_reset_virtio(dev
, vdev
);
1067 if (vdc
->parent_reset
) {
1068 vdc
->parent_reset(d
);
1072 static void virtio_ccw_vmstate_change(DeviceState
*d
, bool running
)
1074 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
1077 virtio_ccw_start_ioeventfd(dev
);
1079 virtio_ccw_stop_ioeventfd(dev
);
1083 static bool virtio_ccw_query_guest_notifiers(DeviceState
*d
)
1085 CcwDevice
*dev
= CCW_DEVICE(d
);
1087 return !!(dev
->sch
->curr_status
.pmcw
.flags
& PMCW_FLAGS_MASK_ENA
);
1090 static int virtio_ccw_get_mappings(VirtioCcwDevice
*dev
)
1093 CcwDevice
*ccw_dev
= CCW_DEVICE(dev
);
1095 if (!ccw_dev
->sch
->thinint_active
) {
1099 r
= map_indicator(&dev
->routes
.adapter
, dev
->summary_indicator
);
1103 r
= map_indicator(&dev
->routes
.adapter
, dev
->indicators
);
1107 dev
->routes
.adapter
.summary_addr
= dev
->summary_indicator
->map
;
1108 dev
->routes
.adapter
.ind_addr
= dev
->indicators
->map
;
1113 static int virtio_ccw_setup_irqroutes(VirtioCcwDevice
*dev
, int nvqs
)
1116 VirtIODevice
*vdev
= virtio_bus_get_device(&dev
->bus
);
1118 S390FLICState
*fs
= s390_get_flic();
1119 S390FLICStateClass
*fsc
= s390_get_flic_class(fs
);
1121 ret
= virtio_ccw_get_mappings(dev
);
1125 for (i
= 0; i
< nvqs
; i
++) {
1126 if (!virtio_queue_get_num(vdev
, i
)) {
1130 dev
->routes
.num_routes
= i
;
1131 return fsc
->add_adapter_routes(fs
, &dev
->routes
);
1134 static void virtio_ccw_release_irqroutes(VirtioCcwDevice
*dev
, int nvqs
)
1136 S390FLICState
*fs
= s390_get_flic();
1137 S390FLICStateClass
*fsc
= s390_get_flic_class(fs
);
1139 fsc
->release_adapter_routes(fs
, &dev
->routes
);
1142 static int virtio_ccw_add_irqfd(VirtioCcwDevice
*dev
, int n
)
1144 VirtIODevice
*vdev
= virtio_bus_get_device(&dev
->bus
);
1145 VirtQueue
*vq
= virtio_get_queue(vdev
, n
);
1146 EventNotifier
*notifier
= virtio_queue_get_guest_notifier(vq
);
1148 return kvm_irqchip_add_irqfd_notifier_gsi(kvm_state
, notifier
, NULL
,
1149 dev
->routes
.gsi
[n
]);
1152 static void virtio_ccw_remove_irqfd(VirtioCcwDevice
*dev
, int n
)
1154 VirtIODevice
*vdev
= virtio_bus_get_device(&dev
->bus
);
1155 VirtQueue
*vq
= virtio_get_queue(vdev
, n
);
1156 EventNotifier
*notifier
= virtio_queue_get_guest_notifier(vq
);
1159 ret
= kvm_irqchip_remove_irqfd_notifier_gsi(kvm_state
, notifier
,
1160 dev
->routes
.gsi
[n
]);
1164 static int virtio_ccw_set_guest_notifier(VirtioCcwDevice
*dev
, int n
,
1165 bool assign
, bool with_irqfd
)
1167 VirtIODevice
*vdev
= virtio_bus_get_device(&dev
->bus
);
1168 VirtQueue
*vq
= virtio_get_queue(vdev
, n
);
1169 EventNotifier
*notifier
= virtio_queue_get_guest_notifier(vq
);
1170 VirtioDeviceClass
*k
= VIRTIO_DEVICE_GET_CLASS(vdev
);
1173 int r
= event_notifier_init(notifier
, 0);
1178 virtio_queue_set_guest_notifier_fd_handler(vq
, true, with_irqfd
);
1180 r
= virtio_ccw_add_irqfd(dev
, n
);
1182 virtio_queue_set_guest_notifier_fd_handler(vq
, false,
1188 * We do not support individual masking for channel devices, so we
1189 * need to manually trigger any guest masking callbacks here.
1191 if (k
->guest_notifier_mask
&& vdev
->use_guest_notifier_mask
) {
1192 k
->guest_notifier_mask(vdev
, n
, false);
1194 /* get lost events and re-inject */
1195 if (k
->guest_notifier_pending
&&
1196 k
->guest_notifier_pending(vdev
, n
)) {
1197 event_notifier_set(notifier
);
1200 if (k
->guest_notifier_mask
&& vdev
->use_guest_notifier_mask
) {
1201 k
->guest_notifier_mask(vdev
, n
, true);
1204 virtio_ccw_remove_irqfd(dev
, n
);
1206 virtio_queue_set_guest_notifier_fd_handler(vq
, false, with_irqfd
);
1207 event_notifier_cleanup(notifier
);
1212 static int virtio_ccw_set_guest_notifiers(DeviceState
*d
, int nvqs
,
1215 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
1216 VirtIODevice
*vdev
= virtio_bus_get_device(&dev
->bus
);
1217 CcwDevice
*ccw_dev
= CCW_DEVICE(d
);
1218 bool with_irqfd
= ccw_dev
->sch
->thinint_active
&& kvm_irqfds_enabled();
1221 if (with_irqfd
&& assigned
) {
1222 /* irq routes need to be set up before assigning irqfds */
1223 r
= virtio_ccw_setup_irqroutes(dev
, nvqs
);
1225 goto irqroute_error
;
1228 for (n
= 0; n
< nvqs
; n
++) {
1229 if (!virtio_queue_get_num(vdev
, n
)) {
1232 r
= virtio_ccw_set_guest_notifier(dev
, n
, assigned
, with_irqfd
);
1237 if (with_irqfd
&& !assigned
) {
1238 /* release irq routes after irqfds have been released */
1239 virtio_ccw_release_irqroutes(dev
, nvqs
);
1245 virtio_ccw_set_guest_notifier(dev
, n
, !assigned
, false);
1248 if (with_irqfd
&& assigned
) {
1249 virtio_ccw_release_irqroutes(dev
, nvqs
);
1254 static void virtio_ccw_save_queue(DeviceState
*d
, int n
, QEMUFile
*f
)
1256 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
1257 VirtIODevice
*vdev
= virtio_bus_get_device(&dev
->bus
);
1259 qemu_put_be16(f
, virtio_queue_vector(vdev
, n
));
1262 static int virtio_ccw_load_queue(DeviceState
*d
, int n
, QEMUFile
*f
)
1264 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
1265 VirtIODevice
*vdev
= virtio_bus_get_device(&dev
->bus
);
1268 qemu_get_be16s(f
, &vector
);
1269 virtio_queue_set_vector(vdev
, n
, vector
);
1274 static void virtio_ccw_save_config(DeviceState
*d
, QEMUFile
*f
)
1276 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
1277 vmstate_save_state(f
, &vmstate_virtio_ccw_dev
, dev
, NULL
);
1280 static int virtio_ccw_load_config(DeviceState
*d
, QEMUFile
*f
)
1282 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
1283 return vmstate_load_state(f
, &vmstate_virtio_ccw_dev
, dev
, 1);
1286 static void virtio_ccw_pre_plugged(DeviceState
*d
, Error
**errp
)
1288 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
1289 VirtIODevice
*vdev
= virtio_bus_get_device(&dev
->bus
);
1291 if (dev
->max_rev
>= 1) {
1292 virtio_add_feature(&vdev
->host_features
, VIRTIO_F_VERSION_1
);
1296 /* This is called by virtio-bus just after the device is plugged. */
1297 static void virtio_ccw_device_plugged(DeviceState
*d
, Error
**errp
)
1299 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
1300 VirtIODevice
*vdev
= virtio_bus_get_device(&dev
->bus
);
1301 CcwDevice
*ccw_dev
= CCW_DEVICE(d
);
1302 SubchDev
*sch
= ccw_dev
->sch
;
1303 int n
= virtio_get_num_queues(vdev
);
1304 S390FLICState
*flic
= s390_get_flic();
1306 if (!virtio_has_feature(vdev
->host_features
, VIRTIO_F_VERSION_1
)) {
1310 if (virtio_get_num_queues(vdev
) > VIRTIO_QUEUE_MAX
) {
1311 error_setg(errp
, "The number of virtqueues %d "
1312 "exceeds virtio limit %d", n
,
1316 if (virtio_get_num_queues(vdev
) > flic
->adapter_routes_max_batch
) {
1317 error_setg(errp
, "The number of virtqueues %d "
1318 "exceeds flic adapter route limit %d", n
,
1319 flic
->adapter_routes_max_batch
);
1323 sch
->id
.cu_model
= virtio_bus_get_vdev_id(&dev
->bus
);
1326 css_generate_sch_crws(sch
->cssid
, sch
->ssid
, sch
->schid
,
1330 static void virtio_ccw_device_unplugged(DeviceState
*d
)
1332 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
1334 virtio_ccw_stop_ioeventfd(dev
);
1336 /**************** Virtio-ccw Bus Device Descriptions *******************/
1338 static Property virtio_ccw_net_properties
[] = {
1339 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice
, flags
,
1340 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT
, true),
1341 DEFINE_PROP_UINT32("max_revision", VirtioCcwDevice
, max_rev
,
1342 VIRTIO_CCW_MAX_REV
),
1343 DEFINE_PROP_END_OF_LIST(),
1346 static void virtio_ccw_net_class_init(ObjectClass
*klass
, void *data
)
1348 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1349 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_CLASS(klass
);
1351 k
->realize
= virtio_ccw_net_realize
;
1352 k
->unrealize
= virtio_ccw_unrealize
;
1353 dc
->props
= virtio_ccw_net_properties
;
1354 set_bit(DEVICE_CATEGORY_NETWORK
, dc
->categories
);
1357 static const TypeInfo virtio_ccw_net
= {
1358 .name
= TYPE_VIRTIO_NET_CCW
,
1359 .parent
= TYPE_VIRTIO_CCW_DEVICE
,
1360 .instance_size
= sizeof(VirtIONetCcw
),
1361 .instance_init
= virtio_ccw_net_instance_init
,
1362 .class_init
= virtio_ccw_net_class_init
,
1365 static Property virtio_ccw_blk_properties
[] = {
1366 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice
, flags
,
1367 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT
, true),
1368 DEFINE_PROP_UINT32("max_revision", VirtioCcwDevice
, max_rev
,
1369 VIRTIO_CCW_MAX_REV
),
1370 DEFINE_PROP_END_OF_LIST(),
1373 static void virtio_ccw_blk_class_init(ObjectClass
*klass
, void *data
)
1375 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1376 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_CLASS(klass
);
1378 k
->realize
= virtio_ccw_blk_realize
;
1379 k
->unrealize
= virtio_ccw_unrealize
;
1380 dc
->props
= virtio_ccw_blk_properties
;
1381 set_bit(DEVICE_CATEGORY_STORAGE
, dc
->categories
);
1384 static const TypeInfo virtio_ccw_blk
= {
1385 .name
= TYPE_VIRTIO_BLK_CCW
,
1386 .parent
= TYPE_VIRTIO_CCW_DEVICE
,
1387 .instance_size
= sizeof(VirtIOBlkCcw
),
1388 .instance_init
= virtio_ccw_blk_instance_init
,
1389 .class_init
= virtio_ccw_blk_class_init
,
1392 static Property virtio_ccw_serial_properties
[] = {
1393 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice
, flags
,
1394 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT
, true),
1395 DEFINE_PROP_UINT32("max_revision", VirtioCcwDevice
, max_rev
,
1396 VIRTIO_CCW_MAX_REV
),
1397 DEFINE_PROP_END_OF_LIST(),
1400 static void virtio_ccw_serial_class_init(ObjectClass
*klass
, void *data
)
1402 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1403 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_CLASS(klass
);
1405 k
->realize
= virtio_ccw_serial_realize
;
1406 k
->unrealize
= virtio_ccw_unrealize
;
1407 dc
->props
= virtio_ccw_serial_properties
;
1408 set_bit(DEVICE_CATEGORY_INPUT
, dc
->categories
);
1411 static const TypeInfo virtio_ccw_serial
= {
1412 .name
= TYPE_VIRTIO_SERIAL_CCW
,
1413 .parent
= TYPE_VIRTIO_CCW_DEVICE
,
1414 .instance_size
= sizeof(VirtioSerialCcw
),
1415 .instance_init
= virtio_ccw_serial_instance_init
,
1416 .class_init
= virtio_ccw_serial_class_init
,
1419 static Property virtio_ccw_balloon_properties
[] = {
1420 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice
, flags
,
1421 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT
, true),
1422 DEFINE_PROP_UINT32("max_revision", VirtioCcwDevice
, max_rev
,
1423 VIRTIO_CCW_MAX_REV
),
1424 DEFINE_PROP_END_OF_LIST(),
1427 static void virtio_ccw_balloon_class_init(ObjectClass
*klass
, void *data
)
1429 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1430 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_CLASS(klass
);
1432 k
->realize
= virtio_ccw_balloon_realize
;
1433 k
->unrealize
= virtio_ccw_unrealize
;
1434 dc
->props
= virtio_ccw_balloon_properties
;
1435 set_bit(DEVICE_CATEGORY_MISC
, dc
->categories
);
1438 static const TypeInfo virtio_ccw_balloon
= {
1439 .name
= TYPE_VIRTIO_BALLOON_CCW
,
1440 .parent
= TYPE_VIRTIO_CCW_DEVICE
,
1441 .instance_size
= sizeof(VirtIOBalloonCcw
),
1442 .instance_init
= virtio_ccw_balloon_instance_init
,
1443 .class_init
= virtio_ccw_balloon_class_init
,
1446 static Property virtio_ccw_scsi_properties
[] = {
1447 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice
, flags
,
1448 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT
, true),
1449 DEFINE_PROP_UINT32("max_revision", VirtioCcwDevice
, max_rev
,
1450 VIRTIO_CCW_MAX_REV
),
1451 DEFINE_PROP_END_OF_LIST(),
1454 static void virtio_ccw_scsi_class_init(ObjectClass
*klass
, void *data
)
1456 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1457 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_CLASS(klass
);
1459 k
->realize
= virtio_ccw_scsi_realize
;
1460 k
->unrealize
= virtio_ccw_unrealize
;
1461 dc
->props
= virtio_ccw_scsi_properties
;
1462 set_bit(DEVICE_CATEGORY_STORAGE
, dc
->categories
);
1465 static const TypeInfo virtio_ccw_scsi
= {
1466 .name
= TYPE_VIRTIO_SCSI_CCW
,
1467 .parent
= TYPE_VIRTIO_CCW_DEVICE
,
1468 .instance_size
= sizeof(VirtIOSCSICcw
),
1469 .instance_init
= virtio_ccw_scsi_instance_init
,
1470 .class_init
= virtio_ccw_scsi_class_init
,
1473 #ifdef CONFIG_VHOST_SCSI
1474 static Property vhost_ccw_scsi_properties
[] = {
1475 DEFINE_PROP_UINT32("max_revision", VirtioCcwDevice
, max_rev
,
1476 VIRTIO_CCW_MAX_REV
),
1477 DEFINE_PROP_END_OF_LIST(),
1480 static void vhost_ccw_scsi_class_init(ObjectClass
*klass
, void *data
)
1482 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1483 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_CLASS(klass
);
1485 k
->realize
= vhost_ccw_scsi_realize
;
1486 k
->unrealize
= virtio_ccw_unrealize
;
1487 dc
->props
= vhost_ccw_scsi_properties
;
1488 set_bit(DEVICE_CATEGORY_STORAGE
, dc
->categories
);
1491 static const TypeInfo vhost_ccw_scsi
= {
1492 .name
= TYPE_VHOST_SCSI_CCW
,
1493 .parent
= TYPE_VIRTIO_CCW_DEVICE
,
1494 .instance_size
= sizeof(VHostSCSICcw
),
1495 .instance_init
= vhost_ccw_scsi_instance_init
,
1496 .class_init
= vhost_ccw_scsi_class_init
,
1500 static void virtio_ccw_rng_instance_init(Object
*obj
)
1502 VirtIORNGCcw
*dev
= VIRTIO_RNG_CCW(obj
);
1504 virtio_instance_init_common(obj
, &dev
->vdev
, sizeof(dev
->vdev
),
1508 static Property virtio_ccw_rng_properties
[] = {
1509 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice
, flags
,
1510 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT
, true),
1511 DEFINE_PROP_UINT32("max_revision", VirtioCcwDevice
, max_rev
,
1512 VIRTIO_CCW_MAX_REV
),
1513 DEFINE_PROP_END_OF_LIST(),
1516 static void virtio_ccw_rng_class_init(ObjectClass
*klass
, void *data
)
1518 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1519 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_CLASS(klass
);
1521 k
->realize
= virtio_ccw_rng_realize
;
1522 k
->unrealize
= virtio_ccw_unrealize
;
1523 dc
->props
= virtio_ccw_rng_properties
;
1524 set_bit(DEVICE_CATEGORY_MISC
, dc
->categories
);
1527 static const TypeInfo virtio_ccw_rng
= {
1528 .name
= TYPE_VIRTIO_RNG_CCW
,
1529 .parent
= TYPE_VIRTIO_CCW_DEVICE
,
1530 .instance_size
= sizeof(VirtIORNGCcw
),
1531 .instance_init
= virtio_ccw_rng_instance_init
,
1532 .class_init
= virtio_ccw_rng_class_init
,
1535 static Property virtio_ccw_crypto_properties
[] = {
1536 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice
, flags
,
1537 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT
, true),
1538 DEFINE_PROP_UINT32("max_revision", VirtioCcwDevice
, max_rev
,
1539 VIRTIO_CCW_MAX_REV
),
1540 DEFINE_PROP_END_OF_LIST(),
1543 static void virtio_ccw_crypto_instance_init(Object
*obj
)
1545 VirtIOCryptoCcw
*dev
= VIRTIO_CRYPTO_CCW(obj
);
1546 VirtioCcwDevice
*ccw_dev
= VIRTIO_CCW_DEVICE(obj
);
1548 ccw_dev
->force_revision_1
= true;
1549 virtio_instance_init_common(obj
, &dev
->vdev
, sizeof(dev
->vdev
),
1550 TYPE_VIRTIO_CRYPTO
);
1553 static void virtio_ccw_crypto_class_init(ObjectClass
*klass
, void *data
)
1555 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1556 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_CLASS(klass
);
1558 k
->realize
= virtio_ccw_crypto_realize
;
1559 k
->unrealize
= virtio_ccw_unrealize
;
1560 dc
->props
= virtio_ccw_crypto_properties
;
1561 set_bit(DEVICE_CATEGORY_MISC
, dc
->categories
);
1564 static const TypeInfo virtio_ccw_crypto
= {
1565 .name
= TYPE_VIRTIO_CRYPTO_CCW
,
1566 .parent
= TYPE_VIRTIO_CCW_DEVICE
,
1567 .instance_size
= sizeof(VirtIOCryptoCcw
),
1568 .instance_init
= virtio_ccw_crypto_instance_init
,
1569 .class_init
= virtio_ccw_crypto_class_init
,
1572 static Property virtio_ccw_gpu_properties
[] = {
1573 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice
, flags
,
1574 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT
, true),
1575 DEFINE_PROP_UINT32("max_revision", VirtioCcwDevice
, max_rev
,
1576 VIRTIO_CCW_MAX_REV
),
1577 DEFINE_PROP_END_OF_LIST(),
1580 static void virtio_ccw_gpu_instance_init(Object
*obj
)
1582 VirtIOGPUCcw
*dev
= VIRTIO_GPU_CCW(obj
);
1583 VirtioCcwDevice
*ccw_dev
= VIRTIO_CCW_DEVICE(obj
);
1585 ccw_dev
->force_revision_1
= true;
1586 virtio_instance_init_common(obj
, &dev
->vdev
, sizeof(dev
->vdev
),
1590 static void virtio_ccw_gpu_class_init(ObjectClass
*klass
, void *data
)
1592 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1593 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_CLASS(klass
);
1595 k
->realize
= virtio_ccw_gpu_realize
;
1596 k
->unrealize
= virtio_ccw_unrealize
;
1597 dc
->props
= virtio_ccw_gpu_properties
;
1598 dc
->hotpluggable
= false;
1599 set_bit(DEVICE_CATEGORY_DISPLAY
, dc
->categories
);
1602 static const TypeInfo virtio_ccw_gpu
= {
1603 .name
= TYPE_VIRTIO_GPU_CCW
,
1604 .parent
= TYPE_VIRTIO_CCW_DEVICE
,
1605 .instance_size
= sizeof(VirtIOGPUCcw
),
1606 .instance_init
= virtio_ccw_gpu_instance_init
,
1607 .class_init
= virtio_ccw_gpu_class_init
,
1610 static Property virtio_ccw_input_properties
[] = {
1611 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice
, flags
,
1612 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT
, true),
1613 DEFINE_PROP_UINT32("max_revision", VirtioCcwDevice
, max_rev
,
1614 VIRTIO_CCW_MAX_REV
),
1615 DEFINE_PROP_END_OF_LIST(),
1618 static void virtio_ccw_input_class_init(ObjectClass
*klass
, void *data
)
1620 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1621 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_CLASS(klass
);
1623 k
->realize
= virtio_ccw_input_realize
;
1624 k
->unrealize
= virtio_ccw_unrealize
;
1625 dc
->props
= virtio_ccw_input_properties
;
1626 set_bit(DEVICE_CATEGORY_INPUT
, dc
->categories
);
1629 static void virtio_ccw_keyboard_instance_init(Object
*obj
)
1631 VirtIOInputHIDCcw
*dev
= VIRTIO_INPUT_HID_CCW(obj
);
1632 VirtioCcwDevice
*ccw_dev
= VIRTIO_CCW_DEVICE(obj
);
1634 ccw_dev
->force_revision_1
= true;
1635 virtio_instance_init_common(obj
, &dev
->vdev
, sizeof(dev
->vdev
),
1636 TYPE_VIRTIO_KEYBOARD
);
1639 static void virtio_ccw_mouse_instance_init(Object
*obj
)
1641 VirtIOInputHIDCcw
*dev
= VIRTIO_INPUT_HID_CCW(obj
);
1642 VirtioCcwDevice
*ccw_dev
= VIRTIO_CCW_DEVICE(obj
);
1644 ccw_dev
->force_revision_1
= true;
1645 virtio_instance_init_common(obj
, &dev
->vdev
, sizeof(dev
->vdev
),
1649 static void virtio_ccw_tablet_instance_init(Object
*obj
)
1651 VirtIOInputHIDCcw
*dev
= VIRTIO_INPUT_HID_CCW(obj
);
1652 VirtioCcwDevice
*ccw_dev
= VIRTIO_CCW_DEVICE(obj
);
1654 ccw_dev
->force_revision_1
= true;
1655 virtio_instance_init_common(obj
, &dev
->vdev
, sizeof(dev
->vdev
),
1656 TYPE_VIRTIO_TABLET
);
1659 static const TypeInfo virtio_ccw_input
= {
1660 .name
= TYPE_VIRTIO_INPUT_CCW
,
1661 .parent
= TYPE_VIRTIO_CCW_DEVICE
,
1662 .instance_size
= sizeof(VirtIOInputCcw
),
1663 .class_init
= virtio_ccw_input_class_init
,
1667 static const TypeInfo virtio_ccw_input_hid
= {
1668 .name
= TYPE_VIRTIO_INPUT_HID_CCW
,
1669 .parent
= TYPE_VIRTIO_INPUT_CCW
,
1670 .instance_size
= sizeof(VirtIOInputHIDCcw
),
1674 static const TypeInfo virtio_ccw_keyboard
= {
1675 .name
= TYPE_VIRTIO_KEYBOARD_CCW
,
1676 .parent
= TYPE_VIRTIO_INPUT_HID_CCW
,
1677 .instance_size
= sizeof(VirtIOInputHIDCcw
),
1678 .instance_init
= virtio_ccw_keyboard_instance_init
,
1681 static const TypeInfo virtio_ccw_mouse
= {
1682 .name
= TYPE_VIRTIO_MOUSE_CCW
,
1683 .parent
= TYPE_VIRTIO_INPUT_HID_CCW
,
1684 .instance_size
= sizeof(VirtIOInputHIDCcw
),
1685 .instance_init
= virtio_ccw_mouse_instance_init
,
1688 static const TypeInfo virtio_ccw_tablet
= {
1689 .name
= TYPE_VIRTIO_TABLET_CCW
,
1690 .parent
= TYPE_VIRTIO_INPUT_HID_CCW
,
1691 .instance_size
= sizeof(VirtIOInputHIDCcw
),
1692 .instance_init
= virtio_ccw_tablet_instance_init
,
1695 static void virtio_ccw_busdev_realize(DeviceState
*dev
, Error
**errp
)
1697 VirtioCcwDevice
*_dev
= (VirtioCcwDevice
*)dev
;
1699 virtio_ccw_bus_new(&_dev
->bus
, sizeof(_dev
->bus
), _dev
);
1700 virtio_ccw_device_realize(_dev
, errp
);
1703 static void virtio_ccw_busdev_unrealize(DeviceState
*dev
, Error
**errp
)
1705 VirtioCcwDevice
*_dev
= (VirtioCcwDevice
*)dev
;
1706 VirtIOCCWDeviceClass
*_info
= VIRTIO_CCW_DEVICE_GET_CLASS(dev
);
1708 _info
->unrealize(_dev
, errp
);
1711 static void virtio_ccw_busdev_unplug(HotplugHandler
*hotplug_dev
,
1712 DeviceState
*dev
, Error
**errp
)
1714 VirtioCcwDevice
*_dev
= to_virtio_ccw_dev_fast(dev
);
1716 virtio_ccw_stop_ioeventfd(_dev
);
1719 static void virtio_ccw_device_class_init(ObjectClass
*klass
, void *data
)
1721 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1722 CCWDeviceClass
*k
= CCW_DEVICE_CLASS(dc
);
1723 VirtIOCCWDeviceClass
*vdc
= VIRTIO_CCW_DEVICE_CLASS(klass
);
1725 k
->unplug
= virtio_ccw_busdev_unplug
;
1726 dc
->realize
= virtio_ccw_busdev_realize
;
1727 dc
->unrealize
= virtio_ccw_busdev_unrealize
;
1728 dc
->bus_type
= TYPE_VIRTUAL_CSS_BUS
;
1729 device_class_set_parent_reset(dc
, virtio_ccw_reset
, &vdc
->parent_reset
);
1732 static const TypeInfo virtio_ccw_device_info
= {
1733 .name
= TYPE_VIRTIO_CCW_DEVICE
,
1734 .parent
= TYPE_CCW_DEVICE
,
1735 .instance_size
= sizeof(VirtioCcwDevice
),
1736 .class_init
= virtio_ccw_device_class_init
,
1737 .class_size
= sizeof(VirtIOCCWDeviceClass
),
1741 /* virtio-ccw-bus */
1743 static void virtio_ccw_bus_new(VirtioBusState
*bus
, size_t bus_size
,
1744 VirtioCcwDevice
*dev
)
1746 DeviceState
*qdev
= DEVICE(dev
);
1747 char virtio_bus_name
[] = "virtio-bus";
1749 qbus_create_inplace(bus
, bus_size
, TYPE_VIRTIO_CCW_BUS
,
1750 qdev
, virtio_bus_name
);
1753 static void virtio_ccw_bus_class_init(ObjectClass
*klass
, void *data
)
1755 VirtioBusClass
*k
= VIRTIO_BUS_CLASS(klass
);
1756 BusClass
*bus_class
= BUS_CLASS(klass
);
1758 bus_class
->max_dev
= 1;
1759 k
->notify
= virtio_ccw_notify
;
1760 k
->vmstate_change
= virtio_ccw_vmstate_change
;
1761 k
->query_guest_notifiers
= virtio_ccw_query_guest_notifiers
;
1762 k
->set_guest_notifiers
= virtio_ccw_set_guest_notifiers
;
1763 k
->save_queue
= virtio_ccw_save_queue
;
1764 k
->load_queue
= virtio_ccw_load_queue
;
1765 k
->save_config
= virtio_ccw_save_config
;
1766 k
->load_config
= virtio_ccw_load_config
;
1767 k
->pre_plugged
= virtio_ccw_pre_plugged
;
1768 k
->device_plugged
= virtio_ccw_device_plugged
;
1769 k
->device_unplugged
= virtio_ccw_device_unplugged
;
1770 k
->ioeventfd_enabled
= virtio_ccw_ioeventfd_enabled
;
1771 k
->ioeventfd_assign
= virtio_ccw_ioeventfd_assign
;
1774 static const TypeInfo virtio_ccw_bus_info
= {
1775 .name
= TYPE_VIRTIO_CCW_BUS
,
1776 .parent
= TYPE_VIRTIO_BUS
,
1777 .instance_size
= sizeof(VirtioCcwBusState
),
1778 .class_init
= virtio_ccw_bus_class_init
,
1781 #ifdef CONFIG_VIRTFS
1782 static Property virtio_ccw_9p_properties
[] = {
1783 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice
, flags
,
1784 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT
, true),
1785 DEFINE_PROP_UINT32("max_revision", VirtioCcwDevice
, max_rev
,
1786 VIRTIO_CCW_MAX_REV
),
1787 DEFINE_PROP_END_OF_LIST(),
1790 static void virtio_ccw_9p_realize(VirtioCcwDevice
*ccw_dev
, Error
**errp
)
1792 V9fsCCWState
*dev
= VIRTIO_9P_CCW(ccw_dev
);
1793 DeviceState
*vdev
= DEVICE(&dev
->vdev
);
1795 qdev_set_parent_bus(vdev
, BUS(&ccw_dev
->bus
));
1796 object_property_set_bool(OBJECT(vdev
), true, "realized", errp
);
1799 static void virtio_ccw_9p_class_init(ObjectClass
*klass
, void *data
)
1801 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1802 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_CLASS(klass
);
1804 k
->unrealize
= virtio_ccw_unrealize
;
1805 k
->realize
= virtio_ccw_9p_realize
;
1806 dc
->props
= virtio_ccw_9p_properties
;
1807 set_bit(DEVICE_CATEGORY_STORAGE
, dc
->categories
);
1810 static void virtio_ccw_9p_instance_init(Object
*obj
)
1812 V9fsCCWState
*dev
= VIRTIO_9P_CCW(obj
);
1814 virtio_instance_init_common(obj
, &dev
->vdev
, sizeof(dev
->vdev
),
1818 static const TypeInfo virtio_ccw_9p_info
= {
1819 .name
= TYPE_VIRTIO_9P_CCW
,
1820 .parent
= TYPE_VIRTIO_CCW_DEVICE
,
1821 .instance_size
= sizeof(V9fsCCWState
),
1822 .instance_init
= virtio_ccw_9p_instance_init
,
1823 .class_init
= virtio_ccw_9p_class_init
,
1827 #ifdef CONFIG_VHOST_VSOCK
1829 static Property vhost_vsock_ccw_properties
[] = {
1830 DEFINE_PROP_UINT32("max_revision", VirtioCcwDevice
, max_rev
,
1831 VIRTIO_CCW_MAX_REV
),
1832 DEFINE_PROP_END_OF_LIST(),
1835 static void vhost_vsock_ccw_realize(VirtioCcwDevice
*ccw_dev
, Error
**errp
)
1837 VHostVSockCCWState
*dev
= VHOST_VSOCK_CCW(ccw_dev
);
1838 DeviceState
*vdev
= DEVICE(&dev
->vdev
);
1840 qdev_set_parent_bus(vdev
, BUS(&ccw_dev
->bus
));
1841 object_property_set_bool(OBJECT(vdev
), true, "realized", errp
);
1844 static void vhost_vsock_ccw_class_init(ObjectClass
*klass
, void *data
)
1846 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1847 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_CLASS(klass
);
1849 k
->realize
= vhost_vsock_ccw_realize
;
1850 k
->unrealize
= virtio_ccw_unrealize
;
1851 set_bit(DEVICE_CATEGORY_MISC
, dc
->categories
);
1852 dc
->props
= vhost_vsock_ccw_properties
;
1855 static void vhost_vsock_ccw_instance_init(Object
*obj
)
1857 VHostVSockCCWState
*dev
= VHOST_VSOCK_CCW(obj
);
1859 virtio_instance_init_common(obj
, &dev
->vdev
, sizeof(dev
->vdev
),
1863 static const TypeInfo vhost_vsock_ccw_info
= {
1864 .name
= TYPE_VHOST_VSOCK_CCW
,
1865 .parent
= TYPE_VIRTIO_CCW_DEVICE
,
1866 .instance_size
= sizeof(VHostVSockCCWState
),
1867 .instance_init
= vhost_vsock_ccw_instance_init
,
1868 .class_init
= vhost_vsock_ccw_class_init
,
1872 static void virtio_ccw_register(void)
1874 type_register_static(&virtio_ccw_bus_info
);
1875 type_register_static(&virtio_ccw_device_info
);
1876 type_register_static(&virtio_ccw_serial
);
1877 type_register_static(&virtio_ccw_blk
);
1878 type_register_static(&virtio_ccw_net
);
1879 type_register_static(&virtio_ccw_balloon
);
1880 type_register_static(&virtio_ccw_scsi
);
1881 #ifdef CONFIG_VHOST_SCSI
1882 type_register_static(&vhost_ccw_scsi
);
1884 type_register_static(&virtio_ccw_rng
);
1885 #ifdef CONFIG_VIRTFS
1886 type_register_static(&virtio_ccw_9p_info
);
1888 #ifdef CONFIG_VHOST_VSOCK
1889 type_register_static(&vhost_vsock_ccw_info
);
1891 type_register_static(&virtio_ccw_crypto
);
1892 type_register_static(&virtio_ccw_gpu
);
1893 type_register_static(&virtio_ccw_input
);
1894 type_register_static(&virtio_ccw_input_hid
);
1895 type_register_static(&virtio_ccw_keyboard
);
1896 type_register_static(&virtio_ccw_mouse
);
1897 type_register_static(&virtio_ccw_tablet
);
1900 type_init(virtio_ccw_register
)