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 #define NR_CLASSIC_INDICATOR_BITS 64
40 static void virtio_ccw_bus_new(VirtioBusState
*bus
, size_t bus_size
,
41 VirtioCcwDevice
*dev
);
43 VirtIODevice
*virtio_ccw_get_vdev(SubchDev
*sch
)
45 VirtIODevice
*vdev
= NULL
;
46 VirtioCcwDevice
*dev
= sch
->driver_data
;
49 vdev
= virtio_bus_get_device(&dev
->bus
);
54 static void virtio_ccw_start_ioeventfd(VirtioCcwDevice
*dev
)
56 virtio_bus_start_ioeventfd(&dev
->bus
);
59 static void virtio_ccw_stop_ioeventfd(VirtioCcwDevice
*dev
)
61 virtio_bus_stop_ioeventfd(&dev
->bus
);
64 static bool virtio_ccw_ioeventfd_enabled(DeviceState
*d
)
66 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
68 return (dev
->flags
& VIRTIO_CCW_FLAG_USE_IOEVENTFD
) != 0;
71 static int virtio_ccw_ioeventfd_assign(DeviceState
*d
, EventNotifier
*notifier
,
74 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
75 CcwDevice
*ccw_dev
= CCW_DEVICE(dev
);
76 SubchDev
*sch
= ccw_dev
->sch
;
77 uint32_t sch_id
= (css_build_subchannel_id(sch
) << 16) | sch
->schid
;
79 return s390_assign_subch_ioeventfd(notifier
, sch_id
, n
, assign
);
82 /* Communication blocks used by several channel commands. */
83 typedef struct VqInfoBlockLegacy
{
88 } QEMU_PACKED VqInfoBlockLegacy
;
90 typedef struct VqInfoBlock
{
97 } QEMU_PACKED VqInfoBlock
;
99 typedef struct VqConfigBlock
{
102 } QEMU_PACKED VqConfigBlock
;
104 typedef struct VirtioFeatDesc
{
107 } QEMU_PACKED VirtioFeatDesc
;
109 typedef struct VirtioThinintInfo
{
110 hwaddr summary_indicator
;
111 hwaddr device_indicator
;
114 } QEMU_PACKED VirtioThinintInfo
;
116 typedef struct VirtioRevInfo
{
120 } QEMU_PACKED VirtioRevInfo
;
122 /* Specify where the virtqueues for the subchannel are in guest memory. */
123 static int virtio_ccw_set_vqs(SubchDev
*sch
, VqInfoBlock
*info
,
124 VqInfoBlockLegacy
*linfo
)
126 VirtIODevice
*vdev
= virtio_ccw_get_vdev(sch
);
127 uint16_t index
= info
? info
->index
: linfo
->index
;
128 uint16_t num
= info
? info
->num
: linfo
->num
;
129 uint64_t desc
= info
? info
->desc
: linfo
->queue
;
131 if (index
>= VIRTIO_QUEUE_MAX
) {
135 /* Current code in virtio.c relies on 4K alignment. */
136 if (linfo
&& desc
&& (linfo
->align
!= 4096)) {
145 virtio_queue_set_rings(vdev
, index
, desc
, info
->avail
, info
->used
);
147 virtio_queue_set_addr(vdev
, index
, desc
);
150 virtio_queue_set_vector(vdev
, index
, VIRTIO_NO_VECTOR
);
153 /* virtio-1 allows changing the ring size. */
154 if (virtio_queue_get_max_num(vdev
, index
) < num
) {
155 /* Fail if we exceed the maximum number. */
158 virtio_queue_set_num(vdev
, index
, num
);
159 } else if (virtio_queue_get_num(vdev
, index
) > num
) {
160 /* Fail if we don't have a big enough queue. */
163 /* We ignore possible increased num for legacy for compatibility. */
164 virtio_queue_set_vector(vdev
, index
, index
);
166 /* tell notify handler in case of config change */
167 vdev
->config_vector
= VIRTIO_QUEUE_MAX
;
171 static void virtio_ccw_reset_virtio(VirtioCcwDevice
*dev
, VirtIODevice
*vdev
)
173 CcwDevice
*ccw_dev
= CCW_DEVICE(dev
);
175 virtio_ccw_stop_ioeventfd(dev
);
177 if (dev
->indicators
) {
178 release_indicator(&dev
->routes
.adapter
, dev
->indicators
);
179 dev
->indicators
= NULL
;
181 if (dev
->indicators2
) {
182 release_indicator(&dev
->routes
.adapter
, dev
->indicators2
);
183 dev
->indicators2
= NULL
;
185 if (dev
->summary_indicator
) {
186 release_indicator(&dev
->routes
.adapter
, dev
->summary_indicator
);
187 dev
->summary_indicator
= NULL
;
189 ccw_dev
->sch
->thinint_active
= false;
192 static int virtio_ccw_handle_set_vq(SubchDev
*sch
, CCW1 ccw
, bool check_len
,
197 VqInfoBlockLegacy linfo
;
198 size_t info_len
= is_legacy
? sizeof(linfo
) : sizeof(info
);
201 if (ccw
.count
!= info_len
) {
204 } else if (ccw
.count
< info_len
) {
205 /* Can't execute command. */
212 linfo
.queue
= address_space_ldq_be(&address_space_memory
, ccw
.cda
,
213 MEMTXATTRS_UNSPECIFIED
, NULL
);
214 linfo
.align
= address_space_ldl_be(&address_space_memory
,
215 ccw
.cda
+ sizeof(linfo
.queue
),
216 MEMTXATTRS_UNSPECIFIED
,
218 linfo
.index
= address_space_lduw_be(&address_space_memory
,
219 ccw
.cda
+ sizeof(linfo
.queue
)
220 + sizeof(linfo
.align
),
221 MEMTXATTRS_UNSPECIFIED
,
223 linfo
.num
= address_space_lduw_be(&address_space_memory
,
224 ccw
.cda
+ sizeof(linfo
.queue
)
225 + sizeof(linfo
.align
)
226 + sizeof(linfo
.index
),
227 MEMTXATTRS_UNSPECIFIED
,
229 ret
= virtio_ccw_set_vqs(sch
, NULL
, &linfo
);
231 info
.desc
= address_space_ldq_be(&address_space_memory
, ccw
.cda
,
232 MEMTXATTRS_UNSPECIFIED
, NULL
);
233 info
.index
= address_space_lduw_be(&address_space_memory
,
234 ccw
.cda
+ sizeof(info
.desc
)
236 MEMTXATTRS_UNSPECIFIED
, NULL
);
237 info
.num
= address_space_lduw_be(&address_space_memory
,
238 ccw
.cda
+ sizeof(info
.desc
)
240 + sizeof(info
.index
),
241 MEMTXATTRS_UNSPECIFIED
, NULL
);
242 info
.avail
= address_space_ldq_be(&address_space_memory
,
243 ccw
.cda
+ sizeof(info
.desc
)
247 MEMTXATTRS_UNSPECIFIED
, NULL
);
248 info
.used
= address_space_ldq_be(&address_space_memory
,
249 ccw
.cda
+ sizeof(info
.desc
)
253 + sizeof(info
.avail
),
254 MEMTXATTRS_UNSPECIFIED
, NULL
);
255 ret
= virtio_ccw_set_vqs(sch
, &info
, NULL
);
257 sch
->curr_status
.scsw
.count
= 0;
261 static int virtio_ccw_cb(SubchDev
*sch
, CCW1 ccw
)
264 VirtioRevInfo revinfo
;
266 VirtioFeatDesc features
;
269 VqConfigBlock vq_config
;
270 VirtioCcwDevice
*dev
= sch
->driver_data
;
271 VirtIODevice
*vdev
= virtio_ccw_get_vdev(sch
);
275 VirtioThinintInfo
*thinint
;
281 trace_virtio_ccw_interpret_ccw(sch
->cssid
, sch
->ssid
, sch
->schid
,
283 check_len
= !((ccw
.flags
& CCW_FLAG_SLI
) && !(ccw
.flags
& CCW_FLAG_DC
));
285 if (dev
->force_revision_1
&& dev
->revision
< 0 &&
286 ccw
.cmd_code
!= CCW_CMD_SET_VIRTIO_REV
) {
288 * virtio-1 drivers must start with negotiating to a revision >= 1,
289 * so post a command reject for all other commands
294 /* Look at the command. */
295 switch (ccw
.cmd_code
) {
297 ret
= virtio_ccw_handle_set_vq(sch
, ccw
, check_len
, dev
->revision
< 1);
299 case CCW_CMD_VDEV_RESET
:
300 virtio_ccw_reset_virtio(dev
, vdev
);
303 case CCW_CMD_READ_FEAT
:
305 if (ccw
.count
!= sizeof(features
)) {
309 } else if (ccw
.count
< sizeof(features
)) {
310 /* Can't execute command. */
317 VirtioDeviceClass
*vdc
= VIRTIO_DEVICE_GET_CLASS(vdev
);
319 features
.index
= address_space_ldub(&address_space_memory
,
321 + sizeof(features
.features
),
322 MEMTXATTRS_UNSPECIFIED
,
324 if (features
.index
== 0) {
325 if (dev
->revision
>= 1) {
326 /* Don't offer legacy features for modern devices. */
327 features
.features
= (uint32_t)
328 (vdev
->host_features
& ~vdc
->legacy_features
);
330 features
.features
= (uint32_t)vdev
->host_features
;
332 } else if ((features
.index
== 1) && (dev
->revision
>= 1)) {
334 * Only offer feature bits beyond 31 if the guest has
335 * negotiated at least revision 1.
337 features
.features
= (uint32_t)(vdev
->host_features
>> 32);
339 /* Return zeroes if the guest supports more feature bits. */
340 features
.features
= 0;
342 address_space_stl_le(&address_space_memory
, ccw
.cda
,
343 features
.features
, MEMTXATTRS_UNSPECIFIED
,
345 sch
->curr_status
.scsw
.count
= ccw
.count
- sizeof(features
);
349 case CCW_CMD_WRITE_FEAT
:
351 if (ccw
.count
!= sizeof(features
)) {
355 } else if (ccw
.count
< sizeof(features
)) {
356 /* Can't execute command. */
363 features
.index
= address_space_ldub(&address_space_memory
,
365 + sizeof(features
.features
),
366 MEMTXATTRS_UNSPECIFIED
,
368 features
.features
= address_space_ldl_le(&address_space_memory
,
370 MEMTXATTRS_UNSPECIFIED
,
372 if (features
.index
== 0) {
373 virtio_set_features(vdev
,
374 (vdev
->guest_features
& 0xffffffff00000000ULL
) |
376 } else if ((features
.index
== 1) && (dev
->revision
>= 1)) {
378 * If the guest did not negotiate at least revision 1,
379 * we did not offer it any feature bits beyond 31. Such a
380 * guest passing us any bit here is therefore buggy.
382 virtio_set_features(vdev
,
383 (vdev
->guest_features
& 0x00000000ffffffffULL
) |
384 ((uint64_t)features
.features
<< 32));
387 * If the guest supports more feature bits, assert that it
388 * passes us zeroes for those we don't support.
390 if (features
.features
) {
391 fprintf(stderr
, "Guest bug: features[%i]=%x (expected 0)\n",
392 features
.index
, features
.features
);
393 /* XXX: do a unit check here? */
396 sch
->curr_status
.scsw
.count
= ccw
.count
- sizeof(features
);
400 case CCW_CMD_READ_CONF
:
402 if (ccw
.count
> vdev
->config_len
) {
407 len
= MIN(ccw
.count
, vdev
->config_len
);
411 virtio_bus_get_vdev_config(&dev
->bus
, vdev
->config
);
412 /* XXX config space endianness */
413 cpu_physical_memory_write(ccw
.cda
, vdev
->config
, len
);
414 sch
->curr_status
.scsw
.count
= ccw
.count
- len
;
418 case CCW_CMD_WRITE_CONF
:
420 if (ccw
.count
> vdev
->config_len
) {
425 len
= MIN(ccw
.count
, vdev
->config_len
);
430 config
= cpu_physical_memory_map(ccw
.cda
, &hw_len
, 0);
435 /* XXX config space endianness */
436 memcpy(vdev
->config
, config
, len
);
437 cpu_physical_memory_unmap(config
, hw_len
, 0, hw_len
);
438 virtio_bus_set_vdev_config(&dev
->bus
, vdev
->config
);
439 sch
->curr_status
.scsw
.count
= ccw
.count
- len
;
444 case CCW_CMD_READ_STATUS
:
446 if (ccw
.count
!= sizeof(status
)) {
450 } else if (ccw
.count
< sizeof(status
)) {
451 /* Can't execute command. */
458 address_space_stb(&address_space_memory
, ccw
.cda
, vdev
->status
,
459 MEMTXATTRS_UNSPECIFIED
, NULL
);
460 sch
->curr_status
.scsw
.count
= ccw
.count
- sizeof(vdev
->status
);;
464 case CCW_CMD_WRITE_STATUS
:
466 if (ccw
.count
!= sizeof(status
)) {
470 } else if (ccw
.count
< sizeof(status
)) {
471 /* Can't execute command. */
478 status
= address_space_ldub(&address_space_memory
, ccw
.cda
,
479 MEMTXATTRS_UNSPECIFIED
, NULL
);
480 if (!(status
& VIRTIO_CONFIG_S_DRIVER_OK
)) {
481 virtio_ccw_stop_ioeventfd(dev
);
483 if (virtio_set_status(vdev
, status
) == 0) {
484 if (vdev
->status
== 0) {
485 virtio_ccw_reset_virtio(dev
, vdev
);
487 if (status
& VIRTIO_CONFIG_S_DRIVER_OK
) {
488 virtio_ccw_start_ioeventfd(dev
);
490 sch
->curr_status
.scsw
.count
= ccw
.count
- sizeof(status
);
493 /* Trigger a command reject. */
498 case CCW_CMD_SET_IND
:
500 if (ccw
.count
!= sizeof(indicators
)) {
504 } else if (ccw
.count
< sizeof(indicators
)) {
505 /* Can't execute command. */
509 if (sch
->thinint_active
) {
510 /* Trigger a command reject. */
514 if (virtio_get_num_queues(vdev
) > NR_CLASSIC_INDICATOR_BITS
) {
515 /* More queues than indicator bits --> trigger a reject */
522 indicators
= address_space_ldq_be(&address_space_memory
, ccw
.cda
,
523 MEMTXATTRS_UNSPECIFIED
, NULL
);
524 dev
->indicators
= get_indicator(indicators
, sizeof(uint64_t));
525 sch
->curr_status
.scsw
.count
= ccw
.count
- sizeof(indicators
);
529 case CCW_CMD_SET_CONF_IND
:
531 if (ccw
.count
!= sizeof(indicators
)) {
535 } else if (ccw
.count
< sizeof(indicators
)) {
536 /* Can't execute command. */
543 indicators
= address_space_ldq_be(&address_space_memory
, ccw
.cda
,
544 MEMTXATTRS_UNSPECIFIED
, NULL
);
545 dev
->indicators2
= get_indicator(indicators
, sizeof(uint64_t));
546 sch
->curr_status
.scsw
.count
= ccw
.count
- sizeof(indicators
);
550 case CCW_CMD_READ_VQ_CONF
:
552 if (ccw
.count
!= sizeof(vq_config
)) {
556 } else if (ccw
.count
< sizeof(vq_config
)) {
557 /* Can't execute command. */
564 vq_config
.index
= address_space_lduw_be(&address_space_memory
,
566 MEMTXATTRS_UNSPECIFIED
,
568 if (vq_config
.index
>= VIRTIO_QUEUE_MAX
) {
572 vq_config
.num_max
= virtio_queue_get_num(vdev
,
574 address_space_stw_be(&address_space_memory
,
575 ccw
.cda
+ sizeof(vq_config
.index
),
577 MEMTXATTRS_UNSPECIFIED
,
579 sch
->curr_status
.scsw
.count
= ccw
.count
- sizeof(vq_config
);
583 case CCW_CMD_SET_IND_ADAPTER
:
585 if (ccw
.count
!= sizeof(*thinint
)) {
589 } else if (ccw
.count
< sizeof(*thinint
)) {
590 /* Can't execute command. */
594 len
= sizeof(*thinint
);
598 } else if (dev
->indicators
&& !sch
->thinint_active
) {
599 /* Trigger a command reject. */
602 thinint
= cpu_physical_memory_map(ccw
.cda
, &hw_len
, 0);
606 uint64_t ind_bit
= ldq_be_p(&thinint
->ind_bit
);
609 dev
->summary_indicator
=
610 get_indicator(ldq_be_p(&thinint
->summary_indicator
),
613 get_indicator(ldq_be_p(&thinint
->device_indicator
),
615 dev
->thinint_isc
= thinint
->isc
;
616 dev
->routes
.adapter
.ind_offset
= ind_bit
;
617 dev
->routes
.adapter
.summary_offset
= 7;
618 cpu_physical_memory_unmap(thinint
, hw_len
, 0, hw_len
);
619 ret
= css_register_io_adapter(CSS_IO_ADAPTER_VIRTIO
,
620 dev
->thinint_isc
, true, false,
621 &dev
->routes
.adapter
.adapter_id
);
623 sch
->thinint_active
= ((dev
->indicators
!= NULL
) &&
624 (dev
->summary_indicator
!= NULL
));
625 sch
->curr_status
.scsw
.count
= ccw
.count
- len
;
630 case CCW_CMD_SET_VIRTIO_REV
:
631 len
= sizeof(revinfo
);
632 if (ccw
.count
< len
) {
641 address_space_lduw_be(&address_space_memory
, ccw
.cda
,
642 MEMTXATTRS_UNSPECIFIED
, NULL
);
644 address_space_lduw_be(&address_space_memory
,
645 ccw
.cda
+ sizeof(revinfo
.revision
),
646 MEMTXATTRS_UNSPECIFIED
, NULL
);
647 if (ccw
.count
< len
+ revinfo
.length
||
648 (check_len
&& ccw
.count
> len
+ revinfo
.length
)) {
653 * Once we start to support revisions with additional data, we'll
654 * need to fetch it here. Nothing to do for now, though.
656 if (dev
->revision
>= 0 ||
657 revinfo
.revision
> virtio_ccw_rev_max(dev
) ||
658 (dev
->force_revision_1
&& !revinfo
.revision
)) {
663 dev
->revision
= revinfo
.revision
;
672 static void virtio_sch_disable_cb(SubchDev
*sch
)
674 VirtioCcwDevice
*dev
= sch
->driver_data
;
679 static void virtio_ccw_device_realize(VirtioCcwDevice
*dev
, Error
**errp
)
681 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_GET_CLASS(dev
);
682 CcwDevice
*ccw_dev
= CCW_DEVICE(dev
);
683 SubchDev
*sch
= css_create_virtual_sch(ccw_dev
->bus_id
, errp
);
689 if (!virtio_ccw_rev_max(dev
) && dev
->force_revision_1
) {
690 error_setg(&err
, "Invalid value of property max_rev "
691 "(is %d expected >= 1)", virtio_ccw_rev_max(dev
));
692 error_propagate(errp
, err
);
696 sch
->driver_data
= dev
;
697 sch
->ccw_cb
= virtio_ccw_cb
;
698 sch
->disable_cb
= virtio_sch_disable_cb
;
699 sch
->id
.reserved
= 0xff;
700 sch
->id
.cu_type
= VIRTIO_CCW_CU_TYPE
;
702 dev
->indicators
= NULL
;
704 css_sch_build_virtual_schib(sch
, 0, VIRTIO_CCW_CHPID_TYPE
);
706 trace_virtio_ccw_new_device(
707 sch
->cssid
, sch
->ssid
, sch
->schid
, sch
->devno
,
708 ccw_dev
->bus_id
.valid
? "user-configured" : "auto-configured");
710 if (!kvm_eventfds_enabled()) {
711 dev
->flags
&= ~VIRTIO_CCW_FLAG_USE_IOEVENTFD
;
715 k
->realize(dev
, &err
);
718 error_propagate(errp
, err
);
719 css_subch_assign(sch
->cssid
, sch
->ssid
, sch
->schid
, sch
->devno
, NULL
);
725 static int virtio_ccw_exit(VirtioCcwDevice
*dev
)
727 CcwDevice
*ccw_dev
= CCW_DEVICE(dev
);
728 SubchDev
*sch
= ccw_dev
->sch
;
731 css_subch_assign(sch
->cssid
, sch
->ssid
, sch
->schid
, sch
->devno
, NULL
);
734 if (dev
->indicators
) {
735 release_indicator(&dev
->routes
.adapter
, dev
->indicators
);
736 dev
->indicators
= NULL
;
741 static void virtio_ccw_net_realize(VirtioCcwDevice
*ccw_dev
, Error
**errp
)
743 DeviceState
*qdev
= DEVICE(ccw_dev
);
744 VirtIONetCcw
*dev
= VIRTIO_NET_CCW(ccw_dev
);
745 DeviceState
*vdev
= DEVICE(&dev
->vdev
);
747 virtio_net_set_netclient_name(&dev
->vdev
, qdev
->id
,
748 object_get_typename(OBJECT(qdev
)));
749 qdev_set_parent_bus(vdev
, BUS(&ccw_dev
->bus
));
750 object_property_set_bool(OBJECT(vdev
), true, "realized", errp
);
753 static void virtio_ccw_net_instance_init(Object
*obj
)
755 VirtIONetCcw
*dev
= VIRTIO_NET_CCW(obj
);
757 virtio_instance_init_common(obj
, &dev
->vdev
, sizeof(dev
->vdev
),
759 object_property_add_alias(obj
, "bootindex", OBJECT(&dev
->vdev
),
760 "bootindex", &error_abort
);
763 static void virtio_ccw_blk_realize(VirtioCcwDevice
*ccw_dev
, Error
**errp
)
765 VirtIOBlkCcw
*dev
= VIRTIO_BLK_CCW(ccw_dev
);
766 DeviceState
*vdev
= DEVICE(&dev
->vdev
);
768 qdev_set_parent_bus(vdev
, BUS(&ccw_dev
->bus
));
769 object_property_set_bool(OBJECT(vdev
), true, "realized", errp
);
772 static void virtio_ccw_blk_instance_init(Object
*obj
)
774 VirtIOBlkCcw
*dev
= VIRTIO_BLK_CCW(obj
);
776 virtio_instance_init_common(obj
, &dev
->vdev
, sizeof(dev
->vdev
),
778 object_property_add_alias(obj
, "iothread", OBJECT(&dev
->vdev
),"iothread",
780 object_property_add_alias(obj
, "bootindex", OBJECT(&dev
->vdev
),
781 "bootindex", &error_abort
);
784 static void virtio_ccw_serial_realize(VirtioCcwDevice
*ccw_dev
, Error
**errp
)
786 VirtioSerialCcw
*dev
= VIRTIO_SERIAL_CCW(ccw_dev
);
787 DeviceState
*vdev
= DEVICE(&dev
->vdev
);
788 DeviceState
*proxy
= DEVICE(ccw_dev
);
792 * For command line compatibility, this sets the virtio-serial-device bus
796 bus_name
= g_strdup_printf("%s.0", proxy
->id
);
797 virtio_device_set_child_bus_name(VIRTIO_DEVICE(vdev
), bus_name
);
801 qdev_set_parent_bus(vdev
, BUS(&ccw_dev
->bus
));
802 object_property_set_bool(OBJECT(vdev
), true, "realized", errp
);
806 static void virtio_ccw_serial_instance_init(Object
*obj
)
808 VirtioSerialCcw
*dev
= VIRTIO_SERIAL_CCW(obj
);
810 virtio_instance_init_common(obj
, &dev
->vdev
, sizeof(dev
->vdev
),
814 static void virtio_ccw_balloon_realize(VirtioCcwDevice
*ccw_dev
, Error
**errp
)
816 VirtIOBalloonCcw
*dev
= VIRTIO_BALLOON_CCW(ccw_dev
);
817 DeviceState
*vdev
= DEVICE(&dev
->vdev
);
819 qdev_set_parent_bus(vdev
, BUS(&ccw_dev
->bus
));
820 object_property_set_bool(OBJECT(vdev
), true, "realized", errp
);
823 static void virtio_ccw_balloon_instance_init(Object
*obj
)
825 VirtIOBalloonCcw
*dev
= VIRTIO_BALLOON_CCW(obj
);
827 virtio_instance_init_common(obj
, &dev
->vdev
, sizeof(dev
->vdev
),
828 TYPE_VIRTIO_BALLOON
);
829 object_property_add_alias(obj
, "guest-stats", OBJECT(&dev
->vdev
),
830 "guest-stats", &error_abort
);
831 object_property_add_alias(obj
, "guest-stats-polling-interval",
833 "guest-stats-polling-interval", &error_abort
);
836 static void virtio_ccw_scsi_realize(VirtioCcwDevice
*ccw_dev
, Error
**errp
)
838 VirtIOSCSICcw
*dev
= VIRTIO_SCSI_CCW(ccw_dev
);
839 DeviceState
*vdev
= DEVICE(&dev
->vdev
);
840 DeviceState
*qdev
= DEVICE(ccw_dev
);
844 * For command line compatibility, this sets the virtio-scsi-device bus
848 bus_name
= g_strdup_printf("%s.0", qdev
->id
);
849 virtio_device_set_child_bus_name(VIRTIO_DEVICE(vdev
), bus_name
);
853 qdev_set_parent_bus(vdev
, BUS(&ccw_dev
->bus
));
854 object_property_set_bool(OBJECT(vdev
), true, "realized", errp
);
857 static void virtio_ccw_scsi_instance_init(Object
*obj
)
859 VirtIOSCSICcw
*dev
= VIRTIO_SCSI_CCW(obj
);
861 virtio_instance_init_common(obj
, &dev
->vdev
, sizeof(dev
->vdev
),
863 object_property_add_alias(obj
, "iothread", OBJECT(&dev
->vdev
), "iothread",
867 #ifdef CONFIG_VHOST_SCSI
868 static void vhost_ccw_scsi_realize(VirtioCcwDevice
*ccw_dev
, Error
**errp
)
870 VHostSCSICcw
*dev
= VHOST_SCSI_CCW(ccw_dev
);
871 DeviceState
*vdev
= DEVICE(&dev
->vdev
);
873 qdev_set_parent_bus(vdev
, BUS(&ccw_dev
->bus
));
874 object_property_set_bool(OBJECT(vdev
), true, "realized", errp
);
877 static void vhost_ccw_scsi_instance_init(Object
*obj
)
879 VHostSCSICcw
*dev
= VHOST_SCSI_CCW(obj
);
881 virtio_instance_init_common(obj
, &dev
->vdev
, sizeof(dev
->vdev
),
886 static void virtio_ccw_rng_realize(VirtioCcwDevice
*ccw_dev
, Error
**errp
)
888 VirtIORNGCcw
*dev
= VIRTIO_RNG_CCW(ccw_dev
);
889 DeviceState
*vdev
= DEVICE(&dev
->vdev
);
892 qdev_set_parent_bus(vdev
, BUS(&ccw_dev
->bus
));
893 object_property_set_bool(OBJECT(vdev
), true, "realized", &err
);
895 error_propagate(errp
, err
);
899 object_property_set_link(OBJECT(dev
),
900 OBJECT(dev
->vdev
.conf
.rng
), "rng",
904 static void virtio_ccw_crypto_realize(VirtioCcwDevice
*ccw_dev
, Error
**errp
)
906 VirtIOCryptoCcw
*dev
= VIRTIO_CRYPTO_CCW(ccw_dev
);
907 DeviceState
*vdev
= DEVICE(&dev
->vdev
);
910 qdev_set_parent_bus(vdev
, BUS(&ccw_dev
->bus
));
911 object_property_set_bool(OBJECT(vdev
), true, "realized", &err
);
913 error_propagate(errp
, err
);
917 object_property_set_link(OBJECT(vdev
),
918 OBJECT(dev
->vdev
.conf
.cryptodev
), "cryptodev",
922 /* DeviceState to VirtioCcwDevice. Note: used on datapath,
923 * be careful and test performance if you change this.
925 static inline VirtioCcwDevice
*to_virtio_ccw_dev_fast(DeviceState
*d
)
927 CcwDevice
*ccw_dev
= to_ccw_dev_fast(d
);
929 return container_of(ccw_dev
, VirtioCcwDevice
, parent_obj
);
932 static uint8_t virtio_set_ind_atomic(SubchDev
*sch
, uint64_t ind_loc
,
935 uint8_t ind_old
, ind_new
;
939 ind_addr
= cpu_physical_memory_map(ind_loc
, &len
, 1);
941 error_report("%s(%x.%x.%04x): unable to access indicator",
942 __func__
, sch
->cssid
, sch
->ssid
, sch
->schid
);
947 ind_new
= ind_old
| to_be_set
;
948 } while (atomic_cmpxchg(ind_addr
, ind_old
, ind_new
) != ind_old
);
949 trace_virtio_ccw_set_ind(ind_loc
, ind_old
, ind_new
);
950 cpu_physical_memory_unmap(ind_addr
, len
, 1, len
);
955 static void virtio_ccw_notify(DeviceState
*d
, uint16_t vector
)
957 VirtioCcwDevice
*dev
= to_virtio_ccw_dev_fast(d
);
958 CcwDevice
*ccw_dev
= to_ccw_dev_fast(d
);
959 SubchDev
*sch
= ccw_dev
->sch
;
962 /* queue indicators + secondary indicators */
963 if (vector
>= VIRTIO_QUEUE_MAX
+ 64) {
967 if (vector
< VIRTIO_QUEUE_MAX
) {
968 if (!dev
->indicators
) {
971 if (sch
->thinint_active
) {
973 * In the adapter interrupt case, indicators points to a
974 * memory area that may be (way) larger than 64 bit and
975 * ind_bit indicates the start of the indicators in a big
978 uint64_t ind_bit
= dev
->routes
.adapter
.ind_offset
;
980 virtio_set_ind_atomic(sch
, dev
->indicators
->addr
+
981 (ind_bit
+ vector
) / 8,
982 0x80 >> ((ind_bit
+ vector
) % 8));
983 if (!virtio_set_ind_atomic(sch
, dev
->summary_indicator
->addr
,
985 css_adapter_interrupt(dev
->thinint_isc
);
988 indicators
= address_space_ldq(&address_space_memory
,
989 dev
->indicators
->addr
,
990 MEMTXATTRS_UNSPECIFIED
,
992 indicators
|= 1ULL << vector
;
993 address_space_stq(&address_space_memory
, dev
->indicators
->addr
,
994 indicators
, MEMTXATTRS_UNSPECIFIED
, NULL
);
995 css_conditional_io_interrupt(sch
);
998 if (!dev
->indicators2
) {
1002 indicators
= address_space_ldq(&address_space_memory
,
1003 dev
->indicators2
->addr
,
1004 MEMTXATTRS_UNSPECIFIED
,
1006 indicators
|= 1ULL << vector
;
1007 address_space_stq(&address_space_memory
, dev
->indicators2
->addr
,
1008 indicators
, MEMTXATTRS_UNSPECIFIED
, NULL
);
1009 css_conditional_io_interrupt(sch
);
1013 static void virtio_ccw_reset(DeviceState
*d
)
1015 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
1016 VirtIODevice
*vdev
= virtio_bus_get_device(&dev
->bus
);
1017 CcwDevice
*ccw_dev
= CCW_DEVICE(d
);
1019 virtio_ccw_reset_virtio(dev
, vdev
);
1020 css_reset_sch(ccw_dev
->sch
);
1023 static void virtio_ccw_vmstate_change(DeviceState
*d
, bool running
)
1025 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
1028 virtio_ccw_start_ioeventfd(dev
);
1030 virtio_ccw_stop_ioeventfd(dev
);
1034 static bool virtio_ccw_query_guest_notifiers(DeviceState
*d
)
1036 CcwDevice
*dev
= CCW_DEVICE(d
);
1038 return !!(dev
->sch
->curr_status
.pmcw
.flags
& PMCW_FLAGS_MASK_ENA
);
1041 static int virtio_ccw_get_mappings(VirtioCcwDevice
*dev
)
1044 CcwDevice
*ccw_dev
= CCW_DEVICE(dev
);
1046 if (!ccw_dev
->sch
->thinint_active
) {
1050 r
= map_indicator(&dev
->routes
.adapter
, dev
->summary_indicator
);
1054 r
= map_indicator(&dev
->routes
.adapter
, dev
->indicators
);
1058 dev
->routes
.adapter
.summary_addr
= dev
->summary_indicator
->map
;
1059 dev
->routes
.adapter
.ind_addr
= dev
->indicators
->map
;
1064 static int virtio_ccw_setup_irqroutes(VirtioCcwDevice
*dev
, int nvqs
)
1067 VirtIODevice
*vdev
= virtio_bus_get_device(&dev
->bus
);
1069 S390FLICState
*fs
= s390_get_flic();
1070 S390FLICStateClass
*fsc
= S390_FLIC_COMMON_GET_CLASS(fs
);
1072 ret
= virtio_ccw_get_mappings(dev
);
1076 for (i
= 0; i
< nvqs
; i
++) {
1077 if (!virtio_queue_get_num(vdev
, i
)) {
1081 dev
->routes
.num_routes
= i
;
1082 return fsc
->add_adapter_routes(fs
, &dev
->routes
);
1085 static void virtio_ccw_release_irqroutes(VirtioCcwDevice
*dev
, int nvqs
)
1087 S390FLICState
*fs
= s390_get_flic();
1088 S390FLICStateClass
*fsc
= S390_FLIC_COMMON_GET_CLASS(fs
);
1090 fsc
->release_adapter_routes(fs
, &dev
->routes
);
1093 static int virtio_ccw_add_irqfd(VirtioCcwDevice
*dev
, int n
)
1095 VirtIODevice
*vdev
= virtio_bus_get_device(&dev
->bus
);
1096 VirtQueue
*vq
= virtio_get_queue(vdev
, n
);
1097 EventNotifier
*notifier
= virtio_queue_get_guest_notifier(vq
);
1099 return kvm_irqchip_add_irqfd_notifier_gsi(kvm_state
, notifier
, NULL
,
1100 dev
->routes
.gsi
[n
]);
1103 static void virtio_ccw_remove_irqfd(VirtioCcwDevice
*dev
, int n
)
1105 VirtIODevice
*vdev
= virtio_bus_get_device(&dev
->bus
);
1106 VirtQueue
*vq
= virtio_get_queue(vdev
, n
);
1107 EventNotifier
*notifier
= virtio_queue_get_guest_notifier(vq
);
1110 ret
= kvm_irqchip_remove_irqfd_notifier_gsi(kvm_state
, notifier
,
1111 dev
->routes
.gsi
[n
]);
1115 static int virtio_ccw_set_guest_notifier(VirtioCcwDevice
*dev
, int n
,
1116 bool assign
, bool with_irqfd
)
1118 VirtIODevice
*vdev
= virtio_bus_get_device(&dev
->bus
);
1119 VirtQueue
*vq
= virtio_get_queue(vdev
, n
);
1120 EventNotifier
*notifier
= virtio_queue_get_guest_notifier(vq
);
1121 VirtioDeviceClass
*k
= VIRTIO_DEVICE_GET_CLASS(vdev
);
1124 int r
= event_notifier_init(notifier
, 0);
1129 virtio_queue_set_guest_notifier_fd_handler(vq
, true, with_irqfd
);
1131 r
= virtio_ccw_add_irqfd(dev
, n
);
1133 virtio_queue_set_guest_notifier_fd_handler(vq
, false,
1139 * We do not support individual masking for channel devices, so we
1140 * need to manually trigger any guest masking callbacks here.
1142 if (k
->guest_notifier_mask
&& vdev
->use_guest_notifier_mask
) {
1143 k
->guest_notifier_mask(vdev
, n
, false);
1145 /* get lost events and re-inject */
1146 if (k
->guest_notifier_pending
&&
1147 k
->guest_notifier_pending(vdev
, n
)) {
1148 event_notifier_set(notifier
);
1151 if (k
->guest_notifier_mask
&& vdev
->use_guest_notifier_mask
) {
1152 k
->guest_notifier_mask(vdev
, n
, true);
1155 virtio_ccw_remove_irqfd(dev
, n
);
1157 virtio_queue_set_guest_notifier_fd_handler(vq
, false, with_irqfd
);
1158 event_notifier_cleanup(notifier
);
1163 static int virtio_ccw_set_guest_notifiers(DeviceState
*d
, int nvqs
,
1166 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
1167 VirtIODevice
*vdev
= virtio_bus_get_device(&dev
->bus
);
1168 CcwDevice
*ccw_dev
= CCW_DEVICE(d
);
1169 bool with_irqfd
= ccw_dev
->sch
->thinint_active
&& kvm_irqfds_enabled();
1172 if (with_irqfd
&& assigned
) {
1173 /* irq routes need to be set up before assigning irqfds */
1174 r
= virtio_ccw_setup_irqroutes(dev
, nvqs
);
1176 goto irqroute_error
;
1179 for (n
= 0; n
< nvqs
; n
++) {
1180 if (!virtio_queue_get_num(vdev
, n
)) {
1183 r
= virtio_ccw_set_guest_notifier(dev
, n
, assigned
, with_irqfd
);
1188 if (with_irqfd
&& !assigned
) {
1189 /* release irq routes after irqfds have been released */
1190 virtio_ccw_release_irqroutes(dev
, nvqs
);
1196 virtio_ccw_set_guest_notifier(dev
, n
, !assigned
, false);
1199 if (with_irqfd
&& assigned
) {
1200 virtio_ccw_release_irqroutes(dev
, nvqs
);
1205 static void virtio_ccw_save_queue(DeviceState
*d
, int n
, QEMUFile
*f
)
1207 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
1208 VirtIODevice
*vdev
= virtio_bus_get_device(&dev
->bus
);
1210 qemu_put_be16(f
, virtio_queue_vector(vdev
, n
));
1213 static int virtio_ccw_load_queue(DeviceState
*d
, int n
, QEMUFile
*f
)
1215 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
1216 VirtIODevice
*vdev
= virtio_bus_get_device(&dev
->bus
);
1219 qemu_get_be16s(f
, &vector
);
1220 virtio_queue_set_vector(vdev
, n
, vector
);
1225 static void virtio_ccw_save_config(DeviceState
*d
, QEMUFile
*f
)
1227 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
1228 CcwDevice
*ccw_dev
= CCW_DEVICE(d
);
1229 SubchDev
*s
= ccw_dev
->sch
;
1230 VirtIODevice
*vdev
= virtio_ccw_get_vdev(s
);
1232 subch_device_save(s
, f
);
1233 if (dev
->indicators
!= NULL
) {
1234 qemu_put_be32(f
, dev
->indicators
->len
);
1235 qemu_put_be64(f
, dev
->indicators
->addr
);
1237 qemu_put_be32(f
, 0);
1238 qemu_put_be64(f
, 0UL);
1240 if (dev
->indicators2
!= NULL
) {
1241 qemu_put_be32(f
, dev
->indicators2
->len
);
1242 qemu_put_be64(f
, dev
->indicators2
->addr
);
1244 qemu_put_be32(f
, 0);
1245 qemu_put_be64(f
, 0UL);
1247 if (dev
->summary_indicator
!= NULL
) {
1248 qemu_put_be32(f
, dev
->summary_indicator
->len
);
1249 qemu_put_be64(f
, dev
->summary_indicator
->addr
);
1251 qemu_put_be32(f
, 0);
1252 qemu_put_be64(f
, 0UL);
1254 qemu_put_be16(f
, vdev
->config_vector
);
1255 qemu_put_be64(f
, dev
->routes
.adapter
.ind_offset
);
1256 qemu_put_byte(f
, dev
->thinint_isc
);
1257 qemu_put_be32(f
, dev
->revision
);
1260 static int virtio_ccw_load_config(DeviceState
*d
, QEMUFile
*f
)
1262 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
1263 CcwDevice
*ccw_dev
= CCW_DEVICE(d
);
1264 SubchDev
*s
= ccw_dev
->sch
;
1265 VirtIODevice
*vdev
= virtio_ccw_get_vdev(s
);
1268 s
->driver_data
= dev
;
1269 subch_device_load(s
, f
);
1270 len
= qemu_get_be32(f
);
1272 dev
->indicators
= get_indicator(qemu_get_be64(f
), len
);
1275 dev
->indicators
= NULL
;
1277 len
= qemu_get_be32(f
);
1279 dev
->indicators2
= get_indicator(qemu_get_be64(f
), len
);
1282 dev
->indicators2
= NULL
;
1284 len
= qemu_get_be32(f
);
1286 dev
->summary_indicator
= get_indicator(qemu_get_be64(f
), len
);
1289 dev
->summary_indicator
= NULL
;
1291 qemu_get_be16s(f
, &vdev
->config_vector
);
1292 dev
->routes
.adapter
.ind_offset
= qemu_get_be64(f
);
1293 dev
->thinint_isc
= qemu_get_byte(f
);
1294 dev
->revision
= qemu_get_be32(f
);
1295 if (s
->thinint_active
) {
1296 return css_register_io_adapter(CSS_IO_ADAPTER_VIRTIO
,
1297 dev
->thinint_isc
, true, false,
1298 &dev
->routes
.adapter
.adapter_id
);
1304 static void virtio_ccw_pre_plugged(DeviceState
*d
, Error
**errp
)
1306 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
1307 VirtIODevice
*vdev
= virtio_bus_get_device(&dev
->bus
);
1309 if (dev
->max_rev
>= 1) {
1310 virtio_add_feature(&vdev
->host_features
, VIRTIO_F_VERSION_1
);
1314 /* This is called by virtio-bus just after the device is plugged. */
1315 static void virtio_ccw_device_plugged(DeviceState
*d
, Error
**errp
)
1317 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
1318 VirtIODevice
*vdev
= virtio_bus_get_device(&dev
->bus
);
1319 CcwDevice
*ccw_dev
= CCW_DEVICE(d
);
1320 SubchDev
*sch
= ccw_dev
->sch
;
1321 int n
= virtio_get_num_queues(vdev
);
1322 S390FLICState
*flic
= s390_get_flic();
1324 if (!virtio_has_feature(vdev
->host_features
, VIRTIO_F_VERSION_1
)) {
1328 if (virtio_get_num_queues(vdev
) > VIRTIO_QUEUE_MAX
) {
1329 error_setg(errp
, "The number of virtqueues %d "
1330 "exceeds virtio limit %d", n
,
1334 if (virtio_get_num_queues(vdev
) > flic
->adapter_routes_max_batch
) {
1335 error_setg(errp
, "The number of virtqueues %d "
1336 "exceeds flic adapter route limit %d", n
,
1337 flic
->adapter_routes_max_batch
);
1341 sch
->id
.cu_model
= virtio_bus_get_vdev_id(&dev
->bus
);
1344 css_generate_sch_crws(sch
->cssid
, sch
->ssid
, sch
->schid
,
1348 static void virtio_ccw_device_unplugged(DeviceState
*d
)
1350 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
1352 virtio_ccw_stop_ioeventfd(dev
);
1354 /**************** Virtio-ccw Bus Device Descriptions *******************/
1356 static Property virtio_ccw_net_properties
[] = {
1357 DEFINE_PROP_CSS_DEV_ID("devno", VirtioCcwDevice
, parent_obj
.bus_id
),
1358 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice
, flags
,
1359 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT
, true),
1360 DEFINE_PROP_UINT32("max_revision", VirtioCcwDevice
, max_rev
,
1361 VIRTIO_CCW_MAX_REV
),
1362 DEFINE_PROP_END_OF_LIST(),
1365 static void virtio_ccw_net_class_init(ObjectClass
*klass
, void *data
)
1367 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1368 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_CLASS(klass
);
1370 k
->realize
= virtio_ccw_net_realize
;
1371 k
->exit
= virtio_ccw_exit
;
1372 dc
->reset
= virtio_ccw_reset
;
1373 dc
->props
= virtio_ccw_net_properties
;
1374 set_bit(DEVICE_CATEGORY_NETWORK
, dc
->categories
);
1377 static const TypeInfo virtio_ccw_net
= {
1378 .name
= TYPE_VIRTIO_NET_CCW
,
1379 .parent
= TYPE_VIRTIO_CCW_DEVICE
,
1380 .instance_size
= sizeof(VirtIONetCcw
),
1381 .instance_init
= virtio_ccw_net_instance_init
,
1382 .class_init
= virtio_ccw_net_class_init
,
1385 static Property virtio_ccw_blk_properties
[] = {
1386 DEFINE_PROP_CSS_DEV_ID("devno", VirtioCcwDevice
, parent_obj
.bus_id
),
1387 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice
, flags
,
1388 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT
, true),
1389 DEFINE_PROP_UINT32("max_revision", VirtioCcwDevice
, max_rev
,
1390 VIRTIO_CCW_MAX_REV
),
1391 DEFINE_PROP_END_OF_LIST(),
1394 static void virtio_ccw_blk_class_init(ObjectClass
*klass
, void *data
)
1396 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1397 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_CLASS(klass
);
1399 k
->realize
= virtio_ccw_blk_realize
;
1400 k
->exit
= virtio_ccw_exit
;
1401 dc
->reset
= virtio_ccw_reset
;
1402 dc
->props
= virtio_ccw_blk_properties
;
1403 set_bit(DEVICE_CATEGORY_STORAGE
, dc
->categories
);
1406 static const TypeInfo virtio_ccw_blk
= {
1407 .name
= TYPE_VIRTIO_BLK_CCW
,
1408 .parent
= TYPE_VIRTIO_CCW_DEVICE
,
1409 .instance_size
= sizeof(VirtIOBlkCcw
),
1410 .instance_init
= virtio_ccw_blk_instance_init
,
1411 .class_init
= virtio_ccw_blk_class_init
,
1414 static Property virtio_ccw_serial_properties
[] = {
1415 DEFINE_PROP_CSS_DEV_ID("devno", VirtioCcwDevice
, parent_obj
.bus_id
),
1416 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice
, flags
,
1417 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT
, true),
1418 DEFINE_PROP_UINT32("max_revision", VirtioCcwDevice
, max_rev
,
1419 VIRTIO_CCW_MAX_REV
),
1420 DEFINE_PROP_END_OF_LIST(),
1423 static void virtio_ccw_serial_class_init(ObjectClass
*klass
, void *data
)
1425 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1426 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_CLASS(klass
);
1428 k
->realize
= virtio_ccw_serial_realize
;
1429 k
->exit
= virtio_ccw_exit
;
1430 dc
->reset
= virtio_ccw_reset
;
1431 dc
->props
= virtio_ccw_serial_properties
;
1432 set_bit(DEVICE_CATEGORY_INPUT
, dc
->categories
);
1435 static const TypeInfo virtio_ccw_serial
= {
1436 .name
= TYPE_VIRTIO_SERIAL_CCW
,
1437 .parent
= TYPE_VIRTIO_CCW_DEVICE
,
1438 .instance_size
= sizeof(VirtioSerialCcw
),
1439 .instance_init
= virtio_ccw_serial_instance_init
,
1440 .class_init
= virtio_ccw_serial_class_init
,
1443 static Property virtio_ccw_balloon_properties
[] = {
1444 DEFINE_PROP_CSS_DEV_ID("devno", VirtioCcwDevice
, parent_obj
.bus_id
),
1445 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice
, flags
,
1446 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT
, true),
1447 DEFINE_PROP_UINT32("max_revision", VirtioCcwDevice
, max_rev
,
1448 VIRTIO_CCW_MAX_REV
),
1449 DEFINE_PROP_END_OF_LIST(),
1452 static void virtio_ccw_balloon_class_init(ObjectClass
*klass
, void *data
)
1454 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1455 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_CLASS(klass
);
1457 k
->realize
= virtio_ccw_balloon_realize
;
1458 k
->exit
= virtio_ccw_exit
;
1459 dc
->reset
= virtio_ccw_reset
;
1460 dc
->props
= virtio_ccw_balloon_properties
;
1461 set_bit(DEVICE_CATEGORY_MISC
, dc
->categories
);
1464 static const TypeInfo virtio_ccw_balloon
= {
1465 .name
= TYPE_VIRTIO_BALLOON_CCW
,
1466 .parent
= TYPE_VIRTIO_CCW_DEVICE
,
1467 .instance_size
= sizeof(VirtIOBalloonCcw
),
1468 .instance_init
= virtio_ccw_balloon_instance_init
,
1469 .class_init
= virtio_ccw_balloon_class_init
,
1472 static Property virtio_ccw_scsi_properties
[] = {
1473 DEFINE_PROP_CSS_DEV_ID("devno", VirtioCcwDevice
, parent_obj
.bus_id
),
1474 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice
, flags
,
1475 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT
, true),
1476 DEFINE_PROP_UINT32("max_revision", VirtioCcwDevice
, max_rev
,
1477 VIRTIO_CCW_MAX_REV
),
1478 DEFINE_PROP_END_OF_LIST(),
1481 static void virtio_ccw_scsi_class_init(ObjectClass
*klass
, void *data
)
1483 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1484 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_CLASS(klass
);
1486 k
->realize
= virtio_ccw_scsi_realize
;
1487 k
->exit
= virtio_ccw_exit
;
1488 dc
->reset
= virtio_ccw_reset
;
1489 dc
->props
= virtio_ccw_scsi_properties
;
1490 set_bit(DEVICE_CATEGORY_STORAGE
, dc
->categories
);
1493 static const TypeInfo virtio_ccw_scsi
= {
1494 .name
= TYPE_VIRTIO_SCSI_CCW
,
1495 .parent
= TYPE_VIRTIO_CCW_DEVICE
,
1496 .instance_size
= sizeof(VirtIOSCSICcw
),
1497 .instance_init
= virtio_ccw_scsi_instance_init
,
1498 .class_init
= virtio_ccw_scsi_class_init
,
1501 #ifdef CONFIG_VHOST_SCSI
1502 static Property vhost_ccw_scsi_properties
[] = {
1503 DEFINE_PROP_CSS_DEV_ID("devno", VirtioCcwDevice
, parent_obj
.bus_id
),
1504 DEFINE_PROP_UINT32("max_revision", VirtioCcwDevice
, max_rev
,
1505 VIRTIO_CCW_MAX_REV
),
1506 DEFINE_PROP_END_OF_LIST(),
1509 static void vhost_ccw_scsi_class_init(ObjectClass
*klass
, void *data
)
1511 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1512 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_CLASS(klass
);
1514 k
->realize
= vhost_ccw_scsi_realize
;
1515 k
->exit
= virtio_ccw_exit
;
1516 dc
->reset
= virtio_ccw_reset
;
1517 dc
->props
= vhost_ccw_scsi_properties
;
1518 set_bit(DEVICE_CATEGORY_STORAGE
, dc
->categories
);
1521 static const TypeInfo vhost_ccw_scsi
= {
1522 .name
= TYPE_VHOST_SCSI_CCW
,
1523 .parent
= TYPE_VIRTIO_CCW_DEVICE
,
1524 .instance_size
= sizeof(VHostSCSICcw
),
1525 .instance_init
= vhost_ccw_scsi_instance_init
,
1526 .class_init
= vhost_ccw_scsi_class_init
,
1530 static void virtio_ccw_rng_instance_init(Object
*obj
)
1532 VirtIORNGCcw
*dev
= VIRTIO_RNG_CCW(obj
);
1534 virtio_instance_init_common(obj
, &dev
->vdev
, sizeof(dev
->vdev
),
1536 object_property_add_alias(obj
, "rng", OBJECT(&dev
->vdev
),
1537 "rng", &error_abort
);
1540 static Property virtio_ccw_rng_properties
[] = {
1541 DEFINE_PROP_CSS_DEV_ID("devno", VirtioCcwDevice
, parent_obj
.bus_id
),
1542 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice
, flags
,
1543 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT
, true),
1544 DEFINE_PROP_UINT32("max_revision", VirtioCcwDevice
, max_rev
,
1545 VIRTIO_CCW_MAX_REV
),
1546 DEFINE_PROP_END_OF_LIST(),
1549 static void virtio_ccw_rng_class_init(ObjectClass
*klass
, void *data
)
1551 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1552 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_CLASS(klass
);
1554 k
->realize
= virtio_ccw_rng_realize
;
1555 k
->exit
= virtio_ccw_exit
;
1556 dc
->reset
= virtio_ccw_reset
;
1557 dc
->props
= virtio_ccw_rng_properties
;
1558 set_bit(DEVICE_CATEGORY_MISC
, dc
->categories
);
1561 static const TypeInfo virtio_ccw_rng
= {
1562 .name
= TYPE_VIRTIO_RNG_CCW
,
1563 .parent
= TYPE_VIRTIO_CCW_DEVICE
,
1564 .instance_size
= sizeof(VirtIORNGCcw
),
1565 .instance_init
= virtio_ccw_rng_instance_init
,
1566 .class_init
= virtio_ccw_rng_class_init
,
1569 static Property virtio_ccw_crypto_properties
[] = {
1570 DEFINE_PROP_CSS_DEV_ID("devno", VirtioCcwDevice
, parent_obj
.bus_id
),
1571 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice
, flags
,
1572 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT
, true),
1573 DEFINE_PROP_UINT32("max_revision", VirtioCcwDevice
, max_rev
,
1574 VIRTIO_CCW_MAX_REV
),
1575 DEFINE_PROP_END_OF_LIST(),
1578 static void virtio_ccw_crypto_instance_init(Object
*obj
)
1580 VirtIOCryptoCcw
*dev
= VIRTIO_CRYPTO_CCW(obj
);
1581 VirtioCcwDevice
*ccw_dev
= VIRTIO_CCW_DEVICE(obj
);
1583 ccw_dev
->force_revision_1
= true;
1584 virtio_instance_init_common(obj
, &dev
->vdev
, sizeof(dev
->vdev
),
1585 TYPE_VIRTIO_CRYPTO
);
1587 object_property_add_alias(obj
, "cryptodev", OBJECT(&dev
->vdev
),
1588 "cryptodev", &error_abort
);
1591 static void virtio_ccw_crypto_class_init(ObjectClass
*klass
, void *data
)
1593 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1594 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_CLASS(klass
);
1596 k
->realize
= virtio_ccw_crypto_realize
;
1597 k
->exit
= virtio_ccw_exit
;
1598 dc
->reset
= virtio_ccw_reset
;
1599 dc
->props
= virtio_ccw_crypto_properties
;
1600 set_bit(DEVICE_CATEGORY_MISC
, dc
->categories
);
1603 static const TypeInfo virtio_ccw_crypto
= {
1604 .name
= TYPE_VIRTIO_CRYPTO_CCW
,
1605 .parent
= TYPE_VIRTIO_CCW_DEVICE
,
1606 .instance_size
= sizeof(VirtIOCryptoCcw
),
1607 .instance_init
= virtio_ccw_crypto_instance_init
,
1608 .class_init
= virtio_ccw_crypto_class_init
,
1611 static void virtio_ccw_busdev_realize(DeviceState
*dev
, Error
**errp
)
1613 VirtioCcwDevice
*_dev
= (VirtioCcwDevice
*)dev
;
1615 virtio_ccw_bus_new(&_dev
->bus
, sizeof(_dev
->bus
), _dev
);
1616 virtio_ccw_device_realize(_dev
, errp
);
1619 static int virtio_ccw_busdev_exit(DeviceState
*dev
)
1621 VirtioCcwDevice
*_dev
= (VirtioCcwDevice
*)dev
;
1622 VirtIOCCWDeviceClass
*_info
= VIRTIO_CCW_DEVICE_GET_CLASS(dev
);
1624 return _info
->exit(_dev
);
1627 static void virtio_ccw_busdev_unplug(HotplugHandler
*hotplug_dev
,
1628 DeviceState
*dev
, Error
**errp
)
1630 VirtioCcwDevice
*_dev
= to_virtio_ccw_dev_fast(dev
);
1632 virtio_ccw_stop_ioeventfd(_dev
);
1635 static void virtio_ccw_device_class_init(ObjectClass
*klass
, void *data
)
1637 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1638 CCWDeviceClass
*k
= CCW_DEVICE_CLASS(dc
);
1640 k
->unplug
= virtio_ccw_busdev_unplug
;
1641 dc
->realize
= virtio_ccw_busdev_realize
;
1642 dc
->exit
= virtio_ccw_busdev_exit
;
1643 dc
->bus_type
= TYPE_VIRTUAL_CSS_BUS
;
1646 static const TypeInfo virtio_ccw_device_info
= {
1647 .name
= TYPE_VIRTIO_CCW_DEVICE
,
1648 .parent
= TYPE_CCW_DEVICE
,
1649 .instance_size
= sizeof(VirtioCcwDevice
),
1650 .class_init
= virtio_ccw_device_class_init
,
1651 .class_size
= sizeof(VirtIOCCWDeviceClass
),
1655 /* virtio-ccw-bus */
1657 static void virtio_ccw_bus_new(VirtioBusState
*bus
, size_t bus_size
,
1658 VirtioCcwDevice
*dev
)
1660 DeviceState
*qdev
= DEVICE(dev
);
1661 char virtio_bus_name
[] = "virtio-bus";
1663 qbus_create_inplace(bus
, bus_size
, TYPE_VIRTIO_CCW_BUS
,
1664 qdev
, virtio_bus_name
);
1667 static void virtio_ccw_bus_class_init(ObjectClass
*klass
, void *data
)
1669 VirtioBusClass
*k
= VIRTIO_BUS_CLASS(klass
);
1670 BusClass
*bus_class
= BUS_CLASS(klass
);
1672 bus_class
->max_dev
= 1;
1673 k
->notify
= virtio_ccw_notify
;
1674 k
->vmstate_change
= virtio_ccw_vmstate_change
;
1675 k
->query_guest_notifiers
= virtio_ccw_query_guest_notifiers
;
1676 k
->set_guest_notifiers
= virtio_ccw_set_guest_notifiers
;
1677 k
->save_queue
= virtio_ccw_save_queue
;
1678 k
->load_queue
= virtio_ccw_load_queue
;
1679 k
->save_config
= virtio_ccw_save_config
;
1680 k
->load_config
= virtio_ccw_load_config
;
1681 k
->pre_plugged
= virtio_ccw_pre_plugged
;
1682 k
->device_plugged
= virtio_ccw_device_plugged
;
1683 k
->device_unplugged
= virtio_ccw_device_unplugged
;
1684 k
->ioeventfd_enabled
= virtio_ccw_ioeventfd_enabled
;
1685 k
->ioeventfd_assign
= virtio_ccw_ioeventfd_assign
;
1688 static const TypeInfo virtio_ccw_bus_info
= {
1689 .name
= TYPE_VIRTIO_CCW_BUS
,
1690 .parent
= TYPE_VIRTIO_BUS
,
1691 .instance_size
= sizeof(VirtioCcwBusState
),
1692 .class_init
= virtio_ccw_bus_class_init
,
1695 #ifdef CONFIG_VIRTFS
1696 static Property virtio_ccw_9p_properties
[] = {
1697 DEFINE_PROP_CSS_DEV_ID("devno", VirtioCcwDevice
, parent_obj
.bus_id
),
1698 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice
, flags
,
1699 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT
, true),
1700 DEFINE_PROP_UINT32("max_revision", VirtioCcwDevice
, max_rev
,
1701 VIRTIO_CCW_MAX_REV
),
1702 DEFINE_PROP_END_OF_LIST(),
1705 static void virtio_ccw_9p_realize(VirtioCcwDevice
*ccw_dev
, Error
**errp
)
1707 V9fsCCWState
*dev
= VIRTIO_9P_CCW(ccw_dev
);
1708 DeviceState
*vdev
= DEVICE(&dev
->vdev
);
1710 qdev_set_parent_bus(vdev
, BUS(&ccw_dev
->bus
));
1711 object_property_set_bool(OBJECT(vdev
), true, "realized", errp
);
1714 static void virtio_ccw_9p_class_init(ObjectClass
*klass
, void *data
)
1716 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1717 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_CLASS(klass
);
1719 k
->exit
= virtio_ccw_exit
;
1720 k
->realize
= virtio_ccw_9p_realize
;
1721 dc
->reset
= virtio_ccw_reset
;
1722 dc
->props
= virtio_ccw_9p_properties
;
1723 set_bit(DEVICE_CATEGORY_STORAGE
, dc
->categories
);
1726 static void virtio_ccw_9p_instance_init(Object
*obj
)
1728 V9fsCCWState
*dev
= VIRTIO_9P_CCW(obj
);
1730 virtio_instance_init_common(obj
, &dev
->vdev
, sizeof(dev
->vdev
),
1734 static const TypeInfo virtio_ccw_9p_info
= {
1735 .name
= TYPE_VIRTIO_9P_CCW
,
1736 .parent
= TYPE_VIRTIO_CCW_DEVICE
,
1737 .instance_size
= sizeof(V9fsCCWState
),
1738 .instance_init
= virtio_ccw_9p_instance_init
,
1739 .class_init
= virtio_ccw_9p_class_init
,
1743 #ifdef CONFIG_VHOST_VSOCK
1745 static Property vhost_vsock_ccw_properties
[] = {
1746 DEFINE_PROP_CSS_DEV_ID("devno", VirtioCcwDevice
, parent_obj
.bus_id
),
1747 DEFINE_PROP_UINT32("max_revision", VirtioCcwDevice
, max_rev
,
1748 VIRTIO_CCW_MAX_REV
),
1749 DEFINE_PROP_END_OF_LIST(),
1752 static void vhost_vsock_ccw_realize(VirtioCcwDevice
*ccw_dev
, Error
**errp
)
1754 VHostVSockCCWState
*dev
= VHOST_VSOCK_CCW(ccw_dev
);
1755 DeviceState
*vdev
= DEVICE(&dev
->vdev
);
1758 qdev_set_parent_bus(vdev
, BUS(&ccw_dev
->bus
));
1759 object_property_set_bool(OBJECT(vdev
), true, "realized", &err
);
1761 error_propagate(errp
, err
);
1765 static void vhost_vsock_ccw_class_init(ObjectClass
*klass
, void *data
)
1767 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1768 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_CLASS(klass
);
1770 k
->realize
= vhost_vsock_ccw_realize
;
1771 k
->exit
= virtio_ccw_exit
;
1772 set_bit(DEVICE_CATEGORY_MISC
, dc
->categories
);
1773 dc
->props
= vhost_vsock_ccw_properties
;
1774 dc
->reset
= virtio_ccw_reset
;
1777 static void vhost_vsock_ccw_instance_init(Object
*obj
)
1779 VHostVSockCCWState
*dev
= VHOST_VSOCK_CCW(obj
);
1781 virtio_instance_init_common(obj
, &dev
->vdev
, sizeof(dev
->vdev
),
1785 static const TypeInfo vhost_vsock_ccw_info
= {
1786 .name
= TYPE_VHOST_VSOCK_CCW
,
1787 .parent
= TYPE_VIRTIO_CCW_DEVICE
,
1788 .instance_size
= sizeof(VHostVSockCCWState
),
1789 .instance_init
= vhost_vsock_ccw_instance_init
,
1790 .class_init
= vhost_vsock_ccw_class_init
,
1794 static void virtio_ccw_register(void)
1796 type_register_static(&virtio_ccw_bus_info
);
1797 type_register_static(&virtio_ccw_device_info
);
1798 type_register_static(&virtio_ccw_serial
);
1799 type_register_static(&virtio_ccw_blk
);
1800 type_register_static(&virtio_ccw_net
);
1801 type_register_static(&virtio_ccw_balloon
);
1802 type_register_static(&virtio_ccw_scsi
);
1803 #ifdef CONFIG_VHOST_SCSI
1804 type_register_static(&vhost_ccw_scsi
);
1806 type_register_static(&virtio_ccw_rng
);
1807 #ifdef CONFIG_VIRTFS
1808 type_register_static(&virtio_ccw_9p_info
);
1810 #ifdef CONFIG_VHOST_VSOCK
1811 type_register_static(&vhost_vsock_ccw_info
);
1813 type_register_static(&virtio_ccw_crypto
);
1816 type_init(virtio_ccw_register
)