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
14 #include "sysemu/block-backend.h"
15 #include "sysemu/blockdev.h"
16 #include "sysemu/sysemu.h"
18 #include "monitor/monitor.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 "hw/virtio/virtio-bus.h"
25 #include "hw/s390x/adapter.h"
26 #include "hw/s390x/s390_flic.h"
30 #include "virtio-ccw.h"
33 static QTAILQ_HEAD(, IndAddr
) indicator_addresses
=
34 QTAILQ_HEAD_INITIALIZER(indicator_addresses
);
36 static IndAddr
*get_indicator(hwaddr ind_addr
, int len
)
40 QTAILQ_FOREACH(indicator
, &indicator_addresses
, sibling
) {
41 if (indicator
->addr
== ind_addr
) {
46 indicator
= g_new0(IndAddr
, 1);
47 indicator
->addr
= ind_addr
;
49 indicator
->refcnt
= 1;
50 QTAILQ_INSERT_TAIL(&indicator_addresses
, indicator
, sibling
);
54 static int s390_io_adapter_map(AdapterInfo
*adapter
, uint64_t map_addr
,
57 S390FLICState
*fs
= s390_get_flic();
58 S390FLICStateClass
*fsc
= S390_FLIC_COMMON_GET_CLASS(fs
);
60 return fsc
->io_adapter_map(fs
, adapter
->adapter_id
, map_addr
, do_map
);
63 static void release_indicator(AdapterInfo
*adapter
, IndAddr
*indicator
)
65 assert(indicator
->refcnt
> 0);
67 if (indicator
->refcnt
> 0) {
70 QTAILQ_REMOVE(&indicator_addresses
, indicator
, sibling
);
72 s390_io_adapter_map(adapter
, indicator
->map
, false);
77 static int map_indicator(AdapterInfo
*adapter
, IndAddr
*indicator
)
82 return 0; /* already mapped is not an error */
84 indicator
->map
= indicator
->addr
;
85 ret
= s390_io_adapter_map(adapter
, indicator
->map
, true);
86 if ((ret
!= 0) && (ret
!= -ENOSYS
)) {
96 static void virtio_ccw_bus_new(VirtioBusState
*bus
, size_t bus_size
,
97 VirtioCcwDevice
*dev
);
99 static void virtual_css_bus_reset(BusState
*qbus
)
101 /* This should actually be modelled via the generic css */
106 static void virtual_css_bus_class_init(ObjectClass
*klass
, void *data
)
108 BusClass
*k
= BUS_CLASS(klass
);
110 k
->reset
= virtual_css_bus_reset
;
113 static const TypeInfo virtual_css_bus_info
= {
114 .name
= TYPE_VIRTUAL_CSS_BUS
,
116 .instance_size
= sizeof(VirtualCssBus
),
117 .class_init
= virtual_css_bus_class_init
,
120 VirtIODevice
*virtio_ccw_get_vdev(SubchDev
*sch
)
122 VirtIODevice
*vdev
= NULL
;
123 VirtioCcwDevice
*dev
= sch
->driver_data
;
126 vdev
= virtio_bus_get_device(&dev
->bus
);
131 static int virtio_ccw_set_guest2host_notifier(VirtioCcwDevice
*dev
, int n
,
132 bool assign
, bool set_handler
)
134 VirtIODevice
*vdev
= virtio_bus_get_device(&dev
->bus
);
135 VirtQueue
*vq
= virtio_get_queue(vdev
, n
);
136 EventNotifier
*notifier
= virtio_queue_get_host_notifier(vq
);
138 SubchDev
*sch
= dev
->sch
;
139 uint32_t sch_id
= (css_build_subchannel_id(sch
) << 16) | sch
->schid
;
142 r
= event_notifier_init(notifier
, 1);
144 error_report("%s: unable to init event notifier: %d", __func__
, r
);
147 virtio_queue_set_host_notifier_fd_handler(vq
, true, set_handler
);
148 r
= s390_assign_subch_ioeventfd(notifier
, sch_id
, n
, assign
);
150 error_report("%s: unable to assign ioeventfd: %d", __func__
, r
);
151 virtio_queue_set_host_notifier_fd_handler(vq
, false, false);
152 event_notifier_cleanup(notifier
);
156 virtio_queue_set_host_notifier_fd_handler(vq
, false, false);
157 s390_assign_subch_ioeventfd(notifier
, sch_id
, n
, assign
);
158 event_notifier_cleanup(notifier
);
163 static void virtio_ccw_start_ioeventfd(VirtioCcwDevice
*dev
)
168 if (!(dev
->flags
& VIRTIO_CCW_FLAG_USE_IOEVENTFD
) ||
169 dev
->ioeventfd_disabled
||
170 dev
->ioeventfd_started
) {
173 vdev
= virtio_bus_get_device(&dev
->bus
);
174 for (n
= 0; n
< VIRTIO_CCW_QUEUE_MAX
; n
++) {
175 if (!virtio_queue_get_num(vdev
, n
)) {
178 r
= virtio_ccw_set_guest2host_notifier(dev
, n
, true, true);
183 dev
->ioeventfd_started
= true;
188 if (!virtio_queue_get_num(vdev
, n
)) {
191 r
= virtio_ccw_set_guest2host_notifier(dev
, n
, false, false);
194 dev
->ioeventfd_started
= false;
195 /* Disable ioeventfd for this device. */
196 dev
->flags
&= ~VIRTIO_CCW_FLAG_USE_IOEVENTFD
;
197 error_report("%s: failed. Fallback to userspace (slower).", __func__
);
200 static void virtio_ccw_stop_ioeventfd(VirtioCcwDevice
*dev
)
205 if (!dev
->ioeventfd_started
) {
208 vdev
= virtio_bus_get_device(&dev
->bus
);
209 for (n
= 0; n
< VIRTIO_CCW_QUEUE_MAX
; n
++) {
210 if (!virtio_queue_get_num(vdev
, n
)) {
213 r
= virtio_ccw_set_guest2host_notifier(dev
, n
, false, false);
216 dev
->ioeventfd_started
= false;
219 VirtualCssBus
*virtual_css_bus_init(void)
225 /* Create bridge device */
226 dev
= qdev_create(NULL
, "virtual-css-bridge");
227 qdev_init_nofail(dev
);
229 /* Create bus on bridge device */
230 bus
= qbus_create(TYPE_VIRTUAL_CSS_BUS
, dev
, "virtual-css");
231 cbus
= VIRTUAL_CSS_BUS(bus
);
233 /* Enable hotplugging */
234 qbus_set_hotplug_handler(bus
, dev
, &error_abort
);
239 /* Communication blocks used by several channel commands. */
240 typedef struct VqInfoBlock
{
245 } QEMU_PACKED VqInfoBlock
;
247 typedef struct VqConfigBlock
{
250 } QEMU_PACKED VqConfigBlock
;
252 typedef struct VirtioFeatDesc
{
255 } QEMU_PACKED VirtioFeatDesc
;
257 typedef struct VirtioThinintInfo
{
258 hwaddr summary_indicator
;
259 hwaddr device_indicator
;
262 } QEMU_PACKED VirtioThinintInfo
;
264 /* Specify where the virtqueues for the subchannel are in guest memory. */
265 static int virtio_ccw_set_vqs(SubchDev
*sch
, uint64_t addr
, uint32_t align
,
266 uint16_t index
, uint16_t num
)
268 VirtIODevice
*vdev
= virtio_ccw_get_vdev(sch
);
270 if (index
>= VIRTIO_CCW_QUEUE_MAX
) {
274 /* Current code in virtio.c relies on 4K alignment. */
275 if (addr
&& (align
!= 4096)) {
283 virtio_queue_set_addr(vdev
, index
, addr
);
285 virtio_queue_set_vector(vdev
, index
, VIRTIO_NO_VECTOR
);
287 /* Fail if we don't have a big enough queue. */
288 /* TODO: Add interface to handle vring.num changing */
289 if (virtio_queue_get_num(vdev
, index
) > num
) {
292 virtio_queue_set_vector(vdev
, index
, index
);
294 /* tell notify handler in case of config change */
295 vdev
->config_vector
= VIRTIO_CCW_QUEUE_MAX
;
299 static int virtio_ccw_cb(SubchDev
*sch
, CCW1 ccw
)
304 VirtioFeatDesc features
;
307 VqConfigBlock vq_config
;
308 VirtioCcwDevice
*dev
= sch
->driver_data
;
309 VirtIODevice
*vdev
= virtio_ccw_get_vdev(sch
);
313 VirtioThinintInfo
*thinint
;
319 trace_virtio_ccw_interpret_ccw(sch
->cssid
, sch
->ssid
, sch
->schid
,
321 check_len
= !((ccw
.flags
& CCW_FLAG_SLI
) && !(ccw
.flags
& CCW_FLAG_DC
));
323 /* Look at the command. */
324 switch (ccw
.cmd_code
) {
327 if (ccw
.count
!= sizeof(info
)) {
331 } else if (ccw
.count
< sizeof(info
)) {
332 /* Can't execute command. */
339 info
.queue
= address_space_ldq(&address_space_memory
, ccw
.cda
,
340 MEMTXATTRS_UNSPECIFIED
, NULL
);
341 info
.align
= address_space_ldl(&address_space_memory
,
342 ccw
.cda
+ sizeof(info
.queue
),
343 MEMTXATTRS_UNSPECIFIED
,
345 info
.index
= address_space_lduw(&address_space_memory
,
346 ccw
.cda
+ sizeof(info
.queue
)
347 + sizeof(info
.align
),
348 MEMTXATTRS_UNSPECIFIED
,
350 info
.num
= address_space_lduw(&address_space_memory
,
351 ccw
.cda
+ sizeof(info
.queue
)
353 + sizeof(info
.index
),
354 MEMTXATTRS_UNSPECIFIED
,
356 ret
= virtio_ccw_set_vqs(sch
, info
.queue
, info
.align
, info
.index
,
358 sch
->curr_status
.scsw
.count
= 0;
361 case CCW_CMD_VDEV_RESET
:
362 virtio_ccw_stop_ioeventfd(dev
);
366 case CCW_CMD_READ_FEAT
:
368 if (ccw
.count
!= sizeof(features
)) {
372 } else if (ccw
.count
< sizeof(features
)) {
373 /* Can't execute command. */
380 features
.index
= address_space_ldub(&address_space_memory
,
382 + sizeof(features
.features
),
383 MEMTXATTRS_UNSPECIFIED
,
385 if (features
.index
== 0) {
386 features
.features
= vdev
->host_features
;
388 /* Return zeroes if the guest supports more feature bits. */
389 features
.features
= 0;
391 address_space_stl_le(&address_space_memory
, ccw
.cda
,
392 features
.features
, MEMTXATTRS_UNSPECIFIED
,
394 sch
->curr_status
.scsw
.count
= ccw
.count
- sizeof(features
);
398 case CCW_CMD_WRITE_FEAT
:
400 if (ccw
.count
!= sizeof(features
)) {
404 } else if (ccw
.count
< sizeof(features
)) {
405 /* Can't execute command. */
412 features
.index
= address_space_ldub(&address_space_memory
,
414 + sizeof(features
.features
),
415 MEMTXATTRS_UNSPECIFIED
,
417 features
.features
= address_space_ldl_le(&address_space_memory
,
419 MEMTXATTRS_UNSPECIFIED
,
421 if (features
.index
== 0) {
422 virtio_set_features(vdev
, features
.features
);
425 * If the guest supports more feature bits, assert that it
426 * passes us zeroes for those we don't support.
428 if (features
.features
) {
429 fprintf(stderr
, "Guest bug: features[%i]=%x (expected 0)\n",
430 features
.index
, features
.features
);
431 /* XXX: do a unit check here? */
434 sch
->curr_status
.scsw
.count
= ccw
.count
- sizeof(features
);
438 case CCW_CMD_READ_CONF
:
440 if (ccw
.count
> vdev
->config_len
) {
445 len
= MIN(ccw
.count
, vdev
->config_len
);
449 virtio_bus_get_vdev_config(&dev
->bus
, vdev
->config
);
450 /* XXX config space endianness */
451 cpu_physical_memory_write(ccw
.cda
, vdev
->config
, len
);
452 sch
->curr_status
.scsw
.count
= ccw
.count
- len
;
456 case CCW_CMD_WRITE_CONF
:
458 if (ccw
.count
> vdev
->config_len
) {
463 len
= MIN(ccw
.count
, vdev
->config_len
);
468 config
= cpu_physical_memory_map(ccw
.cda
, &hw_len
, 0);
473 /* XXX config space endianness */
474 memcpy(vdev
->config
, config
, len
);
475 cpu_physical_memory_unmap(config
, hw_len
, 0, hw_len
);
476 virtio_bus_set_vdev_config(&dev
->bus
, vdev
->config
);
477 sch
->curr_status
.scsw
.count
= ccw
.count
- len
;
482 case CCW_CMD_WRITE_STATUS
:
484 if (ccw
.count
!= sizeof(status
)) {
488 } else if (ccw
.count
< sizeof(status
)) {
489 /* Can't execute command. */
496 status
= address_space_ldub(&address_space_memory
, ccw
.cda
,
497 MEMTXATTRS_UNSPECIFIED
, NULL
);
498 if (!(status
& VIRTIO_CONFIG_S_DRIVER_OK
)) {
499 virtio_ccw_stop_ioeventfd(dev
);
501 if (virtio_set_status(vdev
, status
) == 0) {
502 if (vdev
->status
== 0) {
505 if (status
& VIRTIO_CONFIG_S_DRIVER_OK
) {
506 virtio_ccw_start_ioeventfd(dev
);
508 sch
->curr_status
.scsw
.count
= ccw
.count
- sizeof(status
);
511 /* Trigger a command reject. */
516 case CCW_CMD_SET_IND
:
518 if (ccw
.count
!= sizeof(indicators
)) {
522 } else if (ccw
.count
< sizeof(indicators
)) {
523 /* Can't execute command. */
527 if (sch
->thinint_active
) {
528 /* Trigger a command reject. */
535 indicators
= address_space_ldq_be(&address_space_memory
, ccw
.cda
,
536 MEMTXATTRS_UNSPECIFIED
, NULL
);
537 dev
->indicators
= get_indicator(indicators
, sizeof(uint64_t));
538 sch
->curr_status
.scsw
.count
= ccw
.count
- sizeof(indicators
);
542 case CCW_CMD_SET_CONF_IND
:
544 if (ccw
.count
!= sizeof(indicators
)) {
548 } else if (ccw
.count
< sizeof(indicators
)) {
549 /* Can't execute command. */
556 indicators
= address_space_ldq_be(&address_space_memory
, ccw
.cda
,
557 MEMTXATTRS_UNSPECIFIED
, NULL
);
558 dev
->indicators2
= get_indicator(indicators
, sizeof(uint64_t));
559 sch
->curr_status
.scsw
.count
= ccw
.count
- sizeof(indicators
);
563 case CCW_CMD_READ_VQ_CONF
:
565 if (ccw
.count
!= sizeof(vq_config
)) {
569 } else if (ccw
.count
< sizeof(vq_config
)) {
570 /* Can't execute command. */
577 vq_config
.index
= address_space_lduw_be(&address_space_memory
,
579 MEMTXATTRS_UNSPECIFIED
,
581 if (vq_config
.index
>= VIRTIO_CCW_QUEUE_MAX
) {
585 vq_config
.num_max
= virtio_queue_get_num(vdev
,
587 address_space_stw_be(&address_space_memory
,
588 ccw
.cda
+ sizeof(vq_config
.index
),
590 MEMTXATTRS_UNSPECIFIED
,
592 sch
->curr_status
.scsw
.count
= ccw
.count
- sizeof(vq_config
);
596 case CCW_CMD_SET_IND_ADAPTER
:
598 if (ccw
.count
!= sizeof(*thinint
)) {
602 } else if (ccw
.count
< sizeof(*thinint
)) {
603 /* Can't execute command. */
607 len
= sizeof(*thinint
);
611 } else if (dev
->indicators
&& !sch
->thinint_active
) {
612 /* Trigger a command reject. */
615 thinint
= cpu_physical_memory_map(ccw
.cda
, &hw_len
, 0);
619 uint64_t ind_bit
= ldq_be_p(&thinint
->ind_bit
);
622 dev
->summary_indicator
=
623 get_indicator(ldq_be_p(&thinint
->summary_indicator
),
626 get_indicator(ldq_be_p(&thinint
->device_indicator
),
628 dev
->thinint_isc
= thinint
->isc
;
629 dev
->routes
.adapter
.ind_offset
= ind_bit
;
630 dev
->routes
.adapter
.summary_offset
= 7;
631 cpu_physical_memory_unmap(thinint
, hw_len
, 0, hw_len
);
632 ret
= css_register_io_adapter(CSS_IO_ADAPTER_VIRTIO
,
633 dev
->thinint_isc
, true, false,
634 &dev
->routes
.adapter
.adapter_id
);
636 sch
->thinint_active
= ((dev
->indicators
!= NULL
) &&
637 (dev
->summary_indicator
!= NULL
));
638 sch
->curr_status
.scsw
.count
= ccw
.count
- len
;
650 static void virtio_ccw_device_realize(VirtioCcwDevice
*dev
, Error
**errp
)
652 unsigned int cssid
= 0;
653 unsigned int ssid
= 0;
656 bool have_devno
= false;
661 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_GET_CLASS(dev
);
663 sch
= g_malloc0(sizeof(SubchDev
));
665 sch
->driver_data
= dev
;
668 dev
->indicators
= NULL
;
670 /* Initialize subchannel structure. */
671 sch
->channel_prog
= 0x0;
672 sch
->last_cmd_valid
= false;
673 sch
->thinint_active
= false;
675 * Use a device number if provided. Otherwise, fall back to subchannel
679 num
= sscanf(dev
->bus_id
, "%x.%x.%04x", &cssid
, &ssid
, &devno
);
681 if ((cssid
> MAX_CSSID
) || (ssid
> MAX_SSID
)) {
682 error_setg(errp
, "Invalid cssid or ssid: cssid %x, ssid %x",
686 /* Enforce use of virtual cssid. */
687 if (cssid
!= VIRTUAL_CSSID
) {
688 error_setg(errp
, "cssid %x not valid for virtio devices",
692 if (css_devno_used(cssid
, ssid
, devno
)) {
693 error_setg(errp
, "Device %x.%x.%04x already exists",
702 error_setg(errp
, "Malformed devno parameter '%s'", dev
->bus_id
);
707 /* Find the next free id. */
709 for (schid
= 0; schid
<= MAX_SCHID
; schid
++) {
710 if (!css_find_subch(1, cssid
, ssid
, schid
)) {
712 css_subch_assign(cssid
, ssid
, schid
, devno
, sch
);
718 error_setg(errp
, "No free subchannel found for %x.%x.%04x",
722 trace_virtio_ccw_new_device(cssid
, ssid
, schid
, devno
,
725 cssid
= VIRTUAL_CSSID
;
726 for (ssid
= 0; ssid
<= MAX_SSID
; ssid
++) {
727 for (schid
= 0; schid
<= MAX_SCHID
; schid
++) {
728 if (!css_find_subch(1, cssid
, ssid
, schid
)) {
734 * If the devno is already taken, look further in this
737 while (css_devno_used(cssid
, ssid
, devno
)) {
738 if (devno
== MAX_SCHID
) {
740 } else if (devno
== schid
- 1) {
741 error_setg(errp
, "No free devno found");
748 css_subch_assign(cssid
, ssid
, schid
, devno
, sch
);
758 error_setg(errp
, "Virtual channel subsystem is full!");
761 trace_virtio_ccw_new_device(cssid
, ssid
, schid
, devno
,
765 /* Build initial schib. */
766 css_sch_build_virtual_schib(sch
, 0, VIRTIO_CCW_CHPID_TYPE
);
768 sch
->ccw_cb
= virtio_ccw_cb
;
770 /* Build senseid data. */
771 memset(&sch
->id
, 0, sizeof(SenseId
));
772 sch
->id
.reserved
= 0xff;
773 sch
->id
.cu_type
= VIRTIO_CCW_CU_TYPE
;
776 k
->realize(dev
, &err
);
779 error_propagate(errp
, err
);
780 css_subch_assign(cssid
, ssid
, schid
, devno
, NULL
);
791 static int virtio_ccw_exit(VirtioCcwDevice
*dev
)
793 SubchDev
*sch
= dev
->sch
;
796 css_subch_assign(sch
->cssid
, sch
->ssid
, sch
->schid
, sch
->devno
, NULL
);
799 if (dev
->indicators
) {
800 release_indicator(&dev
->routes
.adapter
, dev
->indicators
);
801 dev
->indicators
= NULL
;
806 static void virtio_ccw_net_realize(VirtioCcwDevice
*ccw_dev
, Error
**errp
)
808 DeviceState
*qdev
= DEVICE(ccw_dev
);
809 VirtIONetCcw
*dev
= VIRTIO_NET_CCW(ccw_dev
);
810 DeviceState
*vdev
= DEVICE(&dev
->vdev
);
813 virtio_net_set_netclient_name(&dev
->vdev
, qdev
->id
,
814 object_get_typename(OBJECT(qdev
)));
815 qdev_set_parent_bus(vdev
, BUS(&ccw_dev
->bus
));
816 object_property_set_bool(OBJECT(vdev
), true, "realized", &err
);
818 error_propagate(errp
, err
);
822 static void virtio_ccw_net_instance_init(Object
*obj
)
824 VirtIONetCcw
*dev
= VIRTIO_NET_CCW(obj
);
826 virtio_instance_init_common(obj
, &dev
->vdev
, sizeof(dev
->vdev
),
828 object_property_add_alias(obj
, "bootindex", OBJECT(&dev
->vdev
),
829 "bootindex", &error_abort
);
832 static void virtio_ccw_blk_realize(VirtioCcwDevice
*ccw_dev
, Error
**errp
)
834 VirtIOBlkCcw
*dev
= VIRTIO_BLK_CCW(ccw_dev
);
835 DeviceState
*vdev
= DEVICE(&dev
->vdev
);
838 qdev_set_parent_bus(vdev
, BUS(&ccw_dev
->bus
));
839 object_property_set_bool(OBJECT(vdev
), true, "realized", &err
);
841 error_propagate(errp
, err
);
845 static void virtio_ccw_blk_instance_init(Object
*obj
)
847 VirtIOBlkCcw
*dev
= VIRTIO_BLK_CCW(obj
);
849 virtio_instance_init_common(obj
, &dev
->vdev
, sizeof(dev
->vdev
),
851 object_property_add_alias(obj
, "iothread", OBJECT(&dev
->vdev
),"iothread",
853 object_property_add_alias(obj
, "bootindex", OBJECT(&dev
->vdev
),
854 "bootindex", &error_abort
);
857 static void virtio_ccw_serial_realize(VirtioCcwDevice
*ccw_dev
, Error
**errp
)
859 VirtioSerialCcw
*dev
= VIRTIO_SERIAL_CCW(ccw_dev
);
860 DeviceState
*vdev
= DEVICE(&dev
->vdev
);
861 DeviceState
*proxy
= DEVICE(ccw_dev
);
866 * For command line compatibility, this sets the virtio-serial-device bus
870 bus_name
= g_strdup_printf("%s.0", proxy
->id
);
871 virtio_device_set_child_bus_name(VIRTIO_DEVICE(vdev
), bus_name
);
875 qdev_set_parent_bus(vdev
, BUS(&ccw_dev
->bus
));
876 object_property_set_bool(OBJECT(vdev
), true, "realized", &err
);
878 error_propagate(errp
, err
);
883 static void virtio_ccw_serial_instance_init(Object
*obj
)
885 VirtioSerialCcw
*dev
= VIRTIO_SERIAL_CCW(obj
);
887 virtio_instance_init_common(obj
, &dev
->vdev
, sizeof(dev
->vdev
),
891 static void virtio_ccw_balloon_realize(VirtioCcwDevice
*ccw_dev
, Error
**errp
)
893 VirtIOBalloonCcw
*dev
= VIRTIO_BALLOON_CCW(ccw_dev
);
894 DeviceState
*vdev
= DEVICE(&dev
->vdev
);
897 qdev_set_parent_bus(vdev
, BUS(&ccw_dev
->bus
));
898 object_property_set_bool(OBJECT(vdev
), true, "realized", &err
);
900 error_propagate(errp
, err
);
904 static void virtio_ccw_balloon_instance_init(Object
*obj
)
906 VirtIOBalloonCcw
*dev
= VIRTIO_BALLOON_CCW(obj
);
908 virtio_instance_init_common(obj
, &dev
->vdev
, sizeof(dev
->vdev
),
909 TYPE_VIRTIO_BALLOON
);
910 object_property_add_alias(obj
, "guest-stats", OBJECT(&dev
->vdev
),
911 "guest-stats", &error_abort
);
912 object_property_add_alias(obj
, "guest-stats-polling-interval",
914 "guest-stats-polling-interval", &error_abort
);
917 static void virtio_ccw_scsi_realize(VirtioCcwDevice
*ccw_dev
, Error
**errp
)
919 VirtIOSCSICcw
*dev
= VIRTIO_SCSI_CCW(ccw_dev
);
920 DeviceState
*vdev
= DEVICE(&dev
->vdev
);
921 DeviceState
*qdev
= DEVICE(ccw_dev
);
926 * For command line compatibility, this sets the virtio-scsi-device bus
930 bus_name
= g_strdup_printf("%s.0", qdev
->id
);
931 virtio_device_set_child_bus_name(VIRTIO_DEVICE(vdev
), bus_name
);
935 qdev_set_parent_bus(vdev
, BUS(&ccw_dev
->bus
));
936 object_property_set_bool(OBJECT(vdev
), true, "realized", &err
);
938 error_propagate(errp
, err
);
942 static void virtio_ccw_scsi_instance_init(Object
*obj
)
944 VirtIOSCSICcw
*dev
= VIRTIO_SCSI_CCW(obj
);
946 virtio_instance_init_common(obj
, &dev
->vdev
, sizeof(dev
->vdev
),
948 object_property_add_alias(obj
, "iothread", OBJECT(&dev
->vdev
), "iothread",
952 #ifdef CONFIG_VHOST_SCSI
953 static void vhost_ccw_scsi_realize(VirtioCcwDevice
*ccw_dev
, Error
**errp
)
955 VHostSCSICcw
*dev
= VHOST_SCSI_CCW(ccw_dev
);
956 DeviceState
*vdev
= DEVICE(&dev
->vdev
);
959 qdev_set_parent_bus(vdev
, BUS(&ccw_dev
->bus
));
960 object_property_set_bool(OBJECT(vdev
), true, "realized", &err
);
962 error_propagate(errp
, err
);
966 static void vhost_ccw_scsi_instance_init(Object
*obj
)
968 VHostSCSICcw
*dev
= VHOST_SCSI_CCW(obj
);
970 virtio_instance_init_common(obj
, &dev
->vdev
, sizeof(dev
->vdev
),
975 static void virtio_ccw_rng_realize(VirtioCcwDevice
*ccw_dev
, Error
**errp
)
977 VirtIORNGCcw
*dev
= VIRTIO_RNG_CCW(ccw_dev
);
978 DeviceState
*vdev
= DEVICE(&dev
->vdev
);
981 qdev_set_parent_bus(vdev
, BUS(&ccw_dev
->bus
));
982 object_property_set_bool(OBJECT(vdev
), true, "realized", &err
);
984 error_propagate(errp
, err
);
988 object_property_set_link(OBJECT(dev
),
989 OBJECT(dev
->vdev
.conf
.rng
), "rng",
993 /* DeviceState to VirtioCcwDevice. Note: used on datapath,
994 * be careful and test performance if you change this.
996 static inline VirtioCcwDevice
*to_virtio_ccw_dev_fast(DeviceState
*d
)
998 return container_of(d
, VirtioCcwDevice
, parent_obj
);
1001 static uint8_t virtio_set_ind_atomic(SubchDev
*sch
, uint64_t ind_loc
,
1004 uint8_t ind_old
, ind_new
;
1008 ind_addr
= cpu_physical_memory_map(ind_loc
, &len
, 1);
1010 error_report("%s(%x.%x.%04x): unable to access indicator",
1011 __func__
, sch
->cssid
, sch
->ssid
, sch
->schid
);
1015 ind_old
= *ind_addr
;
1016 ind_new
= ind_old
| to_be_set
;
1017 } while (atomic_cmpxchg(ind_addr
, ind_old
, ind_new
) != ind_old
);
1018 cpu_physical_memory_unmap(ind_addr
, len
, 1, len
);
1023 static void virtio_ccw_notify(DeviceState
*d
, uint16_t vector
)
1025 VirtioCcwDevice
*dev
= to_virtio_ccw_dev_fast(d
);
1026 SubchDev
*sch
= dev
->sch
;
1027 uint64_t indicators
;
1029 if (vector
>= 128) {
1033 if (vector
< VIRTIO_CCW_QUEUE_MAX
) {
1034 if (!dev
->indicators
) {
1037 if (sch
->thinint_active
) {
1039 * In the adapter interrupt case, indicators points to a
1040 * memory area that may be (way) larger than 64 bit and
1041 * ind_bit indicates the start of the indicators in a big
1044 uint64_t ind_bit
= dev
->routes
.adapter
.ind_offset
;
1046 virtio_set_ind_atomic(sch
, dev
->indicators
->addr
+
1047 (ind_bit
+ vector
) / 8,
1048 0x80 >> ((ind_bit
+ vector
) % 8));
1049 if (!virtio_set_ind_atomic(sch
, dev
->summary_indicator
->addr
,
1051 css_adapter_interrupt(dev
->thinint_isc
);
1054 indicators
= address_space_ldq(&address_space_memory
,
1055 dev
->indicators
->addr
,
1056 MEMTXATTRS_UNSPECIFIED
,
1058 indicators
|= 1ULL << vector
;
1059 address_space_stq(&address_space_memory
, dev
->indicators
->addr
,
1060 indicators
, MEMTXATTRS_UNSPECIFIED
, NULL
);
1061 css_conditional_io_interrupt(sch
);
1064 if (!dev
->indicators2
) {
1068 indicators
= address_space_ldq(&address_space_memory
,
1069 dev
->indicators2
->addr
,
1070 MEMTXATTRS_UNSPECIFIED
,
1072 indicators
|= 1ULL << vector
;
1073 address_space_stq(&address_space_memory
, dev
->indicators2
->addr
,
1074 indicators
, MEMTXATTRS_UNSPECIFIED
, NULL
);
1075 css_conditional_io_interrupt(sch
);
1079 static void virtio_ccw_reset(DeviceState
*d
)
1081 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
1082 VirtIODevice
*vdev
= virtio_bus_get_device(&dev
->bus
);
1084 virtio_ccw_stop_ioeventfd(dev
);
1086 css_reset_sch(dev
->sch
);
1087 if (dev
->indicators
) {
1088 release_indicator(&dev
->routes
.adapter
, dev
->indicators
);
1089 dev
->indicators
= NULL
;
1091 if (dev
->indicators2
) {
1092 release_indicator(&dev
->routes
.adapter
, dev
->indicators2
);
1093 dev
->indicators2
= NULL
;
1095 if (dev
->summary_indicator
) {
1096 release_indicator(&dev
->routes
.adapter
, dev
->summary_indicator
);
1097 dev
->summary_indicator
= NULL
;
1101 static void virtio_ccw_vmstate_change(DeviceState
*d
, bool running
)
1103 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
1106 virtio_ccw_start_ioeventfd(dev
);
1108 virtio_ccw_stop_ioeventfd(dev
);
1112 static bool virtio_ccw_query_guest_notifiers(DeviceState
*d
)
1114 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
1116 return !!(dev
->sch
->curr_status
.pmcw
.flags
& PMCW_FLAGS_MASK_ENA
);
1119 static int virtio_ccw_set_host_notifier(DeviceState
*d
, int n
, bool assign
)
1121 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
1123 /* Stop using the generic ioeventfd, we are doing eventfd handling
1124 * ourselves below */
1125 dev
->ioeventfd_disabled
= assign
;
1127 virtio_ccw_stop_ioeventfd(dev
);
1129 return virtio_ccw_set_guest2host_notifier(dev
, n
, assign
, false);
1132 static int virtio_ccw_get_mappings(VirtioCcwDevice
*dev
)
1136 if (!dev
->sch
->thinint_active
) {
1140 r
= map_indicator(&dev
->routes
.adapter
, dev
->summary_indicator
);
1144 r
= map_indicator(&dev
->routes
.adapter
, dev
->indicators
);
1148 dev
->routes
.adapter
.summary_addr
= dev
->summary_indicator
->map
;
1149 dev
->routes
.adapter
.ind_addr
= dev
->indicators
->map
;
1154 static int virtio_ccw_setup_irqroutes(VirtioCcwDevice
*dev
, int nvqs
)
1157 VirtIODevice
*vdev
= virtio_bus_get_device(&dev
->bus
);
1159 S390FLICState
*fs
= s390_get_flic();
1160 S390FLICStateClass
*fsc
= S390_FLIC_COMMON_GET_CLASS(fs
);
1162 ret
= virtio_ccw_get_mappings(dev
);
1166 for (i
= 0; i
< nvqs
; i
++) {
1167 if (!virtio_queue_get_num(vdev
, i
)) {
1171 dev
->routes
.num_routes
= i
;
1172 return fsc
->add_adapter_routes(fs
, &dev
->routes
);
1175 static void virtio_ccw_release_irqroutes(VirtioCcwDevice
*dev
, int nvqs
)
1177 S390FLICState
*fs
= s390_get_flic();
1178 S390FLICStateClass
*fsc
= S390_FLIC_COMMON_GET_CLASS(fs
);
1180 fsc
->release_adapter_routes(fs
, &dev
->routes
);
1183 static int virtio_ccw_add_irqfd(VirtioCcwDevice
*dev
, int n
)
1185 VirtIODevice
*vdev
= virtio_bus_get_device(&dev
->bus
);
1186 VirtQueue
*vq
= virtio_get_queue(vdev
, n
);
1187 EventNotifier
*notifier
= virtio_queue_get_guest_notifier(vq
);
1189 return kvm_irqchip_add_irqfd_notifier(kvm_state
, notifier
, NULL
,
1190 dev
->routes
.gsi
[n
]);
1193 static void virtio_ccw_remove_irqfd(VirtioCcwDevice
*dev
, int n
)
1195 VirtIODevice
*vdev
= virtio_bus_get_device(&dev
->bus
);
1196 VirtQueue
*vq
= virtio_get_queue(vdev
, n
);
1197 EventNotifier
*notifier
= virtio_queue_get_guest_notifier(vq
);
1200 ret
= kvm_irqchip_remove_irqfd_notifier(kvm_state
, notifier
,
1201 dev
->routes
.gsi
[n
]);
1205 static int virtio_ccw_set_guest_notifier(VirtioCcwDevice
*dev
, int n
,
1206 bool assign
, bool with_irqfd
)
1208 VirtIODevice
*vdev
= virtio_bus_get_device(&dev
->bus
);
1209 VirtQueue
*vq
= virtio_get_queue(vdev
, n
);
1210 EventNotifier
*notifier
= virtio_queue_get_guest_notifier(vq
);
1211 VirtioDeviceClass
*k
= VIRTIO_DEVICE_GET_CLASS(vdev
);
1214 int r
= event_notifier_init(notifier
, 0);
1219 virtio_queue_set_guest_notifier_fd_handler(vq
, true, with_irqfd
);
1221 r
= virtio_ccw_add_irqfd(dev
, n
);
1223 virtio_queue_set_guest_notifier_fd_handler(vq
, false,
1229 * We do not support individual masking for channel devices, so we
1230 * need to manually trigger any guest masking callbacks here.
1232 if (k
->guest_notifier_mask
) {
1233 k
->guest_notifier_mask(vdev
, n
, false);
1235 /* get lost events and re-inject */
1236 if (k
->guest_notifier_pending
&&
1237 k
->guest_notifier_pending(vdev
, n
)) {
1238 event_notifier_set(notifier
);
1241 if (k
->guest_notifier_mask
) {
1242 k
->guest_notifier_mask(vdev
, n
, true);
1245 virtio_ccw_remove_irqfd(dev
, n
);
1247 virtio_queue_set_guest_notifier_fd_handler(vq
, false, with_irqfd
);
1248 event_notifier_cleanup(notifier
);
1253 static int virtio_ccw_set_guest_notifiers(DeviceState
*d
, int nvqs
,
1256 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
1257 VirtIODevice
*vdev
= virtio_bus_get_device(&dev
->bus
);
1258 bool with_irqfd
= dev
->sch
->thinint_active
&& kvm_irqfds_enabled();
1261 if (with_irqfd
&& assigned
) {
1262 /* irq routes need to be set up before assigning irqfds */
1263 r
= virtio_ccw_setup_irqroutes(dev
, nvqs
);
1265 goto irqroute_error
;
1268 for (n
= 0; n
< nvqs
; n
++) {
1269 if (!virtio_queue_get_num(vdev
, n
)) {
1272 r
= virtio_ccw_set_guest_notifier(dev
, n
, assigned
, with_irqfd
);
1277 if (with_irqfd
&& !assigned
) {
1278 /* release irq routes after irqfds have been released */
1279 virtio_ccw_release_irqroutes(dev
, nvqs
);
1285 virtio_ccw_set_guest_notifier(dev
, n
, !assigned
, false);
1288 if (with_irqfd
&& assigned
) {
1289 virtio_ccw_release_irqroutes(dev
, nvqs
);
1294 static void virtio_ccw_save_queue(DeviceState
*d
, int n
, QEMUFile
*f
)
1296 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
1297 VirtIODevice
*vdev
= virtio_bus_get_device(&dev
->bus
);
1299 qemu_put_be16(f
, virtio_queue_vector(vdev
, n
));
1302 static int virtio_ccw_load_queue(DeviceState
*d
, int n
, QEMUFile
*f
)
1304 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
1305 VirtIODevice
*vdev
= virtio_bus_get_device(&dev
->bus
);
1308 qemu_get_be16s(f
, &vector
);
1309 virtio_queue_set_vector(vdev
, n
, vector
);
1314 static void virtio_ccw_save_config(DeviceState
*d
, QEMUFile
*f
)
1316 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
1317 SubchDev
*s
= dev
->sch
;
1318 VirtIODevice
*vdev
= virtio_ccw_get_vdev(s
);
1320 subch_device_save(s
, f
);
1321 if (dev
->indicators
!= NULL
) {
1322 qemu_put_be32(f
, dev
->indicators
->len
);
1323 qemu_put_be64(f
, dev
->indicators
->addr
);
1325 qemu_put_be32(f
, 0);
1326 qemu_put_be64(f
, 0UL);
1328 if (dev
->indicators2
!= NULL
) {
1329 qemu_put_be32(f
, dev
->indicators2
->len
);
1330 qemu_put_be64(f
, dev
->indicators2
->addr
);
1332 qemu_put_be32(f
, 0);
1333 qemu_put_be64(f
, 0UL);
1335 if (dev
->summary_indicator
!= NULL
) {
1336 qemu_put_be32(f
, dev
->summary_indicator
->len
);
1337 qemu_put_be64(f
, dev
->summary_indicator
->addr
);
1339 qemu_put_be32(f
, 0);
1340 qemu_put_be64(f
, 0UL);
1342 qemu_put_be16(f
, vdev
->config_vector
);
1343 qemu_put_be64(f
, dev
->routes
.adapter
.ind_offset
);
1344 qemu_put_byte(f
, dev
->thinint_isc
);
1347 static int virtio_ccw_load_config(DeviceState
*d
, QEMUFile
*f
)
1349 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
1350 SubchDev
*s
= dev
->sch
;
1351 VirtIODevice
*vdev
= virtio_ccw_get_vdev(s
);
1354 s
->driver_data
= dev
;
1355 subch_device_load(s
, f
);
1356 len
= qemu_get_be32(f
);
1358 dev
->indicators
= get_indicator(qemu_get_be64(f
), len
);
1361 dev
->indicators
= NULL
;
1363 len
= qemu_get_be32(f
);
1365 dev
->indicators2
= get_indicator(qemu_get_be64(f
), len
);
1368 dev
->indicators2
= NULL
;
1370 len
= qemu_get_be32(f
);
1372 dev
->summary_indicator
= get_indicator(qemu_get_be64(f
), len
);
1375 dev
->summary_indicator
= NULL
;
1377 qemu_get_be16s(f
, &vdev
->config_vector
);
1378 dev
->routes
.adapter
.ind_offset
= qemu_get_be64(f
);
1379 dev
->thinint_isc
= qemu_get_byte(f
);
1380 if (s
->thinint_active
) {
1381 return css_register_io_adapter(CSS_IO_ADAPTER_VIRTIO
,
1382 dev
->thinint_isc
, true, false,
1383 &dev
->routes
.adapter
.adapter_id
);
1389 /* This is called by virtio-bus just after the device is plugged. */
1390 static void virtio_ccw_device_plugged(DeviceState
*d
, Error
**errp
)
1392 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
1393 VirtIODevice
*vdev
= virtio_bus_get_device(&dev
->bus
);
1394 SubchDev
*sch
= dev
->sch
;
1395 int n
= virtio_get_num_queues(vdev
);
1397 if (virtio_get_num_queues(vdev
) > VIRTIO_CCW_QUEUE_MAX
) {
1398 error_setg(errp
, "The nubmer of virtqueues %d "
1399 "exceeds ccw limit %d", n
,
1400 VIRTIO_CCW_QUEUE_MAX
);
1404 if (!kvm_eventfds_enabled()) {
1405 dev
->flags
&= ~VIRTIO_CCW_FLAG_USE_IOEVENTFD
;
1408 sch
->id
.cu_model
= virtio_bus_get_vdev_id(&dev
->bus
);
1410 css_generate_sch_crws(sch
->cssid
, sch
->ssid
, sch
->schid
,
1414 static void virtio_ccw_device_unplugged(DeviceState
*d
)
1416 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
1418 virtio_ccw_stop_ioeventfd(dev
);
1420 /**************** Virtio-ccw Bus Device Descriptions *******************/
1422 static Property virtio_ccw_net_properties
[] = {
1423 DEFINE_PROP_STRING("devno", VirtioCcwDevice
, bus_id
),
1424 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice
, flags
,
1425 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT
, true),
1426 DEFINE_PROP_END_OF_LIST(),
1429 static void virtio_ccw_net_class_init(ObjectClass
*klass
, void *data
)
1431 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1432 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_CLASS(klass
);
1434 k
->realize
= virtio_ccw_net_realize
;
1435 k
->exit
= virtio_ccw_exit
;
1436 dc
->reset
= virtio_ccw_reset
;
1437 dc
->props
= virtio_ccw_net_properties
;
1438 set_bit(DEVICE_CATEGORY_NETWORK
, dc
->categories
);
1441 static const TypeInfo virtio_ccw_net
= {
1442 .name
= TYPE_VIRTIO_NET_CCW
,
1443 .parent
= TYPE_VIRTIO_CCW_DEVICE
,
1444 .instance_size
= sizeof(VirtIONetCcw
),
1445 .instance_init
= virtio_ccw_net_instance_init
,
1446 .class_init
= virtio_ccw_net_class_init
,
1449 static Property virtio_ccw_blk_properties
[] = {
1450 DEFINE_PROP_STRING("devno", VirtioCcwDevice
, bus_id
),
1451 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice
, flags
,
1452 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT
, true),
1453 DEFINE_PROP_END_OF_LIST(),
1456 static void virtio_ccw_blk_class_init(ObjectClass
*klass
, void *data
)
1458 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1459 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_CLASS(klass
);
1461 k
->realize
= virtio_ccw_blk_realize
;
1462 k
->exit
= virtio_ccw_exit
;
1463 dc
->reset
= virtio_ccw_reset
;
1464 dc
->props
= virtio_ccw_blk_properties
;
1465 set_bit(DEVICE_CATEGORY_STORAGE
, dc
->categories
);
1468 static const TypeInfo virtio_ccw_blk
= {
1469 .name
= TYPE_VIRTIO_BLK_CCW
,
1470 .parent
= TYPE_VIRTIO_CCW_DEVICE
,
1471 .instance_size
= sizeof(VirtIOBlkCcw
),
1472 .instance_init
= virtio_ccw_blk_instance_init
,
1473 .class_init
= virtio_ccw_blk_class_init
,
1476 static Property virtio_ccw_serial_properties
[] = {
1477 DEFINE_PROP_STRING("devno", VirtioCcwDevice
, bus_id
),
1478 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice
, flags
,
1479 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT
, true),
1480 DEFINE_PROP_END_OF_LIST(),
1483 static void virtio_ccw_serial_class_init(ObjectClass
*klass
, void *data
)
1485 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1486 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_CLASS(klass
);
1488 k
->realize
= virtio_ccw_serial_realize
;
1489 k
->exit
= virtio_ccw_exit
;
1490 dc
->reset
= virtio_ccw_reset
;
1491 dc
->props
= virtio_ccw_serial_properties
;
1492 set_bit(DEVICE_CATEGORY_INPUT
, dc
->categories
);
1495 static const TypeInfo virtio_ccw_serial
= {
1496 .name
= TYPE_VIRTIO_SERIAL_CCW
,
1497 .parent
= TYPE_VIRTIO_CCW_DEVICE
,
1498 .instance_size
= sizeof(VirtioSerialCcw
),
1499 .instance_init
= virtio_ccw_serial_instance_init
,
1500 .class_init
= virtio_ccw_serial_class_init
,
1503 static Property virtio_ccw_balloon_properties
[] = {
1504 DEFINE_PROP_STRING("devno", VirtioCcwDevice
, bus_id
),
1505 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice
, flags
,
1506 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT
, true),
1507 DEFINE_PROP_END_OF_LIST(),
1510 static void virtio_ccw_balloon_class_init(ObjectClass
*klass
, void *data
)
1512 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1513 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_CLASS(klass
);
1515 k
->realize
= virtio_ccw_balloon_realize
;
1516 k
->exit
= virtio_ccw_exit
;
1517 dc
->reset
= virtio_ccw_reset
;
1518 dc
->props
= virtio_ccw_balloon_properties
;
1519 set_bit(DEVICE_CATEGORY_MISC
, dc
->categories
);
1522 static const TypeInfo virtio_ccw_balloon
= {
1523 .name
= TYPE_VIRTIO_BALLOON_CCW
,
1524 .parent
= TYPE_VIRTIO_CCW_DEVICE
,
1525 .instance_size
= sizeof(VirtIOBalloonCcw
),
1526 .instance_init
= virtio_ccw_balloon_instance_init
,
1527 .class_init
= virtio_ccw_balloon_class_init
,
1530 static Property virtio_ccw_scsi_properties
[] = {
1531 DEFINE_PROP_STRING("devno", VirtioCcwDevice
, bus_id
),
1532 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice
, flags
,
1533 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT
, true),
1534 DEFINE_PROP_END_OF_LIST(),
1537 static void virtio_ccw_scsi_class_init(ObjectClass
*klass
, void *data
)
1539 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1540 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_CLASS(klass
);
1542 k
->realize
= virtio_ccw_scsi_realize
;
1543 k
->exit
= virtio_ccw_exit
;
1544 dc
->reset
= virtio_ccw_reset
;
1545 dc
->props
= virtio_ccw_scsi_properties
;
1546 set_bit(DEVICE_CATEGORY_STORAGE
, dc
->categories
);
1549 static const TypeInfo virtio_ccw_scsi
= {
1550 .name
= TYPE_VIRTIO_SCSI_CCW
,
1551 .parent
= TYPE_VIRTIO_CCW_DEVICE
,
1552 .instance_size
= sizeof(VirtIOSCSICcw
),
1553 .instance_init
= virtio_ccw_scsi_instance_init
,
1554 .class_init
= virtio_ccw_scsi_class_init
,
1557 #ifdef CONFIG_VHOST_SCSI
1558 static Property vhost_ccw_scsi_properties
[] = {
1559 DEFINE_PROP_STRING("devno", VirtioCcwDevice
, bus_id
),
1560 DEFINE_PROP_END_OF_LIST(),
1563 static void vhost_ccw_scsi_class_init(ObjectClass
*klass
, void *data
)
1565 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1566 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_CLASS(klass
);
1568 k
->realize
= vhost_ccw_scsi_realize
;
1569 k
->exit
= virtio_ccw_exit
;
1570 dc
->reset
= virtio_ccw_reset
;
1571 dc
->props
= vhost_ccw_scsi_properties
;
1572 set_bit(DEVICE_CATEGORY_STORAGE
, dc
->categories
);
1575 static const TypeInfo vhost_ccw_scsi
= {
1576 .name
= TYPE_VHOST_SCSI_CCW
,
1577 .parent
= TYPE_VIRTIO_CCW_DEVICE
,
1578 .instance_size
= sizeof(VHostSCSICcw
),
1579 .instance_init
= vhost_ccw_scsi_instance_init
,
1580 .class_init
= vhost_ccw_scsi_class_init
,
1584 static void virtio_ccw_rng_instance_init(Object
*obj
)
1586 VirtIORNGCcw
*dev
= VIRTIO_RNG_CCW(obj
);
1588 virtio_instance_init_common(obj
, &dev
->vdev
, sizeof(dev
->vdev
),
1590 object_property_add_alias(obj
, "rng", OBJECT(&dev
->vdev
),
1591 "rng", &error_abort
);
1594 static Property virtio_ccw_rng_properties
[] = {
1595 DEFINE_PROP_STRING("devno", VirtioCcwDevice
, bus_id
),
1596 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice
, flags
,
1597 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT
, true),
1598 DEFINE_PROP_END_OF_LIST(),
1601 static void virtio_ccw_rng_class_init(ObjectClass
*klass
, void *data
)
1603 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1604 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_CLASS(klass
);
1606 k
->realize
= virtio_ccw_rng_realize
;
1607 k
->exit
= virtio_ccw_exit
;
1608 dc
->reset
= virtio_ccw_reset
;
1609 dc
->props
= virtio_ccw_rng_properties
;
1610 set_bit(DEVICE_CATEGORY_MISC
, dc
->categories
);
1613 static const TypeInfo virtio_ccw_rng
= {
1614 .name
= TYPE_VIRTIO_RNG_CCW
,
1615 .parent
= TYPE_VIRTIO_CCW_DEVICE
,
1616 .instance_size
= sizeof(VirtIORNGCcw
),
1617 .instance_init
= virtio_ccw_rng_instance_init
,
1618 .class_init
= virtio_ccw_rng_class_init
,
1621 static void virtio_ccw_busdev_realize(DeviceState
*dev
, Error
**errp
)
1623 VirtioCcwDevice
*_dev
= (VirtioCcwDevice
*)dev
;
1625 virtio_ccw_bus_new(&_dev
->bus
, sizeof(_dev
->bus
), _dev
);
1626 virtio_ccw_device_realize(_dev
, errp
);
1629 static int virtio_ccw_busdev_exit(DeviceState
*dev
)
1631 VirtioCcwDevice
*_dev
= (VirtioCcwDevice
*)dev
;
1632 VirtIOCCWDeviceClass
*_info
= VIRTIO_CCW_DEVICE_GET_CLASS(dev
);
1634 return _info
->exit(_dev
);
1637 static void virtio_ccw_busdev_unplug(HotplugHandler
*hotplug_dev
,
1638 DeviceState
*dev
, Error
**errp
)
1640 VirtioCcwDevice
*_dev
= (VirtioCcwDevice
*)dev
;
1641 SubchDev
*sch
= _dev
->sch
;
1643 virtio_ccw_stop_ioeventfd(_dev
);
1646 * We should arrive here only for device_del, since we don't support
1647 * direct hot(un)plug of channels, but only through virtio.
1649 assert(sch
!= NULL
);
1650 /* Subchannel is now disabled and no longer valid. */
1651 sch
->curr_status
.pmcw
.flags
&= ~(PMCW_FLAGS_MASK_ENA
|
1652 PMCW_FLAGS_MASK_DNV
);
1654 css_generate_sch_crws(sch
->cssid
, sch
->ssid
, sch
->schid
, 1, 0);
1656 object_unparent(OBJECT(dev
));
1659 static void virtio_ccw_device_class_init(ObjectClass
*klass
, void *data
)
1661 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1663 dc
->realize
= virtio_ccw_busdev_realize
;
1664 dc
->exit
= virtio_ccw_busdev_exit
;
1665 dc
->bus_type
= TYPE_VIRTUAL_CSS_BUS
;
1668 static const TypeInfo virtio_ccw_device_info
= {
1669 .name
= TYPE_VIRTIO_CCW_DEVICE
,
1670 .parent
= TYPE_DEVICE
,
1671 .instance_size
= sizeof(VirtioCcwDevice
),
1672 .class_init
= virtio_ccw_device_class_init
,
1673 .class_size
= sizeof(VirtIOCCWDeviceClass
),
1677 /***************** Virtual-css Bus Bridge Device ********************/
1678 /* Only required to have the virtio bus as child in the system bus */
1680 static int virtual_css_bridge_init(SysBusDevice
*dev
)
1686 static void virtual_css_bridge_class_init(ObjectClass
*klass
, void *data
)
1688 SysBusDeviceClass
*k
= SYS_BUS_DEVICE_CLASS(klass
);
1689 HotplugHandlerClass
*hc
= HOTPLUG_HANDLER_CLASS(klass
);
1690 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1692 k
->init
= virtual_css_bridge_init
;
1693 hc
->unplug
= virtio_ccw_busdev_unplug
;
1694 set_bit(DEVICE_CATEGORY_BRIDGE
, dc
->categories
);
1697 static const TypeInfo virtual_css_bridge_info
= {
1698 .name
= "virtual-css-bridge",
1699 .parent
= TYPE_SYS_BUS_DEVICE
,
1700 .instance_size
= sizeof(SysBusDevice
),
1701 .class_init
= virtual_css_bridge_class_init
,
1702 .interfaces
= (InterfaceInfo
[]) {
1703 { TYPE_HOTPLUG_HANDLER
},
1708 /* virtio-ccw-bus */
1710 static void virtio_ccw_bus_new(VirtioBusState
*bus
, size_t bus_size
,
1711 VirtioCcwDevice
*dev
)
1713 DeviceState
*qdev
= DEVICE(dev
);
1714 char virtio_bus_name
[] = "virtio-bus";
1716 qbus_create_inplace(bus
, bus_size
, TYPE_VIRTIO_CCW_BUS
,
1717 qdev
, virtio_bus_name
);
1720 static void virtio_ccw_bus_class_init(ObjectClass
*klass
, void *data
)
1722 VirtioBusClass
*k
= VIRTIO_BUS_CLASS(klass
);
1723 BusClass
*bus_class
= BUS_CLASS(klass
);
1725 bus_class
->max_dev
= 1;
1726 k
->notify
= virtio_ccw_notify
;
1727 k
->vmstate_change
= virtio_ccw_vmstate_change
;
1728 k
->query_guest_notifiers
= virtio_ccw_query_guest_notifiers
;
1729 k
->set_host_notifier
= virtio_ccw_set_host_notifier
;
1730 k
->set_guest_notifiers
= virtio_ccw_set_guest_notifiers
;
1731 k
->save_queue
= virtio_ccw_save_queue
;
1732 k
->load_queue
= virtio_ccw_load_queue
;
1733 k
->save_config
= virtio_ccw_save_config
;
1734 k
->load_config
= virtio_ccw_load_config
;
1735 k
->device_plugged
= virtio_ccw_device_plugged
;
1736 k
->device_unplugged
= virtio_ccw_device_unplugged
;
1739 static const TypeInfo virtio_ccw_bus_info
= {
1740 .name
= TYPE_VIRTIO_CCW_BUS
,
1741 .parent
= TYPE_VIRTIO_BUS
,
1742 .instance_size
= sizeof(VirtioCcwBusState
),
1743 .class_init
= virtio_ccw_bus_class_init
,
1746 #ifdef CONFIG_VIRTFS
1747 static Property virtio_ccw_9p_properties
[] = {
1748 DEFINE_PROP_STRING("devno", VirtioCcwDevice
, bus_id
),
1749 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice
, flags
,
1750 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT
, true),
1751 DEFINE_PROP_END_OF_LIST(),
1754 static void virtio_ccw_9p_realize(VirtioCcwDevice
*ccw_dev
, Error
**errp
)
1756 V9fsCCWState
*dev
= VIRTIO_9P_CCW(ccw_dev
);
1757 DeviceState
*vdev
= DEVICE(&dev
->vdev
);
1760 qdev_set_parent_bus(vdev
, BUS(&ccw_dev
->bus
));
1761 object_property_set_bool(OBJECT(vdev
), true, "realized", &err
);
1763 error_propagate(errp
, err
);
1767 static void virtio_ccw_9p_class_init(ObjectClass
*klass
, void *data
)
1769 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1770 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_CLASS(klass
);
1772 k
->exit
= virtio_ccw_exit
;
1773 k
->realize
= virtio_ccw_9p_realize
;
1774 dc
->reset
= virtio_ccw_reset
;
1775 dc
->props
= virtio_ccw_9p_properties
;
1776 set_bit(DEVICE_CATEGORY_STORAGE
, dc
->categories
);
1779 static void virtio_ccw_9p_instance_init(Object
*obj
)
1781 V9fsCCWState
*dev
= VIRTIO_9P_CCW(obj
);
1783 virtio_instance_init_common(obj
, &dev
->vdev
, sizeof(dev
->vdev
),
1787 static const TypeInfo virtio_ccw_9p_info
= {
1788 .name
= TYPE_VIRTIO_9P_CCW
,
1789 .parent
= TYPE_VIRTIO_CCW_DEVICE
,
1790 .instance_size
= sizeof(V9fsCCWState
),
1791 .instance_init
= virtio_ccw_9p_instance_init
,
1792 .class_init
= virtio_ccw_9p_class_init
,
1796 static void virtio_ccw_register(void)
1798 type_register_static(&virtio_ccw_bus_info
);
1799 type_register_static(&virtual_css_bus_info
);
1800 type_register_static(&virtio_ccw_device_info
);
1801 type_register_static(&virtio_ccw_serial
);
1802 type_register_static(&virtio_ccw_blk
);
1803 type_register_static(&virtio_ccw_net
);
1804 type_register_static(&virtio_ccw_balloon
);
1805 type_register_static(&virtio_ccw_scsi
);
1806 #ifdef CONFIG_VHOST_SCSI
1807 type_register_static(&vhost_ccw_scsi
);
1809 type_register_static(&virtio_ccw_rng
);
1810 type_register_static(&virtual_css_bridge_info
);
1811 #ifdef CONFIG_VIRTFS
1812 type_register_static(&virtio_ccw_9p_info
);
1816 type_init(virtio_ccw_register
)