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"
37 static void virtio_ccw_bus_new(VirtioBusState
*bus
, size_t bus_size
,
38 VirtioCcwDevice
*dev
);
40 static void virtual_css_bus_reset(BusState
*qbus
)
42 /* This should actually be modelled via the generic css */
47 static void virtual_css_bus_class_init(ObjectClass
*klass
, void *data
)
49 BusClass
*k
= BUS_CLASS(klass
);
51 k
->reset
= virtual_css_bus_reset
;
54 static const TypeInfo virtual_css_bus_info
= {
55 .name
= TYPE_VIRTUAL_CSS_BUS
,
57 .instance_size
= sizeof(VirtualCssBus
),
58 .class_init
= virtual_css_bus_class_init
,
61 VirtIODevice
*virtio_ccw_get_vdev(SubchDev
*sch
)
63 VirtIODevice
*vdev
= NULL
;
64 VirtioCcwDevice
*dev
= sch
->driver_data
;
67 vdev
= virtio_bus_get_device(&dev
->bus
);
72 static int virtio_ccw_set_guest2host_notifier(VirtioCcwDevice
*dev
, int n
,
73 bool assign
, bool set_handler
)
75 VirtIODevice
*vdev
= virtio_bus_get_device(&dev
->bus
);
76 VirtQueue
*vq
= virtio_get_queue(vdev
, n
);
77 EventNotifier
*notifier
= virtio_queue_get_host_notifier(vq
);
79 SubchDev
*sch
= dev
->sch
;
80 uint32_t sch_id
= (css_build_subchannel_id(sch
) << 16) | sch
->schid
;
83 r
= event_notifier_init(notifier
, 1);
85 error_report("%s: unable to init event notifier: %d", __func__
, r
);
88 virtio_queue_set_host_notifier_fd_handler(vq
, true, set_handler
);
89 r
= s390_assign_subch_ioeventfd(notifier
, sch_id
, n
, assign
);
91 error_report("%s: unable to assign ioeventfd: %d", __func__
, r
);
92 virtio_queue_set_host_notifier_fd_handler(vq
, false, false);
93 event_notifier_cleanup(notifier
);
97 virtio_queue_set_host_notifier_fd_handler(vq
, false, false);
98 s390_assign_subch_ioeventfd(notifier
, sch_id
, n
, assign
);
99 event_notifier_cleanup(notifier
);
104 static void virtio_ccw_start_ioeventfd(VirtioCcwDevice
*dev
)
109 if (!(dev
->flags
& VIRTIO_CCW_FLAG_USE_IOEVENTFD
) ||
110 dev
->ioeventfd_disabled
||
111 dev
->ioeventfd_started
) {
114 vdev
= virtio_bus_get_device(&dev
->bus
);
115 for (n
= 0; n
< VIRTIO_CCW_QUEUE_MAX
; n
++) {
116 if (!virtio_queue_get_num(vdev
, n
)) {
119 r
= virtio_ccw_set_guest2host_notifier(dev
, n
, true, true);
124 dev
->ioeventfd_started
= true;
129 if (!virtio_queue_get_num(vdev
, n
)) {
132 r
= virtio_ccw_set_guest2host_notifier(dev
, n
, false, false);
135 dev
->ioeventfd_started
= false;
136 /* Disable ioeventfd for this device. */
137 dev
->flags
&= ~VIRTIO_CCW_FLAG_USE_IOEVENTFD
;
138 error_report("%s: failed. Fallback to userspace (slower).", __func__
);
141 static void virtio_ccw_stop_ioeventfd(VirtioCcwDevice
*dev
)
146 if (!dev
->ioeventfd_started
) {
149 vdev
= virtio_bus_get_device(&dev
->bus
);
150 for (n
= 0; n
< VIRTIO_CCW_QUEUE_MAX
; n
++) {
151 if (!virtio_queue_get_num(vdev
, n
)) {
154 r
= virtio_ccw_set_guest2host_notifier(dev
, n
, false, false);
157 dev
->ioeventfd_started
= false;
160 VirtualCssBus
*virtual_css_bus_init(void)
166 /* Create bridge device */
167 dev
= qdev_create(NULL
, "virtual-css-bridge");
168 qdev_init_nofail(dev
);
170 /* Create bus on bridge device */
171 bus
= qbus_create(TYPE_VIRTUAL_CSS_BUS
, dev
, "virtual-css");
172 cbus
= VIRTUAL_CSS_BUS(bus
);
174 /* Enable hotplugging */
175 qbus_set_hotplug_handler(bus
, dev
, &error_abort
);
180 /* Communication blocks used by several channel commands. */
181 typedef struct VqInfoBlockLegacy
{
186 } QEMU_PACKED VqInfoBlockLegacy
;
188 typedef struct VqInfoBlock
{
195 } QEMU_PACKED VqInfoBlock
;
197 typedef struct VqConfigBlock
{
200 } QEMU_PACKED VqConfigBlock
;
202 typedef struct VirtioFeatDesc
{
205 } QEMU_PACKED VirtioFeatDesc
;
207 typedef struct VirtioThinintInfo
{
208 hwaddr summary_indicator
;
209 hwaddr device_indicator
;
212 } QEMU_PACKED VirtioThinintInfo
;
214 typedef struct VirtioRevInfo
{
218 } QEMU_PACKED VirtioRevInfo
;
220 /* Specify where the virtqueues for the subchannel are in guest memory. */
221 static int virtio_ccw_set_vqs(SubchDev
*sch
, VqInfoBlock
*info
,
222 VqInfoBlockLegacy
*linfo
)
224 VirtIODevice
*vdev
= virtio_ccw_get_vdev(sch
);
225 uint16_t index
= info
? info
->index
: linfo
->index
;
226 uint16_t num
= info
? info
->num
: linfo
->num
;
227 uint64_t desc
= info
? info
->desc
: linfo
->queue
;
229 if (index
>= VIRTIO_CCW_QUEUE_MAX
) {
233 /* Current code in virtio.c relies on 4K alignment. */
234 if (linfo
&& desc
&& (linfo
->align
!= 4096)) {
243 virtio_queue_set_rings(vdev
, index
, desc
, info
->avail
, info
->used
);
245 virtio_queue_set_addr(vdev
, index
, desc
);
248 virtio_queue_set_vector(vdev
, index
, VIRTIO_NO_VECTOR
);
251 /* virtio-1 allows changing the ring size. */
252 if (virtio_queue_get_num(vdev
, index
) < num
) {
253 /* Fail if we exceed the maximum number. */
256 virtio_queue_set_num(vdev
, index
, num
);
257 } else if (virtio_queue_get_num(vdev
, index
) > num
) {
258 /* Fail if we don't have a big enough queue. */
261 /* We ignore possible increased num for legacy for compatibility. */
262 virtio_queue_set_vector(vdev
, index
, index
);
264 /* tell notify handler in case of config change */
265 vdev
->config_vector
= VIRTIO_CCW_QUEUE_MAX
;
269 static void virtio_ccw_reset_virtio(VirtioCcwDevice
*dev
, VirtIODevice
*vdev
)
271 virtio_ccw_stop_ioeventfd(dev
);
273 if (dev
->indicators
) {
274 release_indicator(&dev
->routes
.adapter
, dev
->indicators
);
275 dev
->indicators
= NULL
;
277 if (dev
->indicators2
) {
278 release_indicator(&dev
->routes
.adapter
, dev
->indicators2
);
279 dev
->indicators2
= NULL
;
281 if (dev
->summary_indicator
) {
282 release_indicator(&dev
->routes
.adapter
, dev
->summary_indicator
);
283 dev
->summary_indicator
= NULL
;
285 dev
->sch
->thinint_active
= false;
288 static int virtio_ccw_handle_set_vq(SubchDev
*sch
, CCW1 ccw
, bool check_len
,
293 VqInfoBlockLegacy linfo
;
294 size_t info_len
= is_legacy
? sizeof(linfo
) : sizeof(info
);
297 if (ccw
.count
!= info_len
) {
300 } else if (ccw
.count
< info_len
) {
301 /* Can't execute command. */
308 linfo
.queue
= address_space_ldq_be(&address_space_memory
, ccw
.cda
,
309 MEMTXATTRS_UNSPECIFIED
, NULL
);
310 linfo
.align
= address_space_ldl_be(&address_space_memory
,
311 ccw
.cda
+ sizeof(linfo
.queue
),
312 MEMTXATTRS_UNSPECIFIED
,
314 linfo
.index
= address_space_lduw_be(&address_space_memory
,
315 ccw
.cda
+ sizeof(linfo
.queue
)
316 + sizeof(linfo
.align
),
317 MEMTXATTRS_UNSPECIFIED
,
319 linfo
.num
= address_space_lduw_be(&address_space_memory
,
320 ccw
.cda
+ sizeof(linfo
.queue
)
321 + sizeof(linfo
.align
)
322 + sizeof(linfo
.index
),
323 MEMTXATTRS_UNSPECIFIED
,
325 ret
= virtio_ccw_set_vqs(sch
, NULL
, &linfo
);
327 info
.desc
= address_space_ldq_be(&address_space_memory
, ccw
.cda
,
328 MEMTXATTRS_UNSPECIFIED
, NULL
);
329 info
.index
= address_space_lduw_be(&address_space_memory
,
330 ccw
.cda
+ sizeof(info
.desc
)
332 MEMTXATTRS_UNSPECIFIED
, NULL
);
333 info
.num
= address_space_lduw_be(&address_space_memory
,
334 ccw
.cda
+ sizeof(info
.desc
)
336 + sizeof(info
.index
),
337 MEMTXATTRS_UNSPECIFIED
, NULL
);
338 info
.avail
= address_space_ldq_be(&address_space_memory
,
339 ccw
.cda
+ sizeof(info
.desc
)
343 MEMTXATTRS_UNSPECIFIED
, NULL
);
344 info
.used
= address_space_ldq_be(&address_space_memory
,
345 ccw
.cda
+ sizeof(info
.desc
)
349 + sizeof(info
.avail
),
350 MEMTXATTRS_UNSPECIFIED
, NULL
);
351 ret
= virtio_ccw_set_vqs(sch
, &info
, NULL
);
353 sch
->curr_status
.scsw
.count
= 0;
357 static int virtio_ccw_cb(SubchDev
*sch
, CCW1 ccw
)
360 VirtioRevInfo revinfo
;
362 VirtioFeatDesc features
;
365 VqConfigBlock vq_config
;
366 VirtioCcwDevice
*dev
= sch
->driver_data
;
367 VirtIODevice
*vdev
= virtio_ccw_get_vdev(sch
);
371 VirtioThinintInfo
*thinint
;
377 trace_virtio_ccw_interpret_ccw(sch
->cssid
, sch
->ssid
, sch
->schid
,
379 check_len
= !((ccw
.flags
& CCW_FLAG_SLI
) && !(ccw
.flags
& CCW_FLAG_DC
));
381 /* Look at the command. */
382 switch (ccw
.cmd_code
) {
384 ret
= virtio_ccw_handle_set_vq(sch
, ccw
, check_len
, dev
->revision
< 1);
386 case CCW_CMD_VDEV_RESET
:
387 virtio_ccw_reset_virtio(dev
, vdev
);
390 case CCW_CMD_READ_FEAT
:
392 if (ccw
.count
!= sizeof(features
)) {
396 } else if (ccw
.count
< sizeof(features
)) {
397 /* Can't execute command. */
404 features
.index
= address_space_ldub(&address_space_memory
,
406 + sizeof(features
.features
),
407 MEMTXATTRS_UNSPECIFIED
,
409 if (features
.index
== 0) {
410 if (dev
->revision
>= 1) {
411 /* Don't offer legacy features for modern devices. */
412 features
.features
= (uint32_t)
413 (vdev
->host_features
& ~VIRTIO_LEGACY_FEATURES
);
415 features
.features
= (uint32_t)vdev
->host_features
;
417 } else if ((features
.index
== 1) && (dev
->revision
>= 1)) {
419 * Only offer feature bits beyond 31 if the guest has
420 * negotiated at least revision 1.
422 features
.features
= (uint32_t)(vdev
->host_features
>> 32);
424 /* Return zeroes if the guest supports more feature bits. */
425 features
.features
= 0;
427 address_space_stl_le(&address_space_memory
, ccw
.cda
,
428 features
.features
, MEMTXATTRS_UNSPECIFIED
,
430 sch
->curr_status
.scsw
.count
= ccw
.count
- sizeof(features
);
434 case CCW_CMD_WRITE_FEAT
:
436 if (ccw
.count
!= sizeof(features
)) {
440 } else if (ccw
.count
< sizeof(features
)) {
441 /* Can't execute command. */
448 features
.index
= address_space_ldub(&address_space_memory
,
450 + sizeof(features
.features
),
451 MEMTXATTRS_UNSPECIFIED
,
453 features
.features
= address_space_ldl_le(&address_space_memory
,
455 MEMTXATTRS_UNSPECIFIED
,
457 if (features
.index
== 0) {
458 virtio_set_features(vdev
,
459 (vdev
->guest_features
& 0xffffffff00000000ULL
) |
461 } else if ((features
.index
== 1) && (dev
->revision
>= 1)) {
463 * If the guest did not negotiate at least revision 1,
464 * we did not offer it any feature bits beyond 31. Such a
465 * guest passing us any bit here is therefore buggy.
467 virtio_set_features(vdev
,
468 (vdev
->guest_features
& 0x00000000ffffffffULL
) |
469 ((uint64_t)features
.features
<< 32));
472 * If the guest supports more feature bits, assert that it
473 * passes us zeroes for those we don't support.
475 if (features
.features
) {
476 fprintf(stderr
, "Guest bug: features[%i]=%x (expected 0)\n",
477 features
.index
, features
.features
);
478 /* XXX: do a unit check here? */
481 sch
->curr_status
.scsw
.count
= ccw
.count
- sizeof(features
);
485 case CCW_CMD_READ_CONF
:
487 if (ccw
.count
> vdev
->config_len
) {
492 len
= MIN(ccw
.count
, vdev
->config_len
);
496 virtio_bus_get_vdev_config(&dev
->bus
, vdev
->config
);
497 /* XXX config space endianness */
498 cpu_physical_memory_write(ccw
.cda
, vdev
->config
, len
);
499 sch
->curr_status
.scsw
.count
= ccw
.count
- len
;
503 case CCW_CMD_WRITE_CONF
:
505 if (ccw
.count
> vdev
->config_len
) {
510 len
= MIN(ccw
.count
, vdev
->config_len
);
515 config
= cpu_physical_memory_map(ccw
.cda
, &hw_len
, 0);
520 /* XXX config space endianness */
521 memcpy(vdev
->config
, config
, len
);
522 cpu_physical_memory_unmap(config
, hw_len
, 0, hw_len
);
523 virtio_bus_set_vdev_config(&dev
->bus
, vdev
->config
);
524 sch
->curr_status
.scsw
.count
= ccw
.count
- len
;
529 case CCW_CMD_WRITE_STATUS
:
531 if (ccw
.count
!= sizeof(status
)) {
535 } else if (ccw
.count
< sizeof(status
)) {
536 /* Can't execute command. */
543 status
= address_space_ldub(&address_space_memory
, ccw
.cda
,
544 MEMTXATTRS_UNSPECIFIED
, NULL
);
545 if (!(status
& VIRTIO_CONFIG_S_DRIVER_OK
)) {
546 virtio_ccw_stop_ioeventfd(dev
);
548 if (virtio_set_status(vdev
, status
) == 0) {
549 if (vdev
->status
== 0) {
550 virtio_ccw_reset_virtio(dev
, vdev
);
552 if (status
& VIRTIO_CONFIG_S_DRIVER_OK
) {
553 virtio_ccw_start_ioeventfd(dev
);
555 sch
->curr_status
.scsw
.count
= ccw
.count
- sizeof(status
);
558 /* Trigger a command reject. */
563 case CCW_CMD_SET_IND
:
565 if (ccw
.count
!= sizeof(indicators
)) {
569 } else if (ccw
.count
< sizeof(indicators
)) {
570 /* Can't execute command. */
574 if (sch
->thinint_active
) {
575 /* Trigger a command reject. */
582 indicators
= address_space_ldq_be(&address_space_memory
, ccw
.cda
,
583 MEMTXATTRS_UNSPECIFIED
, NULL
);
584 dev
->indicators
= get_indicator(indicators
, sizeof(uint64_t));
585 sch
->curr_status
.scsw
.count
= ccw
.count
- sizeof(indicators
);
589 case CCW_CMD_SET_CONF_IND
:
591 if (ccw
.count
!= sizeof(indicators
)) {
595 } else if (ccw
.count
< sizeof(indicators
)) {
596 /* Can't execute command. */
603 indicators
= address_space_ldq_be(&address_space_memory
, ccw
.cda
,
604 MEMTXATTRS_UNSPECIFIED
, NULL
);
605 dev
->indicators2
= get_indicator(indicators
, sizeof(uint64_t));
606 sch
->curr_status
.scsw
.count
= ccw
.count
- sizeof(indicators
);
610 case CCW_CMD_READ_VQ_CONF
:
612 if (ccw
.count
!= sizeof(vq_config
)) {
616 } else if (ccw
.count
< sizeof(vq_config
)) {
617 /* Can't execute command. */
624 vq_config
.index
= address_space_lduw_be(&address_space_memory
,
626 MEMTXATTRS_UNSPECIFIED
,
628 if (vq_config
.index
>= VIRTIO_CCW_QUEUE_MAX
) {
632 vq_config
.num_max
= virtio_queue_get_num(vdev
,
634 address_space_stw_be(&address_space_memory
,
635 ccw
.cda
+ sizeof(vq_config
.index
),
637 MEMTXATTRS_UNSPECIFIED
,
639 sch
->curr_status
.scsw
.count
= ccw
.count
- sizeof(vq_config
);
643 case CCW_CMD_SET_IND_ADAPTER
:
645 if (ccw
.count
!= sizeof(*thinint
)) {
649 } else if (ccw
.count
< sizeof(*thinint
)) {
650 /* Can't execute command. */
654 len
= sizeof(*thinint
);
658 } else if (dev
->indicators
&& !sch
->thinint_active
) {
659 /* Trigger a command reject. */
662 thinint
= cpu_physical_memory_map(ccw
.cda
, &hw_len
, 0);
666 uint64_t ind_bit
= ldq_be_p(&thinint
->ind_bit
);
669 dev
->summary_indicator
=
670 get_indicator(ldq_be_p(&thinint
->summary_indicator
),
673 get_indicator(ldq_be_p(&thinint
->device_indicator
),
675 dev
->thinint_isc
= thinint
->isc
;
676 dev
->routes
.adapter
.ind_offset
= ind_bit
;
677 dev
->routes
.adapter
.summary_offset
= 7;
678 cpu_physical_memory_unmap(thinint
, hw_len
, 0, hw_len
);
679 ret
= css_register_io_adapter(CSS_IO_ADAPTER_VIRTIO
,
680 dev
->thinint_isc
, true, false,
681 &dev
->routes
.adapter
.adapter_id
);
683 sch
->thinint_active
= ((dev
->indicators
!= NULL
) &&
684 (dev
->summary_indicator
!= NULL
));
685 sch
->curr_status
.scsw
.count
= ccw
.count
- len
;
690 case CCW_CMD_SET_VIRTIO_REV
:
691 len
= sizeof(revinfo
);
692 if (ccw
.count
< len
) {
701 address_space_lduw_be(&address_space_memory
, ccw
.cda
,
702 MEMTXATTRS_UNSPECIFIED
, NULL
);
704 address_space_lduw_be(&address_space_memory
,
705 ccw
.cda
+ sizeof(revinfo
.revision
),
706 MEMTXATTRS_UNSPECIFIED
, NULL
);
707 if (ccw
.count
< len
+ revinfo
.length
||
708 (check_len
&& ccw
.count
> len
+ revinfo
.length
)) {
713 * Once we start to support revisions with additional data, we'll
714 * need to fetch it here. Nothing to do for now, though.
716 if (dev
->revision
>= 0 ||
717 revinfo
.revision
> virtio_ccw_rev_max(dev
)) {
722 dev
->revision
= revinfo
.revision
;
731 static void virtio_sch_disable_cb(SubchDev
*sch
)
733 VirtioCcwDevice
*dev
= sch
->driver_data
;
738 static void virtio_ccw_device_realize(VirtioCcwDevice
*dev
, Error
**errp
)
744 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_GET_CLASS(dev
);
746 sch
= g_malloc0(sizeof(SubchDev
));
748 sch
->driver_data
= dev
;
751 dev
->indicators
= NULL
;
753 /* Initialize subchannel structure. */
754 sch
->channel_prog
= 0x0;
755 sch
->last_cmd_valid
= false;
756 sch
->thinint_active
= false;
758 * Use a device number if provided. Otherwise, fall back to subchannel
761 if (dev
->bus_id
.valid
) {
762 /* Enforce use of virtual cssid. */
763 if (dev
->bus_id
.cssid
!= VIRTUAL_CSSID
) {
764 error_setg(errp
, "cssid %x not valid for virtio devices",
768 if (css_devno_used(dev
->bus_id
.cssid
, dev
->bus_id
.ssid
,
769 dev
->bus_id
.devid
)) {
770 error_setg(errp
, "Device %x.%x.%04x already exists",
771 dev
->bus_id
.cssid
, dev
->bus_id
.ssid
,
775 sch
->cssid
= dev
->bus_id
.cssid
;
776 sch
->ssid
= dev
->bus_id
.ssid
;
777 sch
->devno
= dev
->bus_id
.devid
;
779 /* Find the next free id. */
780 for (schid
= 0; schid
<= MAX_SCHID
; schid
++) {
781 if (!css_find_subch(1, sch
->cssid
, sch
->ssid
, schid
)) {
783 css_subch_assign(sch
->cssid
, sch
->ssid
, sch
->schid
,
790 error_setg(errp
, "No free subchannel found for %x.%x.%04x",
791 sch
->cssid
, sch
->ssid
, sch
->devno
);
794 trace_virtio_ccw_new_device(sch
->cssid
, sch
->ssid
, sch
->schid
,
795 sch
->devno
, "user-configured");
797 unsigned int cssid
= VIRTUAL_CSSID
, ssid
, devno
;
799 for (ssid
= 0; ssid
<= MAX_SSID
; ssid
++) {
800 for (schid
= 0; schid
<= MAX_SCHID
; schid
++) {
801 if (!css_find_subch(1, cssid
, ssid
, schid
)) {
807 * If the devno is already taken, look further in this
810 while (css_devno_used(cssid
, ssid
, devno
)) {
811 if (devno
== MAX_SCHID
) {
813 } else if (devno
== schid
- 1) {
814 error_setg(errp
, "No free devno found");
821 css_subch_assign(cssid
, ssid
, schid
, devno
, sch
);
831 error_setg(errp
, "Virtual channel subsystem is full!");
834 trace_virtio_ccw_new_device(cssid
, ssid
, schid
, devno
,
838 /* Build initial schib. */
839 css_sch_build_virtual_schib(sch
, 0, VIRTIO_CCW_CHPID_TYPE
);
841 sch
->ccw_cb
= virtio_ccw_cb
;
842 sch
->disable_cb
= virtio_sch_disable_cb
;
844 /* Build senseid data. */
845 memset(&sch
->id
, 0, sizeof(SenseId
));
846 sch
->id
.reserved
= 0xff;
847 sch
->id
.cu_type
= VIRTIO_CCW_CU_TYPE
;
852 k
->realize(dev
, &err
);
855 error_propagate(errp
, err
);
856 css_subch_assign(sch
->cssid
, sch
->ssid
, sch
->schid
, sch
->devno
, NULL
);
867 static int virtio_ccw_exit(VirtioCcwDevice
*dev
)
869 SubchDev
*sch
= dev
->sch
;
872 css_subch_assign(sch
->cssid
, sch
->ssid
, sch
->schid
, sch
->devno
, NULL
);
875 if (dev
->indicators
) {
876 release_indicator(&dev
->routes
.adapter
, dev
->indicators
);
877 dev
->indicators
= NULL
;
882 static void virtio_ccw_net_realize(VirtioCcwDevice
*ccw_dev
, Error
**errp
)
884 DeviceState
*qdev
= DEVICE(ccw_dev
);
885 VirtIONetCcw
*dev
= VIRTIO_NET_CCW(ccw_dev
);
886 DeviceState
*vdev
= DEVICE(&dev
->vdev
);
888 virtio_net_set_netclient_name(&dev
->vdev
, qdev
->id
,
889 object_get_typename(OBJECT(qdev
)));
890 qdev_set_parent_bus(vdev
, BUS(&ccw_dev
->bus
));
891 object_property_set_bool(OBJECT(vdev
), true, "realized", errp
);
894 static void virtio_ccw_net_instance_init(Object
*obj
)
896 VirtIONetCcw
*dev
= VIRTIO_NET_CCW(obj
);
898 virtio_instance_init_common(obj
, &dev
->vdev
, sizeof(dev
->vdev
),
900 object_property_add_alias(obj
, "bootindex", OBJECT(&dev
->vdev
),
901 "bootindex", &error_abort
);
904 static void virtio_ccw_blk_realize(VirtioCcwDevice
*ccw_dev
, Error
**errp
)
906 VirtIOBlkCcw
*dev
= VIRTIO_BLK_CCW(ccw_dev
);
907 DeviceState
*vdev
= DEVICE(&dev
->vdev
);
909 qdev_set_parent_bus(vdev
, BUS(&ccw_dev
->bus
));
910 object_property_set_bool(OBJECT(vdev
), true, "realized", errp
);
913 static void virtio_ccw_blk_instance_init(Object
*obj
)
915 VirtIOBlkCcw
*dev
= VIRTIO_BLK_CCW(obj
);
917 virtio_instance_init_common(obj
, &dev
->vdev
, sizeof(dev
->vdev
),
919 object_property_add_alias(obj
, "iothread", OBJECT(&dev
->vdev
),"iothread",
921 object_property_add_alias(obj
, "bootindex", OBJECT(&dev
->vdev
),
922 "bootindex", &error_abort
);
925 static void virtio_ccw_serial_realize(VirtioCcwDevice
*ccw_dev
, Error
**errp
)
927 VirtioSerialCcw
*dev
= VIRTIO_SERIAL_CCW(ccw_dev
);
928 DeviceState
*vdev
= DEVICE(&dev
->vdev
);
929 DeviceState
*proxy
= DEVICE(ccw_dev
);
933 * For command line compatibility, this sets the virtio-serial-device bus
937 bus_name
= g_strdup_printf("%s.0", proxy
->id
);
938 virtio_device_set_child_bus_name(VIRTIO_DEVICE(vdev
), bus_name
);
942 qdev_set_parent_bus(vdev
, BUS(&ccw_dev
->bus
));
943 object_property_set_bool(OBJECT(vdev
), true, "realized", errp
);
947 static void virtio_ccw_serial_instance_init(Object
*obj
)
949 VirtioSerialCcw
*dev
= VIRTIO_SERIAL_CCW(obj
);
951 virtio_instance_init_common(obj
, &dev
->vdev
, sizeof(dev
->vdev
),
955 static void virtio_ccw_balloon_realize(VirtioCcwDevice
*ccw_dev
, Error
**errp
)
957 VirtIOBalloonCcw
*dev
= VIRTIO_BALLOON_CCW(ccw_dev
);
958 DeviceState
*vdev
= DEVICE(&dev
->vdev
);
960 qdev_set_parent_bus(vdev
, BUS(&ccw_dev
->bus
));
961 object_property_set_bool(OBJECT(vdev
), true, "realized", errp
);
964 static void virtio_ccw_balloon_instance_init(Object
*obj
)
966 VirtIOBalloonCcw
*dev
= VIRTIO_BALLOON_CCW(obj
);
968 virtio_instance_init_common(obj
, &dev
->vdev
, sizeof(dev
->vdev
),
969 TYPE_VIRTIO_BALLOON
);
970 object_property_add_alias(obj
, "guest-stats", OBJECT(&dev
->vdev
),
971 "guest-stats", &error_abort
);
972 object_property_add_alias(obj
, "guest-stats-polling-interval",
974 "guest-stats-polling-interval", &error_abort
);
977 static void virtio_ccw_scsi_realize(VirtioCcwDevice
*ccw_dev
, Error
**errp
)
979 VirtIOSCSICcw
*dev
= VIRTIO_SCSI_CCW(ccw_dev
);
980 DeviceState
*vdev
= DEVICE(&dev
->vdev
);
981 DeviceState
*qdev
= DEVICE(ccw_dev
);
985 * For command line compatibility, this sets the virtio-scsi-device bus
989 bus_name
= g_strdup_printf("%s.0", qdev
->id
);
990 virtio_device_set_child_bus_name(VIRTIO_DEVICE(vdev
), bus_name
);
994 qdev_set_parent_bus(vdev
, BUS(&ccw_dev
->bus
));
995 object_property_set_bool(OBJECT(vdev
), true, "realized", errp
);
998 static void virtio_ccw_scsi_instance_init(Object
*obj
)
1000 VirtIOSCSICcw
*dev
= VIRTIO_SCSI_CCW(obj
);
1002 virtio_instance_init_common(obj
, &dev
->vdev
, sizeof(dev
->vdev
),
1004 object_property_add_alias(obj
, "iothread", OBJECT(&dev
->vdev
), "iothread",
1008 #ifdef CONFIG_VHOST_SCSI
1009 static void vhost_ccw_scsi_realize(VirtioCcwDevice
*ccw_dev
, Error
**errp
)
1011 VHostSCSICcw
*dev
= VHOST_SCSI_CCW(ccw_dev
);
1012 DeviceState
*vdev
= DEVICE(&dev
->vdev
);
1014 qdev_set_parent_bus(vdev
, BUS(&ccw_dev
->bus
));
1015 object_property_set_bool(OBJECT(vdev
), true, "realized", errp
);
1018 static void vhost_ccw_scsi_instance_init(Object
*obj
)
1020 VHostSCSICcw
*dev
= VHOST_SCSI_CCW(obj
);
1022 virtio_instance_init_common(obj
, &dev
->vdev
, sizeof(dev
->vdev
),
1027 static void virtio_ccw_rng_realize(VirtioCcwDevice
*ccw_dev
, Error
**errp
)
1029 VirtIORNGCcw
*dev
= VIRTIO_RNG_CCW(ccw_dev
);
1030 DeviceState
*vdev
= DEVICE(&dev
->vdev
);
1033 qdev_set_parent_bus(vdev
, BUS(&ccw_dev
->bus
));
1034 object_property_set_bool(OBJECT(vdev
), true, "realized", &err
);
1036 error_propagate(errp
, err
);
1040 object_property_set_link(OBJECT(dev
),
1041 OBJECT(dev
->vdev
.conf
.rng
), "rng",
1045 /* DeviceState to VirtioCcwDevice. Note: used on datapath,
1046 * be careful and test performance if you change this.
1048 static inline VirtioCcwDevice
*to_virtio_ccw_dev_fast(DeviceState
*d
)
1050 return container_of(d
, VirtioCcwDevice
, parent_obj
);
1053 static uint8_t virtio_set_ind_atomic(SubchDev
*sch
, uint64_t ind_loc
,
1056 uint8_t ind_old
, ind_new
;
1060 ind_addr
= cpu_physical_memory_map(ind_loc
, &len
, 1);
1062 error_report("%s(%x.%x.%04x): unable to access indicator",
1063 __func__
, sch
->cssid
, sch
->ssid
, sch
->schid
);
1067 ind_old
= *ind_addr
;
1068 ind_new
= ind_old
| to_be_set
;
1069 } while (atomic_cmpxchg(ind_addr
, ind_old
, ind_new
) != ind_old
);
1070 trace_virtio_ccw_set_ind(ind_loc
, ind_old
, ind_new
);
1071 cpu_physical_memory_unmap(ind_addr
, len
, 1, len
);
1076 static void virtio_ccw_notify(DeviceState
*d
, uint16_t vector
)
1078 VirtioCcwDevice
*dev
= to_virtio_ccw_dev_fast(d
);
1079 SubchDev
*sch
= dev
->sch
;
1080 uint64_t indicators
;
1082 /* queue indicators + secondary indicators */
1083 if (vector
>= VIRTIO_CCW_QUEUE_MAX
+ 64) {
1087 if (vector
< VIRTIO_CCW_QUEUE_MAX
) {
1088 if (!dev
->indicators
) {
1091 if (sch
->thinint_active
) {
1093 * In the adapter interrupt case, indicators points to a
1094 * memory area that may be (way) larger than 64 bit and
1095 * ind_bit indicates the start of the indicators in a big
1098 uint64_t ind_bit
= dev
->routes
.adapter
.ind_offset
;
1100 virtio_set_ind_atomic(sch
, dev
->indicators
->addr
+
1101 (ind_bit
+ vector
) / 8,
1102 0x80 >> ((ind_bit
+ vector
) % 8));
1103 if (!virtio_set_ind_atomic(sch
, dev
->summary_indicator
->addr
,
1105 css_adapter_interrupt(dev
->thinint_isc
);
1108 indicators
= address_space_ldq(&address_space_memory
,
1109 dev
->indicators
->addr
,
1110 MEMTXATTRS_UNSPECIFIED
,
1112 indicators
|= 1ULL << vector
;
1113 address_space_stq(&address_space_memory
, dev
->indicators
->addr
,
1114 indicators
, MEMTXATTRS_UNSPECIFIED
, NULL
);
1115 css_conditional_io_interrupt(sch
);
1118 if (!dev
->indicators2
) {
1122 indicators
= address_space_ldq(&address_space_memory
,
1123 dev
->indicators2
->addr
,
1124 MEMTXATTRS_UNSPECIFIED
,
1126 indicators
|= 1ULL << vector
;
1127 address_space_stq(&address_space_memory
, dev
->indicators2
->addr
,
1128 indicators
, MEMTXATTRS_UNSPECIFIED
, NULL
);
1129 css_conditional_io_interrupt(sch
);
1133 static void virtio_ccw_reset(DeviceState
*d
)
1135 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
1136 VirtIODevice
*vdev
= virtio_bus_get_device(&dev
->bus
);
1138 virtio_ccw_reset_virtio(dev
, vdev
);
1139 css_reset_sch(dev
->sch
);
1142 static void virtio_ccw_vmstate_change(DeviceState
*d
, bool running
)
1144 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
1147 virtio_ccw_start_ioeventfd(dev
);
1149 virtio_ccw_stop_ioeventfd(dev
);
1153 static bool virtio_ccw_query_guest_notifiers(DeviceState
*d
)
1155 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
1157 return !!(dev
->sch
->curr_status
.pmcw
.flags
& PMCW_FLAGS_MASK_ENA
);
1160 static int virtio_ccw_set_host_notifier(DeviceState
*d
, int n
, bool assign
)
1162 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
1164 /* Stop using the generic ioeventfd, we are doing eventfd handling
1165 * ourselves below */
1166 dev
->ioeventfd_disabled
= assign
;
1168 virtio_ccw_stop_ioeventfd(dev
);
1170 return virtio_ccw_set_guest2host_notifier(dev
, n
, assign
, false);
1173 static int virtio_ccw_get_mappings(VirtioCcwDevice
*dev
)
1177 if (!dev
->sch
->thinint_active
) {
1181 r
= map_indicator(&dev
->routes
.adapter
, dev
->summary_indicator
);
1185 r
= map_indicator(&dev
->routes
.adapter
, dev
->indicators
);
1189 dev
->routes
.adapter
.summary_addr
= dev
->summary_indicator
->map
;
1190 dev
->routes
.adapter
.ind_addr
= dev
->indicators
->map
;
1195 static int virtio_ccw_setup_irqroutes(VirtioCcwDevice
*dev
, int nvqs
)
1198 VirtIODevice
*vdev
= virtio_bus_get_device(&dev
->bus
);
1200 S390FLICState
*fs
= s390_get_flic();
1201 S390FLICStateClass
*fsc
= S390_FLIC_COMMON_GET_CLASS(fs
);
1203 ret
= virtio_ccw_get_mappings(dev
);
1207 for (i
= 0; i
< nvqs
; i
++) {
1208 if (!virtio_queue_get_num(vdev
, i
)) {
1212 dev
->routes
.num_routes
= i
;
1213 return fsc
->add_adapter_routes(fs
, &dev
->routes
);
1216 static void virtio_ccw_release_irqroutes(VirtioCcwDevice
*dev
, int nvqs
)
1218 S390FLICState
*fs
= s390_get_flic();
1219 S390FLICStateClass
*fsc
= S390_FLIC_COMMON_GET_CLASS(fs
);
1221 fsc
->release_adapter_routes(fs
, &dev
->routes
);
1224 static int virtio_ccw_add_irqfd(VirtioCcwDevice
*dev
, int n
)
1226 VirtIODevice
*vdev
= virtio_bus_get_device(&dev
->bus
);
1227 VirtQueue
*vq
= virtio_get_queue(vdev
, n
);
1228 EventNotifier
*notifier
= virtio_queue_get_guest_notifier(vq
);
1230 return kvm_irqchip_add_irqfd_notifier_gsi(kvm_state
, notifier
, NULL
,
1231 dev
->routes
.gsi
[n
]);
1234 static void virtio_ccw_remove_irqfd(VirtioCcwDevice
*dev
, int n
)
1236 VirtIODevice
*vdev
= virtio_bus_get_device(&dev
->bus
);
1237 VirtQueue
*vq
= virtio_get_queue(vdev
, n
);
1238 EventNotifier
*notifier
= virtio_queue_get_guest_notifier(vq
);
1241 ret
= kvm_irqchip_remove_irqfd_notifier_gsi(kvm_state
, notifier
,
1242 dev
->routes
.gsi
[n
]);
1246 static int virtio_ccw_set_guest_notifier(VirtioCcwDevice
*dev
, int n
,
1247 bool assign
, bool with_irqfd
)
1249 VirtIODevice
*vdev
= virtio_bus_get_device(&dev
->bus
);
1250 VirtQueue
*vq
= virtio_get_queue(vdev
, n
);
1251 EventNotifier
*notifier
= virtio_queue_get_guest_notifier(vq
);
1252 VirtioDeviceClass
*k
= VIRTIO_DEVICE_GET_CLASS(vdev
);
1255 int r
= event_notifier_init(notifier
, 0);
1260 virtio_queue_set_guest_notifier_fd_handler(vq
, true, with_irqfd
);
1262 r
= virtio_ccw_add_irqfd(dev
, n
);
1264 virtio_queue_set_guest_notifier_fd_handler(vq
, false,
1270 * We do not support individual masking for channel devices, so we
1271 * need to manually trigger any guest masking callbacks here.
1273 if (k
->guest_notifier_mask
) {
1274 k
->guest_notifier_mask(vdev
, n
, false);
1276 /* get lost events and re-inject */
1277 if (k
->guest_notifier_pending
&&
1278 k
->guest_notifier_pending(vdev
, n
)) {
1279 event_notifier_set(notifier
);
1282 if (k
->guest_notifier_mask
) {
1283 k
->guest_notifier_mask(vdev
, n
, true);
1286 virtio_ccw_remove_irqfd(dev
, n
);
1288 virtio_queue_set_guest_notifier_fd_handler(vq
, false, with_irqfd
);
1289 event_notifier_cleanup(notifier
);
1294 static int virtio_ccw_set_guest_notifiers(DeviceState
*d
, int nvqs
,
1297 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
1298 VirtIODevice
*vdev
= virtio_bus_get_device(&dev
->bus
);
1299 bool with_irqfd
= dev
->sch
->thinint_active
&& kvm_irqfds_enabled();
1302 if (with_irqfd
&& assigned
) {
1303 /* irq routes need to be set up before assigning irqfds */
1304 r
= virtio_ccw_setup_irqroutes(dev
, nvqs
);
1306 goto irqroute_error
;
1309 for (n
= 0; n
< nvqs
; n
++) {
1310 if (!virtio_queue_get_num(vdev
, n
)) {
1313 r
= virtio_ccw_set_guest_notifier(dev
, n
, assigned
, with_irqfd
);
1318 if (with_irqfd
&& !assigned
) {
1319 /* release irq routes after irqfds have been released */
1320 virtio_ccw_release_irqroutes(dev
, nvqs
);
1326 virtio_ccw_set_guest_notifier(dev
, n
, !assigned
, false);
1329 if (with_irqfd
&& assigned
) {
1330 virtio_ccw_release_irqroutes(dev
, nvqs
);
1335 static void virtio_ccw_save_queue(DeviceState
*d
, int n
, QEMUFile
*f
)
1337 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
1338 VirtIODevice
*vdev
= virtio_bus_get_device(&dev
->bus
);
1340 qemu_put_be16(f
, virtio_queue_vector(vdev
, n
));
1343 static int virtio_ccw_load_queue(DeviceState
*d
, int n
, QEMUFile
*f
)
1345 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
1346 VirtIODevice
*vdev
= virtio_bus_get_device(&dev
->bus
);
1349 qemu_get_be16s(f
, &vector
);
1350 virtio_queue_set_vector(vdev
, n
, vector
);
1355 static void virtio_ccw_save_config(DeviceState
*d
, QEMUFile
*f
)
1357 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
1358 SubchDev
*s
= dev
->sch
;
1359 VirtIODevice
*vdev
= virtio_ccw_get_vdev(s
);
1361 subch_device_save(s
, f
);
1362 if (dev
->indicators
!= NULL
) {
1363 qemu_put_be32(f
, dev
->indicators
->len
);
1364 qemu_put_be64(f
, dev
->indicators
->addr
);
1366 qemu_put_be32(f
, 0);
1367 qemu_put_be64(f
, 0UL);
1369 if (dev
->indicators2
!= NULL
) {
1370 qemu_put_be32(f
, dev
->indicators2
->len
);
1371 qemu_put_be64(f
, dev
->indicators2
->addr
);
1373 qemu_put_be32(f
, 0);
1374 qemu_put_be64(f
, 0UL);
1376 if (dev
->summary_indicator
!= NULL
) {
1377 qemu_put_be32(f
, dev
->summary_indicator
->len
);
1378 qemu_put_be64(f
, dev
->summary_indicator
->addr
);
1380 qemu_put_be32(f
, 0);
1381 qemu_put_be64(f
, 0UL);
1383 qemu_put_be16(f
, vdev
->config_vector
);
1384 qemu_put_be64(f
, dev
->routes
.adapter
.ind_offset
);
1385 qemu_put_byte(f
, dev
->thinint_isc
);
1386 qemu_put_be32(f
, dev
->revision
);
1389 static int virtio_ccw_load_config(DeviceState
*d
, QEMUFile
*f
)
1391 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
1392 SubchDev
*s
= dev
->sch
;
1393 VirtIODevice
*vdev
= virtio_ccw_get_vdev(s
);
1396 s
->driver_data
= dev
;
1397 subch_device_load(s
, f
);
1398 len
= qemu_get_be32(f
);
1400 dev
->indicators
= get_indicator(qemu_get_be64(f
), len
);
1403 dev
->indicators
= NULL
;
1405 len
= qemu_get_be32(f
);
1407 dev
->indicators2
= get_indicator(qemu_get_be64(f
), len
);
1410 dev
->indicators2
= NULL
;
1412 len
= qemu_get_be32(f
);
1414 dev
->summary_indicator
= get_indicator(qemu_get_be64(f
), len
);
1417 dev
->summary_indicator
= NULL
;
1419 qemu_get_be16s(f
, &vdev
->config_vector
);
1420 dev
->routes
.adapter
.ind_offset
= qemu_get_be64(f
);
1421 dev
->thinint_isc
= qemu_get_byte(f
);
1422 dev
->revision
= qemu_get_be32(f
);
1423 if (s
->thinint_active
) {
1424 return css_register_io_adapter(CSS_IO_ADAPTER_VIRTIO
,
1425 dev
->thinint_isc
, true, false,
1426 &dev
->routes
.adapter
.adapter_id
);
1432 /* This is called by virtio-bus just after the device is plugged. */
1433 static void virtio_ccw_device_plugged(DeviceState
*d
, Error
**errp
)
1435 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
1436 VirtIODevice
*vdev
= virtio_bus_get_device(&dev
->bus
);
1437 SubchDev
*sch
= dev
->sch
;
1438 int n
= virtio_get_num_queues(vdev
);
1440 if (virtio_get_num_queues(vdev
) > VIRTIO_CCW_QUEUE_MAX
) {
1441 error_setg(errp
, "The number of virtqueues %d "
1442 "exceeds ccw limit %d", n
,
1443 VIRTIO_CCW_QUEUE_MAX
);
1447 if (!kvm_eventfds_enabled()) {
1448 dev
->flags
&= ~VIRTIO_CCW_FLAG_USE_IOEVENTFD
;
1451 sch
->id
.cu_model
= virtio_bus_get_vdev_id(&dev
->bus
);
1453 if (dev
->max_rev
>= 1) {
1454 virtio_add_feature(&vdev
->host_features
, VIRTIO_F_VERSION_1
);
1457 css_generate_sch_crws(sch
->cssid
, sch
->ssid
, sch
->schid
,
1461 static void virtio_ccw_post_plugged(DeviceState
*d
, Error
**errp
)
1463 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
1464 VirtIODevice
*vdev
= virtio_bus_get_device(&dev
->bus
);
1466 if (!virtio_host_has_feature(vdev
, VIRTIO_F_VERSION_1
)) {
1467 /* A backend didn't support modern virtio. */
1472 static void virtio_ccw_device_unplugged(DeviceState
*d
)
1474 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
1476 virtio_ccw_stop_ioeventfd(dev
);
1478 /**************** Virtio-ccw Bus Device Descriptions *******************/
1480 static Property virtio_ccw_net_properties
[] = {
1481 DEFINE_PROP_CSS_DEV_ID("devno", VirtioCcwDevice
, bus_id
),
1482 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice
, flags
,
1483 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT
, true),
1484 DEFINE_PROP_UINT32("max_revision", VirtioCcwDevice
, max_rev
,
1485 VIRTIO_CCW_MAX_REV
),
1486 DEFINE_PROP_END_OF_LIST(),
1489 static void virtio_ccw_net_class_init(ObjectClass
*klass
, void *data
)
1491 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1492 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_CLASS(klass
);
1494 k
->realize
= virtio_ccw_net_realize
;
1495 k
->exit
= virtio_ccw_exit
;
1496 dc
->reset
= virtio_ccw_reset
;
1497 dc
->props
= virtio_ccw_net_properties
;
1498 set_bit(DEVICE_CATEGORY_NETWORK
, dc
->categories
);
1501 static const TypeInfo virtio_ccw_net
= {
1502 .name
= TYPE_VIRTIO_NET_CCW
,
1503 .parent
= TYPE_VIRTIO_CCW_DEVICE
,
1504 .instance_size
= sizeof(VirtIONetCcw
),
1505 .instance_init
= virtio_ccw_net_instance_init
,
1506 .class_init
= virtio_ccw_net_class_init
,
1509 static Property virtio_ccw_blk_properties
[] = {
1510 DEFINE_PROP_CSS_DEV_ID("devno", VirtioCcwDevice
, bus_id
),
1511 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice
, flags
,
1512 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT
, true),
1513 DEFINE_PROP_UINT32("max_revision", VirtioCcwDevice
, max_rev
,
1514 VIRTIO_CCW_MAX_REV
),
1515 DEFINE_PROP_END_OF_LIST(),
1518 static void virtio_ccw_blk_class_init(ObjectClass
*klass
, void *data
)
1520 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1521 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_CLASS(klass
);
1523 k
->realize
= virtio_ccw_blk_realize
;
1524 k
->exit
= virtio_ccw_exit
;
1525 dc
->reset
= virtio_ccw_reset
;
1526 dc
->props
= virtio_ccw_blk_properties
;
1527 set_bit(DEVICE_CATEGORY_STORAGE
, dc
->categories
);
1530 static const TypeInfo virtio_ccw_blk
= {
1531 .name
= TYPE_VIRTIO_BLK_CCW
,
1532 .parent
= TYPE_VIRTIO_CCW_DEVICE
,
1533 .instance_size
= sizeof(VirtIOBlkCcw
),
1534 .instance_init
= virtio_ccw_blk_instance_init
,
1535 .class_init
= virtio_ccw_blk_class_init
,
1538 static Property virtio_ccw_serial_properties
[] = {
1539 DEFINE_PROP_CSS_DEV_ID("devno", VirtioCcwDevice
, bus_id
),
1540 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice
, flags
,
1541 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT
, true),
1542 DEFINE_PROP_UINT32("max_revision", VirtioCcwDevice
, max_rev
,
1543 VIRTIO_CCW_MAX_REV
),
1544 DEFINE_PROP_END_OF_LIST(),
1547 static void virtio_ccw_serial_class_init(ObjectClass
*klass
, void *data
)
1549 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1550 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_CLASS(klass
);
1552 k
->realize
= virtio_ccw_serial_realize
;
1553 k
->exit
= virtio_ccw_exit
;
1554 dc
->reset
= virtio_ccw_reset
;
1555 dc
->props
= virtio_ccw_serial_properties
;
1556 set_bit(DEVICE_CATEGORY_INPUT
, dc
->categories
);
1559 static const TypeInfo virtio_ccw_serial
= {
1560 .name
= TYPE_VIRTIO_SERIAL_CCW
,
1561 .parent
= TYPE_VIRTIO_CCW_DEVICE
,
1562 .instance_size
= sizeof(VirtioSerialCcw
),
1563 .instance_init
= virtio_ccw_serial_instance_init
,
1564 .class_init
= virtio_ccw_serial_class_init
,
1567 static Property virtio_ccw_balloon_properties
[] = {
1568 DEFINE_PROP_CSS_DEV_ID("devno", VirtioCcwDevice
, bus_id
),
1569 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice
, flags
,
1570 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT
, true),
1571 DEFINE_PROP_UINT32("max_revision", VirtioCcwDevice
, max_rev
,
1572 VIRTIO_CCW_MAX_REV
),
1573 DEFINE_PROP_END_OF_LIST(),
1576 static void virtio_ccw_balloon_class_init(ObjectClass
*klass
, void *data
)
1578 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1579 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_CLASS(klass
);
1581 k
->realize
= virtio_ccw_balloon_realize
;
1582 k
->exit
= virtio_ccw_exit
;
1583 dc
->reset
= virtio_ccw_reset
;
1584 dc
->props
= virtio_ccw_balloon_properties
;
1585 set_bit(DEVICE_CATEGORY_MISC
, dc
->categories
);
1588 static const TypeInfo virtio_ccw_balloon
= {
1589 .name
= TYPE_VIRTIO_BALLOON_CCW
,
1590 .parent
= TYPE_VIRTIO_CCW_DEVICE
,
1591 .instance_size
= sizeof(VirtIOBalloonCcw
),
1592 .instance_init
= virtio_ccw_balloon_instance_init
,
1593 .class_init
= virtio_ccw_balloon_class_init
,
1596 static Property virtio_ccw_scsi_properties
[] = {
1597 DEFINE_PROP_CSS_DEV_ID("devno", VirtioCcwDevice
, bus_id
),
1598 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice
, flags
,
1599 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT
, true),
1600 DEFINE_PROP_UINT32("max_revision", VirtioCcwDevice
, max_rev
,
1601 VIRTIO_CCW_MAX_REV
),
1602 DEFINE_PROP_END_OF_LIST(),
1605 static void virtio_ccw_scsi_class_init(ObjectClass
*klass
, void *data
)
1607 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1608 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_CLASS(klass
);
1610 k
->realize
= virtio_ccw_scsi_realize
;
1611 k
->exit
= virtio_ccw_exit
;
1612 dc
->reset
= virtio_ccw_reset
;
1613 dc
->props
= virtio_ccw_scsi_properties
;
1614 set_bit(DEVICE_CATEGORY_STORAGE
, dc
->categories
);
1617 static const TypeInfo virtio_ccw_scsi
= {
1618 .name
= TYPE_VIRTIO_SCSI_CCW
,
1619 .parent
= TYPE_VIRTIO_CCW_DEVICE
,
1620 .instance_size
= sizeof(VirtIOSCSICcw
),
1621 .instance_init
= virtio_ccw_scsi_instance_init
,
1622 .class_init
= virtio_ccw_scsi_class_init
,
1625 #ifdef CONFIG_VHOST_SCSI
1626 static Property vhost_ccw_scsi_properties
[] = {
1627 DEFINE_PROP_CSS_DEV_ID("devno", VirtioCcwDevice
, bus_id
),
1628 DEFINE_PROP_UINT32("max_revision", VirtioCcwDevice
, max_rev
,
1629 VIRTIO_CCW_MAX_REV
),
1630 DEFINE_PROP_END_OF_LIST(),
1633 static void vhost_ccw_scsi_class_init(ObjectClass
*klass
, void *data
)
1635 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1636 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_CLASS(klass
);
1638 k
->realize
= vhost_ccw_scsi_realize
;
1639 k
->exit
= virtio_ccw_exit
;
1640 dc
->reset
= virtio_ccw_reset
;
1641 dc
->props
= vhost_ccw_scsi_properties
;
1642 set_bit(DEVICE_CATEGORY_STORAGE
, dc
->categories
);
1645 static const TypeInfo vhost_ccw_scsi
= {
1646 .name
= TYPE_VHOST_SCSI_CCW
,
1647 .parent
= TYPE_VIRTIO_CCW_DEVICE
,
1648 .instance_size
= sizeof(VHostSCSICcw
),
1649 .instance_init
= vhost_ccw_scsi_instance_init
,
1650 .class_init
= vhost_ccw_scsi_class_init
,
1654 static void virtio_ccw_rng_instance_init(Object
*obj
)
1656 VirtIORNGCcw
*dev
= VIRTIO_RNG_CCW(obj
);
1658 virtio_instance_init_common(obj
, &dev
->vdev
, sizeof(dev
->vdev
),
1660 object_property_add_alias(obj
, "rng", OBJECT(&dev
->vdev
),
1661 "rng", &error_abort
);
1664 static Property virtio_ccw_rng_properties
[] = {
1665 DEFINE_PROP_CSS_DEV_ID("devno", VirtioCcwDevice
, bus_id
),
1666 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice
, flags
,
1667 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT
, true),
1668 DEFINE_PROP_UINT32("max_revision", VirtioCcwDevice
, max_rev
,
1669 VIRTIO_CCW_MAX_REV
),
1670 DEFINE_PROP_END_OF_LIST(),
1673 static void virtio_ccw_rng_class_init(ObjectClass
*klass
, void *data
)
1675 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1676 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_CLASS(klass
);
1678 k
->realize
= virtio_ccw_rng_realize
;
1679 k
->exit
= virtio_ccw_exit
;
1680 dc
->reset
= virtio_ccw_reset
;
1681 dc
->props
= virtio_ccw_rng_properties
;
1682 set_bit(DEVICE_CATEGORY_MISC
, dc
->categories
);
1685 static const TypeInfo virtio_ccw_rng
= {
1686 .name
= TYPE_VIRTIO_RNG_CCW
,
1687 .parent
= TYPE_VIRTIO_CCW_DEVICE
,
1688 .instance_size
= sizeof(VirtIORNGCcw
),
1689 .instance_init
= virtio_ccw_rng_instance_init
,
1690 .class_init
= virtio_ccw_rng_class_init
,
1693 static void virtio_ccw_busdev_realize(DeviceState
*dev
, Error
**errp
)
1695 VirtioCcwDevice
*_dev
= (VirtioCcwDevice
*)dev
;
1697 virtio_ccw_bus_new(&_dev
->bus
, sizeof(_dev
->bus
), _dev
);
1698 virtio_ccw_device_realize(_dev
, errp
);
1701 static int virtio_ccw_busdev_exit(DeviceState
*dev
)
1703 VirtioCcwDevice
*_dev
= (VirtioCcwDevice
*)dev
;
1704 VirtIOCCWDeviceClass
*_info
= VIRTIO_CCW_DEVICE_GET_CLASS(dev
);
1706 return _info
->exit(_dev
);
1709 static void virtio_ccw_busdev_unplug(HotplugHandler
*hotplug_dev
,
1710 DeviceState
*dev
, Error
**errp
)
1712 VirtioCcwDevice
*_dev
= (VirtioCcwDevice
*)dev
;
1713 SubchDev
*sch
= _dev
->sch
;
1715 virtio_ccw_stop_ioeventfd(_dev
);
1718 * We should arrive here only for device_del, since we don't support
1719 * direct hot(un)plug of channels, but only through virtio.
1721 assert(sch
!= NULL
);
1722 /* Subchannel is now disabled and no longer valid. */
1723 sch
->curr_status
.pmcw
.flags
&= ~(PMCW_FLAGS_MASK_ENA
|
1724 PMCW_FLAGS_MASK_DNV
);
1726 css_generate_sch_crws(sch
->cssid
, sch
->ssid
, sch
->schid
, 1, 0);
1728 object_unparent(OBJECT(dev
));
1731 static void virtio_ccw_device_class_init(ObjectClass
*klass
, void *data
)
1733 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1735 dc
->realize
= virtio_ccw_busdev_realize
;
1736 dc
->exit
= virtio_ccw_busdev_exit
;
1737 dc
->bus_type
= TYPE_VIRTUAL_CSS_BUS
;
1740 static const TypeInfo virtio_ccw_device_info
= {
1741 .name
= TYPE_VIRTIO_CCW_DEVICE
,
1742 .parent
= TYPE_DEVICE
,
1743 .instance_size
= sizeof(VirtioCcwDevice
),
1744 .class_init
= virtio_ccw_device_class_init
,
1745 .class_size
= sizeof(VirtIOCCWDeviceClass
),
1749 /***************** Virtual-css Bus Bridge Device ********************/
1750 /* Only required to have the virtio bus as child in the system bus */
1752 static int virtual_css_bridge_init(SysBusDevice
*dev
)
1758 static void virtual_css_bridge_class_init(ObjectClass
*klass
, void *data
)
1760 SysBusDeviceClass
*k
= SYS_BUS_DEVICE_CLASS(klass
);
1761 HotplugHandlerClass
*hc
= HOTPLUG_HANDLER_CLASS(klass
);
1762 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1764 k
->init
= virtual_css_bridge_init
;
1765 hc
->unplug
= virtio_ccw_busdev_unplug
;
1766 set_bit(DEVICE_CATEGORY_BRIDGE
, dc
->categories
);
1769 static const TypeInfo virtual_css_bridge_info
= {
1770 .name
= "virtual-css-bridge",
1771 .parent
= TYPE_SYS_BUS_DEVICE
,
1772 .instance_size
= sizeof(SysBusDevice
),
1773 .class_init
= virtual_css_bridge_class_init
,
1774 .interfaces
= (InterfaceInfo
[]) {
1775 { TYPE_HOTPLUG_HANDLER
},
1780 /* virtio-ccw-bus */
1782 static void virtio_ccw_bus_new(VirtioBusState
*bus
, size_t bus_size
,
1783 VirtioCcwDevice
*dev
)
1785 DeviceState
*qdev
= DEVICE(dev
);
1786 char virtio_bus_name
[] = "virtio-bus";
1788 qbus_create_inplace(bus
, bus_size
, TYPE_VIRTIO_CCW_BUS
,
1789 qdev
, virtio_bus_name
);
1792 static void virtio_ccw_bus_class_init(ObjectClass
*klass
, void *data
)
1794 VirtioBusClass
*k
= VIRTIO_BUS_CLASS(klass
);
1795 BusClass
*bus_class
= BUS_CLASS(klass
);
1797 bus_class
->max_dev
= 1;
1798 k
->notify
= virtio_ccw_notify
;
1799 k
->vmstate_change
= virtio_ccw_vmstate_change
;
1800 k
->query_guest_notifiers
= virtio_ccw_query_guest_notifiers
;
1801 k
->set_host_notifier
= virtio_ccw_set_host_notifier
;
1802 k
->set_guest_notifiers
= virtio_ccw_set_guest_notifiers
;
1803 k
->save_queue
= virtio_ccw_save_queue
;
1804 k
->load_queue
= virtio_ccw_load_queue
;
1805 k
->save_config
= virtio_ccw_save_config
;
1806 k
->load_config
= virtio_ccw_load_config
;
1807 k
->device_plugged
= virtio_ccw_device_plugged
;
1808 k
->post_plugged
= virtio_ccw_post_plugged
;
1809 k
->device_unplugged
= virtio_ccw_device_unplugged
;
1812 static const TypeInfo virtio_ccw_bus_info
= {
1813 .name
= TYPE_VIRTIO_CCW_BUS
,
1814 .parent
= TYPE_VIRTIO_BUS
,
1815 .instance_size
= sizeof(VirtioCcwBusState
),
1816 .class_init
= virtio_ccw_bus_class_init
,
1819 #ifdef CONFIG_VIRTFS
1820 static Property virtio_ccw_9p_properties
[] = {
1821 DEFINE_PROP_CSS_DEV_ID("devno", VirtioCcwDevice
, bus_id
),
1822 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice
, flags
,
1823 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT
, true),
1824 DEFINE_PROP_UINT32("max_revision", VirtioCcwDevice
, max_rev
,
1825 VIRTIO_CCW_MAX_REV
),
1826 DEFINE_PROP_END_OF_LIST(),
1829 static void virtio_ccw_9p_realize(VirtioCcwDevice
*ccw_dev
, Error
**errp
)
1831 V9fsCCWState
*dev
= VIRTIO_9P_CCW(ccw_dev
);
1832 DeviceState
*vdev
= DEVICE(&dev
->vdev
);
1834 qdev_set_parent_bus(vdev
, BUS(&ccw_dev
->bus
));
1835 object_property_set_bool(OBJECT(vdev
), true, "realized", errp
);
1838 static void virtio_ccw_9p_class_init(ObjectClass
*klass
, void *data
)
1840 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1841 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_CLASS(klass
);
1843 k
->exit
= virtio_ccw_exit
;
1844 k
->realize
= virtio_ccw_9p_realize
;
1845 dc
->reset
= virtio_ccw_reset
;
1846 dc
->props
= virtio_ccw_9p_properties
;
1847 set_bit(DEVICE_CATEGORY_STORAGE
, dc
->categories
);
1850 static void virtio_ccw_9p_instance_init(Object
*obj
)
1852 V9fsCCWState
*dev
= VIRTIO_9P_CCW(obj
);
1854 virtio_instance_init_common(obj
, &dev
->vdev
, sizeof(dev
->vdev
),
1858 static const TypeInfo virtio_ccw_9p_info
= {
1859 .name
= TYPE_VIRTIO_9P_CCW
,
1860 .parent
= TYPE_VIRTIO_CCW_DEVICE
,
1861 .instance_size
= sizeof(V9fsCCWState
),
1862 .instance_init
= virtio_ccw_9p_instance_init
,
1863 .class_init
= virtio_ccw_9p_class_init
,
1867 static void virtio_ccw_register(void)
1869 type_register_static(&virtio_ccw_bus_info
);
1870 type_register_static(&virtual_css_bus_info
);
1871 type_register_static(&virtio_ccw_device_info
);
1872 type_register_static(&virtio_ccw_serial
);
1873 type_register_static(&virtio_ccw_blk
);
1874 type_register_static(&virtio_ccw_net
);
1875 type_register_static(&virtio_ccw_balloon
);
1876 type_register_static(&virtio_ccw_scsi
);
1877 #ifdef CONFIG_VHOST_SCSI
1878 type_register_static(&vhost_ccw_scsi
);
1880 type_register_static(&virtio_ccw_rng
);
1881 type_register_static(&virtual_css_bridge_info
);
1882 #ifdef CONFIG_VIRTFS
1883 type_register_static(&virtio_ccw_9p_info
);
1887 type_init(virtio_ccw_register
)