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/block-backend.h"
17 #include "sysemu/blockdev.h"
18 #include "sysemu/sysemu.h"
19 #include "sysemu/kvm.h"
21 #include "hw/virtio/virtio.h"
22 #include "hw/virtio/virtio-serial.h"
23 #include "hw/virtio/virtio-net.h"
24 #include "hw/sysbus.h"
25 #include "qemu/bitops.h"
26 #include "qemu/error-report.h"
27 #include "hw/virtio/virtio-access.h"
28 #include "hw/virtio/virtio-bus.h"
29 #include "hw/s390x/adapter.h"
30 #include "hw/s390x/s390_flic.h"
32 #include "hw/s390x/ioinst.h"
33 #include "hw/s390x/css.h"
34 #include "virtio-ccw.h"
36 #include "hw/s390x/css-bridge.h"
38 static void virtio_ccw_bus_new(VirtioBusState
*bus
, size_t bus_size
,
39 VirtioCcwDevice
*dev
);
41 VirtIODevice
*virtio_ccw_get_vdev(SubchDev
*sch
)
43 VirtIODevice
*vdev
= NULL
;
44 VirtioCcwDevice
*dev
= sch
->driver_data
;
47 vdev
= virtio_bus_get_device(&dev
->bus
);
52 static void virtio_ccw_start_ioeventfd(VirtioCcwDevice
*dev
)
54 virtio_bus_start_ioeventfd(&dev
->bus
);
57 static void virtio_ccw_stop_ioeventfd(VirtioCcwDevice
*dev
)
59 virtio_bus_stop_ioeventfd(&dev
->bus
);
62 static bool virtio_ccw_ioeventfd_enabled(DeviceState
*d
)
64 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
66 return (dev
->flags
& VIRTIO_CCW_FLAG_USE_IOEVENTFD
) != 0;
69 static int virtio_ccw_ioeventfd_assign(DeviceState
*d
, EventNotifier
*notifier
,
72 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
73 CcwDevice
*ccw_dev
= CCW_DEVICE(dev
);
74 SubchDev
*sch
= ccw_dev
->sch
;
75 uint32_t sch_id
= (css_build_subchannel_id(sch
) << 16) | sch
->schid
;
77 return s390_assign_subch_ioeventfd(notifier
, sch_id
, n
, assign
);
80 /* Communication blocks used by several channel commands. */
81 typedef struct VqInfoBlockLegacy
{
86 } QEMU_PACKED VqInfoBlockLegacy
;
88 typedef struct VqInfoBlock
{
95 } QEMU_PACKED VqInfoBlock
;
97 typedef struct VqConfigBlock
{
100 } QEMU_PACKED VqConfigBlock
;
102 typedef struct VirtioFeatDesc
{
105 } QEMU_PACKED VirtioFeatDesc
;
107 typedef struct VirtioThinintInfo
{
108 hwaddr summary_indicator
;
109 hwaddr device_indicator
;
112 } QEMU_PACKED VirtioThinintInfo
;
114 typedef struct VirtioRevInfo
{
118 } QEMU_PACKED VirtioRevInfo
;
120 /* Specify where the virtqueues for the subchannel are in guest memory. */
121 static int virtio_ccw_set_vqs(SubchDev
*sch
, VqInfoBlock
*info
,
122 VqInfoBlockLegacy
*linfo
)
124 VirtIODevice
*vdev
= virtio_ccw_get_vdev(sch
);
125 uint16_t index
= info
? info
->index
: linfo
->index
;
126 uint16_t num
= info
? info
->num
: linfo
->num
;
127 uint64_t desc
= info
? info
->desc
: linfo
->queue
;
129 if (index
>= VIRTIO_CCW_QUEUE_MAX
) {
133 /* Current code in virtio.c relies on 4K alignment. */
134 if (linfo
&& desc
&& (linfo
->align
!= 4096)) {
143 virtio_queue_set_rings(vdev
, index
, desc
, info
->avail
, info
->used
);
145 virtio_queue_set_addr(vdev
, index
, desc
);
148 virtio_queue_set_vector(vdev
, index
, VIRTIO_NO_VECTOR
);
151 /* virtio-1 allows changing the ring size. */
152 if (virtio_queue_get_max_num(vdev
, index
) < num
) {
153 /* Fail if we exceed the maximum number. */
156 virtio_queue_set_num(vdev
, index
, num
);
157 } else if (virtio_queue_get_num(vdev
, index
) > num
) {
158 /* Fail if we don't have a big enough queue. */
161 /* We ignore possible increased num for legacy for compatibility. */
162 virtio_queue_set_vector(vdev
, index
, index
);
164 /* tell notify handler in case of config change */
165 vdev
->config_vector
= VIRTIO_CCW_QUEUE_MAX
;
169 static void virtio_ccw_reset_virtio(VirtioCcwDevice
*dev
, VirtIODevice
*vdev
)
171 CcwDevice
*ccw_dev
= CCW_DEVICE(dev
);
173 virtio_ccw_stop_ioeventfd(dev
);
175 if (dev
->indicators
) {
176 release_indicator(&dev
->routes
.adapter
, dev
->indicators
);
177 dev
->indicators
= NULL
;
179 if (dev
->indicators2
) {
180 release_indicator(&dev
->routes
.adapter
, dev
->indicators2
);
181 dev
->indicators2
= NULL
;
183 if (dev
->summary_indicator
) {
184 release_indicator(&dev
->routes
.adapter
, dev
->summary_indicator
);
185 dev
->summary_indicator
= NULL
;
187 ccw_dev
->sch
->thinint_active
= false;
190 static int virtio_ccw_handle_set_vq(SubchDev
*sch
, CCW1 ccw
, bool check_len
,
195 VqInfoBlockLegacy linfo
;
196 size_t info_len
= is_legacy
? sizeof(linfo
) : sizeof(info
);
199 if (ccw
.count
!= info_len
) {
202 } else if (ccw
.count
< info_len
) {
203 /* Can't execute command. */
210 linfo
.queue
= address_space_ldq_be(&address_space_memory
, ccw
.cda
,
211 MEMTXATTRS_UNSPECIFIED
, NULL
);
212 linfo
.align
= address_space_ldl_be(&address_space_memory
,
213 ccw
.cda
+ sizeof(linfo
.queue
),
214 MEMTXATTRS_UNSPECIFIED
,
216 linfo
.index
= address_space_lduw_be(&address_space_memory
,
217 ccw
.cda
+ sizeof(linfo
.queue
)
218 + sizeof(linfo
.align
),
219 MEMTXATTRS_UNSPECIFIED
,
221 linfo
.num
= address_space_lduw_be(&address_space_memory
,
222 ccw
.cda
+ sizeof(linfo
.queue
)
223 + sizeof(linfo
.align
)
224 + sizeof(linfo
.index
),
225 MEMTXATTRS_UNSPECIFIED
,
227 ret
= virtio_ccw_set_vqs(sch
, NULL
, &linfo
);
229 info
.desc
= address_space_ldq_be(&address_space_memory
, ccw
.cda
,
230 MEMTXATTRS_UNSPECIFIED
, NULL
);
231 info
.index
= address_space_lduw_be(&address_space_memory
,
232 ccw
.cda
+ sizeof(info
.desc
)
234 MEMTXATTRS_UNSPECIFIED
, NULL
);
235 info
.num
= address_space_lduw_be(&address_space_memory
,
236 ccw
.cda
+ sizeof(info
.desc
)
238 + sizeof(info
.index
),
239 MEMTXATTRS_UNSPECIFIED
, NULL
);
240 info
.avail
= address_space_ldq_be(&address_space_memory
,
241 ccw
.cda
+ sizeof(info
.desc
)
245 MEMTXATTRS_UNSPECIFIED
, NULL
);
246 info
.used
= address_space_ldq_be(&address_space_memory
,
247 ccw
.cda
+ sizeof(info
.desc
)
251 + sizeof(info
.avail
),
252 MEMTXATTRS_UNSPECIFIED
, NULL
);
253 ret
= virtio_ccw_set_vqs(sch
, &info
, NULL
);
255 sch
->curr_status
.scsw
.count
= 0;
259 static int virtio_ccw_cb(SubchDev
*sch
, CCW1 ccw
)
262 VirtioRevInfo revinfo
;
264 VirtioFeatDesc features
;
267 VqConfigBlock vq_config
;
268 VirtioCcwDevice
*dev
= sch
->driver_data
;
269 VirtIODevice
*vdev
= virtio_ccw_get_vdev(sch
);
273 VirtioThinintInfo
*thinint
;
279 trace_virtio_ccw_interpret_ccw(sch
->cssid
, sch
->ssid
, sch
->schid
,
281 check_len
= !((ccw
.flags
& CCW_FLAG_SLI
) && !(ccw
.flags
& CCW_FLAG_DC
));
283 if (dev
->force_revision_1
&& dev
->revision
< 0 &&
284 ccw
.cmd_code
!= CCW_CMD_SET_VIRTIO_REV
) {
286 * virtio-1 drivers must start with negotiating to a revision >= 1,
287 * so post a command reject for all other commands
292 /* Look at the command. */
293 switch (ccw
.cmd_code
) {
295 ret
= virtio_ccw_handle_set_vq(sch
, ccw
, check_len
, dev
->revision
< 1);
297 case CCW_CMD_VDEV_RESET
:
298 virtio_ccw_reset_virtio(dev
, vdev
);
301 case CCW_CMD_READ_FEAT
:
303 if (ccw
.count
!= sizeof(features
)) {
307 } else if (ccw
.count
< sizeof(features
)) {
308 /* Can't execute command. */
315 VirtioDeviceClass
*vdc
= VIRTIO_DEVICE_GET_CLASS(vdev
);
317 features
.index
= address_space_ldub(&address_space_memory
,
319 + sizeof(features
.features
),
320 MEMTXATTRS_UNSPECIFIED
,
322 if (features
.index
== 0) {
323 if (dev
->revision
>= 1) {
324 /* Don't offer legacy features for modern devices. */
325 features
.features
= (uint32_t)
326 (vdev
->host_features
& ~vdc
->legacy_features
);
328 features
.features
= (uint32_t)vdev
->host_features
;
330 } else if ((features
.index
== 1) && (dev
->revision
>= 1)) {
332 * Only offer feature bits beyond 31 if the guest has
333 * negotiated at least revision 1.
335 features
.features
= (uint32_t)(vdev
->host_features
>> 32);
337 /* Return zeroes if the guest supports more feature bits. */
338 features
.features
= 0;
340 address_space_stl_le(&address_space_memory
, ccw
.cda
,
341 features
.features
, MEMTXATTRS_UNSPECIFIED
,
343 sch
->curr_status
.scsw
.count
= ccw
.count
- sizeof(features
);
347 case CCW_CMD_WRITE_FEAT
:
349 if (ccw
.count
!= sizeof(features
)) {
353 } else if (ccw
.count
< sizeof(features
)) {
354 /* Can't execute command. */
361 features
.index
= address_space_ldub(&address_space_memory
,
363 + sizeof(features
.features
),
364 MEMTXATTRS_UNSPECIFIED
,
366 features
.features
= address_space_ldl_le(&address_space_memory
,
368 MEMTXATTRS_UNSPECIFIED
,
370 if (features
.index
== 0) {
371 virtio_set_features(vdev
,
372 (vdev
->guest_features
& 0xffffffff00000000ULL
) |
374 } else if ((features
.index
== 1) && (dev
->revision
>= 1)) {
376 * If the guest did not negotiate at least revision 1,
377 * we did not offer it any feature bits beyond 31. Such a
378 * guest passing us any bit here is therefore buggy.
380 virtio_set_features(vdev
,
381 (vdev
->guest_features
& 0x00000000ffffffffULL
) |
382 ((uint64_t)features
.features
<< 32));
385 * If the guest supports more feature bits, assert that it
386 * passes us zeroes for those we don't support.
388 if (features
.features
) {
389 fprintf(stderr
, "Guest bug: features[%i]=%x (expected 0)\n",
390 features
.index
, features
.features
);
391 /* XXX: do a unit check here? */
394 sch
->curr_status
.scsw
.count
= ccw
.count
- sizeof(features
);
398 case CCW_CMD_READ_CONF
:
400 if (ccw
.count
> vdev
->config_len
) {
405 len
= MIN(ccw
.count
, vdev
->config_len
);
409 virtio_bus_get_vdev_config(&dev
->bus
, vdev
->config
);
410 /* XXX config space endianness */
411 cpu_physical_memory_write(ccw
.cda
, vdev
->config
, len
);
412 sch
->curr_status
.scsw
.count
= ccw
.count
- len
;
416 case CCW_CMD_WRITE_CONF
:
418 if (ccw
.count
> vdev
->config_len
) {
423 len
= MIN(ccw
.count
, vdev
->config_len
);
428 config
= cpu_physical_memory_map(ccw
.cda
, &hw_len
, 0);
433 /* XXX config space endianness */
434 memcpy(vdev
->config
, config
, len
);
435 cpu_physical_memory_unmap(config
, hw_len
, 0, hw_len
);
436 virtio_bus_set_vdev_config(&dev
->bus
, vdev
->config
);
437 sch
->curr_status
.scsw
.count
= ccw
.count
- len
;
442 case CCW_CMD_READ_STATUS
:
444 if (ccw
.count
!= sizeof(status
)) {
448 } else if (ccw
.count
< sizeof(status
)) {
449 /* Can't execute command. */
456 address_space_stb(&address_space_memory
, ccw
.cda
, vdev
->status
,
457 MEMTXATTRS_UNSPECIFIED
, NULL
);
458 sch
->curr_status
.scsw
.count
= ccw
.count
- sizeof(vdev
->status
);;
462 case CCW_CMD_WRITE_STATUS
:
464 if (ccw
.count
!= sizeof(status
)) {
468 } else if (ccw
.count
< sizeof(status
)) {
469 /* Can't execute command. */
476 status
= address_space_ldub(&address_space_memory
, ccw
.cda
,
477 MEMTXATTRS_UNSPECIFIED
, NULL
);
478 if (!(status
& VIRTIO_CONFIG_S_DRIVER_OK
)) {
479 virtio_ccw_stop_ioeventfd(dev
);
481 if (virtio_set_status(vdev
, status
) == 0) {
482 if (vdev
->status
== 0) {
483 virtio_ccw_reset_virtio(dev
, vdev
);
485 if (status
& VIRTIO_CONFIG_S_DRIVER_OK
) {
486 virtio_ccw_start_ioeventfd(dev
);
488 sch
->curr_status
.scsw
.count
= ccw
.count
- sizeof(status
);
491 /* Trigger a command reject. */
496 case CCW_CMD_SET_IND
:
498 if (ccw
.count
!= sizeof(indicators
)) {
502 } else if (ccw
.count
< sizeof(indicators
)) {
503 /* Can't execute command. */
507 if (sch
->thinint_active
) {
508 /* Trigger a command reject. */
515 indicators
= address_space_ldq_be(&address_space_memory
, ccw
.cda
,
516 MEMTXATTRS_UNSPECIFIED
, NULL
);
517 dev
->indicators
= get_indicator(indicators
, sizeof(uint64_t));
518 sch
->curr_status
.scsw
.count
= ccw
.count
- sizeof(indicators
);
522 case CCW_CMD_SET_CONF_IND
:
524 if (ccw
.count
!= sizeof(indicators
)) {
528 } else if (ccw
.count
< sizeof(indicators
)) {
529 /* Can't execute command. */
536 indicators
= address_space_ldq_be(&address_space_memory
, ccw
.cda
,
537 MEMTXATTRS_UNSPECIFIED
, NULL
);
538 dev
->indicators2
= get_indicator(indicators
, sizeof(uint64_t));
539 sch
->curr_status
.scsw
.count
= ccw
.count
- sizeof(indicators
);
543 case CCW_CMD_READ_VQ_CONF
:
545 if (ccw
.count
!= sizeof(vq_config
)) {
549 } else if (ccw
.count
< sizeof(vq_config
)) {
550 /* Can't execute command. */
557 vq_config
.index
= address_space_lduw_be(&address_space_memory
,
559 MEMTXATTRS_UNSPECIFIED
,
561 if (vq_config
.index
>= VIRTIO_CCW_QUEUE_MAX
) {
565 vq_config
.num_max
= virtio_queue_get_num(vdev
,
567 address_space_stw_be(&address_space_memory
,
568 ccw
.cda
+ sizeof(vq_config
.index
),
570 MEMTXATTRS_UNSPECIFIED
,
572 sch
->curr_status
.scsw
.count
= ccw
.count
- sizeof(vq_config
);
576 case CCW_CMD_SET_IND_ADAPTER
:
578 if (ccw
.count
!= sizeof(*thinint
)) {
582 } else if (ccw
.count
< sizeof(*thinint
)) {
583 /* Can't execute command. */
587 len
= sizeof(*thinint
);
591 } else if (dev
->indicators
&& !sch
->thinint_active
) {
592 /* Trigger a command reject. */
595 thinint
= cpu_physical_memory_map(ccw
.cda
, &hw_len
, 0);
599 uint64_t ind_bit
= ldq_be_p(&thinint
->ind_bit
);
602 dev
->summary_indicator
=
603 get_indicator(ldq_be_p(&thinint
->summary_indicator
),
606 get_indicator(ldq_be_p(&thinint
->device_indicator
),
608 dev
->thinint_isc
= thinint
->isc
;
609 dev
->routes
.adapter
.ind_offset
= ind_bit
;
610 dev
->routes
.adapter
.summary_offset
= 7;
611 cpu_physical_memory_unmap(thinint
, hw_len
, 0, hw_len
);
612 ret
= css_register_io_adapter(CSS_IO_ADAPTER_VIRTIO
,
613 dev
->thinint_isc
, true, false,
614 &dev
->routes
.adapter
.adapter_id
);
616 sch
->thinint_active
= ((dev
->indicators
!= NULL
) &&
617 (dev
->summary_indicator
!= NULL
));
618 sch
->curr_status
.scsw
.count
= ccw
.count
- len
;
623 case CCW_CMD_SET_VIRTIO_REV
:
624 len
= sizeof(revinfo
);
625 if (ccw
.count
< len
) {
634 address_space_lduw_be(&address_space_memory
, ccw
.cda
,
635 MEMTXATTRS_UNSPECIFIED
, NULL
);
637 address_space_lduw_be(&address_space_memory
,
638 ccw
.cda
+ sizeof(revinfo
.revision
),
639 MEMTXATTRS_UNSPECIFIED
, NULL
);
640 if (ccw
.count
< len
+ revinfo
.length
||
641 (check_len
&& ccw
.count
> len
+ revinfo
.length
)) {
646 * Once we start to support revisions with additional data, we'll
647 * need to fetch it here. Nothing to do for now, though.
649 if (dev
->revision
>= 0 ||
650 revinfo
.revision
> virtio_ccw_rev_max(dev
) ||
651 (dev
->force_revision_1
&& !revinfo
.revision
)) {
656 dev
->revision
= revinfo
.revision
;
665 static void virtio_sch_disable_cb(SubchDev
*sch
)
667 VirtioCcwDevice
*dev
= sch
->driver_data
;
672 static void virtio_ccw_device_realize(VirtioCcwDevice
*dev
, Error
**errp
)
674 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_GET_CLASS(dev
);
675 CcwDevice
*ccw_dev
= CCW_DEVICE(dev
);
676 SubchDev
*sch
= css_create_virtual_sch(ccw_dev
->bus_id
, errp
);
682 if (!virtio_ccw_rev_max(dev
) && dev
->force_revision_1
) {
683 error_setg(&err
, "Invalid value of property max_rev "
684 "(is %d expected >= 1)", virtio_ccw_rev_max(dev
));
685 error_propagate(errp
, err
);
689 sch
->driver_data
= dev
;
690 sch
->ccw_cb
= virtio_ccw_cb
;
691 sch
->disable_cb
= virtio_sch_disable_cb
;
692 sch
->id
.reserved
= 0xff;
693 sch
->id
.cu_type
= VIRTIO_CCW_CU_TYPE
;
695 dev
->indicators
= NULL
;
697 css_sch_build_virtual_schib(sch
, 0, VIRTIO_CCW_CHPID_TYPE
);
699 trace_virtio_ccw_new_device(
700 sch
->cssid
, sch
->ssid
, sch
->schid
, sch
->devno
,
701 ccw_dev
->bus_id
.valid
? "user-configured" : "auto-configured");
703 if (!kvm_eventfds_enabled()) {
704 dev
->flags
&= ~VIRTIO_CCW_FLAG_USE_IOEVENTFD
;
708 k
->realize(dev
, &err
);
711 error_propagate(errp
, err
);
712 css_subch_assign(sch
->cssid
, sch
->ssid
, sch
->schid
, sch
->devno
, NULL
);
718 static int virtio_ccw_exit(VirtioCcwDevice
*dev
)
720 CcwDevice
*ccw_dev
= CCW_DEVICE(dev
);
721 SubchDev
*sch
= ccw_dev
->sch
;
724 css_subch_assign(sch
->cssid
, sch
->ssid
, sch
->schid
, sch
->devno
, NULL
);
727 if (dev
->indicators
) {
728 release_indicator(&dev
->routes
.adapter
, dev
->indicators
);
729 dev
->indicators
= NULL
;
734 static void virtio_ccw_net_realize(VirtioCcwDevice
*ccw_dev
, Error
**errp
)
736 DeviceState
*qdev
= DEVICE(ccw_dev
);
737 VirtIONetCcw
*dev
= VIRTIO_NET_CCW(ccw_dev
);
738 DeviceState
*vdev
= DEVICE(&dev
->vdev
);
740 virtio_net_set_netclient_name(&dev
->vdev
, qdev
->id
,
741 object_get_typename(OBJECT(qdev
)));
742 qdev_set_parent_bus(vdev
, BUS(&ccw_dev
->bus
));
743 object_property_set_bool(OBJECT(vdev
), true, "realized", errp
);
746 static void virtio_ccw_net_instance_init(Object
*obj
)
748 VirtIONetCcw
*dev
= VIRTIO_NET_CCW(obj
);
750 virtio_instance_init_common(obj
, &dev
->vdev
, sizeof(dev
->vdev
),
752 object_property_add_alias(obj
, "bootindex", OBJECT(&dev
->vdev
),
753 "bootindex", &error_abort
);
756 static void virtio_ccw_blk_realize(VirtioCcwDevice
*ccw_dev
, Error
**errp
)
758 VirtIOBlkCcw
*dev
= VIRTIO_BLK_CCW(ccw_dev
);
759 DeviceState
*vdev
= DEVICE(&dev
->vdev
);
761 qdev_set_parent_bus(vdev
, BUS(&ccw_dev
->bus
));
762 object_property_set_bool(OBJECT(vdev
), true, "realized", errp
);
765 static void virtio_ccw_blk_instance_init(Object
*obj
)
767 VirtIOBlkCcw
*dev
= VIRTIO_BLK_CCW(obj
);
769 virtio_instance_init_common(obj
, &dev
->vdev
, sizeof(dev
->vdev
),
771 object_property_add_alias(obj
, "iothread", OBJECT(&dev
->vdev
),"iothread",
773 object_property_add_alias(obj
, "bootindex", OBJECT(&dev
->vdev
),
774 "bootindex", &error_abort
);
777 static void virtio_ccw_serial_realize(VirtioCcwDevice
*ccw_dev
, Error
**errp
)
779 VirtioSerialCcw
*dev
= VIRTIO_SERIAL_CCW(ccw_dev
);
780 DeviceState
*vdev
= DEVICE(&dev
->vdev
);
781 DeviceState
*proxy
= DEVICE(ccw_dev
);
785 * For command line compatibility, this sets the virtio-serial-device bus
789 bus_name
= g_strdup_printf("%s.0", proxy
->id
);
790 virtio_device_set_child_bus_name(VIRTIO_DEVICE(vdev
), bus_name
);
794 qdev_set_parent_bus(vdev
, BUS(&ccw_dev
->bus
));
795 object_property_set_bool(OBJECT(vdev
), true, "realized", errp
);
799 static void virtio_ccw_serial_instance_init(Object
*obj
)
801 VirtioSerialCcw
*dev
= VIRTIO_SERIAL_CCW(obj
);
803 virtio_instance_init_common(obj
, &dev
->vdev
, sizeof(dev
->vdev
),
807 static void virtio_ccw_balloon_realize(VirtioCcwDevice
*ccw_dev
, Error
**errp
)
809 VirtIOBalloonCcw
*dev
= VIRTIO_BALLOON_CCW(ccw_dev
);
810 DeviceState
*vdev
= DEVICE(&dev
->vdev
);
812 qdev_set_parent_bus(vdev
, BUS(&ccw_dev
->bus
));
813 object_property_set_bool(OBJECT(vdev
), true, "realized", errp
);
816 static void virtio_ccw_balloon_instance_init(Object
*obj
)
818 VirtIOBalloonCcw
*dev
= VIRTIO_BALLOON_CCW(obj
);
820 virtio_instance_init_common(obj
, &dev
->vdev
, sizeof(dev
->vdev
),
821 TYPE_VIRTIO_BALLOON
);
822 object_property_add_alias(obj
, "guest-stats", OBJECT(&dev
->vdev
),
823 "guest-stats", &error_abort
);
824 object_property_add_alias(obj
, "guest-stats-polling-interval",
826 "guest-stats-polling-interval", &error_abort
);
829 static void virtio_ccw_scsi_realize(VirtioCcwDevice
*ccw_dev
, Error
**errp
)
831 VirtIOSCSICcw
*dev
= VIRTIO_SCSI_CCW(ccw_dev
);
832 DeviceState
*vdev
= DEVICE(&dev
->vdev
);
833 DeviceState
*qdev
= DEVICE(ccw_dev
);
837 * For command line compatibility, this sets the virtio-scsi-device bus
841 bus_name
= g_strdup_printf("%s.0", qdev
->id
);
842 virtio_device_set_child_bus_name(VIRTIO_DEVICE(vdev
), bus_name
);
846 qdev_set_parent_bus(vdev
, BUS(&ccw_dev
->bus
));
847 object_property_set_bool(OBJECT(vdev
), true, "realized", errp
);
850 static void virtio_ccw_scsi_instance_init(Object
*obj
)
852 VirtIOSCSICcw
*dev
= VIRTIO_SCSI_CCW(obj
);
854 virtio_instance_init_common(obj
, &dev
->vdev
, sizeof(dev
->vdev
),
856 object_property_add_alias(obj
, "iothread", OBJECT(&dev
->vdev
), "iothread",
860 #ifdef CONFIG_VHOST_SCSI
861 static void vhost_ccw_scsi_realize(VirtioCcwDevice
*ccw_dev
, Error
**errp
)
863 VHostSCSICcw
*dev
= VHOST_SCSI_CCW(ccw_dev
);
864 DeviceState
*vdev
= DEVICE(&dev
->vdev
);
866 qdev_set_parent_bus(vdev
, BUS(&ccw_dev
->bus
));
867 object_property_set_bool(OBJECT(vdev
), true, "realized", errp
);
870 static void vhost_ccw_scsi_instance_init(Object
*obj
)
872 VHostSCSICcw
*dev
= VHOST_SCSI_CCW(obj
);
874 virtio_instance_init_common(obj
, &dev
->vdev
, sizeof(dev
->vdev
),
879 static void virtio_ccw_rng_realize(VirtioCcwDevice
*ccw_dev
, Error
**errp
)
881 VirtIORNGCcw
*dev
= VIRTIO_RNG_CCW(ccw_dev
);
882 DeviceState
*vdev
= DEVICE(&dev
->vdev
);
885 qdev_set_parent_bus(vdev
, BUS(&ccw_dev
->bus
));
886 object_property_set_bool(OBJECT(vdev
), true, "realized", &err
);
888 error_propagate(errp
, err
);
892 object_property_set_link(OBJECT(dev
),
893 OBJECT(dev
->vdev
.conf
.rng
), "rng",
897 static void virtio_ccw_crypto_realize(VirtioCcwDevice
*ccw_dev
, Error
**errp
)
899 VirtIOCryptoCcw
*dev
= VIRTIO_CRYPTO_CCW(ccw_dev
);
900 DeviceState
*vdev
= DEVICE(&dev
->vdev
);
903 qdev_set_parent_bus(vdev
, BUS(&ccw_dev
->bus
));
904 object_property_set_bool(OBJECT(vdev
), true, "realized", &err
);
906 error_propagate(errp
, err
);
910 object_property_set_link(OBJECT(vdev
),
911 OBJECT(dev
->vdev
.conf
.cryptodev
), "cryptodev",
915 /* DeviceState to VirtioCcwDevice. Note: used on datapath,
916 * be careful and test performance if you change this.
918 static inline VirtioCcwDevice
*to_virtio_ccw_dev_fast(DeviceState
*d
)
920 CcwDevice
*ccw_dev
= to_ccw_dev_fast(d
);
922 return container_of(ccw_dev
, VirtioCcwDevice
, parent_obj
);
925 static uint8_t virtio_set_ind_atomic(SubchDev
*sch
, uint64_t ind_loc
,
928 uint8_t ind_old
, ind_new
;
932 ind_addr
= cpu_physical_memory_map(ind_loc
, &len
, 1);
934 error_report("%s(%x.%x.%04x): unable to access indicator",
935 __func__
, sch
->cssid
, sch
->ssid
, sch
->schid
);
940 ind_new
= ind_old
| to_be_set
;
941 } while (atomic_cmpxchg(ind_addr
, ind_old
, ind_new
) != ind_old
);
942 trace_virtio_ccw_set_ind(ind_loc
, ind_old
, ind_new
);
943 cpu_physical_memory_unmap(ind_addr
, len
, 1, len
);
948 static void virtio_ccw_notify(DeviceState
*d
, uint16_t vector
)
950 VirtioCcwDevice
*dev
= to_virtio_ccw_dev_fast(d
);
951 CcwDevice
*ccw_dev
= to_ccw_dev_fast(d
);
952 SubchDev
*sch
= ccw_dev
->sch
;
955 /* queue indicators + secondary indicators */
956 if (vector
>= VIRTIO_CCW_QUEUE_MAX
+ 64) {
960 if (vector
< VIRTIO_CCW_QUEUE_MAX
) {
961 if (!dev
->indicators
) {
964 if (sch
->thinint_active
) {
966 * In the adapter interrupt case, indicators points to a
967 * memory area that may be (way) larger than 64 bit and
968 * ind_bit indicates the start of the indicators in a big
971 uint64_t ind_bit
= dev
->routes
.adapter
.ind_offset
;
973 virtio_set_ind_atomic(sch
, dev
->indicators
->addr
+
974 (ind_bit
+ vector
) / 8,
975 0x80 >> ((ind_bit
+ vector
) % 8));
976 if (!virtio_set_ind_atomic(sch
, dev
->summary_indicator
->addr
,
978 css_adapter_interrupt(dev
->thinint_isc
);
981 indicators
= address_space_ldq(&address_space_memory
,
982 dev
->indicators
->addr
,
983 MEMTXATTRS_UNSPECIFIED
,
985 indicators
|= 1ULL << vector
;
986 address_space_stq(&address_space_memory
, dev
->indicators
->addr
,
987 indicators
, MEMTXATTRS_UNSPECIFIED
, NULL
);
988 css_conditional_io_interrupt(sch
);
991 if (!dev
->indicators2
) {
995 indicators
= address_space_ldq(&address_space_memory
,
996 dev
->indicators2
->addr
,
997 MEMTXATTRS_UNSPECIFIED
,
999 indicators
|= 1ULL << vector
;
1000 address_space_stq(&address_space_memory
, dev
->indicators2
->addr
,
1001 indicators
, MEMTXATTRS_UNSPECIFIED
, NULL
);
1002 css_conditional_io_interrupt(sch
);
1006 static void virtio_ccw_reset(DeviceState
*d
)
1008 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
1009 VirtIODevice
*vdev
= virtio_bus_get_device(&dev
->bus
);
1010 CcwDevice
*ccw_dev
= CCW_DEVICE(d
);
1012 virtio_ccw_reset_virtio(dev
, vdev
);
1013 css_reset_sch(ccw_dev
->sch
);
1016 static void virtio_ccw_vmstate_change(DeviceState
*d
, bool running
)
1018 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
1021 virtio_ccw_start_ioeventfd(dev
);
1023 virtio_ccw_stop_ioeventfd(dev
);
1027 static bool virtio_ccw_query_guest_notifiers(DeviceState
*d
)
1029 CcwDevice
*dev
= CCW_DEVICE(d
);
1031 return !!(dev
->sch
->curr_status
.pmcw
.flags
& PMCW_FLAGS_MASK_ENA
);
1034 static int virtio_ccw_get_mappings(VirtioCcwDevice
*dev
)
1037 CcwDevice
*ccw_dev
= CCW_DEVICE(dev
);
1039 if (!ccw_dev
->sch
->thinint_active
) {
1043 r
= map_indicator(&dev
->routes
.adapter
, dev
->summary_indicator
);
1047 r
= map_indicator(&dev
->routes
.adapter
, dev
->indicators
);
1051 dev
->routes
.adapter
.summary_addr
= dev
->summary_indicator
->map
;
1052 dev
->routes
.adapter
.ind_addr
= dev
->indicators
->map
;
1057 static int virtio_ccw_setup_irqroutes(VirtioCcwDevice
*dev
, int nvqs
)
1060 VirtIODevice
*vdev
= virtio_bus_get_device(&dev
->bus
);
1062 S390FLICState
*fs
= s390_get_flic();
1063 S390FLICStateClass
*fsc
= S390_FLIC_COMMON_GET_CLASS(fs
);
1065 ret
= virtio_ccw_get_mappings(dev
);
1069 for (i
= 0; i
< nvqs
; i
++) {
1070 if (!virtio_queue_get_num(vdev
, i
)) {
1074 dev
->routes
.num_routes
= i
;
1075 return fsc
->add_adapter_routes(fs
, &dev
->routes
);
1078 static void virtio_ccw_release_irqroutes(VirtioCcwDevice
*dev
, int nvqs
)
1080 S390FLICState
*fs
= s390_get_flic();
1081 S390FLICStateClass
*fsc
= S390_FLIC_COMMON_GET_CLASS(fs
);
1083 fsc
->release_adapter_routes(fs
, &dev
->routes
);
1086 static int virtio_ccw_add_irqfd(VirtioCcwDevice
*dev
, int n
)
1088 VirtIODevice
*vdev
= virtio_bus_get_device(&dev
->bus
);
1089 VirtQueue
*vq
= virtio_get_queue(vdev
, n
);
1090 EventNotifier
*notifier
= virtio_queue_get_guest_notifier(vq
);
1092 return kvm_irqchip_add_irqfd_notifier_gsi(kvm_state
, notifier
, NULL
,
1093 dev
->routes
.gsi
[n
]);
1096 static void virtio_ccw_remove_irqfd(VirtioCcwDevice
*dev
, int n
)
1098 VirtIODevice
*vdev
= virtio_bus_get_device(&dev
->bus
);
1099 VirtQueue
*vq
= virtio_get_queue(vdev
, n
);
1100 EventNotifier
*notifier
= virtio_queue_get_guest_notifier(vq
);
1103 ret
= kvm_irqchip_remove_irqfd_notifier_gsi(kvm_state
, notifier
,
1104 dev
->routes
.gsi
[n
]);
1108 static int virtio_ccw_set_guest_notifier(VirtioCcwDevice
*dev
, int n
,
1109 bool assign
, bool with_irqfd
)
1111 VirtIODevice
*vdev
= virtio_bus_get_device(&dev
->bus
);
1112 VirtQueue
*vq
= virtio_get_queue(vdev
, n
);
1113 EventNotifier
*notifier
= virtio_queue_get_guest_notifier(vq
);
1114 VirtioDeviceClass
*k
= VIRTIO_DEVICE_GET_CLASS(vdev
);
1117 int r
= event_notifier_init(notifier
, 0);
1122 virtio_queue_set_guest_notifier_fd_handler(vq
, true, with_irqfd
);
1124 r
= virtio_ccw_add_irqfd(dev
, n
);
1126 virtio_queue_set_guest_notifier_fd_handler(vq
, false,
1132 * We do not support individual masking for channel devices, so we
1133 * need to manually trigger any guest masking callbacks here.
1135 if (k
->guest_notifier_mask
&& vdev
->use_guest_notifier_mask
) {
1136 k
->guest_notifier_mask(vdev
, n
, false);
1138 /* get lost events and re-inject */
1139 if (k
->guest_notifier_pending
&&
1140 k
->guest_notifier_pending(vdev
, n
)) {
1141 event_notifier_set(notifier
);
1144 if (k
->guest_notifier_mask
&& vdev
->use_guest_notifier_mask
) {
1145 k
->guest_notifier_mask(vdev
, n
, true);
1148 virtio_ccw_remove_irqfd(dev
, n
);
1150 virtio_queue_set_guest_notifier_fd_handler(vq
, false, with_irqfd
);
1151 event_notifier_cleanup(notifier
);
1156 static int virtio_ccw_set_guest_notifiers(DeviceState
*d
, int nvqs
,
1159 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
1160 VirtIODevice
*vdev
= virtio_bus_get_device(&dev
->bus
);
1161 CcwDevice
*ccw_dev
= CCW_DEVICE(d
);
1162 bool with_irqfd
= ccw_dev
->sch
->thinint_active
&& kvm_irqfds_enabled();
1165 if (with_irqfd
&& assigned
) {
1166 /* irq routes need to be set up before assigning irqfds */
1167 r
= virtio_ccw_setup_irqroutes(dev
, nvqs
);
1169 goto irqroute_error
;
1172 for (n
= 0; n
< nvqs
; n
++) {
1173 if (!virtio_queue_get_num(vdev
, n
)) {
1176 r
= virtio_ccw_set_guest_notifier(dev
, n
, assigned
, with_irqfd
);
1181 if (with_irqfd
&& !assigned
) {
1182 /* release irq routes after irqfds have been released */
1183 virtio_ccw_release_irqroutes(dev
, nvqs
);
1189 virtio_ccw_set_guest_notifier(dev
, n
, !assigned
, false);
1192 if (with_irqfd
&& assigned
) {
1193 virtio_ccw_release_irqroutes(dev
, nvqs
);
1198 static void virtio_ccw_save_queue(DeviceState
*d
, int n
, QEMUFile
*f
)
1200 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
1201 VirtIODevice
*vdev
= virtio_bus_get_device(&dev
->bus
);
1203 qemu_put_be16(f
, virtio_queue_vector(vdev
, n
));
1206 static int virtio_ccw_load_queue(DeviceState
*d
, int n
, QEMUFile
*f
)
1208 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
1209 VirtIODevice
*vdev
= virtio_bus_get_device(&dev
->bus
);
1212 qemu_get_be16s(f
, &vector
);
1213 virtio_queue_set_vector(vdev
, n
, vector
);
1218 static void virtio_ccw_save_config(DeviceState
*d
, QEMUFile
*f
)
1220 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
1221 CcwDevice
*ccw_dev
= CCW_DEVICE(d
);
1222 SubchDev
*s
= ccw_dev
->sch
;
1223 VirtIODevice
*vdev
= virtio_ccw_get_vdev(s
);
1225 subch_device_save(s
, f
);
1226 if (dev
->indicators
!= NULL
) {
1227 qemu_put_be32(f
, dev
->indicators
->len
);
1228 qemu_put_be64(f
, dev
->indicators
->addr
);
1230 qemu_put_be32(f
, 0);
1231 qemu_put_be64(f
, 0UL);
1233 if (dev
->indicators2
!= NULL
) {
1234 qemu_put_be32(f
, dev
->indicators2
->len
);
1235 qemu_put_be64(f
, dev
->indicators2
->addr
);
1237 qemu_put_be32(f
, 0);
1238 qemu_put_be64(f
, 0UL);
1240 if (dev
->summary_indicator
!= NULL
) {
1241 qemu_put_be32(f
, dev
->summary_indicator
->len
);
1242 qemu_put_be64(f
, dev
->summary_indicator
->addr
);
1244 qemu_put_be32(f
, 0);
1245 qemu_put_be64(f
, 0UL);
1247 qemu_put_be16(f
, vdev
->config_vector
);
1248 qemu_put_be64(f
, dev
->routes
.adapter
.ind_offset
);
1249 qemu_put_byte(f
, dev
->thinint_isc
);
1250 qemu_put_be32(f
, dev
->revision
);
1253 static int virtio_ccw_load_config(DeviceState
*d
, QEMUFile
*f
)
1255 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
1256 CcwDevice
*ccw_dev
= CCW_DEVICE(d
);
1257 SubchDev
*s
= ccw_dev
->sch
;
1258 VirtIODevice
*vdev
= virtio_ccw_get_vdev(s
);
1261 s
->driver_data
= dev
;
1262 subch_device_load(s
, f
);
1263 len
= qemu_get_be32(f
);
1265 dev
->indicators
= get_indicator(qemu_get_be64(f
), len
);
1268 dev
->indicators
= NULL
;
1270 len
= qemu_get_be32(f
);
1272 dev
->indicators2
= get_indicator(qemu_get_be64(f
), len
);
1275 dev
->indicators2
= NULL
;
1277 len
= qemu_get_be32(f
);
1279 dev
->summary_indicator
= get_indicator(qemu_get_be64(f
), len
);
1282 dev
->summary_indicator
= NULL
;
1284 qemu_get_be16s(f
, &vdev
->config_vector
);
1285 dev
->routes
.adapter
.ind_offset
= qemu_get_be64(f
);
1286 dev
->thinint_isc
= qemu_get_byte(f
);
1287 dev
->revision
= qemu_get_be32(f
);
1288 if (s
->thinint_active
) {
1289 return css_register_io_adapter(CSS_IO_ADAPTER_VIRTIO
,
1290 dev
->thinint_isc
, true, false,
1291 &dev
->routes
.adapter
.adapter_id
);
1297 static void virtio_ccw_pre_plugged(DeviceState
*d
, Error
**errp
)
1299 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
1300 VirtIODevice
*vdev
= virtio_bus_get_device(&dev
->bus
);
1302 if (dev
->max_rev
>= 1) {
1303 virtio_add_feature(&vdev
->host_features
, VIRTIO_F_VERSION_1
);
1307 /* This is called by virtio-bus just after the device is plugged. */
1308 static void virtio_ccw_device_plugged(DeviceState
*d
, Error
**errp
)
1310 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
1311 VirtIODevice
*vdev
= virtio_bus_get_device(&dev
->bus
);
1312 CcwDevice
*ccw_dev
= CCW_DEVICE(d
);
1313 SubchDev
*sch
= ccw_dev
->sch
;
1314 int n
= virtio_get_num_queues(vdev
);
1316 if (!virtio_has_feature(vdev
->host_features
, VIRTIO_F_VERSION_1
)) {
1320 if (virtio_get_num_queues(vdev
) > VIRTIO_CCW_QUEUE_MAX
) {
1321 error_setg(errp
, "The number of virtqueues %d "
1322 "exceeds ccw limit %d", n
,
1323 VIRTIO_CCW_QUEUE_MAX
);
1327 sch
->id
.cu_model
= virtio_bus_get_vdev_id(&dev
->bus
);
1330 css_generate_sch_crws(sch
->cssid
, sch
->ssid
, sch
->schid
,
1334 static void virtio_ccw_device_unplugged(DeviceState
*d
)
1336 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
1338 virtio_ccw_stop_ioeventfd(dev
);
1340 /**************** Virtio-ccw Bus Device Descriptions *******************/
1342 static Property virtio_ccw_net_properties
[] = {
1343 DEFINE_PROP_CSS_DEV_ID("devno", VirtioCcwDevice
, parent_obj
.bus_id
),
1344 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice
, flags
,
1345 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT
, true),
1346 DEFINE_PROP_UINT32("max_revision", VirtioCcwDevice
, max_rev
,
1347 VIRTIO_CCW_MAX_REV
),
1348 DEFINE_PROP_END_OF_LIST(),
1351 static void virtio_ccw_net_class_init(ObjectClass
*klass
, void *data
)
1353 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1354 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_CLASS(klass
);
1356 k
->realize
= virtio_ccw_net_realize
;
1357 k
->exit
= virtio_ccw_exit
;
1358 dc
->reset
= virtio_ccw_reset
;
1359 dc
->props
= virtio_ccw_net_properties
;
1360 set_bit(DEVICE_CATEGORY_NETWORK
, dc
->categories
);
1363 static const TypeInfo virtio_ccw_net
= {
1364 .name
= TYPE_VIRTIO_NET_CCW
,
1365 .parent
= TYPE_VIRTIO_CCW_DEVICE
,
1366 .instance_size
= sizeof(VirtIONetCcw
),
1367 .instance_init
= virtio_ccw_net_instance_init
,
1368 .class_init
= virtio_ccw_net_class_init
,
1371 static Property virtio_ccw_blk_properties
[] = {
1372 DEFINE_PROP_CSS_DEV_ID("devno", VirtioCcwDevice
, parent_obj
.bus_id
),
1373 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice
, flags
,
1374 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT
, true),
1375 DEFINE_PROP_UINT32("max_revision", VirtioCcwDevice
, max_rev
,
1376 VIRTIO_CCW_MAX_REV
),
1377 DEFINE_PROP_END_OF_LIST(),
1380 static void virtio_ccw_blk_class_init(ObjectClass
*klass
, void *data
)
1382 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1383 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_CLASS(klass
);
1385 k
->realize
= virtio_ccw_blk_realize
;
1386 k
->exit
= virtio_ccw_exit
;
1387 dc
->reset
= virtio_ccw_reset
;
1388 dc
->props
= virtio_ccw_blk_properties
;
1389 set_bit(DEVICE_CATEGORY_STORAGE
, dc
->categories
);
1392 static const TypeInfo virtio_ccw_blk
= {
1393 .name
= TYPE_VIRTIO_BLK_CCW
,
1394 .parent
= TYPE_VIRTIO_CCW_DEVICE
,
1395 .instance_size
= sizeof(VirtIOBlkCcw
),
1396 .instance_init
= virtio_ccw_blk_instance_init
,
1397 .class_init
= virtio_ccw_blk_class_init
,
1400 static Property virtio_ccw_serial_properties
[] = {
1401 DEFINE_PROP_CSS_DEV_ID("devno", VirtioCcwDevice
, parent_obj
.bus_id
),
1402 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice
, flags
,
1403 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT
, true),
1404 DEFINE_PROP_UINT32("max_revision", VirtioCcwDevice
, max_rev
,
1405 VIRTIO_CCW_MAX_REV
),
1406 DEFINE_PROP_END_OF_LIST(),
1409 static void virtio_ccw_serial_class_init(ObjectClass
*klass
, void *data
)
1411 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1412 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_CLASS(klass
);
1414 k
->realize
= virtio_ccw_serial_realize
;
1415 k
->exit
= virtio_ccw_exit
;
1416 dc
->reset
= virtio_ccw_reset
;
1417 dc
->props
= virtio_ccw_serial_properties
;
1418 set_bit(DEVICE_CATEGORY_INPUT
, dc
->categories
);
1421 static const TypeInfo virtio_ccw_serial
= {
1422 .name
= TYPE_VIRTIO_SERIAL_CCW
,
1423 .parent
= TYPE_VIRTIO_CCW_DEVICE
,
1424 .instance_size
= sizeof(VirtioSerialCcw
),
1425 .instance_init
= virtio_ccw_serial_instance_init
,
1426 .class_init
= virtio_ccw_serial_class_init
,
1429 static Property virtio_ccw_balloon_properties
[] = {
1430 DEFINE_PROP_CSS_DEV_ID("devno", VirtioCcwDevice
, parent_obj
.bus_id
),
1431 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice
, flags
,
1432 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT
, true),
1433 DEFINE_PROP_UINT32("max_revision", VirtioCcwDevice
, max_rev
,
1434 VIRTIO_CCW_MAX_REV
),
1435 DEFINE_PROP_END_OF_LIST(),
1438 static void virtio_ccw_balloon_class_init(ObjectClass
*klass
, void *data
)
1440 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1441 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_CLASS(klass
);
1443 k
->realize
= virtio_ccw_balloon_realize
;
1444 k
->exit
= virtio_ccw_exit
;
1445 dc
->reset
= virtio_ccw_reset
;
1446 dc
->props
= virtio_ccw_balloon_properties
;
1447 set_bit(DEVICE_CATEGORY_MISC
, dc
->categories
);
1450 static const TypeInfo virtio_ccw_balloon
= {
1451 .name
= TYPE_VIRTIO_BALLOON_CCW
,
1452 .parent
= TYPE_VIRTIO_CCW_DEVICE
,
1453 .instance_size
= sizeof(VirtIOBalloonCcw
),
1454 .instance_init
= virtio_ccw_balloon_instance_init
,
1455 .class_init
= virtio_ccw_balloon_class_init
,
1458 static Property virtio_ccw_scsi_properties
[] = {
1459 DEFINE_PROP_CSS_DEV_ID("devno", VirtioCcwDevice
, parent_obj
.bus_id
),
1460 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice
, flags
,
1461 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT
, true),
1462 DEFINE_PROP_UINT32("max_revision", VirtioCcwDevice
, max_rev
,
1463 VIRTIO_CCW_MAX_REV
),
1464 DEFINE_PROP_END_OF_LIST(),
1467 static void virtio_ccw_scsi_class_init(ObjectClass
*klass
, void *data
)
1469 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1470 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_CLASS(klass
);
1472 k
->realize
= virtio_ccw_scsi_realize
;
1473 k
->exit
= virtio_ccw_exit
;
1474 dc
->reset
= virtio_ccw_reset
;
1475 dc
->props
= virtio_ccw_scsi_properties
;
1476 set_bit(DEVICE_CATEGORY_STORAGE
, dc
->categories
);
1479 static const TypeInfo virtio_ccw_scsi
= {
1480 .name
= TYPE_VIRTIO_SCSI_CCW
,
1481 .parent
= TYPE_VIRTIO_CCW_DEVICE
,
1482 .instance_size
= sizeof(VirtIOSCSICcw
),
1483 .instance_init
= virtio_ccw_scsi_instance_init
,
1484 .class_init
= virtio_ccw_scsi_class_init
,
1487 #ifdef CONFIG_VHOST_SCSI
1488 static Property vhost_ccw_scsi_properties
[] = {
1489 DEFINE_PROP_CSS_DEV_ID("devno", VirtioCcwDevice
, parent_obj
.bus_id
),
1490 DEFINE_PROP_UINT32("max_revision", VirtioCcwDevice
, max_rev
,
1491 VIRTIO_CCW_MAX_REV
),
1492 DEFINE_PROP_END_OF_LIST(),
1495 static void vhost_ccw_scsi_class_init(ObjectClass
*klass
, void *data
)
1497 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1498 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_CLASS(klass
);
1500 k
->realize
= vhost_ccw_scsi_realize
;
1501 k
->exit
= virtio_ccw_exit
;
1502 dc
->reset
= virtio_ccw_reset
;
1503 dc
->props
= vhost_ccw_scsi_properties
;
1504 set_bit(DEVICE_CATEGORY_STORAGE
, dc
->categories
);
1507 static const TypeInfo vhost_ccw_scsi
= {
1508 .name
= TYPE_VHOST_SCSI_CCW
,
1509 .parent
= TYPE_VIRTIO_CCW_DEVICE
,
1510 .instance_size
= sizeof(VHostSCSICcw
),
1511 .instance_init
= vhost_ccw_scsi_instance_init
,
1512 .class_init
= vhost_ccw_scsi_class_init
,
1516 static void virtio_ccw_rng_instance_init(Object
*obj
)
1518 VirtIORNGCcw
*dev
= VIRTIO_RNG_CCW(obj
);
1520 virtio_instance_init_common(obj
, &dev
->vdev
, sizeof(dev
->vdev
),
1522 object_property_add_alias(obj
, "rng", OBJECT(&dev
->vdev
),
1523 "rng", &error_abort
);
1526 static Property virtio_ccw_rng_properties
[] = {
1527 DEFINE_PROP_CSS_DEV_ID("devno", VirtioCcwDevice
, parent_obj
.bus_id
),
1528 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice
, flags
,
1529 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT
, true),
1530 DEFINE_PROP_UINT32("max_revision", VirtioCcwDevice
, max_rev
,
1531 VIRTIO_CCW_MAX_REV
),
1532 DEFINE_PROP_END_OF_LIST(),
1535 static void virtio_ccw_rng_class_init(ObjectClass
*klass
, void *data
)
1537 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1538 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_CLASS(klass
);
1540 k
->realize
= virtio_ccw_rng_realize
;
1541 k
->exit
= virtio_ccw_exit
;
1542 dc
->reset
= virtio_ccw_reset
;
1543 dc
->props
= virtio_ccw_rng_properties
;
1544 set_bit(DEVICE_CATEGORY_MISC
, dc
->categories
);
1547 static const TypeInfo virtio_ccw_rng
= {
1548 .name
= TYPE_VIRTIO_RNG_CCW
,
1549 .parent
= TYPE_VIRTIO_CCW_DEVICE
,
1550 .instance_size
= sizeof(VirtIORNGCcw
),
1551 .instance_init
= virtio_ccw_rng_instance_init
,
1552 .class_init
= virtio_ccw_rng_class_init
,
1555 static Property virtio_ccw_crypto_properties
[] = {
1556 DEFINE_PROP_CSS_DEV_ID("devno", VirtioCcwDevice
, parent_obj
.bus_id
),
1557 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice
, flags
,
1558 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT
, true),
1559 DEFINE_PROP_UINT32("max_revision", VirtioCcwDevice
, max_rev
,
1560 VIRTIO_CCW_MAX_REV
),
1561 DEFINE_PROP_END_OF_LIST(),
1564 static void virtio_ccw_crypto_instance_init(Object
*obj
)
1566 VirtIOCryptoCcw
*dev
= VIRTIO_CRYPTO_CCW(obj
);
1567 VirtioCcwDevice
*ccw_dev
= VIRTIO_CCW_DEVICE(obj
);
1569 ccw_dev
->force_revision_1
= true;
1570 virtio_instance_init_common(obj
, &dev
->vdev
, sizeof(dev
->vdev
),
1571 TYPE_VIRTIO_CRYPTO
);
1573 object_property_add_alias(obj
, "cryptodev", OBJECT(&dev
->vdev
),
1574 "cryptodev", &error_abort
);
1577 static void virtio_ccw_crypto_class_init(ObjectClass
*klass
, void *data
)
1579 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1580 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_CLASS(klass
);
1582 k
->realize
= virtio_ccw_crypto_realize
;
1583 k
->exit
= virtio_ccw_exit
;
1584 dc
->reset
= virtio_ccw_reset
;
1585 dc
->props
= virtio_ccw_crypto_properties
;
1586 set_bit(DEVICE_CATEGORY_MISC
, dc
->categories
);
1589 static const TypeInfo virtio_ccw_crypto
= {
1590 .name
= TYPE_VIRTIO_CRYPTO_CCW
,
1591 .parent
= TYPE_VIRTIO_CCW_DEVICE
,
1592 .instance_size
= sizeof(VirtIOCryptoCcw
),
1593 .instance_init
= virtio_ccw_crypto_instance_init
,
1594 .class_init
= virtio_ccw_crypto_class_init
,
1597 static void virtio_ccw_busdev_realize(DeviceState
*dev
, Error
**errp
)
1599 VirtioCcwDevice
*_dev
= (VirtioCcwDevice
*)dev
;
1601 virtio_ccw_bus_new(&_dev
->bus
, sizeof(_dev
->bus
), _dev
);
1602 virtio_ccw_device_realize(_dev
, errp
);
1605 static int virtio_ccw_busdev_exit(DeviceState
*dev
)
1607 VirtioCcwDevice
*_dev
= (VirtioCcwDevice
*)dev
;
1608 VirtIOCCWDeviceClass
*_info
= VIRTIO_CCW_DEVICE_GET_CLASS(dev
);
1610 return _info
->exit(_dev
);
1613 static void virtio_ccw_busdev_unplug(HotplugHandler
*hotplug_dev
,
1614 DeviceState
*dev
, Error
**errp
)
1616 VirtioCcwDevice
*_dev
= to_virtio_ccw_dev_fast(dev
);
1618 virtio_ccw_stop_ioeventfd(_dev
);
1621 static void virtio_ccw_device_class_init(ObjectClass
*klass
, void *data
)
1623 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1624 CCWDeviceClass
*k
= CCW_DEVICE_CLASS(dc
);
1626 k
->unplug
= virtio_ccw_busdev_unplug
;
1627 dc
->realize
= virtio_ccw_busdev_realize
;
1628 dc
->exit
= virtio_ccw_busdev_exit
;
1629 dc
->bus_type
= TYPE_VIRTUAL_CSS_BUS
;
1632 static const TypeInfo virtio_ccw_device_info
= {
1633 .name
= TYPE_VIRTIO_CCW_DEVICE
,
1634 .parent
= TYPE_CCW_DEVICE
,
1635 .instance_size
= sizeof(VirtioCcwDevice
),
1636 .class_init
= virtio_ccw_device_class_init
,
1637 .class_size
= sizeof(VirtIOCCWDeviceClass
),
1641 /* virtio-ccw-bus */
1643 static void virtio_ccw_bus_new(VirtioBusState
*bus
, size_t bus_size
,
1644 VirtioCcwDevice
*dev
)
1646 DeviceState
*qdev
= DEVICE(dev
);
1647 char virtio_bus_name
[] = "virtio-bus";
1649 qbus_create_inplace(bus
, bus_size
, TYPE_VIRTIO_CCW_BUS
,
1650 qdev
, virtio_bus_name
);
1653 static void virtio_ccw_bus_class_init(ObjectClass
*klass
, void *data
)
1655 VirtioBusClass
*k
= VIRTIO_BUS_CLASS(klass
);
1656 BusClass
*bus_class
= BUS_CLASS(klass
);
1658 bus_class
->max_dev
= 1;
1659 k
->notify
= virtio_ccw_notify
;
1660 k
->vmstate_change
= virtio_ccw_vmstate_change
;
1661 k
->query_guest_notifiers
= virtio_ccw_query_guest_notifiers
;
1662 k
->set_guest_notifiers
= virtio_ccw_set_guest_notifiers
;
1663 k
->save_queue
= virtio_ccw_save_queue
;
1664 k
->load_queue
= virtio_ccw_load_queue
;
1665 k
->save_config
= virtio_ccw_save_config
;
1666 k
->load_config
= virtio_ccw_load_config
;
1667 k
->pre_plugged
= virtio_ccw_pre_plugged
;
1668 k
->device_plugged
= virtio_ccw_device_plugged
;
1669 k
->device_unplugged
= virtio_ccw_device_unplugged
;
1670 k
->ioeventfd_enabled
= virtio_ccw_ioeventfd_enabled
;
1671 k
->ioeventfd_assign
= virtio_ccw_ioeventfd_assign
;
1674 static const TypeInfo virtio_ccw_bus_info
= {
1675 .name
= TYPE_VIRTIO_CCW_BUS
,
1676 .parent
= TYPE_VIRTIO_BUS
,
1677 .instance_size
= sizeof(VirtioCcwBusState
),
1678 .class_init
= virtio_ccw_bus_class_init
,
1681 #ifdef CONFIG_VIRTFS
1682 static Property virtio_ccw_9p_properties
[] = {
1683 DEFINE_PROP_CSS_DEV_ID("devno", VirtioCcwDevice
, parent_obj
.bus_id
),
1684 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice
, flags
,
1685 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT
, true),
1686 DEFINE_PROP_UINT32("max_revision", VirtioCcwDevice
, max_rev
,
1687 VIRTIO_CCW_MAX_REV
),
1688 DEFINE_PROP_END_OF_LIST(),
1691 static void virtio_ccw_9p_realize(VirtioCcwDevice
*ccw_dev
, Error
**errp
)
1693 V9fsCCWState
*dev
= VIRTIO_9P_CCW(ccw_dev
);
1694 DeviceState
*vdev
= DEVICE(&dev
->vdev
);
1696 qdev_set_parent_bus(vdev
, BUS(&ccw_dev
->bus
));
1697 object_property_set_bool(OBJECT(vdev
), true, "realized", errp
);
1700 static void virtio_ccw_9p_class_init(ObjectClass
*klass
, void *data
)
1702 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1703 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_CLASS(klass
);
1705 k
->exit
= virtio_ccw_exit
;
1706 k
->realize
= virtio_ccw_9p_realize
;
1707 dc
->reset
= virtio_ccw_reset
;
1708 dc
->props
= virtio_ccw_9p_properties
;
1709 set_bit(DEVICE_CATEGORY_STORAGE
, dc
->categories
);
1712 static void virtio_ccw_9p_instance_init(Object
*obj
)
1714 V9fsCCWState
*dev
= VIRTIO_9P_CCW(obj
);
1716 virtio_instance_init_common(obj
, &dev
->vdev
, sizeof(dev
->vdev
),
1720 static const TypeInfo virtio_ccw_9p_info
= {
1721 .name
= TYPE_VIRTIO_9P_CCW
,
1722 .parent
= TYPE_VIRTIO_CCW_DEVICE
,
1723 .instance_size
= sizeof(V9fsCCWState
),
1724 .instance_init
= virtio_ccw_9p_instance_init
,
1725 .class_init
= virtio_ccw_9p_class_init
,
1729 #ifdef CONFIG_VHOST_VSOCK
1731 static Property vhost_vsock_ccw_properties
[] = {
1732 DEFINE_PROP_CSS_DEV_ID("devno", VirtioCcwDevice
, parent_obj
.bus_id
),
1733 DEFINE_PROP_UINT32("max_revision", VirtioCcwDevice
, max_rev
,
1734 VIRTIO_CCW_MAX_REV
),
1735 DEFINE_PROP_END_OF_LIST(),
1738 static void vhost_vsock_ccw_realize(VirtioCcwDevice
*ccw_dev
, Error
**errp
)
1740 VHostVSockCCWState
*dev
= VHOST_VSOCK_CCW(ccw_dev
);
1741 DeviceState
*vdev
= DEVICE(&dev
->vdev
);
1744 qdev_set_parent_bus(vdev
, BUS(&ccw_dev
->bus
));
1745 object_property_set_bool(OBJECT(vdev
), true, "realized", &err
);
1747 error_propagate(errp
, err
);
1751 static void vhost_vsock_ccw_class_init(ObjectClass
*klass
, void *data
)
1753 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1754 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_CLASS(klass
);
1756 k
->realize
= vhost_vsock_ccw_realize
;
1757 k
->exit
= virtio_ccw_exit
;
1758 set_bit(DEVICE_CATEGORY_MISC
, dc
->categories
);
1759 dc
->props
= vhost_vsock_ccw_properties
;
1760 dc
->reset
= virtio_ccw_reset
;
1763 static void vhost_vsock_ccw_instance_init(Object
*obj
)
1765 VHostVSockCCWState
*dev
= VHOST_VSOCK_CCW(obj
);
1767 virtio_instance_init_common(obj
, &dev
->vdev
, sizeof(dev
->vdev
),
1771 static const TypeInfo vhost_vsock_ccw_info
= {
1772 .name
= TYPE_VHOST_VSOCK_CCW
,
1773 .parent
= TYPE_VIRTIO_CCW_DEVICE
,
1774 .instance_size
= sizeof(VHostVSockCCWState
),
1775 .instance_init
= vhost_vsock_ccw_instance_init
,
1776 .class_init
= vhost_vsock_ccw_class_init
,
1780 static void virtio_ccw_register(void)
1782 type_register_static(&virtio_ccw_bus_info
);
1783 type_register_static(&virtio_ccw_device_info
);
1784 type_register_static(&virtio_ccw_serial
);
1785 type_register_static(&virtio_ccw_blk
);
1786 type_register_static(&virtio_ccw_net
);
1787 type_register_static(&virtio_ccw_balloon
);
1788 type_register_static(&virtio_ccw_scsi
);
1789 #ifdef CONFIG_VHOST_SCSI
1790 type_register_static(&vhost_ccw_scsi
);
1792 type_register_static(&virtio_ccw_rng
);
1793 #ifdef CONFIG_VIRTFS
1794 type_register_static(&virtio_ccw_9p_info
);
1796 #ifdef CONFIG_VHOST_VSOCK
1797 type_register_static(&vhost_vsock_ccw_info
);
1799 type_register_static(&virtio_ccw_crypto
);
1802 type_init(virtio_ccw_register
)