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"
15 #include "sysemu/block-backend.h"
16 #include "sysemu/blockdev.h"
17 #include "sysemu/sysemu.h"
19 #include "hw/virtio/virtio.h"
20 #include "hw/virtio/virtio-serial.h"
21 #include "hw/virtio/virtio-net.h"
22 #include "hw/sysbus.h"
23 #include "qemu/bitops.h"
24 #include "qemu/error-report.h"
25 #include "hw/virtio/virtio-access.h"
26 #include "hw/virtio/virtio-bus.h"
27 #include "hw/s390x/adapter.h"
28 #include "hw/s390x/s390_flic.h"
32 #include "virtio-ccw.h"
35 static QTAILQ_HEAD(, IndAddr
) indicator_addresses
=
36 QTAILQ_HEAD_INITIALIZER(indicator_addresses
);
38 static IndAddr
*get_indicator(hwaddr ind_addr
, int len
)
42 QTAILQ_FOREACH(indicator
, &indicator_addresses
, sibling
) {
43 if (indicator
->addr
== ind_addr
) {
48 indicator
= g_new0(IndAddr
, 1);
49 indicator
->addr
= ind_addr
;
51 indicator
->refcnt
= 1;
52 QTAILQ_INSERT_TAIL(&indicator_addresses
, indicator
, sibling
);
56 static int s390_io_adapter_map(AdapterInfo
*adapter
, uint64_t map_addr
,
59 S390FLICState
*fs
= s390_get_flic();
60 S390FLICStateClass
*fsc
= S390_FLIC_COMMON_GET_CLASS(fs
);
62 return fsc
->io_adapter_map(fs
, adapter
->adapter_id
, map_addr
, do_map
);
65 static void release_indicator(AdapterInfo
*adapter
, IndAddr
*indicator
)
67 assert(indicator
->refcnt
> 0);
69 if (indicator
->refcnt
> 0) {
72 QTAILQ_REMOVE(&indicator_addresses
, indicator
, sibling
);
74 s390_io_adapter_map(adapter
, indicator
->map
, false);
79 static int map_indicator(AdapterInfo
*adapter
, IndAddr
*indicator
)
84 return 0; /* already mapped is not an error */
86 indicator
->map
= indicator
->addr
;
87 ret
= s390_io_adapter_map(adapter
, indicator
->map
, true);
88 if ((ret
!= 0) && (ret
!= -ENOSYS
)) {
98 static void virtio_ccw_bus_new(VirtioBusState
*bus
, size_t bus_size
,
99 VirtioCcwDevice
*dev
);
101 static void virtual_css_bus_reset(BusState
*qbus
)
103 /* This should actually be modelled via the generic css */
108 static void virtual_css_bus_class_init(ObjectClass
*klass
, void *data
)
110 BusClass
*k
= BUS_CLASS(klass
);
112 k
->reset
= virtual_css_bus_reset
;
115 static const TypeInfo virtual_css_bus_info
= {
116 .name
= TYPE_VIRTUAL_CSS_BUS
,
118 .instance_size
= sizeof(VirtualCssBus
),
119 .class_init
= virtual_css_bus_class_init
,
122 VirtIODevice
*virtio_ccw_get_vdev(SubchDev
*sch
)
124 VirtIODevice
*vdev
= NULL
;
125 VirtioCcwDevice
*dev
= sch
->driver_data
;
128 vdev
= virtio_bus_get_device(&dev
->bus
);
133 static int virtio_ccw_set_guest2host_notifier(VirtioCcwDevice
*dev
, int n
,
134 bool assign
, bool set_handler
)
136 VirtIODevice
*vdev
= virtio_bus_get_device(&dev
->bus
);
137 VirtQueue
*vq
= virtio_get_queue(vdev
, n
);
138 EventNotifier
*notifier
= virtio_queue_get_host_notifier(vq
);
140 SubchDev
*sch
= dev
->sch
;
141 uint32_t sch_id
= (css_build_subchannel_id(sch
) << 16) | sch
->schid
;
144 r
= event_notifier_init(notifier
, 1);
146 error_report("%s: unable to init event notifier: %d", __func__
, r
);
149 virtio_queue_set_host_notifier_fd_handler(vq
, true, set_handler
);
150 r
= s390_assign_subch_ioeventfd(notifier
, sch_id
, n
, assign
);
152 error_report("%s: unable to assign ioeventfd: %d", __func__
, r
);
153 virtio_queue_set_host_notifier_fd_handler(vq
, false, false);
154 event_notifier_cleanup(notifier
);
158 virtio_queue_set_host_notifier_fd_handler(vq
, false, false);
159 s390_assign_subch_ioeventfd(notifier
, sch_id
, n
, assign
);
160 event_notifier_cleanup(notifier
);
165 static void virtio_ccw_start_ioeventfd(VirtioCcwDevice
*dev
)
170 if (!(dev
->flags
& VIRTIO_CCW_FLAG_USE_IOEVENTFD
) ||
171 dev
->ioeventfd_disabled
||
172 dev
->ioeventfd_started
) {
175 vdev
= virtio_bus_get_device(&dev
->bus
);
176 for (n
= 0; n
< VIRTIO_CCW_QUEUE_MAX
; n
++) {
177 if (!virtio_queue_get_num(vdev
, n
)) {
180 r
= virtio_ccw_set_guest2host_notifier(dev
, n
, true, true);
185 dev
->ioeventfd_started
= true;
190 if (!virtio_queue_get_num(vdev
, n
)) {
193 r
= virtio_ccw_set_guest2host_notifier(dev
, n
, false, false);
196 dev
->ioeventfd_started
= false;
197 /* Disable ioeventfd for this device. */
198 dev
->flags
&= ~VIRTIO_CCW_FLAG_USE_IOEVENTFD
;
199 error_report("%s: failed. Fallback to userspace (slower).", __func__
);
202 static void virtio_ccw_stop_ioeventfd(VirtioCcwDevice
*dev
)
207 if (!dev
->ioeventfd_started
) {
210 vdev
= virtio_bus_get_device(&dev
->bus
);
211 for (n
= 0; n
< VIRTIO_CCW_QUEUE_MAX
; n
++) {
212 if (!virtio_queue_get_num(vdev
, n
)) {
215 r
= virtio_ccw_set_guest2host_notifier(dev
, n
, false, false);
218 dev
->ioeventfd_started
= false;
221 VirtualCssBus
*virtual_css_bus_init(void)
227 /* Create bridge device */
228 dev
= qdev_create(NULL
, "virtual-css-bridge");
229 qdev_init_nofail(dev
);
231 /* Create bus on bridge device */
232 bus
= qbus_create(TYPE_VIRTUAL_CSS_BUS
, dev
, "virtual-css");
233 cbus
= VIRTUAL_CSS_BUS(bus
);
235 /* Enable hotplugging */
236 qbus_set_hotplug_handler(bus
, dev
, &error_abort
);
241 /* Communication blocks used by several channel commands. */
242 typedef struct VqInfoBlockLegacy
{
247 } QEMU_PACKED VqInfoBlockLegacy
;
249 typedef struct VqInfoBlock
{
256 } QEMU_PACKED VqInfoBlock
;
258 typedef struct VqConfigBlock
{
261 } QEMU_PACKED VqConfigBlock
;
263 typedef struct VirtioFeatDesc
{
266 } QEMU_PACKED VirtioFeatDesc
;
268 typedef struct VirtioThinintInfo
{
269 hwaddr summary_indicator
;
270 hwaddr device_indicator
;
273 } QEMU_PACKED VirtioThinintInfo
;
275 typedef struct VirtioRevInfo
{
279 } QEMU_PACKED VirtioRevInfo
;
281 /* Specify where the virtqueues for the subchannel are in guest memory. */
282 static int virtio_ccw_set_vqs(SubchDev
*sch
, VqInfoBlock
*info
,
283 VqInfoBlockLegacy
*linfo
)
285 VirtIODevice
*vdev
= virtio_ccw_get_vdev(sch
);
286 uint16_t index
= info
? info
->index
: linfo
->index
;
287 uint16_t num
= info
? info
->num
: linfo
->num
;
288 uint64_t desc
= info
? info
->desc
: linfo
->queue
;
290 if (index
>= VIRTIO_CCW_QUEUE_MAX
) {
294 /* Current code in virtio.c relies on 4K alignment. */
295 if (linfo
&& desc
&& (linfo
->align
!= 4096)) {
304 virtio_queue_set_rings(vdev
, index
, desc
, info
->avail
, info
->used
);
306 virtio_queue_set_addr(vdev
, index
, desc
);
309 virtio_queue_set_vector(vdev
, index
, VIRTIO_NO_VECTOR
);
312 /* virtio-1 allows changing the ring size. */
313 if (virtio_queue_get_num(vdev
, index
) < num
) {
314 /* Fail if we exceed the maximum number. */
317 virtio_queue_set_num(vdev
, index
, num
);
318 } else if (virtio_queue_get_num(vdev
, index
) > num
) {
319 /* Fail if we don't have a big enough queue. */
322 /* We ignore possible increased num for legacy for compatibility. */
323 virtio_queue_set_vector(vdev
, index
, index
);
325 /* tell notify handler in case of config change */
326 vdev
->config_vector
= VIRTIO_CCW_QUEUE_MAX
;
330 static void virtio_ccw_reset_virtio(VirtioCcwDevice
*dev
, VirtIODevice
*vdev
)
332 virtio_ccw_stop_ioeventfd(dev
);
334 if (dev
->indicators
) {
335 release_indicator(&dev
->routes
.adapter
, dev
->indicators
);
336 dev
->indicators
= NULL
;
338 if (dev
->indicators2
) {
339 release_indicator(&dev
->routes
.adapter
, dev
->indicators2
);
340 dev
->indicators2
= NULL
;
342 if (dev
->summary_indicator
) {
343 release_indicator(&dev
->routes
.adapter
, dev
->summary_indicator
);
344 dev
->summary_indicator
= NULL
;
346 dev
->sch
->thinint_active
= false;
349 static int virtio_ccw_handle_set_vq(SubchDev
*sch
, CCW1 ccw
, bool check_len
,
354 VqInfoBlockLegacy linfo
;
355 size_t info_len
= is_legacy
? sizeof(linfo
) : sizeof(info
);
358 if (ccw
.count
!= info_len
) {
361 } else if (ccw
.count
< info_len
) {
362 /* Can't execute command. */
369 linfo
.queue
= address_space_ldq_be(&address_space_memory
, ccw
.cda
,
370 MEMTXATTRS_UNSPECIFIED
, NULL
);
371 linfo
.align
= address_space_ldl_be(&address_space_memory
,
372 ccw
.cda
+ sizeof(linfo
.queue
),
373 MEMTXATTRS_UNSPECIFIED
,
375 linfo
.index
= address_space_lduw_be(&address_space_memory
,
376 ccw
.cda
+ sizeof(linfo
.queue
)
377 + sizeof(linfo
.align
),
378 MEMTXATTRS_UNSPECIFIED
,
380 linfo
.num
= address_space_lduw_be(&address_space_memory
,
381 ccw
.cda
+ sizeof(linfo
.queue
)
382 + sizeof(linfo
.align
)
383 + sizeof(linfo
.index
),
384 MEMTXATTRS_UNSPECIFIED
,
386 ret
= virtio_ccw_set_vqs(sch
, NULL
, &linfo
);
388 info
.desc
= address_space_ldq_be(&address_space_memory
, ccw
.cda
,
389 MEMTXATTRS_UNSPECIFIED
, NULL
);
390 info
.index
= address_space_lduw_be(&address_space_memory
,
391 ccw
.cda
+ sizeof(info
.desc
)
393 MEMTXATTRS_UNSPECIFIED
, NULL
);
394 info
.num
= address_space_lduw_be(&address_space_memory
,
395 ccw
.cda
+ sizeof(info
.desc
)
397 + sizeof(info
.index
),
398 MEMTXATTRS_UNSPECIFIED
, NULL
);
399 info
.avail
= address_space_ldq_be(&address_space_memory
,
400 ccw
.cda
+ sizeof(info
.desc
)
404 MEMTXATTRS_UNSPECIFIED
, NULL
);
405 info
.used
= address_space_ldq_be(&address_space_memory
,
406 ccw
.cda
+ sizeof(info
.desc
)
410 + sizeof(info
.avail
),
411 MEMTXATTRS_UNSPECIFIED
, NULL
);
412 ret
= virtio_ccw_set_vqs(sch
, &info
, NULL
);
414 sch
->curr_status
.scsw
.count
= 0;
418 static int virtio_ccw_cb(SubchDev
*sch
, CCW1 ccw
)
421 VirtioRevInfo revinfo
;
423 VirtioFeatDesc features
;
426 VqConfigBlock vq_config
;
427 VirtioCcwDevice
*dev
= sch
->driver_data
;
428 VirtIODevice
*vdev
= virtio_ccw_get_vdev(sch
);
432 VirtioThinintInfo
*thinint
;
438 trace_virtio_ccw_interpret_ccw(sch
->cssid
, sch
->ssid
, sch
->schid
,
440 check_len
= !((ccw
.flags
& CCW_FLAG_SLI
) && !(ccw
.flags
& CCW_FLAG_DC
));
442 /* Look at the command. */
443 switch (ccw
.cmd_code
) {
445 ret
= virtio_ccw_handle_set_vq(sch
, ccw
, check_len
, dev
->revision
< 1);
447 case CCW_CMD_VDEV_RESET
:
448 virtio_ccw_reset_virtio(dev
, vdev
);
451 case CCW_CMD_READ_FEAT
:
453 if (ccw
.count
!= sizeof(features
)) {
457 } else if (ccw
.count
< sizeof(features
)) {
458 /* Can't execute command. */
465 features
.index
= address_space_ldub(&address_space_memory
,
467 + sizeof(features
.features
),
468 MEMTXATTRS_UNSPECIFIED
,
470 if (features
.index
== 0) {
471 if (dev
->revision
>= 1) {
472 /* Don't offer legacy features for modern devices. */
473 features
.features
= (uint32_t)
474 (vdev
->host_features
& ~VIRTIO_LEGACY_FEATURES
);
476 features
.features
= (uint32_t)vdev
->host_features
;
478 } else if ((features
.index
== 1) && (dev
->revision
>= 1)) {
480 * Only offer feature bits beyond 31 if the guest has
481 * negotiated at least revision 1.
483 features
.features
= (uint32_t)(vdev
->host_features
>> 32);
485 /* Return zeroes if the guest supports more feature bits. */
486 features
.features
= 0;
488 address_space_stl_le(&address_space_memory
, ccw
.cda
,
489 features
.features
, MEMTXATTRS_UNSPECIFIED
,
491 sch
->curr_status
.scsw
.count
= ccw
.count
- sizeof(features
);
495 case CCW_CMD_WRITE_FEAT
:
497 if (ccw
.count
!= sizeof(features
)) {
501 } else if (ccw
.count
< sizeof(features
)) {
502 /* Can't execute command. */
509 features
.index
= address_space_ldub(&address_space_memory
,
511 + sizeof(features
.features
),
512 MEMTXATTRS_UNSPECIFIED
,
514 features
.features
= address_space_ldl_le(&address_space_memory
,
516 MEMTXATTRS_UNSPECIFIED
,
518 if (features
.index
== 0) {
519 virtio_set_features(vdev
,
520 (vdev
->guest_features
& 0xffffffff00000000ULL
) |
522 } else if ((features
.index
== 1) && (dev
->revision
>= 1)) {
524 * If the guest did not negotiate at least revision 1,
525 * we did not offer it any feature bits beyond 31. Such a
526 * guest passing us any bit here is therefore buggy.
528 virtio_set_features(vdev
,
529 (vdev
->guest_features
& 0x00000000ffffffffULL
) |
530 ((uint64_t)features
.features
<< 32));
533 * If the guest supports more feature bits, assert that it
534 * passes us zeroes for those we don't support.
536 if (features
.features
) {
537 fprintf(stderr
, "Guest bug: features[%i]=%x (expected 0)\n",
538 features
.index
, features
.features
);
539 /* XXX: do a unit check here? */
542 sch
->curr_status
.scsw
.count
= ccw
.count
- sizeof(features
);
546 case CCW_CMD_READ_CONF
:
548 if (ccw
.count
> vdev
->config_len
) {
553 len
= MIN(ccw
.count
, vdev
->config_len
);
557 virtio_bus_get_vdev_config(&dev
->bus
, vdev
->config
);
558 /* XXX config space endianness */
559 cpu_physical_memory_write(ccw
.cda
, vdev
->config
, len
);
560 sch
->curr_status
.scsw
.count
= ccw
.count
- len
;
564 case CCW_CMD_WRITE_CONF
:
566 if (ccw
.count
> vdev
->config_len
) {
571 len
= MIN(ccw
.count
, vdev
->config_len
);
576 config
= cpu_physical_memory_map(ccw
.cda
, &hw_len
, 0);
581 /* XXX config space endianness */
582 memcpy(vdev
->config
, config
, len
);
583 cpu_physical_memory_unmap(config
, hw_len
, 0, hw_len
);
584 virtio_bus_set_vdev_config(&dev
->bus
, vdev
->config
);
585 sch
->curr_status
.scsw
.count
= ccw
.count
- len
;
590 case CCW_CMD_WRITE_STATUS
:
592 if (ccw
.count
!= sizeof(status
)) {
596 } else if (ccw
.count
< sizeof(status
)) {
597 /* Can't execute command. */
604 status
= address_space_ldub(&address_space_memory
, ccw
.cda
,
605 MEMTXATTRS_UNSPECIFIED
, NULL
);
606 if (!(status
& VIRTIO_CONFIG_S_DRIVER_OK
)) {
607 virtio_ccw_stop_ioeventfd(dev
);
609 if (virtio_set_status(vdev
, status
) == 0) {
610 if (vdev
->status
== 0) {
611 virtio_ccw_reset_virtio(dev
, vdev
);
613 if (status
& VIRTIO_CONFIG_S_DRIVER_OK
) {
614 virtio_ccw_start_ioeventfd(dev
);
616 sch
->curr_status
.scsw
.count
= ccw
.count
- sizeof(status
);
619 /* Trigger a command reject. */
624 case CCW_CMD_SET_IND
:
626 if (ccw
.count
!= sizeof(indicators
)) {
630 } else if (ccw
.count
< sizeof(indicators
)) {
631 /* Can't execute command. */
635 if (sch
->thinint_active
) {
636 /* Trigger a command reject. */
643 indicators
= address_space_ldq_be(&address_space_memory
, ccw
.cda
,
644 MEMTXATTRS_UNSPECIFIED
, NULL
);
645 dev
->indicators
= get_indicator(indicators
, sizeof(uint64_t));
646 sch
->curr_status
.scsw
.count
= ccw
.count
- sizeof(indicators
);
650 case CCW_CMD_SET_CONF_IND
:
652 if (ccw
.count
!= sizeof(indicators
)) {
656 } else if (ccw
.count
< sizeof(indicators
)) {
657 /* Can't execute command. */
664 indicators
= address_space_ldq_be(&address_space_memory
, ccw
.cda
,
665 MEMTXATTRS_UNSPECIFIED
, NULL
);
666 dev
->indicators2
= get_indicator(indicators
, sizeof(uint64_t));
667 sch
->curr_status
.scsw
.count
= ccw
.count
- sizeof(indicators
);
671 case CCW_CMD_READ_VQ_CONF
:
673 if (ccw
.count
!= sizeof(vq_config
)) {
677 } else if (ccw
.count
< sizeof(vq_config
)) {
678 /* Can't execute command. */
685 vq_config
.index
= address_space_lduw_be(&address_space_memory
,
687 MEMTXATTRS_UNSPECIFIED
,
689 if (vq_config
.index
>= VIRTIO_CCW_QUEUE_MAX
) {
693 vq_config
.num_max
= virtio_queue_get_num(vdev
,
695 address_space_stw_be(&address_space_memory
,
696 ccw
.cda
+ sizeof(vq_config
.index
),
698 MEMTXATTRS_UNSPECIFIED
,
700 sch
->curr_status
.scsw
.count
= ccw
.count
- sizeof(vq_config
);
704 case CCW_CMD_SET_IND_ADAPTER
:
706 if (ccw
.count
!= sizeof(*thinint
)) {
710 } else if (ccw
.count
< sizeof(*thinint
)) {
711 /* Can't execute command. */
715 len
= sizeof(*thinint
);
719 } else if (dev
->indicators
&& !sch
->thinint_active
) {
720 /* Trigger a command reject. */
723 thinint
= cpu_physical_memory_map(ccw
.cda
, &hw_len
, 0);
727 uint64_t ind_bit
= ldq_be_p(&thinint
->ind_bit
);
730 dev
->summary_indicator
=
731 get_indicator(ldq_be_p(&thinint
->summary_indicator
),
734 get_indicator(ldq_be_p(&thinint
->device_indicator
),
736 dev
->thinint_isc
= thinint
->isc
;
737 dev
->routes
.adapter
.ind_offset
= ind_bit
;
738 dev
->routes
.adapter
.summary_offset
= 7;
739 cpu_physical_memory_unmap(thinint
, hw_len
, 0, hw_len
);
740 ret
= css_register_io_adapter(CSS_IO_ADAPTER_VIRTIO
,
741 dev
->thinint_isc
, true, false,
742 &dev
->routes
.adapter
.adapter_id
);
744 sch
->thinint_active
= ((dev
->indicators
!= NULL
) &&
745 (dev
->summary_indicator
!= NULL
));
746 sch
->curr_status
.scsw
.count
= ccw
.count
- len
;
751 case CCW_CMD_SET_VIRTIO_REV
:
752 len
= sizeof(revinfo
);
753 if (ccw
.count
< len
) {
762 address_space_lduw_be(&address_space_memory
, ccw
.cda
,
763 MEMTXATTRS_UNSPECIFIED
, NULL
);
765 address_space_lduw_be(&address_space_memory
,
766 ccw
.cda
+ sizeof(revinfo
.revision
),
767 MEMTXATTRS_UNSPECIFIED
, NULL
);
768 if (ccw
.count
< len
+ revinfo
.length
||
769 (check_len
&& ccw
.count
> len
+ revinfo
.length
)) {
774 * Once we start to support revisions with additional data, we'll
775 * need to fetch it here. Nothing to do for now, though.
777 if (dev
->revision
>= 0 ||
778 revinfo
.revision
> virtio_ccw_rev_max(dev
)) {
783 dev
->revision
= revinfo
.revision
;
792 static void virtio_sch_disable_cb(SubchDev
*sch
)
794 VirtioCcwDevice
*dev
= sch
->driver_data
;
799 static void virtio_ccw_device_realize(VirtioCcwDevice
*dev
, Error
**errp
)
801 unsigned int cssid
= 0;
802 unsigned int ssid
= 0;
805 bool have_devno
= false;
810 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_GET_CLASS(dev
);
812 sch
= g_malloc0(sizeof(SubchDev
));
814 sch
->driver_data
= dev
;
817 dev
->indicators
= NULL
;
819 /* Initialize subchannel structure. */
820 sch
->channel_prog
= 0x0;
821 sch
->last_cmd_valid
= false;
822 sch
->thinint_active
= false;
824 * Use a device number if provided. Otherwise, fall back to subchannel
828 num
= sscanf(dev
->bus_id
, "%x.%x.%04x", &cssid
, &ssid
, &devno
);
830 if ((cssid
> MAX_CSSID
) || (ssid
> MAX_SSID
)) {
831 error_setg(errp
, "Invalid cssid or ssid: cssid %x, ssid %x",
835 /* Enforce use of virtual cssid. */
836 if (cssid
!= VIRTUAL_CSSID
) {
837 error_setg(errp
, "cssid %x not valid for virtio devices",
841 if (css_devno_used(cssid
, ssid
, devno
)) {
842 error_setg(errp
, "Device %x.%x.%04x already exists",
851 error_setg(errp
, "Malformed devno parameter '%s'", dev
->bus_id
);
856 /* Find the next free id. */
858 for (schid
= 0; schid
<= MAX_SCHID
; schid
++) {
859 if (!css_find_subch(1, cssid
, ssid
, schid
)) {
861 css_subch_assign(cssid
, ssid
, schid
, devno
, sch
);
867 error_setg(errp
, "No free subchannel found for %x.%x.%04x",
871 trace_virtio_ccw_new_device(cssid
, ssid
, schid
, devno
,
874 cssid
= VIRTUAL_CSSID
;
875 for (ssid
= 0; ssid
<= MAX_SSID
; ssid
++) {
876 for (schid
= 0; schid
<= MAX_SCHID
; schid
++) {
877 if (!css_find_subch(1, cssid
, ssid
, schid
)) {
883 * If the devno is already taken, look further in this
886 while (css_devno_used(cssid
, ssid
, devno
)) {
887 if (devno
== MAX_SCHID
) {
889 } else if (devno
== schid
- 1) {
890 error_setg(errp
, "No free devno found");
897 css_subch_assign(cssid
, ssid
, schid
, devno
, sch
);
907 error_setg(errp
, "Virtual channel subsystem is full!");
910 trace_virtio_ccw_new_device(cssid
, ssid
, schid
, devno
,
914 /* Build initial schib. */
915 css_sch_build_virtual_schib(sch
, 0, VIRTIO_CCW_CHPID_TYPE
);
917 sch
->ccw_cb
= virtio_ccw_cb
;
918 sch
->disable_cb
= virtio_sch_disable_cb
;
920 /* Build senseid data. */
921 memset(&sch
->id
, 0, sizeof(SenseId
));
922 sch
->id
.reserved
= 0xff;
923 sch
->id
.cu_type
= VIRTIO_CCW_CU_TYPE
;
928 k
->realize(dev
, &err
);
931 error_propagate(errp
, err
);
932 css_subch_assign(cssid
, ssid
, schid
, devno
, NULL
);
943 static int virtio_ccw_exit(VirtioCcwDevice
*dev
)
945 SubchDev
*sch
= dev
->sch
;
948 css_subch_assign(sch
->cssid
, sch
->ssid
, sch
->schid
, sch
->devno
, NULL
);
951 if (dev
->indicators
) {
952 release_indicator(&dev
->routes
.adapter
, dev
->indicators
);
953 dev
->indicators
= NULL
;
958 static void virtio_ccw_net_realize(VirtioCcwDevice
*ccw_dev
, Error
**errp
)
960 DeviceState
*qdev
= DEVICE(ccw_dev
);
961 VirtIONetCcw
*dev
= VIRTIO_NET_CCW(ccw_dev
);
962 DeviceState
*vdev
= DEVICE(&dev
->vdev
);
965 virtio_net_set_netclient_name(&dev
->vdev
, qdev
->id
,
966 object_get_typename(OBJECT(qdev
)));
967 qdev_set_parent_bus(vdev
, BUS(&ccw_dev
->bus
));
968 object_property_set_bool(OBJECT(vdev
), true, "realized", &err
);
970 error_propagate(errp
, err
);
974 static void virtio_ccw_net_instance_init(Object
*obj
)
976 VirtIONetCcw
*dev
= VIRTIO_NET_CCW(obj
);
978 virtio_instance_init_common(obj
, &dev
->vdev
, sizeof(dev
->vdev
),
980 object_property_add_alias(obj
, "bootindex", OBJECT(&dev
->vdev
),
981 "bootindex", &error_abort
);
984 static void virtio_ccw_blk_realize(VirtioCcwDevice
*ccw_dev
, Error
**errp
)
986 VirtIOBlkCcw
*dev
= VIRTIO_BLK_CCW(ccw_dev
);
987 DeviceState
*vdev
= DEVICE(&dev
->vdev
);
990 qdev_set_parent_bus(vdev
, BUS(&ccw_dev
->bus
));
991 object_property_set_bool(OBJECT(vdev
), true, "realized", &err
);
993 error_propagate(errp
, err
);
997 static void virtio_ccw_blk_instance_init(Object
*obj
)
999 VirtIOBlkCcw
*dev
= VIRTIO_BLK_CCW(obj
);
1001 virtio_instance_init_common(obj
, &dev
->vdev
, sizeof(dev
->vdev
),
1003 object_property_add_alias(obj
, "iothread", OBJECT(&dev
->vdev
),"iothread",
1005 object_property_add_alias(obj
, "bootindex", OBJECT(&dev
->vdev
),
1006 "bootindex", &error_abort
);
1009 static void virtio_ccw_serial_realize(VirtioCcwDevice
*ccw_dev
, Error
**errp
)
1011 VirtioSerialCcw
*dev
= VIRTIO_SERIAL_CCW(ccw_dev
);
1012 DeviceState
*vdev
= DEVICE(&dev
->vdev
);
1013 DeviceState
*proxy
= DEVICE(ccw_dev
);
1018 * For command line compatibility, this sets the virtio-serial-device bus
1022 bus_name
= g_strdup_printf("%s.0", proxy
->id
);
1023 virtio_device_set_child_bus_name(VIRTIO_DEVICE(vdev
), bus_name
);
1027 qdev_set_parent_bus(vdev
, BUS(&ccw_dev
->bus
));
1028 object_property_set_bool(OBJECT(vdev
), true, "realized", &err
);
1030 error_propagate(errp
, err
);
1035 static void virtio_ccw_serial_instance_init(Object
*obj
)
1037 VirtioSerialCcw
*dev
= VIRTIO_SERIAL_CCW(obj
);
1039 virtio_instance_init_common(obj
, &dev
->vdev
, sizeof(dev
->vdev
),
1040 TYPE_VIRTIO_SERIAL
);
1043 static void virtio_ccw_balloon_realize(VirtioCcwDevice
*ccw_dev
, Error
**errp
)
1045 VirtIOBalloonCcw
*dev
= VIRTIO_BALLOON_CCW(ccw_dev
);
1046 DeviceState
*vdev
= DEVICE(&dev
->vdev
);
1049 qdev_set_parent_bus(vdev
, BUS(&ccw_dev
->bus
));
1050 object_property_set_bool(OBJECT(vdev
), true, "realized", &err
);
1052 error_propagate(errp
, err
);
1056 static void virtio_ccw_balloon_instance_init(Object
*obj
)
1058 VirtIOBalloonCcw
*dev
= VIRTIO_BALLOON_CCW(obj
);
1060 virtio_instance_init_common(obj
, &dev
->vdev
, sizeof(dev
->vdev
),
1061 TYPE_VIRTIO_BALLOON
);
1062 object_property_add_alias(obj
, "guest-stats", OBJECT(&dev
->vdev
),
1063 "guest-stats", &error_abort
);
1064 object_property_add_alias(obj
, "guest-stats-polling-interval",
1066 "guest-stats-polling-interval", &error_abort
);
1069 static void virtio_ccw_scsi_realize(VirtioCcwDevice
*ccw_dev
, Error
**errp
)
1071 VirtIOSCSICcw
*dev
= VIRTIO_SCSI_CCW(ccw_dev
);
1072 DeviceState
*vdev
= DEVICE(&dev
->vdev
);
1073 DeviceState
*qdev
= DEVICE(ccw_dev
);
1078 * For command line compatibility, this sets the virtio-scsi-device bus
1082 bus_name
= g_strdup_printf("%s.0", qdev
->id
);
1083 virtio_device_set_child_bus_name(VIRTIO_DEVICE(vdev
), bus_name
);
1087 qdev_set_parent_bus(vdev
, BUS(&ccw_dev
->bus
));
1088 object_property_set_bool(OBJECT(vdev
), true, "realized", &err
);
1090 error_propagate(errp
, err
);
1094 static void virtio_ccw_scsi_instance_init(Object
*obj
)
1096 VirtIOSCSICcw
*dev
= VIRTIO_SCSI_CCW(obj
);
1098 virtio_instance_init_common(obj
, &dev
->vdev
, sizeof(dev
->vdev
),
1100 object_property_add_alias(obj
, "iothread", OBJECT(&dev
->vdev
), "iothread",
1104 #ifdef CONFIG_VHOST_SCSI
1105 static void vhost_ccw_scsi_realize(VirtioCcwDevice
*ccw_dev
, Error
**errp
)
1107 VHostSCSICcw
*dev
= VHOST_SCSI_CCW(ccw_dev
);
1108 DeviceState
*vdev
= DEVICE(&dev
->vdev
);
1111 qdev_set_parent_bus(vdev
, BUS(&ccw_dev
->bus
));
1112 object_property_set_bool(OBJECT(vdev
), true, "realized", &err
);
1114 error_propagate(errp
, err
);
1118 static void vhost_ccw_scsi_instance_init(Object
*obj
)
1120 VHostSCSICcw
*dev
= VHOST_SCSI_CCW(obj
);
1122 virtio_instance_init_common(obj
, &dev
->vdev
, sizeof(dev
->vdev
),
1127 static void virtio_ccw_rng_realize(VirtioCcwDevice
*ccw_dev
, Error
**errp
)
1129 VirtIORNGCcw
*dev
= VIRTIO_RNG_CCW(ccw_dev
);
1130 DeviceState
*vdev
= DEVICE(&dev
->vdev
);
1133 qdev_set_parent_bus(vdev
, BUS(&ccw_dev
->bus
));
1134 object_property_set_bool(OBJECT(vdev
), true, "realized", &err
);
1136 error_propagate(errp
, err
);
1140 object_property_set_link(OBJECT(dev
),
1141 OBJECT(dev
->vdev
.conf
.rng
), "rng",
1145 /* DeviceState to VirtioCcwDevice. Note: used on datapath,
1146 * be careful and test performance if you change this.
1148 static inline VirtioCcwDevice
*to_virtio_ccw_dev_fast(DeviceState
*d
)
1150 return container_of(d
, VirtioCcwDevice
, parent_obj
);
1153 static uint8_t virtio_set_ind_atomic(SubchDev
*sch
, uint64_t ind_loc
,
1156 uint8_t ind_old
, ind_new
;
1160 ind_addr
= cpu_physical_memory_map(ind_loc
, &len
, 1);
1162 error_report("%s(%x.%x.%04x): unable to access indicator",
1163 __func__
, sch
->cssid
, sch
->ssid
, sch
->schid
);
1167 ind_old
= *ind_addr
;
1168 ind_new
= ind_old
| to_be_set
;
1169 } while (atomic_cmpxchg(ind_addr
, ind_old
, ind_new
) != ind_old
);
1170 cpu_physical_memory_unmap(ind_addr
, len
, 1, len
);
1175 static void virtio_ccw_notify(DeviceState
*d
, uint16_t vector
)
1177 VirtioCcwDevice
*dev
= to_virtio_ccw_dev_fast(d
);
1178 SubchDev
*sch
= dev
->sch
;
1179 uint64_t indicators
;
1181 /* queue indicators + secondary indicators */
1182 if (vector
>= VIRTIO_CCW_QUEUE_MAX
+ 64) {
1186 if (vector
< VIRTIO_CCW_QUEUE_MAX
) {
1187 if (!dev
->indicators
) {
1190 if (sch
->thinint_active
) {
1192 * In the adapter interrupt case, indicators points to a
1193 * memory area that may be (way) larger than 64 bit and
1194 * ind_bit indicates the start of the indicators in a big
1197 uint64_t ind_bit
= dev
->routes
.adapter
.ind_offset
;
1199 virtio_set_ind_atomic(sch
, dev
->indicators
->addr
+
1200 (ind_bit
+ vector
) / 8,
1201 0x80 >> ((ind_bit
+ vector
) % 8));
1202 if (!virtio_set_ind_atomic(sch
, dev
->summary_indicator
->addr
,
1204 css_adapter_interrupt(dev
->thinint_isc
);
1207 indicators
= address_space_ldq(&address_space_memory
,
1208 dev
->indicators
->addr
,
1209 MEMTXATTRS_UNSPECIFIED
,
1211 indicators
|= 1ULL << vector
;
1212 address_space_stq(&address_space_memory
, dev
->indicators
->addr
,
1213 indicators
, MEMTXATTRS_UNSPECIFIED
, NULL
);
1214 css_conditional_io_interrupt(sch
);
1217 if (!dev
->indicators2
) {
1221 indicators
= address_space_ldq(&address_space_memory
,
1222 dev
->indicators2
->addr
,
1223 MEMTXATTRS_UNSPECIFIED
,
1225 indicators
|= 1ULL << vector
;
1226 address_space_stq(&address_space_memory
, dev
->indicators2
->addr
,
1227 indicators
, MEMTXATTRS_UNSPECIFIED
, NULL
);
1228 css_conditional_io_interrupt(sch
);
1232 static void virtio_ccw_reset(DeviceState
*d
)
1234 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
1235 VirtIODevice
*vdev
= virtio_bus_get_device(&dev
->bus
);
1237 virtio_ccw_reset_virtio(dev
, vdev
);
1238 css_reset_sch(dev
->sch
);
1241 static void virtio_ccw_vmstate_change(DeviceState
*d
, bool running
)
1243 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
1246 virtio_ccw_start_ioeventfd(dev
);
1248 virtio_ccw_stop_ioeventfd(dev
);
1252 static bool virtio_ccw_query_guest_notifiers(DeviceState
*d
)
1254 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
1256 return !!(dev
->sch
->curr_status
.pmcw
.flags
& PMCW_FLAGS_MASK_ENA
);
1259 static int virtio_ccw_set_host_notifier(DeviceState
*d
, int n
, bool assign
)
1261 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
1263 /* Stop using the generic ioeventfd, we are doing eventfd handling
1264 * ourselves below */
1265 dev
->ioeventfd_disabled
= assign
;
1267 virtio_ccw_stop_ioeventfd(dev
);
1269 return virtio_ccw_set_guest2host_notifier(dev
, n
, assign
, false);
1272 static int virtio_ccw_get_mappings(VirtioCcwDevice
*dev
)
1276 if (!dev
->sch
->thinint_active
) {
1280 r
= map_indicator(&dev
->routes
.adapter
, dev
->summary_indicator
);
1284 r
= map_indicator(&dev
->routes
.adapter
, dev
->indicators
);
1288 dev
->routes
.adapter
.summary_addr
= dev
->summary_indicator
->map
;
1289 dev
->routes
.adapter
.ind_addr
= dev
->indicators
->map
;
1294 static int virtio_ccw_setup_irqroutes(VirtioCcwDevice
*dev
, int nvqs
)
1297 VirtIODevice
*vdev
= virtio_bus_get_device(&dev
->bus
);
1299 S390FLICState
*fs
= s390_get_flic();
1300 S390FLICStateClass
*fsc
= S390_FLIC_COMMON_GET_CLASS(fs
);
1302 ret
= virtio_ccw_get_mappings(dev
);
1306 for (i
= 0; i
< nvqs
; i
++) {
1307 if (!virtio_queue_get_num(vdev
, i
)) {
1311 dev
->routes
.num_routes
= i
;
1312 return fsc
->add_adapter_routes(fs
, &dev
->routes
);
1315 static void virtio_ccw_release_irqroutes(VirtioCcwDevice
*dev
, int nvqs
)
1317 S390FLICState
*fs
= s390_get_flic();
1318 S390FLICStateClass
*fsc
= S390_FLIC_COMMON_GET_CLASS(fs
);
1320 fsc
->release_adapter_routes(fs
, &dev
->routes
);
1323 static int virtio_ccw_add_irqfd(VirtioCcwDevice
*dev
, int n
)
1325 VirtIODevice
*vdev
= virtio_bus_get_device(&dev
->bus
);
1326 VirtQueue
*vq
= virtio_get_queue(vdev
, n
);
1327 EventNotifier
*notifier
= virtio_queue_get_guest_notifier(vq
);
1329 return kvm_irqchip_add_irqfd_notifier_gsi(kvm_state
, notifier
, NULL
,
1330 dev
->routes
.gsi
[n
]);
1333 static void virtio_ccw_remove_irqfd(VirtioCcwDevice
*dev
, int n
)
1335 VirtIODevice
*vdev
= virtio_bus_get_device(&dev
->bus
);
1336 VirtQueue
*vq
= virtio_get_queue(vdev
, n
);
1337 EventNotifier
*notifier
= virtio_queue_get_guest_notifier(vq
);
1340 ret
= kvm_irqchip_remove_irqfd_notifier_gsi(kvm_state
, notifier
,
1341 dev
->routes
.gsi
[n
]);
1345 static int virtio_ccw_set_guest_notifier(VirtioCcwDevice
*dev
, int n
,
1346 bool assign
, bool with_irqfd
)
1348 VirtIODevice
*vdev
= virtio_bus_get_device(&dev
->bus
);
1349 VirtQueue
*vq
= virtio_get_queue(vdev
, n
);
1350 EventNotifier
*notifier
= virtio_queue_get_guest_notifier(vq
);
1351 VirtioDeviceClass
*k
= VIRTIO_DEVICE_GET_CLASS(vdev
);
1354 int r
= event_notifier_init(notifier
, 0);
1359 virtio_queue_set_guest_notifier_fd_handler(vq
, true, with_irqfd
);
1361 r
= virtio_ccw_add_irqfd(dev
, n
);
1363 virtio_queue_set_guest_notifier_fd_handler(vq
, false,
1369 * We do not support individual masking for channel devices, so we
1370 * need to manually trigger any guest masking callbacks here.
1372 if (k
->guest_notifier_mask
) {
1373 k
->guest_notifier_mask(vdev
, n
, false);
1375 /* get lost events and re-inject */
1376 if (k
->guest_notifier_pending
&&
1377 k
->guest_notifier_pending(vdev
, n
)) {
1378 event_notifier_set(notifier
);
1381 if (k
->guest_notifier_mask
) {
1382 k
->guest_notifier_mask(vdev
, n
, true);
1385 virtio_ccw_remove_irqfd(dev
, n
);
1387 virtio_queue_set_guest_notifier_fd_handler(vq
, false, with_irqfd
);
1388 event_notifier_cleanup(notifier
);
1393 static int virtio_ccw_set_guest_notifiers(DeviceState
*d
, int nvqs
,
1396 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
1397 VirtIODevice
*vdev
= virtio_bus_get_device(&dev
->bus
);
1398 bool with_irqfd
= dev
->sch
->thinint_active
&& kvm_irqfds_enabled();
1401 if (with_irqfd
&& assigned
) {
1402 /* irq routes need to be set up before assigning irqfds */
1403 r
= virtio_ccw_setup_irqroutes(dev
, nvqs
);
1405 goto irqroute_error
;
1408 for (n
= 0; n
< nvqs
; n
++) {
1409 if (!virtio_queue_get_num(vdev
, n
)) {
1412 r
= virtio_ccw_set_guest_notifier(dev
, n
, assigned
, with_irqfd
);
1417 if (with_irqfd
&& !assigned
) {
1418 /* release irq routes after irqfds have been released */
1419 virtio_ccw_release_irqroutes(dev
, nvqs
);
1425 virtio_ccw_set_guest_notifier(dev
, n
, !assigned
, false);
1428 if (with_irqfd
&& assigned
) {
1429 virtio_ccw_release_irqroutes(dev
, nvqs
);
1434 static void virtio_ccw_save_queue(DeviceState
*d
, int n
, QEMUFile
*f
)
1436 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
1437 VirtIODevice
*vdev
= virtio_bus_get_device(&dev
->bus
);
1439 qemu_put_be16(f
, virtio_queue_vector(vdev
, n
));
1442 static int virtio_ccw_load_queue(DeviceState
*d
, int n
, QEMUFile
*f
)
1444 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
1445 VirtIODevice
*vdev
= virtio_bus_get_device(&dev
->bus
);
1448 qemu_get_be16s(f
, &vector
);
1449 virtio_queue_set_vector(vdev
, n
, vector
);
1454 static void virtio_ccw_save_config(DeviceState
*d
, QEMUFile
*f
)
1456 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
1457 SubchDev
*s
= dev
->sch
;
1458 VirtIODevice
*vdev
= virtio_ccw_get_vdev(s
);
1460 subch_device_save(s
, f
);
1461 if (dev
->indicators
!= NULL
) {
1462 qemu_put_be32(f
, dev
->indicators
->len
);
1463 qemu_put_be64(f
, dev
->indicators
->addr
);
1465 qemu_put_be32(f
, 0);
1466 qemu_put_be64(f
, 0UL);
1468 if (dev
->indicators2
!= NULL
) {
1469 qemu_put_be32(f
, dev
->indicators2
->len
);
1470 qemu_put_be64(f
, dev
->indicators2
->addr
);
1472 qemu_put_be32(f
, 0);
1473 qemu_put_be64(f
, 0UL);
1475 if (dev
->summary_indicator
!= NULL
) {
1476 qemu_put_be32(f
, dev
->summary_indicator
->len
);
1477 qemu_put_be64(f
, dev
->summary_indicator
->addr
);
1479 qemu_put_be32(f
, 0);
1480 qemu_put_be64(f
, 0UL);
1482 qemu_put_be16(f
, vdev
->config_vector
);
1483 qemu_put_be64(f
, dev
->routes
.adapter
.ind_offset
);
1484 qemu_put_byte(f
, dev
->thinint_isc
);
1485 qemu_put_be32(f
, dev
->revision
);
1488 static int virtio_ccw_load_config(DeviceState
*d
, QEMUFile
*f
)
1490 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
1491 SubchDev
*s
= dev
->sch
;
1492 VirtIODevice
*vdev
= virtio_ccw_get_vdev(s
);
1495 s
->driver_data
= dev
;
1496 subch_device_load(s
, f
);
1497 len
= qemu_get_be32(f
);
1499 dev
->indicators
= get_indicator(qemu_get_be64(f
), len
);
1502 dev
->indicators
= NULL
;
1504 len
= qemu_get_be32(f
);
1506 dev
->indicators2
= get_indicator(qemu_get_be64(f
), len
);
1509 dev
->indicators2
= NULL
;
1511 len
= qemu_get_be32(f
);
1513 dev
->summary_indicator
= get_indicator(qemu_get_be64(f
), len
);
1516 dev
->summary_indicator
= NULL
;
1518 qemu_get_be16s(f
, &vdev
->config_vector
);
1519 dev
->routes
.adapter
.ind_offset
= qemu_get_be64(f
);
1520 dev
->thinint_isc
= qemu_get_byte(f
);
1521 dev
->revision
= qemu_get_be32(f
);
1522 if (s
->thinint_active
) {
1523 return css_register_io_adapter(CSS_IO_ADAPTER_VIRTIO
,
1524 dev
->thinint_isc
, true, false,
1525 &dev
->routes
.adapter
.adapter_id
);
1531 /* This is called by virtio-bus just after the device is plugged. */
1532 static void virtio_ccw_device_plugged(DeviceState
*d
, Error
**errp
)
1534 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
1535 VirtIODevice
*vdev
= virtio_bus_get_device(&dev
->bus
);
1536 SubchDev
*sch
= dev
->sch
;
1537 int n
= virtio_get_num_queues(vdev
);
1539 if (virtio_get_num_queues(vdev
) > VIRTIO_CCW_QUEUE_MAX
) {
1540 error_setg(errp
, "The nubmer of virtqueues %d "
1541 "exceeds ccw limit %d", n
,
1542 VIRTIO_CCW_QUEUE_MAX
);
1546 if (!kvm_eventfds_enabled()) {
1547 dev
->flags
&= ~VIRTIO_CCW_FLAG_USE_IOEVENTFD
;
1550 sch
->id
.cu_model
= virtio_bus_get_vdev_id(&dev
->bus
);
1552 if (dev
->max_rev
>= 1) {
1553 virtio_add_feature(&vdev
->host_features
, VIRTIO_F_VERSION_1
);
1556 css_generate_sch_crws(sch
->cssid
, sch
->ssid
, sch
->schid
,
1560 static void virtio_ccw_post_plugged(DeviceState
*d
, Error
**errp
)
1562 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
1563 VirtIODevice
*vdev
= virtio_bus_get_device(&dev
->bus
);
1565 if (!virtio_host_has_feature(vdev
, VIRTIO_F_VERSION_1
)) {
1566 /* A backend didn't support modern virtio. */
1571 static void virtio_ccw_device_unplugged(DeviceState
*d
)
1573 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
1575 virtio_ccw_stop_ioeventfd(dev
);
1577 /**************** Virtio-ccw Bus Device Descriptions *******************/
1579 static Property virtio_ccw_net_properties
[] = {
1580 DEFINE_PROP_STRING("devno", VirtioCcwDevice
, bus_id
),
1581 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice
, flags
,
1582 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT
, true),
1583 DEFINE_PROP_UINT32("max_revision", VirtioCcwDevice
, max_rev
,
1584 VIRTIO_CCW_MAX_REV
),
1585 DEFINE_PROP_END_OF_LIST(),
1588 static void virtio_ccw_net_class_init(ObjectClass
*klass
, void *data
)
1590 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1591 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_CLASS(klass
);
1593 k
->realize
= virtio_ccw_net_realize
;
1594 k
->exit
= virtio_ccw_exit
;
1595 dc
->reset
= virtio_ccw_reset
;
1596 dc
->props
= virtio_ccw_net_properties
;
1597 set_bit(DEVICE_CATEGORY_NETWORK
, dc
->categories
);
1600 static const TypeInfo virtio_ccw_net
= {
1601 .name
= TYPE_VIRTIO_NET_CCW
,
1602 .parent
= TYPE_VIRTIO_CCW_DEVICE
,
1603 .instance_size
= sizeof(VirtIONetCcw
),
1604 .instance_init
= virtio_ccw_net_instance_init
,
1605 .class_init
= virtio_ccw_net_class_init
,
1608 static Property virtio_ccw_blk_properties
[] = {
1609 DEFINE_PROP_STRING("devno", VirtioCcwDevice
, bus_id
),
1610 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice
, flags
,
1611 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT
, true),
1612 DEFINE_PROP_UINT32("max_revision", VirtioCcwDevice
, max_rev
,
1613 VIRTIO_CCW_MAX_REV
),
1614 DEFINE_PROP_END_OF_LIST(),
1617 static void virtio_ccw_blk_class_init(ObjectClass
*klass
, void *data
)
1619 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1620 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_CLASS(klass
);
1622 k
->realize
= virtio_ccw_blk_realize
;
1623 k
->exit
= virtio_ccw_exit
;
1624 dc
->reset
= virtio_ccw_reset
;
1625 dc
->props
= virtio_ccw_blk_properties
;
1626 set_bit(DEVICE_CATEGORY_STORAGE
, dc
->categories
);
1629 static const TypeInfo virtio_ccw_blk
= {
1630 .name
= TYPE_VIRTIO_BLK_CCW
,
1631 .parent
= TYPE_VIRTIO_CCW_DEVICE
,
1632 .instance_size
= sizeof(VirtIOBlkCcw
),
1633 .instance_init
= virtio_ccw_blk_instance_init
,
1634 .class_init
= virtio_ccw_blk_class_init
,
1637 static Property virtio_ccw_serial_properties
[] = {
1638 DEFINE_PROP_STRING("devno", VirtioCcwDevice
, bus_id
),
1639 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice
, flags
,
1640 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT
, true),
1641 DEFINE_PROP_UINT32("max_revision", VirtioCcwDevice
, max_rev
,
1642 VIRTIO_CCW_MAX_REV
),
1643 DEFINE_PROP_END_OF_LIST(),
1646 static void virtio_ccw_serial_class_init(ObjectClass
*klass
, void *data
)
1648 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1649 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_CLASS(klass
);
1651 k
->realize
= virtio_ccw_serial_realize
;
1652 k
->exit
= virtio_ccw_exit
;
1653 dc
->reset
= virtio_ccw_reset
;
1654 dc
->props
= virtio_ccw_serial_properties
;
1655 set_bit(DEVICE_CATEGORY_INPUT
, dc
->categories
);
1658 static const TypeInfo virtio_ccw_serial
= {
1659 .name
= TYPE_VIRTIO_SERIAL_CCW
,
1660 .parent
= TYPE_VIRTIO_CCW_DEVICE
,
1661 .instance_size
= sizeof(VirtioSerialCcw
),
1662 .instance_init
= virtio_ccw_serial_instance_init
,
1663 .class_init
= virtio_ccw_serial_class_init
,
1666 static Property virtio_ccw_balloon_properties
[] = {
1667 DEFINE_PROP_STRING("devno", VirtioCcwDevice
, bus_id
),
1668 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice
, flags
,
1669 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT
, true),
1670 DEFINE_PROP_UINT32("max_revision", VirtioCcwDevice
, max_rev
,
1671 VIRTIO_CCW_MAX_REV
),
1672 DEFINE_PROP_END_OF_LIST(),
1675 static void virtio_ccw_balloon_class_init(ObjectClass
*klass
, void *data
)
1677 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1678 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_CLASS(klass
);
1680 k
->realize
= virtio_ccw_balloon_realize
;
1681 k
->exit
= virtio_ccw_exit
;
1682 dc
->reset
= virtio_ccw_reset
;
1683 dc
->props
= virtio_ccw_balloon_properties
;
1684 set_bit(DEVICE_CATEGORY_MISC
, dc
->categories
);
1687 static const TypeInfo virtio_ccw_balloon
= {
1688 .name
= TYPE_VIRTIO_BALLOON_CCW
,
1689 .parent
= TYPE_VIRTIO_CCW_DEVICE
,
1690 .instance_size
= sizeof(VirtIOBalloonCcw
),
1691 .instance_init
= virtio_ccw_balloon_instance_init
,
1692 .class_init
= virtio_ccw_balloon_class_init
,
1695 static Property virtio_ccw_scsi_properties
[] = {
1696 DEFINE_PROP_STRING("devno", VirtioCcwDevice
, bus_id
),
1697 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice
, flags
,
1698 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT
, true),
1699 DEFINE_PROP_UINT32("max_revision", VirtioCcwDevice
, max_rev
,
1700 VIRTIO_CCW_MAX_REV
),
1701 DEFINE_PROP_END_OF_LIST(),
1704 static void virtio_ccw_scsi_class_init(ObjectClass
*klass
, void *data
)
1706 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1707 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_CLASS(klass
);
1709 k
->realize
= virtio_ccw_scsi_realize
;
1710 k
->exit
= virtio_ccw_exit
;
1711 dc
->reset
= virtio_ccw_reset
;
1712 dc
->props
= virtio_ccw_scsi_properties
;
1713 set_bit(DEVICE_CATEGORY_STORAGE
, dc
->categories
);
1716 static const TypeInfo virtio_ccw_scsi
= {
1717 .name
= TYPE_VIRTIO_SCSI_CCW
,
1718 .parent
= TYPE_VIRTIO_CCW_DEVICE
,
1719 .instance_size
= sizeof(VirtIOSCSICcw
),
1720 .instance_init
= virtio_ccw_scsi_instance_init
,
1721 .class_init
= virtio_ccw_scsi_class_init
,
1724 #ifdef CONFIG_VHOST_SCSI
1725 static Property vhost_ccw_scsi_properties
[] = {
1726 DEFINE_PROP_STRING("devno", VirtioCcwDevice
, bus_id
),
1727 DEFINE_PROP_UINT32("max_revision", VirtioCcwDevice
, max_rev
,
1728 VIRTIO_CCW_MAX_REV
),
1729 DEFINE_PROP_END_OF_LIST(),
1732 static void vhost_ccw_scsi_class_init(ObjectClass
*klass
, void *data
)
1734 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1735 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_CLASS(klass
);
1737 k
->realize
= vhost_ccw_scsi_realize
;
1738 k
->exit
= virtio_ccw_exit
;
1739 dc
->reset
= virtio_ccw_reset
;
1740 dc
->props
= vhost_ccw_scsi_properties
;
1741 set_bit(DEVICE_CATEGORY_STORAGE
, dc
->categories
);
1744 static const TypeInfo vhost_ccw_scsi
= {
1745 .name
= TYPE_VHOST_SCSI_CCW
,
1746 .parent
= TYPE_VIRTIO_CCW_DEVICE
,
1747 .instance_size
= sizeof(VHostSCSICcw
),
1748 .instance_init
= vhost_ccw_scsi_instance_init
,
1749 .class_init
= vhost_ccw_scsi_class_init
,
1753 static void virtio_ccw_rng_instance_init(Object
*obj
)
1755 VirtIORNGCcw
*dev
= VIRTIO_RNG_CCW(obj
);
1757 virtio_instance_init_common(obj
, &dev
->vdev
, sizeof(dev
->vdev
),
1759 object_property_add_alias(obj
, "rng", OBJECT(&dev
->vdev
),
1760 "rng", &error_abort
);
1763 static Property virtio_ccw_rng_properties
[] = {
1764 DEFINE_PROP_STRING("devno", VirtioCcwDevice
, bus_id
),
1765 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice
, flags
,
1766 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT
, true),
1767 DEFINE_PROP_UINT32("max_revision", VirtioCcwDevice
, max_rev
,
1768 VIRTIO_CCW_MAX_REV
),
1769 DEFINE_PROP_END_OF_LIST(),
1772 static void virtio_ccw_rng_class_init(ObjectClass
*klass
, void *data
)
1774 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1775 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_CLASS(klass
);
1777 k
->realize
= virtio_ccw_rng_realize
;
1778 k
->exit
= virtio_ccw_exit
;
1779 dc
->reset
= virtio_ccw_reset
;
1780 dc
->props
= virtio_ccw_rng_properties
;
1781 set_bit(DEVICE_CATEGORY_MISC
, dc
->categories
);
1784 static const TypeInfo virtio_ccw_rng
= {
1785 .name
= TYPE_VIRTIO_RNG_CCW
,
1786 .parent
= TYPE_VIRTIO_CCW_DEVICE
,
1787 .instance_size
= sizeof(VirtIORNGCcw
),
1788 .instance_init
= virtio_ccw_rng_instance_init
,
1789 .class_init
= virtio_ccw_rng_class_init
,
1792 static void virtio_ccw_busdev_realize(DeviceState
*dev
, Error
**errp
)
1794 VirtioCcwDevice
*_dev
= (VirtioCcwDevice
*)dev
;
1796 virtio_ccw_bus_new(&_dev
->bus
, sizeof(_dev
->bus
), _dev
);
1797 virtio_ccw_device_realize(_dev
, errp
);
1800 static int virtio_ccw_busdev_exit(DeviceState
*dev
)
1802 VirtioCcwDevice
*_dev
= (VirtioCcwDevice
*)dev
;
1803 VirtIOCCWDeviceClass
*_info
= VIRTIO_CCW_DEVICE_GET_CLASS(dev
);
1805 return _info
->exit(_dev
);
1808 static void virtio_ccw_busdev_unplug(HotplugHandler
*hotplug_dev
,
1809 DeviceState
*dev
, Error
**errp
)
1811 VirtioCcwDevice
*_dev
= (VirtioCcwDevice
*)dev
;
1812 SubchDev
*sch
= _dev
->sch
;
1814 virtio_ccw_stop_ioeventfd(_dev
);
1817 * We should arrive here only for device_del, since we don't support
1818 * direct hot(un)plug of channels, but only through virtio.
1820 assert(sch
!= NULL
);
1821 /* Subchannel is now disabled and no longer valid. */
1822 sch
->curr_status
.pmcw
.flags
&= ~(PMCW_FLAGS_MASK_ENA
|
1823 PMCW_FLAGS_MASK_DNV
);
1825 css_generate_sch_crws(sch
->cssid
, sch
->ssid
, sch
->schid
, 1, 0);
1827 object_unparent(OBJECT(dev
));
1830 static void virtio_ccw_device_class_init(ObjectClass
*klass
, void *data
)
1832 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1834 dc
->realize
= virtio_ccw_busdev_realize
;
1835 dc
->exit
= virtio_ccw_busdev_exit
;
1836 dc
->bus_type
= TYPE_VIRTUAL_CSS_BUS
;
1839 static const TypeInfo virtio_ccw_device_info
= {
1840 .name
= TYPE_VIRTIO_CCW_DEVICE
,
1841 .parent
= TYPE_DEVICE
,
1842 .instance_size
= sizeof(VirtioCcwDevice
),
1843 .class_init
= virtio_ccw_device_class_init
,
1844 .class_size
= sizeof(VirtIOCCWDeviceClass
),
1848 /***************** Virtual-css Bus Bridge Device ********************/
1849 /* Only required to have the virtio bus as child in the system bus */
1851 static int virtual_css_bridge_init(SysBusDevice
*dev
)
1857 static void virtual_css_bridge_class_init(ObjectClass
*klass
, void *data
)
1859 SysBusDeviceClass
*k
= SYS_BUS_DEVICE_CLASS(klass
);
1860 HotplugHandlerClass
*hc
= HOTPLUG_HANDLER_CLASS(klass
);
1861 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1863 k
->init
= virtual_css_bridge_init
;
1864 hc
->unplug
= virtio_ccw_busdev_unplug
;
1865 set_bit(DEVICE_CATEGORY_BRIDGE
, dc
->categories
);
1868 static const TypeInfo virtual_css_bridge_info
= {
1869 .name
= "virtual-css-bridge",
1870 .parent
= TYPE_SYS_BUS_DEVICE
,
1871 .instance_size
= sizeof(SysBusDevice
),
1872 .class_init
= virtual_css_bridge_class_init
,
1873 .interfaces
= (InterfaceInfo
[]) {
1874 { TYPE_HOTPLUG_HANDLER
},
1879 /* virtio-ccw-bus */
1881 static void virtio_ccw_bus_new(VirtioBusState
*bus
, size_t bus_size
,
1882 VirtioCcwDevice
*dev
)
1884 DeviceState
*qdev
= DEVICE(dev
);
1885 char virtio_bus_name
[] = "virtio-bus";
1887 qbus_create_inplace(bus
, bus_size
, TYPE_VIRTIO_CCW_BUS
,
1888 qdev
, virtio_bus_name
);
1891 static void virtio_ccw_bus_class_init(ObjectClass
*klass
, void *data
)
1893 VirtioBusClass
*k
= VIRTIO_BUS_CLASS(klass
);
1894 BusClass
*bus_class
= BUS_CLASS(klass
);
1896 bus_class
->max_dev
= 1;
1897 k
->notify
= virtio_ccw_notify
;
1898 k
->vmstate_change
= virtio_ccw_vmstate_change
;
1899 k
->query_guest_notifiers
= virtio_ccw_query_guest_notifiers
;
1900 k
->set_host_notifier
= virtio_ccw_set_host_notifier
;
1901 k
->set_guest_notifiers
= virtio_ccw_set_guest_notifiers
;
1902 k
->save_queue
= virtio_ccw_save_queue
;
1903 k
->load_queue
= virtio_ccw_load_queue
;
1904 k
->save_config
= virtio_ccw_save_config
;
1905 k
->load_config
= virtio_ccw_load_config
;
1906 k
->device_plugged
= virtio_ccw_device_plugged
;
1907 k
->post_plugged
= virtio_ccw_post_plugged
;
1908 k
->device_unplugged
= virtio_ccw_device_unplugged
;
1911 static const TypeInfo virtio_ccw_bus_info
= {
1912 .name
= TYPE_VIRTIO_CCW_BUS
,
1913 .parent
= TYPE_VIRTIO_BUS
,
1914 .instance_size
= sizeof(VirtioCcwBusState
),
1915 .class_init
= virtio_ccw_bus_class_init
,
1918 #ifdef CONFIG_VIRTFS
1919 static Property virtio_ccw_9p_properties
[] = {
1920 DEFINE_PROP_STRING("devno", VirtioCcwDevice
, bus_id
),
1921 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice
, flags
,
1922 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT
, true),
1923 DEFINE_PROP_UINT32("max_revision", VirtioCcwDevice
, max_rev
,
1924 VIRTIO_CCW_MAX_REV
),
1925 DEFINE_PROP_END_OF_LIST(),
1928 static void virtio_ccw_9p_realize(VirtioCcwDevice
*ccw_dev
, Error
**errp
)
1930 V9fsCCWState
*dev
= VIRTIO_9P_CCW(ccw_dev
);
1931 DeviceState
*vdev
= DEVICE(&dev
->vdev
);
1934 qdev_set_parent_bus(vdev
, BUS(&ccw_dev
->bus
));
1935 object_property_set_bool(OBJECT(vdev
), true, "realized", &err
);
1937 error_propagate(errp
, err
);
1941 static void virtio_ccw_9p_class_init(ObjectClass
*klass
, void *data
)
1943 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1944 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_CLASS(klass
);
1946 k
->exit
= virtio_ccw_exit
;
1947 k
->realize
= virtio_ccw_9p_realize
;
1948 dc
->reset
= virtio_ccw_reset
;
1949 dc
->props
= virtio_ccw_9p_properties
;
1950 set_bit(DEVICE_CATEGORY_STORAGE
, dc
->categories
);
1953 static void virtio_ccw_9p_instance_init(Object
*obj
)
1955 V9fsCCWState
*dev
= VIRTIO_9P_CCW(obj
);
1957 virtio_instance_init_common(obj
, &dev
->vdev
, sizeof(dev
->vdev
),
1961 static const TypeInfo virtio_ccw_9p_info
= {
1962 .name
= TYPE_VIRTIO_9P_CCW
,
1963 .parent
= TYPE_VIRTIO_CCW_DEVICE
,
1964 .instance_size
= sizeof(V9fsCCWState
),
1965 .instance_init
= virtio_ccw_9p_instance_init
,
1966 .class_init
= virtio_ccw_9p_class_init
,
1970 static void virtio_ccw_register(void)
1972 type_register_static(&virtio_ccw_bus_info
);
1973 type_register_static(&virtual_css_bus_info
);
1974 type_register_static(&virtio_ccw_device_info
);
1975 type_register_static(&virtio_ccw_serial
);
1976 type_register_static(&virtio_ccw_blk
);
1977 type_register_static(&virtio_ccw_net
);
1978 type_register_static(&virtio_ccw_balloon
);
1979 type_register_static(&virtio_ccw_scsi
);
1980 #ifdef CONFIG_VHOST_SCSI
1981 type_register_static(&vhost_ccw_scsi
);
1983 type_register_static(&virtio_ccw_rng
);
1984 type_register_static(&virtual_css_bridge_info
);
1985 #ifdef CONFIG_VIRTFS
1986 type_register_static(&virtio_ccw_9p_info
);
1990 type_init(virtio_ccw_register
)