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"
37 #include "hw/s390x/s390-virtio-ccw.h"
39 #define NR_CLASSIC_INDICATOR_BITS 64
41 static int virtio_ccw_dev_post_load(void *opaque
, int version_id
)
43 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(opaque
);
44 CcwDevice
*ccw_dev
= CCW_DEVICE(dev
);
45 CCWDeviceClass
*ck
= CCW_DEVICE_GET_CLASS(ccw_dev
);
47 ccw_dev
->sch
->driver_data
= dev
;
48 if (ccw_dev
->sch
->thinint_active
) {
49 dev
->routes
.adapter
.adapter_id
= css_get_adapter_id(
50 CSS_IO_ADAPTER_VIRTIO
,
53 /* Re-fill subch_id after loading the subchannel states.*/
55 ck
->refill_ids(ccw_dev
);
60 typedef struct VirtioCcwDeviceTmp
{
61 VirtioCcwDevice
*parent
;
62 uint16_t config_vector
;
65 static void virtio_ccw_dev_tmp_pre_save(void *opaque
)
67 VirtioCcwDeviceTmp
*tmp
= opaque
;
68 VirtioCcwDevice
*dev
= tmp
->parent
;
69 VirtIODevice
*vdev
= virtio_bus_get_device(&dev
->bus
);
71 tmp
->config_vector
= vdev
->config_vector
;
74 static int virtio_ccw_dev_tmp_post_load(void *opaque
, int version_id
)
76 VirtioCcwDeviceTmp
*tmp
= opaque
;
77 VirtioCcwDevice
*dev
= tmp
->parent
;
78 VirtIODevice
*vdev
= virtio_bus_get_device(&dev
->bus
);
80 vdev
->config_vector
= tmp
->config_vector
;
84 const VMStateDescription vmstate_virtio_ccw_dev_tmp
= {
85 .name
= "s390_virtio_ccw_dev_tmp",
86 .pre_save
= virtio_ccw_dev_tmp_pre_save
,
87 .post_load
= virtio_ccw_dev_tmp_post_load
,
88 .fields
= (VMStateField
[]) {
89 VMSTATE_UINT16(config_vector
, VirtioCcwDeviceTmp
),
94 const VMStateDescription vmstate_virtio_ccw_dev
= {
95 .name
= "s390_virtio_ccw_dev",
97 .minimum_version_id
= 1,
98 .post_load
= virtio_ccw_dev_post_load
,
99 .fields
= (VMStateField
[]) {
100 VMSTATE_CCW_DEVICE(parent_obj
, VirtioCcwDevice
),
101 VMSTATE_PTR_TO_IND_ADDR(indicators
, VirtioCcwDevice
),
102 VMSTATE_PTR_TO_IND_ADDR(indicators2
, VirtioCcwDevice
),
103 VMSTATE_PTR_TO_IND_ADDR(summary_indicator
, VirtioCcwDevice
),
105 * Ugly hack because VirtIODevice does not migrate itself.
106 * This also makes legacy via vmstate_save_state possible.
108 VMSTATE_WITH_TMP(VirtioCcwDevice
, VirtioCcwDeviceTmp
,
109 vmstate_virtio_ccw_dev_tmp
),
110 VMSTATE_STRUCT(routes
, VirtioCcwDevice
, 1, vmstate_adapter_routes
,
112 VMSTATE_UINT8(thinint_isc
, VirtioCcwDevice
),
113 VMSTATE_INT32(revision
, VirtioCcwDevice
),
114 VMSTATE_END_OF_LIST()
118 static void virtio_ccw_bus_new(VirtioBusState
*bus
, size_t bus_size
,
119 VirtioCcwDevice
*dev
);
121 VirtIODevice
*virtio_ccw_get_vdev(SubchDev
*sch
)
123 VirtIODevice
*vdev
= NULL
;
124 VirtioCcwDevice
*dev
= sch
->driver_data
;
127 vdev
= virtio_bus_get_device(&dev
->bus
);
132 static void virtio_ccw_start_ioeventfd(VirtioCcwDevice
*dev
)
134 virtio_bus_start_ioeventfd(&dev
->bus
);
137 static void virtio_ccw_stop_ioeventfd(VirtioCcwDevice
*dev
)
139 virtio_bus_stop_ioeventfd(&dev
->bus
);
142 static bool virtio_ccw_ioeventfd_enabled(DeviceState
*d
)
144 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
146 return (dev
->flags
& VIRTIO_CCW_FLAG_USE_IOEVENTFD
) != 0;
149 static int virtio_ccw_ioeventfd_assign(DeviceState
*d
, EventNotifier
*notifier
,
152 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
153 CcwDevice
*ccw_dev
= CCW_DEVICE(dev
);
154 SubchDev
*sch
= ccw_dev
->sch
;
155 uint32_t sch_id
= (css_build_subchannel_id(sch
) << 16) | sch
->schid
;
157 return s390_assign_subch_ioeventfd(notifier
, sch_id
, n
, assign
);
160 /* Communication blocks used by several channel commands. */
161 typedef struct VqInfoBlockLegacy
{
166 } QEMU_PACKED VqInfoBlockLegacy
;
168 typedef struct VqInfoBlock
{
175 } QEMU_PACKED VqInfoBlock
;
177 typedef struct VqConfigBlock
{
180 } QEMU_PACKED VqConfigBlock
;
182 typedef struct VirtioFeatDesc
{
185 } QEMU_PACKED VirtioFeatDesc
;
187 typedef struct VirtioThinintInfo
{
188 hwaddr summary_indicator
;
189 hwaddr device_indicator
;
192 } QEMU_PACKED VirtioThinintInfo
;
194 typedef struct VirtioRevInfo
{
198 } QEMU_PACKED VirtioRevInfo
;
200 /* Specify where the virtqueues for the subchannel are in guest memory. */
201 static int virtio_ccw_set_vqs(SubchDev
*sch
, VqInfoBlock
*info
,
202 VqInfoBlockLegacy
*linfo
)
204 VirtIODevice
*vdev
= virtio_ccw_get_vdev(sch
);
205 uint16_t index
= info
? info
->index
: linfo
->index
;
206 uint16_t num
= info
? info
->num
: linfo
->num
;
207 uint64_t desc
= info
? info
->desc
: linfo
->queue
;
209 if (index
>= VIRTIO_QUEUE_MAX
) {
213 /* Current code in virtio.c relies on 4K alignment. */
214 if (linfo
&& desc
&& (linfo
->align
!= 4096)) {
223 virtio_queue_set_rings(vdev
, index
, desc
, info
->avail
, info
->used
);
225 virtio_queue_set_addr(vdev
, index
, desc
);
228 virtio_queue_set_vector(vdev
, index
, VIRTIO_NO_VECTOR
);
231 /* virtio-1 allows changing the ring size. */
232 if (virtio_queue_get_max_num(vdev
, index
) < num
) {
233 /* Fail if we exceed the maximum number. */
236 virtio_queue_set_num(vdev
, index
, num
);
237 } else if (virtio_queue_get_num(vdev
, index
) > num
) {
238 /* Fail if we don't have a big enough queue. */
241 /* We ignore possible increased num for legacy for compatibility. */
242 virtio_queue_set_vector(vdev
, index
, index
);
244 /* tell notify handler in case of config change */
245 vdev
->config_vector
= VIRTIO_QUEUE_MAX
;
249 static void virtio_ccw_reset_virtio(VirtioCcwDevice
*dev
, VirtIODevice
*vdev
)
251 CcwDevice
*ccw_dev
= CCW_DEVICE(dev
);
253 virtio_ccw_stop_ioeventfd(dev
);
255 if (dev
->indicators
) {
256 release_indicator(&dev
->routes
.adapter
, dev
->indicators
);
257 dev
->indicators
= NULL
;
259 if (dev
->indicators2
) {
260 release_indicator(&dev
->routes
.adapter
, dev
->indicators2
);
261 dev
->indicators2
= NULL
;
263 if (dev
->summary_indicator
) {
264 release_indicator(&dev
->routes
.adapter
, dev
->summary_indicator
);
265 dev
->summary_indicator
= NULL
;
267 ccw_dev
->sch
->thinint_active
= false;
270 static int virtio_ccw_handle_set_vq(SubchDev
*sch
, CCW1 ccw
, bool check_len
,
275 VqInfoBlockLegacy linfo
;
276 size_t info_len
= is_legacy
? sizeof(linfo
) : sizeof(info
);
279 if (ccw
.count
!= info_len
) {
282 } else if (ccw
.count
< info_len
) {
283 /* Can't execute command. */
290 linfo
.queue
= address_space_ldq_be(&address_space_memory
, ccw
.cda
,
291 MEMTXATTRS_UNSPECIFIED
, NULL
);
292 linfo
.align
= address_space_ldl_be(&address_space_memory
,
293 ccw
.cda
+ sizeof(linfo
.queue
),
294 MEMTXATTRS_UNSPECIFIED
,
296 linfo
.index
= address_space_lduw_be(&address_space_memory
,
297 ccw
.cda
+ sizeof(linfo
.queue
)
298 + sizeof(linfo
.align
),
299 MEMTXATTRS_UNSPECIFIED
,
301 linfo
.num
= address_space_lduw_be(&address_space_memory
,
302 ccw
.cda
+ sizeof(linfo
.queue
)
303 + sizeof(linfo
.align
)
304 + sizeof(linfo
.index
),
305 MEMTXATTRS_UNSPECIFIED
,
307 ret
= virtio_ccw_set_vqs(sch
, NULL
, &linfo
);
309 info
.desc
= address_space_ldq_be(&address_space_memory
, ccw
.cda
,
310 MEMTXATTRS_UNSPECIFIED
, NULL
);
311 info
.index
= address_space_lduw_be(&address_space_memory
,
312 ccw
.cda
+ sizeof(info
.desc
)
314 MEMTXATTRS_UNSPECIFIED
, NULL
);
315 info
.num
= address_space_lduw_be(&address_space_memory
,
316 ccw
.cda
+ sizeof(info
.desc
)
318 + sizeof(info
.index
),
319 MEMTXATTRS_UNSPECIFIED
, NULL
);
320 info
.avail
= address_space_ldq_be(&address_space_memory
,
321 ccw
.cda
+ sizeof(info
.desc
)
325 MEMTXATTRS_UNSPECIFIED
, NULL
);
326 info
.used
= address_space_ldq_be(&address_space_memory
,
327 ccw
.cda
+ sizeof(info
.desc
)
331 + sizeof(info
.avail
),
332 MEMTXATTRS_UNSPECIFIED
, NULL
);
333 ret
= virtio_ccw_set_vqs(sch
, &info
, NULL
);
335 sch
->curr_status
.scsw
.count
= 0;
339 static int virtio_ccw_cb(SubchDev
*sch
, CCW1 ccw
)
342 VirtioRevInfo revinfo
;
344 VirtioFeatDesc features
;
347 VqConfigBlock vq_config
;
348 VirtioCcwDevice
*dev
= sch
->driver_data
;
349 VirtIODevice
*vdev
= virtio_ccw_get_vdev(sch
);
353 VirtioThinintInfo
*thinint
;
359 trace_virtio_ccw_interpret_ccw(sch
->cssid
, sch
->ssid
, sch
->schid
,
361 check_len
= !((ccw
.flags
& CCW_FLAG_SLI
) && !(ccw
.flags
& CCW_FLAG_DC
));
363 if (dev
->force_revision_1
&& dev
->revision
< 0 &&
364 ccw
.cmd_code
!= CCW_CMD_SET_VIRTIO_REV
) {
366 * virtio-1 drivers must start with negotiating to a revision >= 1,
367 * so post a command reject for all other commands
372 /* Look at the command. */
373 switch (ccw
.cmd_code
) {
375 ret
= virtio_ccw_handle_set_vq(sch
, ccw
, check_len
, dev
->revision
< 1);
377 case CCW_CMD_VDEV_RESET
:
378 virtio_ccw_reset_virtio(dev
, vdev
);
381 case CCW_CMD_READ_FEAT
:
383 if (ccw
.count
!= sizeof(features
)) {
387 } else if (ccw
.count
< sizeof(features
)) {
388 /* Can't execute command. */
395 VirtioDeviceClass
*vdc
= VIRTIO_DEVICE_GET_CLASS(vdev
);
397 features
.index
= address_space_ldub(&address_space_memory
,
399 + sizeof(features
.features
),
400 MEMTXATTRS_UNSPECIFIED
,
402 if (features
.index
== 0) {
403 if (dev
->revision
>= 1) {
404 /* Don't offer legacy features for modern devices. */
405 features
.features
= (uint32_t)
406 (vdev
->host_features
& ~vdc
->legacy_features
);
408 features
.features
= (uint32_t)vdev
->host_features
;
410 } else if ((features
.index
== 1) && (dev
->revision
>= 1)) {
412 * Only offer feature bits beyond 31 if the guest has
413 * negotiated at least revision 1.
415 features
.features
= (uint32_t)(vdev
->host_features
>> 32);
417 /* Return zeroes if the guest supports more feature bits. */
418 features
.features
= 0;
420 address_space_stl_le(&address_space_memory
, ccw
.cda
,
421 features
.features
, MEMTXATTRS_UNSPECIFIED
,
423 sch
->curr_status
.scsw
.count
= ccw
.count
- sizeof(features
);
427 case CCW_CMD_WRITE_FEAT
:
429 if (ccw
.count
!= sizeof(features
)) {
433 } else if (ccw
.count
< sizeof(features
)) {
434 /* Can't execute command. */
441 features
.index
= address_space_ldub(&address_space_memory
,
443 + sizeof(features
.features
),
444 MEMTXATTRS_UNSPECIFIED
,
446 features
.features
= address_space_ldl_le(&address_space_memory
,
448 MEMTXATTRS_UNSPECIFIED
,
450 if (features
.index
== 0) {
451 virtio_set_features(vdev
,
452 (vdev
->guest_features
& 0xffffffff00000000ULL
) |
454 } else if ((features
.index
== 1) && (dev
->revision
>= 1)) {
456 * If the guest did not negotiate at least revision 1,
457 * we did not offer it any feature bits beyond 31. Such a
458 * guest passing us any bit here is therefore buggy.
460 virtio_set_features(vdev
,
461 (vdev
->guest_features
& 0x00000000ffffffffULL
) |
462 ((uint64_t)features
.features
<< 32));
465 * If the guest supports more feature bits, assert that it
466 * passes us zeroes for those we don't support.
468 if (features
.features
) {
469 fprintf(stderr
, "Guest bug: features[%i]=%x (expected 0)\n",
470 features
.index
, features
.features
);
471 /* XXX: do a unit check here? */
474 sch
->curr_status
.scsw
.count
= ccw
.count
- sizeof(features
);
478 case CCW_CMD_READ_CONF
:
480 if (ccw
.count
> vdev
->config_len
) {
485 len
= MIN(ccw
.count
, vdev
->config_len
);
489 virtio_bus_get_vdev_config(&dev
->bus
, vdev
->config
);
490 /* XXX config space endianness */
491 cpu_physical_memory_write(ccw
.cda
, vdev
->config
, len
);
492 sch
->curr_status
.scsw
.count
= ccw
.count
- len
;
496 case CCW_CMD_WRITE_CONF
:
498 if (ccw
.count
> vdev
->config_len
) {
503 len
= MIN(ccw
.count
, vdev
->config_len
);
508 config
= cpu_physical_memory_map(ccw
.cda
, &hw_len
, 0);
513 /* XXX config space endianness */
514 memcpy(vdev
->config
, config
, len
);
515 cpu_physical_memory_unmap(config
, hw_len
, 0, hw_len
);
516 virtio_bus_set_vdev_config(&dev
->bus
, vdev
->config
);
517 sch
->curr_status
.scsw
.count
= ccw
.count
- len
;
522 case CCW_CMD_READ_STATUS
:
524 if (ccw
.count
!= sizeof(status
)) {
528 } else if (ccw
.count
< sizeof(status
)) {
529 /* Can't execute command. */
536 address_space_stb(&address_space_memory
, ccw
.cda
, vdev
->status
,
537 MEMTXATTRS_UNSPECIFIED
, NULL
);
538 sch
->curr_status
.scsw
.count
= ccw
.count
- sizeof(vdev
->status
);;
542 case CCW_CMD_WRITE_STATUS
:
544 if (ccw
.count
!= sizeof(status
)) {
548 } else if (ccw
.count
< sizeof(status
)) {
549 /* Can't execute command. */
556 status
= address_space_ldub(&address_space_memory
, ccw
.cda
,
557 MEMTXATTRS_UNSPECIFIED
, NULL
);
558 if (!(status
& VIRTIO_CONFIG_S_DRIVER_OK
)) {
559 virtio_ccw_stop_ioeventfd(dev
);
561 if (virtio_set_status(vdev
, status
) == 0) {
562 if (vdev
->status
== 0) {
563 virtio_ccw_reset_virtio(dev
, vdev
);
565 if (status
& VIRTIO_CONFIG_S_DRIVER_OK
) {
566 virtio_ccw_start_ioeventfd(dev
);
568 sch
->curr_status
.scsw
.count
= ccw
.count
- sizeof(status
);
571 /* Trigger a command reject. */
576 case CCW_CMD_SET_IND
:
578 if (ccw
.count
!= sizeof(indicators
)) {
582 } else if (ccw
.count
< sizeof(indicators
)) {
583 /* Can't execute command. */
587 if (sch
->thinint_active
) {
588 /* Trigger a command reject. */
592 if (virtio_get_num_queues(vdev
) > NR_CLASSIC_INDICATOR_BITS
) {
593 /* More queues than indicator bits --> trigger a reject */
600 indicators
= address_space_ldq_be(&address_space_memory
, ccw
.cda
,
601 MEMTXATTRS_UNSPECIFIED
, NULL
);
602 dev
->indicators
= get_indicator(indicators
, sizeof(uint64_t));
603 sch
->curr_status
.scsw
.count
= ccw
.count
- sizeof(indicators
);
607 case CCW_CMD_SET_CONF_IND
:
609 if (ccw
.count
!= sizeof(indicators
)) {
613 } else if (ccw
.count
< sizeof(indicators
)) {
614 /* Can't execute command. */
621 indicators
= address_space_ldq_be(&address_space_memory
, ccw
.cda
,
622 MEMTXATTRS_UNSPECIFIED
, NULL
);
623 dev
->indicators2
= get_indicator(indicators
, sizeof(uint64_t));
624 sch
->curr_status
.scsw
.count
= ccw
.count
- sizeof(indicators
);
628 case CCW_CMD_READ_VQ_CONF
:
630 if (ccw
.count
!= sizeof(vq_config
)) {
634 } else if (ccw
.count
< sizeof(vq_config
)) {
635 /* Can't execute command. */
642 vq_config
.index
= address_space_lduw_be(&address_space_memory
,
644 MEMTXATTRS_UNSPECIFIED
,
646 if (vq_config
.index
>= VIRTIO_QUEUE_MAX
) {
650 vq_config
.num_max
= virtio_queue_get_num(vdev
,
652 address_space_stw_be(&address_space_memory
,
653 ccw
.cda
+ sizeof(vq_config
.index
),
655 MEMTXATTRS_UNSPECIFIED
,
657 sch
->curr_status
.scsw
.count
= ccw
.count
- sizeof(vq_config
);
661 case CCW_CMD_SET_IND_ADAPTER
:
663 if (ccw
.count
!= sizeof(*thinint
)) {
667 } else if (ccw
.count
< sizeof(*thinint
)) {
668 /* Can't execute command. */
672 len
= sizeof(*thinint
);
676 } else if (dev
->indicators
&& !sch
->thinint_active
) {
677 /* Trigger a command reject. */
680 thinint
= cpu_physical_memory_map(ccw
.cda
, &hw_len
, 0);
684 uint64_t ind_bit
= ldq_be_p(&thinint
->ind_bit
);
687 dev
->summary_indicator
=
688 get_indicator(ldq_be_p(&thinint
->summary_indicator
),
691 get_indicator(ldq_be_p(&thinint
->device_indicator
),
693 dev
->thinint_isc
= thinint
->isc
;
694 dev
->routes
.adapter
.ind_offset
= ind_bit
;
695 dev
->routes
.adapter
.summary_offset
= 7;
696 cpu_physical_memory_unmap(thinint
, hw_len
, 0, hw_len
);
697 dev
->routes
.adapter
.adapter_id
= css_get_adapter_id(
698 CSS_IO_ADAPTER_VIRTIO
,
700 sch
->thinint_active
= ((dev
->indicators
!= NULL
) &&
701 (dev
->summary_indicator
!= NULL
));
702 sch
->curr_status
.scsw
.count
= ccw
.count
- len
;
707 case CCW_CMD_SET_VIRTIO_REV
:
708 len
= sizeof(revinfo
);
709 if (ccw
.count
< len
) {
718 address_space_lduw_be(&address_space_memory
, ccw
.cda
,
719 MEMTXATTRS_UNSPECIFIED
, NULL
);
721 address_space_lduw_be(&address_space_memory
,
722 ccw
.cda
+ sizeof(revinfo
.revision
),
723 MEMTXATTRS_UNSPECIFIED
, NULL
);
724 if (ccw
.count
< len
+ revinfo
.length
||
725 (check_len
&& ccw
.count
> len
+ revinfo
.length
)) {
730 * Once we start to support revisions with additional data, we'll
731 * need to fetch it here. Nothing to do for now, though.
733 if (dev
->revision
>= 0 ||
734 revinfo
.revision
> virtio_ccw_rev_max(dev
) ||
735 (dev
->force_revision_1
&& !revinfo
.revision
)) {
740 dev
->revision
= revinfo
.revision
;
749 static void virtio_sch_disable_cb(SubchDev
*sch
)
751 VirtioCcwDevice
*dev
= sch
->driver_data
;
756 static void virtio_ccw_device_realize(VirtioCcwDevice
*dev
, Error
**errp
)
758 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_GET_CLASS(dev
);
759 CcwDevice
*ccw_dev
= CCW_DEVICE(dev
);
760 CCWDeviceClass
*ck
= CCW_DEVICE_GET_CLASS(ccw_dev
);
761 DeviceState
*parent
= DEVICE(ccw_dev
);
762 BusState
*qbus
= qdev_get_parent_bus(parent
);
763 VirtualCssBus
*cbus
= VIRTUAL_CSS_BUS(qbus
);
767 sch
= css_create_sch(ccw_dev
->devno
, true, cbus
->squash_mcss
, errp
);
771 if (!virtio_ccw_rev_max(dev
) && dev
->force_revision_1
) {
772 error_setg(&err
, "Invalid value of property max_rev "
773 "(is %d expected >= 1)", virtio_ccw_rev_max(dev
));
777 sch
->driver_data
= dev
;
778 sch
->ccw_cb
= virtio_ccw_cb
;
779 sch
->disable_cb
= virtio_sch_disable_cb
;
780 sch
->id
.reserved
= 0xff;
781 sch
->id
.cu_type
= VIRTIO_CCW_CU_TYPE
;
782 sch
->do_subchannel_work
= do_subchannel_work_virtual
;
784 dev
->indicators
= NULL
;
786 css_sch_build_virtual_schib(sch
, 0, VIRTIO_CCW_CHPID_TYPE
);
788 trace_virtio_ccw_new_device(
789 sch
->cssid
, sch
->ssid
, sch
->schid
, sch
->devno
,
790 ccw_dev
->devno
.valid
? "user-configured" : "auto-configured");
792 if (!kvm_eventfds_enabled()) {
793 dev
->flags
&= ~VIRTIO_CCW_FLAG_USE_IOEVENTFD
;
797 k
->realize(dev
, &err
);
803 ck
->realize(ccw_dev
, &err
);
811 error_propagate(errp
, err
);
812 css_subch_assign(sch
->cssid
, sch
->ssid
, sch
->schid
, sch
->devno
, NULL
);
817 static int virtio_ccw_exit(VirtioCcwDevice
*dev
)
819 CcwDevice
*ccw_dev
= CCW_DEVICE(dev
);
820 SubchDev
*sch
= ccw_dev
->sch
;
823 css_subch_assign(sch
->cssid
, sch
->ssid
, sch
->schid
, sch
->devno
, NULL
);
826 if (dev
->indicators
) {
827 release_indicator(&dev
->routes
.adapter
, dev
->indicators
);
828 dev
->indicators
= NULL
;
833 static void virtio_ccw_net_realize(VirtioCcwDevice
*ccw_dev
, Error
**errp
)
835 DeviceState
*qdev
= DEVICE(ccw_dev
);
836 VirtIONetCcw
*dev
= VIRTIO_NET_CCW(ccw_dev
);
837 DeviceState
*vdev
= DEVICE(&dev
->vdev
);
839 virtio_net_set_netclient_name(&dev
->vdev
, qdev
->id
,
840 object_get_typename(OBJECT(qdev
)));
841 qdev_set_parent_bus(vdev
, BUS(&ccw_dev
->bus
));
842 object_property_set_bool(OBJECT(vdev
), true, "realized", errp
);
845 static void virtio_ccw_net_instance_init(Object
*obj
)
847 VirtIONetCcw
*dev
= VIRTIO_NET_CCW(obj
);
849 virtio_instance_init_common(obj
, &dev
->vdev
, sizeof(dev
->vdev
),
851 object_property_add_alias(obj
, "bootindex", OBJECT(&dev
->vdev
),
852 "bootindex", &error_abort
);
855 static void virtio_ccw_blk_realize(VirtioCcwDevice
*ccw_dev
, Error
**errp
)
857 VirtIOBlkCcw
*dev
= VIRTIO_BLK_CCW(ccw_dev
);
858 DeviceState
*vdev
= DEVICE(&dev
->vdev
);
860 qdev_set_parent_bus(vdev
, BUS(&ccw_dev
->bus
));
861 object_property_set_bool(OBJECT(vdev
), true, "realized", errp
);
864 static void virtio_ccw_blk_instance_init(Object
*obj
)
866 VirtIOBlkCcw
*dev
= VIRTIO_BLK_CCW(obj
);
868 virtio_instance_init_common(obj
, &dev
->vdev
, sizeof(dev
->vdev
),
870 object_property_add_alias(obj
, "iothread", OBJECT(&dev
->vdev
),"iothread",
872 object_property_add_alias(obj
, "bootindex", OBJECT(&dev
->vdev
),
873 "bootindex", &error_abort
);
876 static void virtio_ccw_serial_realize(VirtioCcwDevice
*ccw_dev
, Error
**errp
)
878 VirtioSerialCcw
*dev
= VIRTIO_SERIAL_CCW(ccw_dev
);
879 DeviceState
*vdev
= DEVICE(&dev
->vdev
);
880 DeviceState
*proxy
= DEVICE(ccw_dev
);
884 * For command line compatibility, this sets the virtio-serial-device bus
888 bus_name
= g_strdup_printf("%s.0", proxy
->id
);
889 virtio_device_set_child_bus_name(VIRTIO_DEVICE(vdev
), bus_name
);
893 qdev_set_parent_bus(vdev
, BUS(&ccw_dev
->bus
));
894 object_property_set_bool(OBJECT(vdev
), true, "realized", errp
);
898 static void virtio_ccw_serial_instance_init(Object
*obj
)
900 VirtioSerialCcw
*dev
= VIRTIO_SERIAL_CCW(obj
);
902 virtio_instance_init_common(obj
, &dev
->vdev
, sizeof(dev
->vdev
),
906 static void virtio_ccw_balloon_realize(VirtioCcwDevice
*ccw_dev
, Error
**errp
)
908 VirtIOBalloonCcw
*dev
= VIRTIO_BALLOON_CCW(ccw_dev
);
909 DeviceState
*vdev
= DEVICE(&dev
->vdev
);
911 qdev_set_parent_bus(vdev
, BUS(&ccw_dev
->bus
));
912 object_property_set_bool(OBJECT(vdev
), true, "realized", errp
);
915 static void virtio_ccw_balloon_instance_init(Object
*obj
)
917 VirtIOBalloonCcw
*dev
= VIRTIO_BALLOON_CCW(obj
);
919 virtio_instance_init_common(obj
, &dev
->vdev
, sizeof(dev
->vdev
),
920 TYPE_VIRTIO_BALLOON
);
921 object_property_add_alias(obj
, "guest-stats", OBJECT(&dev
->vdev
),
922 "guest-stats", &error_abort
);
923 object_property_add_alias(obj
, "guest-stats-polling-interval",
925 "guest-stats-polling-interval", &error_abort
);
928 static void virtio_ccw_scsi_realize(VirtioCcwDevice
*ccw_dev
, Error
**errp
)
930 VirtIOSCSICcw
*dev
= VIRTIO_SCSI_CCW(ccw_dev
);
931 DeviceState
*vdev
= DEVICE(&dev
->vdev
);
932 DeviceState
*qdev
= DEVICE(ccw_dev
);
936 * For command line compatibility, this sets the virtio-scsi-device bus
940 bus_name
= g_strdup_printf("%s.0", qdev
->id
);
941 virtio_device_set_child_bus_name(VIRTIO_DEVICE(vdev
), bus_name
);
945 qdev_set_parent_bus(vdev
, BUS(&ccw_dev
->bus
));
946 object_property_set_bool(OBJECT(vdev
), true, "realized", errp
);
949 static void virtio_ccw_scsi_instance_init(Object
*obj
)
951 VirtIOSCSICcw
*dev
= VIRTIO_SCSI_CCW(obj
);
953 virtio_instance_init_common(obj
, &dev
->vdev
, sizeof(dev
->vdev
),
955 object_property_add_alias(obj
, "iothread", OBJECT(&dev
->vdev
), "iothread",
959 #ifdef CONFIG_VHOST_SCSI
960 static void vhost_ccw_scsi_realize(VirtioCcwDevice
*ccw_dev
, Error
**errp
)
962 VHostSCSICcw
*dev
= VHOST_SCSI_CCW(ccw_dev
);
963 DeviceState
*vdev
= DEVICE(&dev
->vdev
);
965 qdev_set_parent_bus(vdev
, BUS(&ccw_dev
->bus
));
966 object_property_set_bool(OBJECT(vdev
), true, "realized", errp
);
969 static void vhost_ccw_scsi_instance_init(Object
*obj
)
971 VHostSCSICcw
*dev
= VHOST_SCSI_CCW(obj
);
973 virtio_instance_init_common(obj
, &dev
->vdev
, sizeof(dev
->vdev
),
978 static void virtio_ccw_rng_realize(VirtioCcwDevice
*ccw_dev
, Error
**errp
)
980 VirtIORNGCcw
*dev
= VIRTIO_RNG_CCW(ccw_dev
);
981 DeviceState
*vdev
= DEVICE(&dev
->vdev
);
984 qdev_set_parent_bus(vdev
, BUS(&ccw_dev
->bus
));
985 object_property_set_bool(OBJECT(vdev
), true, "realized", &err
);
987 error_propagate(errp
, err
);
991 object_property_set_link(OBJECT(dev
),
992 OBJECT(dev
->vdev
.conf
.rng
), "rng",
996 static void virtio_ccw_crypto_realize(VirtioCcwDevice
*ccw_dev
, Error
**errp
)
998 VirtIOCryptoCcw
*dev
= VIRTIO_CRYPTO_CCW(ccw_dev
);
999 DeviceState
*vdev
= DEVICE(&dev
->vdev
);
1002 qdev_set_parent_bus(vdev
, BUS(&ccw_dev
->bus
));
1003 object_property_set_bool(OBJECT(vdev
), true, "realized", &err
);
1005 error_propagate(errp
, err
);
1009 object_property_set_link(OBJECT(vdev
),
1010 OBJECT(dev
->vdev
.conf
.cryptodev
), "cryptodev",
1014 /* DeviceState to VirtioCcwDevice. Note: used on datapath,
1015 * be careful and test performance if you change this.
1017 static inline VirtioCcwDevice
*to_virtio_ccw_dev_fast(DeviceState
*d
)
1019 CcwDevice
*ccw_dev
= to_ccw_dev_fast(d
);
1021 return container_of(ccw_dev
, VirtioCcwDevice
, parent_obj
);
1024 static uint8_t virtio_set_ind_atomic(SubchDev
*sch
, uint64_t ind_loc
,
1027 uint8_t ind_old
, ind_new
;
1031 ind_addr
= cpu_physical_memory_map(ind_loc
, &len
, 1);
1033 error_report("%s(%x.%x.%04x): unable to access indicator",
1034 __func__
, sch
->cssid
, sch
->ssid
, sch
->schid
);
1038 ind_old
= *ind_addr
;
1039 ind_new
= ind_old
| to_be_set
;
1040 } while (atomic_cmpxchg(ind_addr
, ind_old
, ind_new
) != ind_old
);
1041 trace_virtio_ccw_set_ind(ind_loc
, ind_old
, ind_new
);
1042 cpu_physical_memory_unmap(ind_addr
, len
, 1, len
);
1047 static void virtio_ccw_notify(DeviceState
*d
, uint16_t vector
)
1049 VirtioCcwDevice
*dev
= to_virtio_ccw_dev_fast(d
);
1050 CcwDevice
*ccw_dev
= to_ccw_dev_fast(d
);
1051 SubchDev
*sch
= ccw_dev
->sch
;
1052 uint64_t indicators
;
1054 /* queue indicators + secondary indicators */
1055 if (vector
>= VIRTIO_QUEUE_MAX
+ 64) {
1059 if (vector
< VIRTIO_QUEUE_MAX
) {
1060 if (!dev
->indicators
) {
1063 if (sch
->thinint_active
) {
1065 * In the adapter interrupt case, indicators points to a
1066 * memory area that may be (way) larger than 64 bit and
1067 * ind_bit indicates the start of the indicators in a big
1070 uint64_t ind_bit
= dev
->routes
.adapter
.ind_offset
;
1072 virtio_set_ind_atomic(sch
, dev
->indicators
->addr
+
1073 (ind_bit
+ vector
) / 8,
1074 0x80 >> ((ind_bit
+ vector
) % 8));
1075 if (!virtio_set_ind_atomic(sch
, dev
->summary_indicator
->addr
,
1077 css_adapter_interrupt(dev
->thinint_isc
);
1080 indicators
= address_space_ldq(&address_space_memory
,
1081 dev
->indicators
->addr
,
1082 MEMTXATTRS_UNSPECIFIED
,
1084 indicators
|= 1ULL << vector
;
1085 address_space_stq(&address_space_memory
, dev
->indicators
->addr
,
1086 indicators
, MEMTXATTRS_UNSPECIFIED
, NULL
);
1087 css_conditional_io_interrupt(sch
);
1090 if (!dev
->indicators2
) {
1094 indicators
= address_space_ldq(&address_space_memory
,
1095 dev
->indicators2
->addr
,
1096 MEMTXATTRS_UNSPECIFIED
,
1098 indicators
|= 1ULL << vector
;
1099 address_space_stq(&address_space_memory
, dev
->indicators2
->addr
,
1100 indicators
, MEMTXATTRS_UNSPECIFIED
, NULL
);
1101 css_conditional_io_interrupt(sch
);
1105 static void virtio_ccw_reset(DeviceState
*d
)
1107 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
1108 VirtIODevice
*vdev
= virtio_bus_get_device(&dev
->bus
);
1109 CcwDevice
*ccw_dev
= CCW_DEVICE(d
);
1111 virtio_ccw_reset_virtio(dev
, vdev
);
1112 css_reset_sch(ccw_dev
->sch
);
1115 static void virtio_ccw_vmstate_change(DeviceState
*d
, bool running
)
1117 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
1120 virtio_ccw_start_ioeventfd(dev
);
1122 virtio_ccw_stop_ioeventfd(dev
);
1126 static bool virtio_ccw_query_guest_notifiers(DeviceState
*d
)
1128 CcwDevice
*dev
= CCW_DEVICE(d
);
1130 return !!(dev
->sch
->curr_status
.pmcw
.flags
& PMCW_FLAGS_MASK_ENA
);
1133 static int virtio_ccw_get_mappings(VirtioCcwDevice
*dev
)
1136 CcwDevice
*ccw_dev
= CCW_DEVICE(dev
);
1138 if (!ccw_dev
->sch
->thinint_active
) {
1142 r
= map_indicator(&dev
->routes
.adapter
, dev
->summary_indicator
);
1146 r
= map_indicator(&dev
->routes
.adapter
, dev
->indicators
);
1150 dev
->routes
.adapter
.summary_addr
= dev
->summary_indicator
->map
;
1151 dev
->routes
.adapter
.ind_addr
= dev
->indicators
->map
;
1156 static int virtio_ccw_setup_irqroutes(VirtioCcwDevice
*dev
, int nvqs
)
1159 VirtIODevice
*vdev
= virtio_bus_get_device(&dev
->bus
);
1161 S390FLICState
*fs
= s390_get_flic();
1162 S390FLICStateClass
*fsc
= S390_FLIC_COMMON_GET_CLASS(fs
);
1164 ret
= virtio_ccw_get_mappings(dev
);
1168 for (i
= 0; i
< nvqs
; i
++) {
1169 if (!virtio_queue_get_num(vdev
, i
)) {
1173 dev
->routes
.num_routes
= i
;
1174 return fsc
->add_adapter_routes(fs
, &dev
->routes
);
1177 static void virtio_ccw_release_irqroutes(VirtioCcwDevice
*dev
, int nvqs
)
1179 S390FLICState
*fs
= s390_get_flic();
1180 S390FLICStateClass
*fsc
= S390_FLIC_COMMON_GET_CLASS(fs
);
1182 fsc
->release_adapter_routes(fs
, &dev
->routes
);
1185 static int virtio_ccw_add_irqfd(VirtioCcwDevice
*dev
, int n
)
1187 VirtIODevice
*vdev
= virtio_bus_get_device(&dev
->bus
);
1188 VirtQueue
*vq
= virtio_get_queue(vdev
, n
);
1189 EventNotifier
*notifier
= virtio_queue_get_guest_notifier(vq
);
1191 return kvm_irqchip_add_irqfd_notifier_gsi(kvm_state
, notifier
, NULL
,
1192 dev
->routes
.gsi
[n
]);
1195 static void virtio_ccw_remove_irqfd(VirtioCcwDevice
*dev
, int n
)
1197 VirtIODevice
*vdev
= virtio_bus_get_device(&dev
->bus
);
1198 VirtQueue
*vq
= virtio_get_queue(vdev
, n
);
1199 EventNotifier
*notifier
= virtio_queue_get_guest_notifier(vq
);
1202 ret
= kvm_irqchip_remove_irqfd_notifier_gsi(kvm_state
, notifier
,
1203 dev
->routes
.gsi
[n
]);
1207 static int virtio_ccw_set_guest_notifier(VirtioCcwDevice
*dev
, int n
,
1208 bool assign
, bool with_irqfd
)
1210 VirtIODevice
*vdev
= virtio_bus_get_device(&dev
->bus
);
1211 VirtQueue
*vq
= virtio_get_queue(vdev
, n
);
1212 EventNotifier
*notifier
= virtio_queue_get_guest_notifier(vq
);
1213 VirtioDeviceClass
*k
= VIRTIO_DEVICE_GET_CLASS(vdev
);
1216 int r
= event_notifier_init(notifier
, 0);
1221 virtio_queue_set_guest_notifier_fd_handler(vq
, true, with_irqfd
);
1223 r
= virtio_ccw_add_irqfd(dev
, n
);
1225 virtio_queue_set_guest_notifier_fd_handler(vq
, false,
1231 * We do not support individual masking for channel devices, so we
1232 * need to manually trigger any guest masking callbacks here.
1234 if (k
->guest_notifier_mask
&& vdev
->use_guest_notifier_mask
) {
1235 k
->guest_notifier_mask(vdev
, n
, false);
1237 /* get lost events and re-inject */
1238 if (k
->guest_notifier_pending
&&
1239 k
->guest_notifier_pending(vdev
, n
)) {
1240 event_notifier_set(notifier
);
1243 if (k
->guest_notifier_mask
&& vdev
->use_guest_notifier_mask
) {
1244 k
->guest_notifier_mask(vdev
, n
, true);
1247 virtio_ccw_remove_irqfd(dev
, n
);
1249 virtio_queue_set_guest_notifier_fd_handler(vq
, false, with_irqfd
);
1250 event_notifier_cleanup(notifier
);
1255 static int virtio_ccw_set_guest_notifiers(DeviceState
*d
, int nvqs
,
1258 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
1259 VirtIODevice
*vdev
= virtio_bus_get_device(&dev
->bus
);
1260 CcwDevice
*ccw_dev
= CCW_DEVICE(d
);
1261 bool with_irqfd
= ccw_dev
->sch
->thinint_active
&& kvm_irqfds_enabled();
1264 if (with_irqfd
&& assigned
) {
1265 /* irq routes need to be set up before assigning irqfds */
1266 r
= virtio_ccw_setup_irqroutes(dev
, nvqs
);
1268 goto irqroute_error
;
1271 for (n
= 0; n
< nvqs
; n
++) {
1272 if (!virtio_queue_get_num(vdev
, n
)) {
1275 r
= virtio_ccw_set_guest_notifier(dev
, n
, assigned
, with_irqfd
);
1280 if (with_irqfd
&& !assigned
) {
1281 /* release irq routes after irqfds have been released */
1282 virtio_ccw_release_irqroutes(dev
, nvqs
);
1288 virtio_ccw_set_guest_notifier(dev
, n
, !assigned
, false);
1291 if (with_irqfd
&& assigned
) {
1292 virtio_ccw_release_irqroutes(dev
, nvqs
);
1297 static void virtio_ccw_save_queue(DeviceState
*d
, int n
, QEMUFile
*f
)
1299 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
1300 VirtIODevice
*vdev
= virtio_bus_get_device(&dev
->bus
);
1302 qemu_put_be16(f
, virtio_queue_vector(vdev
, n
));
1305 static int virtio_ccw_load_queue(DeviceState
*d
, int n
, QEMUFile
*f
)
1307 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
1308 VirtIODevice
*vdev
= virtio_bus_get_device(&dev
->bus
);
1311 qemu_get_be16s(f
, &vector
);
1312 virtio_queue_set_vector(vdev
, n
, vector
);
1317 static void virtio_ccw_save_config(DeviceState
*d
, QEMUFile
*f
)
1319 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
1320 vmstate_save_state(f
, &vmstate_virtio_ccw_dev
, dev
, NULL
);
1323 static int virtio_ccw_load_config(DeviceState
*d
, QEMUFile
*f
)
1325 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
1326 return vmstate_load_state(f
, &vmstate_virtio_ccw_dev
, dev
, 1);
1329 static void virtio_ccw_pre_plugged(DeviceState
*d
, Error
**errp
)
1331 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
1332 VirtIODevice
*vdev
= virtio_bus_get_device(&dev
->bus
);
1334 if (dev
->max_rev
>= 1) {
1335 virtio_add_feature(&vdev
->host_features
, VIRTIO_F_VERSION_1
);
1339 /* This is called by virtio-bus just after the device is plugged. */
1340 static void virtio_ccw_device_plugged(DeviceState
*d
, Error
**errp
)
1342 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
1343 VirtIODevice
*vdev
= virtio_bus_get_device(&dev
->bus
);
1344 CcwDevice
*ccw_dev
= CCW_DEVICE(d
);
1345 SubchDev
*sch
= ccw_dev
->sch
;
1346 int n
= virtio_get_num_queues(vdev
);
1347 S390FLICState
*flic
= s390_get_flic();
1349 if (!virtio_has_feature(vdev
->host_features
, VIRTIO_F_VERSION_1
)) {
1353 if (virtio_get_num_queues(vdev
) > VIRTIO_QUEUE_MAX
) {
1354 error_setg(errp
, "The number of virtqueues %d "
1355 "exceeds virtio limit %d", n
,
1359 if (virtio_get_num_queues(vdev
) > flic
->adapter_routes_max_batch
) {
1360 error_setg(errp
, "The number of virtqueues %d "
1361 "exceeds flic adapter route limit %d", n
,
1362 flic
->adapter_routes_max_batch
);
1366 sch
->id
.cu_model
= virtio_bus_get_vdev_id(&dev
->bus
);
1369 css_generate_sch_crws(sch
->cssid
, sch
->ssid
, sch
->schid
,
1373 static void virtio_ccw_device_unplugged(DeviceState
*d
)
1375 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
1377 virtio_ccw_stop_ioeventfd(dev
);
1379 /**************** Virtio-ccw Bus Device Descriptions *******************/
1381 static Property virtio_ccw_net_properties
[] = {
1382 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice
, flags
,
1383 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT
, true),
1384 DEFINE_PROP_UINT32("max_revision", VirtioCcwDevice
, max_rev
,
1385 VIRTIO_CCW_MAX_REV
),
1386 DEFINE_PROP_END_OF_LIST(),
1389 static void virtio_ccw_net_class_init(ObjectClass
*klass
, void *data
)
1391 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1392 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_CLASS(klass
);
1394 k
->realize
= virtio_ccw_net_realize
;
1395 k
->exit
= virtio_ccw_exit
;
1396 dc
->reset
= virtio_ccw_reset
;
1397 dc
->props
= virtio_ccw_net_properties
;
1398 set_bit(DEVICE_CATEGORY_NETWORK
, dc
->categories
);
1401 static const TypeInfo virtio_ccw_net
= {
1402 .name
= TYPE_VIRTIO_NET_CCW
,
1403 .parent
= TYPE_VIRTIO_CCW_DEVICE
,
1404 .instance_size
= sizeof(VirtIONetCcw
),
1405 .instance_init
= virtio_ccw_net_instance_init
,
1406 .class_init
= virtio_ccw_net_class_init
,
1409 static Property virtio_ccw_blk_properties
[] = {
1410 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice
, flags
,
1411 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT
, true),
1412 DEFINE_PROP_UINT32("max_revision", VirtioCcwDevice
, max_rev
,
1413 VIRTIO_CCW_MAX_REV
),
1414 DEFINE_PROP_END_OF_LIST(),
1417 static void virtio_ccw_blk_class_init(ObjectClass
*klass
, void *data
)
1419 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1420 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_CLASS(klass
);
1422 k
->realize
= virtio_ccw_blk_realize
;
1423 k
->exit
= virtio_ccw_exit
;
1424 dc
->reset
= virtio_ccw_reset
;
1425 dc
->props
= virtio_ccw_blk_properties
;
1426 set_bit(DEVICE_CATEGORY_STORAGE
, dc
->categories
);
1429 static const TypeInfo virtio_ccw_blk
= {
1430 .name
= TYPE_VIRTIO_BLK_CCW
,
1431 .parent
= TYPE_VIRTIO_CCW_DEVICE
,
1432 .instance_size
= sizeof(VirtIOBlkCcw
),
1433 .instance_init
= virtio_ccw_blk_instance_init
,
1434 .class_init
= virtio_ccw_blk_class_init
,
1437 static Property virtio_ccw_serial_properties
[] = {
1438 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice
, flags
,
1439 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT
, true),
1440 DEFINE_PROP_UINT32("max_revision", VirtioCcwDevice
, max_rev
,
1441 VIRTIO_CCW_MAX_REV
),
1442 DEFINE_PROP_END_OF_LIST(),
1445 static void virtio_ccw_serial_class_init(ObjectClass
*klass
, void *data
)
1447 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1448 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_CLASS(klass
);
1450 k
->realize
= virtio_ccw_serial_realize
;
1451 k
->exit
= virtio_ccw_exit
;
1452 dc
->reset
= virtio_ccw_reset
;
1453 dc
->props
= virtio_ccw_serial_properties
;
1454 set_bit(DEVICE_CATEGORY_INPUT
, dc
->categories
);
1457 static const TypeInfo virtio_ccw_serial
= {
1458 .name
= TYPE_VIRTIO_SERIAL_CCW
,
1459 .parent
= TYPE_VIRTIO_CCW_DEVICE
,
1460 .instance_size
= sizeof(VirtioSerialCcw
),
1461 .instance_init
= virtio_ccw_serial_instance_init
,
1462 .class_init
= virtio_ccw_serial_class_init
,
1465 static Property virtio_ccw_balloon_properties
[] = {
1466 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice
, flags
,
1467 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT
, true),
1468 DEFINE_PROP_UINT32("max_revision", VirtioCcwDevice
, max_rev
,
1469 VIRTIO_CCW_MAX_REV
),
1470 DEFINE_PROP_END_OF_LIST(),
1473 static void virtio_ccw_balloon_class_init(ObjectClass
*klass
, void *data
)
1475 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1476 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_CLASS(klass
);
1478 k
->realize
= virtio_ccw_balloon_realize
;
1479 k
->exit
= virtio_ccw_exit
;
1480 dc
->reset
= virtio_ccw_reset
;
1481 dc
->props
= virtio_ccw_balloon_properties
;
1482 set_bit(DEVICE_CATEGORY_MISC
, dc
->categories
);
1485 static const TypeInfo virtio_ccw_balloon
= {
1486 .name
= TYPE_VIRTIO_BALLOON_CCW
,
1487 .parent
= TYPE_VIRTIO_CCW_DEVICE
,
1488 .instance_size
= sizeof(VirtIOBalloonCcw
),
1489 .instance_init
= virtio_ccw_balloon_instance_init
,
1490 .class_init
= virtio_ccw_balloon_class_init
,
1493 static Property virtio_ccw_scsi_properties
[] = {
1494 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice
, flags
,
1495 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT
, true),
1496 DEFINE_PROP_UINT32("max_revision", VirtioCcwDevice
, max_rev
,
1497 VIRTIO_CCW_MAX_REV
),
1498 DEFINE_PROP_END_OF_LIST(),
1501 static void virtio_ccw_scsi_class_init(ObjectClass
*klass
, void *data
)
1503 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1504 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_CLASS(klass
);
1506 k
->realize
= virtio_ccw_scsi_realize
;
1507 k
->exit
= virtio_ccw_exit
;
1508 dc
->reset
= virtio_ccw_reset
;
1509 dc
->props
= virtio_ccw_scsi_properties
;
1510 set_bit(DEVICE_CATEGORY_STORAGE
, dc
->categories
);
1513 static const TypeInfo virtio_ccw_scsi
= {
1514 .name
= TYPE_VIRTIO_SCSI_CCW
,
1515 .parent
= TYPE_VIRTIO_CCW_DEVICE
,
1516 .instance_size
= sizeof(VirtIOSCSICcw
),
1517 .instance_init
= virtio_ccw_scsi_instance_init
,
1518 .class_init
= virtio_ccw_scsi_class_init
,
1521 #ifdef CONFIG_VHOST_SCSI
1522 static Property vhost_ccw_scsi_properties
[] = {
1523 DEFINE_PROP_UINT32("max_revision", VirtioCcwDevice
, max_rev
,
1524 VIRTIO_CCW_MAX_REV
),
1525 DEFINE_PROP_END_OF_LIST(),
1528 static void vhost_ccw_scsi_class_init(ObjectClass
*klass
, void *data
)
1530 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1531 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_CLASS(klass
);
1533 k
->realize
= vhost_ccw_scsi_realize
;
1534 k
->exit
= virtio_ccw_exit
;
1535 dc
->reset
= virtio_ccw_reset
;
1536 dc
->props
= vhost_ccw_scsi_properties
;
1537 set_bit(DEVICE_CATEGORY_STORAGE
, dc
->categories
);
1540 static const TypeInfo vhost_ccw_scsi
= {
1541 .name
= TYPE_VHOST_SCSI_CCW
,
1542 .parent
= TYPE_VIRTIO_CCW_DEVICE
,
1543 .instance_size
= sizeof(VHostSCSICcw
),
1544 .instance_init
= vhost_ccw_scsi_instance_init
,
1545 .class_init
= vhost_ccw_scsi_class_init
,
1549 static void virtio_ccw_rng_instance_init(Object
*obj
)
1551 VirtIORNGCcw
*dev
= VIRTIO_RNG_CCW(obj
);
1553 virtio_instance_init_common(obj
, &dev
->vdev
, sizeof(dev
->vdev
),
1555 object_property_add_alias(obj
, "rng", OBJECT(&dev
->vdev
),
1556 "rng", &error_abort
);
1559 static Property virtio_ccw_rng_properties
[] = {
1560 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice
, flags
,
1561 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT
, true),
1562 DEFINE_PROP_UINT32("max_revision", VirtioCcwDevice
, max_rev
,
1563 VIRTIO_CCW_MAX_REV
),
1564 DEFINE_PROP_END_OF_LIST(),
1567 static void virtio_ccw_rng_class_init(ObjectClass
*klass
, void *data
)
1569 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1570 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_CLASS(klass
);
1572 k
->realize
= virtio_ccw_rng_realize
;
1573 k
->exit
= virtio_ccw_exit
;
1574 dc
->reset
= virtio_ccw_reset
;
1575 dc
->props
= virtio_ccw_rng_properties
;
1576 set_bit(DEVICE_CATEGORY_MISC
, dc
->categories
);
1579 static const TypeInfo virtio_ccw_rng
= {
1580 .name
= TYPE_VIRTIO_RNG_CCW
,
1581 .parent
= TYPE_VIRTIO_CCW_DEVICE
,
1582 .instance_size
= sizeof(VirtIORNGCcw
),
1583 .instance_init
= virtio_ccw_rng_instance_init
,
1584 .class_init
= virtio_ccw_rng_class_init
,
1587 static Property virtio_ccw_crypto_properties
[] = {
1588 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice
, flags
,
1589 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT
, true),
1590 DEFINE_PROP_UINT32("max_revision", VirtioCcwDevice
, max_rev
,
1591 VIRTIO_CCW_MAX_REV
),
1592 DEFINE_PROP_END_OF_LIST(),
1595 static void virtio_ccw_crypto_instance_init(Object
*obj
)
1597 VirtIOCryptoCcw
*dev
= VIRTIO_CRYPTO_CCW(obj
);
1598 VirtioCcwDevice
*ccw_dev
= VIRTIO_CCW_DEVICE(obj
);
1600 ccw_dev
->force_revision_1
= true;
1601 virtio_instance_init_common(obj
, &dev
->vdev
, sizeof(dev
->vdev
),
1602 TYPE_VIRTIO_CRYPTO
);
1604 object_property_add_alias(obj
, "cryptodev", OBJECT(&dev
->vdev
),
1605 "cryptodev", &error_abort
);
1608 static void virtio_ccw_crypto_class_init(ObjectClass
*klass
, void *data
)
1610 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1611 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_CLASS(klass
);
1613 k
->realize
= virtio_ccw_crypto_realize
;
1614 k
->exit
= virtio_ccw_exit
;
1615 dc
->reset
= virtio_ccw_reset
;
1616 dc
->props
= virtio_ccw_crypto_properties
;
1617 set_bit(DEVICE_CATEGORY_MISC
, dc
->categories
);
1620 static const TypeInfo virtio_ccw_crypto
= {
1621 .name
= TYPE_VIRTIO_CRYPTO_CCW
,
1622 .parent
= TYPE_VIRTIO_CCW_DEVICE
,
1623 .instance_size
= sizeof(VirtIOCryptoCcw
),
1624 .instance_init
= virtio_ccw_crypto_instance_init
,
1625 .class_init
= virtio_ccw_crypto_class_init
,
1628 static void virtio_ccw_busdev_realize(DeviceState
*dev
, Error
**errp
)
1630 VirtioCcwDevice
*_dev
= (VirtioCcwDevice
*)dev
;
1632 virtio_ccw_bus_new(&_dev
->bus
, sizeof(_dev
->bus
), _dev
);
1633 virtio_ccw_device_realize(_dev
, errp
);
1636 static int virtio_ccw_busdev_exit(DeviceState
*dev
)
1638 VirtioCcwDevice
*_dev
= (VirtioCcwDevice
*)dev
;
1639 VirtIOCCWDeviceClass
*_info
= VIRTIO_CCW_DEVICE_GET_CLASS(dev
);
1641 return _info
->exit(_dev
);
1644 static void virtio_ccw_busdev_unplug(HotplugHandler
*hotplug_dev
,
1645 DeviceState
*dev
, Error
**errp
)
1647 VirtioCcwDevice
*_dev
= to_virtio_ccw_dev_fast(dev
);
1649 virtio_ccw_stop_ioeventfd(_dev
);
1652 static void virtio_ccw_device_class_init(ObjectClass
*klass
, void *data
)
1654 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1655 CCWDeviceClass
*k
= CCW_DEVICE_CLASS(dc
);
1657 k
->unplug
= virtio_ccw_busdev_unplug
;
1658 dc
->realize
= virtio_ccw_busdev_realize
;
1659 dc
->exit
= virtio_ccw_busdev_exit
;
1660 dc
->bus_type
= TYPE_VIRTUAL_CSS_BUS
;
1663 static const TypeInfo virtio_ccw_device_info
= {
1664 .name
= TYPE_VIRTIO_CCW_DEVICE
,
1665 .parent
= TYPE_CCW_DEVICE
,
1666 .instance_size
= sizeof(VirtioCcwDevice
),
1667 .class_init
= virtio_ccw_device_class_init
,
1668 .class_size
= sizeof(VirtIOCCWDeviceClass
),
1672 /* virtio-ccw-bus */
1674 static void virtio_ccw_bus_new(VirtioBusState
*bus
, size_t bus_size
,
1675 VirtioCcwDevice
*dev
)
1677 DeviceState
*qdev
= DEVICE(dev
);
1678 char virtio_bus_name
[] = "virtio-bus";
1680 qbus_create_inplace(bus
, bus_size
, TYPE_VIRTIO_CCW_BUS
,
1681 qdev
, virtio_bus_name
);
1684 static void virtio_ccw_bus_class_init(ObjectClass
*klass
, void *data
)
1686 VirtioBusClass
*k
= VIRTIO_BUS_CLASS(klass
);
1687 BusClass
*bus_class
= BUS_CLASS(klass
);
1689 bus_class
->max_dev
= 1;
1690 k
->notify
= virtio_ccw_notify
;
1691 k
->vmstate_change
= virtio_ccw_vmstate_change
;
1692 k
->query_guest_notifiers
= virtio_ccw_query_guest_notifiers
;
1693 k
->set_guest_notifiers
= virtio_ccw_set_guest_notifiers
;
1694 k
->save_queue
= virtio_ccw_save_queue
;
1695 k
->load_queue
= virtio_ccw_load_queue
;
1696 k
->save_config
= virtio_ccw_save_config
;
1697 k
->load_config
= virtio_ccw_load_config
;
1698 k
->pre_plugged
= virtio_ccw_pre_plugged
;
1699 k
->device_plugged
= virtio_ccw_device_plugged
;
1700 k
->device_unplugged
= virtio_ccw_device_unplugged
;
1701 k
->ioeventfd_enabled
= virtio_ccw_ioeventfd_enabled
;
1702 k
->ioeventfd_assign
= virtio_ccw_ioeventfd_assign
;
1705 static const TypeInfo virtio_ccw_bus_info
= {
1706 .name
= TYPE_VIRTIO_CCW_BUS
,
1707 .parent
= TYPE_VIRTIO_BUS
,
1708 .instance_size
= sizeof(VirtioCcwBusState
),
1709 .class_init
= virtio_ccw_bus_class_init
,
1712 #ifdef CONFIG_VIRTFS
1713 static Property virtio_ccw_9p_properties
[] = {
1714 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice
, flags
,
1715 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT
, true),
1716 DEFINE_PROP_UINT32("max_revision", VirtioCcwDevice
, max_rev
,
1717 VIRTIO_CCW_MAX_REV
),
1718 DEFINE_PROP_END_OF_LIST(),
1721 static void virtio_ccw_9p_realize(VirtioCcwDevice
*ccw_dev
, Error
**errp
)
1723 V9fsCCWState
*dev
= VIRTIO_9P_CCW(ccw_dev
);
1724 DeviceState
*vdev
= DEVICE(&dev
->vdev
);
1726 qdev_set_parent_bus(vdev
, BUS(&ccw_dev
->bus
));
1727 object_property_set_bool(OBJECT(vdev
), true, "realized", errp
);
1730 static void virtio_ccw_9p_class_init(ObjectClass
*klass
, void *data
)
1732 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1733 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_CLASS(klass
);
1735 k
->exit
= virtio_ccw_exit
;
1736 k
->realize
= virtio_ccw_9p_realize
;
1737 dc
->reset
= virtio_ccw_reset
;
1738 dc
->props
= virtio_ccw_9p_properties
;
1739 set_bit(DEVICE_CATEGORY_STORAGE
, dc
->categories
);
1742 static void virtio_ccw_9p_instance_init(Object
*obj
)
1744 V9fsCCWState
*dev
= VIRTIO_9P_CCW(obj
);
1746 virtio_instance_init_common(obj
, &dev
->vdev
, sizeof(dev
->vdev
),
1750 static const TypeInfo virtio_ccw_9p_info
= {
1751 .name
= TYPE_VIRTIO_9P_CCW
,
1752 .parent
= TYPE_VIRTIO_CCW_DEVICE
,
1753 .instance_size
= sizeof(V9fsCCWState
),
1754 .instance_init
= virtio_ccw_9p_instance_init
,
1755 .class_init
= virtio_ccw_9p_class_init
,
1759 #ifdef CONFIG_VHOST_VSOCK
1761 static Property vhost_vsock_ccw_properties
[] = {
1762 DEFINE_PROP_UINT32("max_revision", VirtioCcwDevice
, max_rev
,
1763 VIRTIO_CCW_MAX_REV
),
1764 DEFINE_PROP_END_OF_LIST(),
1767 static void vhost_vsock_ccw_realize(VirtioCcwDevice
*ccw_dev
, Error
**errp
)
1769 VHostVSockCCWState
*dev
= VHOST_VSOCK_CCW(ccw_dev
);
1770 DeviceState
*vdev
= DEVICE(&dev
->vdev
);
1773 qdev_set_parent_bus(vdev
, BUS(&ccw_dev
->bus
));
1774 object_property_set_bool(OBJECT(vdev
), true, "realized", &err
);
1775 error_propagate(errp
, err
);
1778 static void vhost_vsock_ccw_class_init(ObjectClass
*klass
, void *data
)
1780 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1781 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_CLASS(klass
);
1783 k
->realize
= vhost_vsock_ccw_realize
;
1784 k
->exit
= virtio_ccw_exit
;
1785 set_bit(DEVICE_CATEGORY_MISC
, dc
->categories
);
1786 dc
->props
= vhost_vsock_ccw_properties
;
1787 dc
->reset
= virtio_ccw_reset
;
1790 static void vhost_vsock_ccw_instance_init(Object
*obj
)
1792 VHostVSockCCWState
*dev
= VHOST_VSOCK_CCW(obj
);
1794 virtio_instance_init_common(obj
, &dev
->vdev
, sizeof(dev
->vdev
),
1798 static const TypeInfo vhost_vsock_ccw_info
= {
1799 .name
= TYPE_VHOST_VSOCK_CCW
,
1800 .parent
= TYPE_VIRTIO_CCW_DEVICE
,
1801 .instance_size
= sizeof(VHostVSockCCWState
),
1802 .instance_init
= vhost_vsock_ccw_instance_init
,
1803 .class_init
= vhost_vsock_ccw_class_init
,
1807 static void virtio_ccw_register(void)
1809 type_register_static(&virtio_ccw_bus_info
);
1810 type_register_static(&virtio_ccw_device_info
);
1811 type_register_static(&virtio_ccw_serial
);
1812 type_register_static(&virtio_ccw_blk
);
1813 type_register_static(&virtio_ccw_net
);
1814 type_register_static(&virtio_ccw_balloon
);
1815 type_register_static(&virtio_ccw_scsi
);
1816 #ifdef CONFIG_VHOST_SCSI
1817 type_register_static(&vhost_ccw_scsi
);
1819 type_register_static(&virtio_ccw_rng
);
1820 #ifdef CONFIG_VIRTFS
1821 type_register_static(&virtio_ccw_9p_info
);
1823 #ifdef CONFIG_VHOST_VSOCK
1824 type_register_static(&vhost_vsock_ccw_info
);
1826 type_register_static(&virtio_ccw_crypto
);
1829 type_init(virtio_ccw_register
)