2 * virtio ccw target implementation
4 * Copyright 2012 IBM Corp.
5 * Author(s): Cornelia Huck <cornelia.huck@de.ibm.com>
7 * This work is licensed under the terms of the GNU GPL, version 2 or (at
8 * your option) any later version. See the COPYING file in the top-level
13 #include "block/block.h"
14 #include "sysemu/blockdev.h"
15 #include "sysemu/sysemu.h"
17 #include "monitor/monitor.h"
18 #include "hw/virtio/virtio.h"
19 #include "hw/virtio/virtio-serial.h"
20 #include "hw/virtio/virtio-net.h"
21 #include "hw/sysbus.h"
22 #include "qemu/bitops.h"
23 #include "hw/virtio/virtio-bus.h"
27 #include "virtio-ccw.h"
30 static void virtio_ccw_bus_new(VirtioBusState
*bus
, size_t bus_size
,
31 VirtioCcwDevice
*dev
);
33 static int virtual_css_bus_reset(BusState
*qbus
)
35 /* This should actually be modelled via the generic css */
38 /* we dont traverse ourself, return 0 */
43 static void virtual_css_bus_class_init(ObjectClass
*klass
, void *data
)
45 BusClass
*k
= BUS_CLASS(klass
);
47 k
->reset
= virtual_css_bus_reset
;
50 static const TypeInfo virtual_css_bus_info
= {
51 .name
= TYPE_VIRTUAL_CSS_BUS
,
53 .instance_size
= sizeof(VirtualCssBus
),
54 .class_init
= virtual_css_bus_class_init
,
57 VirtIODevice
*virtio_ccw_get_vdev(SubchDev
*sch
)
59 VirtIODevice
*vdev
= NULL
;
61 if (sch
->driver_data
) {
62 vdev
= ((VirtioCcwDevice
*)sch
->driver_data
)->vdev
;
67 static int virtio_ccw_set_guest2host_notifier(VirtioCcwDevice
*dev
, int n
,
68 bool assign
, bool set_handler
)
70 VirtQueue
*vq
= virtio_get_queue(dev
->vdev
, n
);
71 EventNotifier
*notifier
= virtio_queue_get_host_notifier(vq
);
73 SubchDev
*sch
= dev
->sch
;
74 uint32_t sch_id
= (css_build_subchannel_id(sch
) << 16) | sch
->schid
;
77 r
= event_notifier_init(notifier
, 1);
79 error_report("%s: unable to init event notifier: %d", __func__
, r
);
82 virtio_queue_set_host_notifier_fd_handler(vq
, true, set_handler
);
83 r
= s390_assign_subch_ioeventfd(notifier
, sch_id
, n
, assign
);
85 error_report("%s: unable to assign ioeventfd: %d", __func__
, r
);
86 virtio_queue_set_host_notifier_fd_handler(vq
, false, false);
87 event_notifier_cleanup(notifier
);
91 virtio_queue_set_host_notifier_fd_handler(vq
, false, false);
92 s390_assign_subch_ioeventfd(notifier
, sch_id
, n
, assign
);
93 event_notifier_cleanup(notifier
);
98 static void virtio_ccw_start_ioeventfd(VirtioCcwDevice
*dev
)
102 if (!(dev
->flags
& VIRTIO_CCW_FLAG_USE_IOEVENTFD
) ||
103 dev
->ioeventfd_disabled
||
104 dev
->ioeventfd_started
) {
107 for (n
= 0; n
< VIRTIO_PCI_QUEUE_MAX
; n
++) {
108 if (!virtio_queue_get_num(dev
->vdev
, n
)) {
111 r
= virtio_ccw_set_guest2host_notifier(dev
, n
, true, true);
116 dev
->ioeventfd_started
= true;
121 if (!virtio_queue_get_num(dev
->vdev
, n
)) {
124 r
= virtio_ccw_set_guest2host_notifier(dev
, n
, false, false);
127 dev
->ioeventfd_started
= false;
128 /* Disable ioeventfd for this device. */
129 dev
->flags
&= ~VIRTIO_CCW_FLAG_USE_IOEVENTFD
;
130 error_report("%s: failed. Fallback to userspace (slower).", __func__
);
133 static void virtio_ccw_stop_ioeventfd(VirtioCcwDevice
*dev
)
137 if (!dev
->ioeventfd_started
) {
140 for (n
= 0; n
< VIRTIO_PCI_QUEUE_MAX
; n
++) {
141 if (!virtio_queue_get_num(dev
->vdev
, n
)) {
144 r
= virtio_ccw_set_guest2host_notifier(dev
, n
, false, false);
147 dev
->ioeventfd_started
= false;
150 VirtualCssBus
*virtual_css_bus_init(void)
156 /* Create bridge device */
157 dev
= qdev_create(NULL
, "virtual-css-bridge");
158 qdev_init_nofail(dev
);
160 /* Create bus on bridge device */
161 bus
= qbus_create(TYPE_VIRTUAL_CSS_BUS
, dev
, "virtual-css");
162 cbus
= VIRTUAL_CSS_BUS(bus
);
164 /* Enable hotplugging */
165 bus
->allow_hotplug
= 1;
170 /* Communication blocks used by several channel commands. */
171 typedef struct VqInfoBlock
{
176 } QEMU_PACKED VqInfoBlock
;
178 typedef struct VqConfigBlock
{
181 } QEMU_PACKED VqConfigBlock
;
183 typedef struct VirtioFeatDesc
{
186 } QEMU_PACKED VirtioFeatDesc
;
188 /* Specify where the virtqueues for the subchannel are in guest memory. */
189 static int virtio_ccw_set_vqs(SubchDev
*sch
, uint64_t addr
, uint32_t align
,
190 uint16_t index
, uint16_t num
)
192 VirtioCcwDevice
*dev
= sch
->driver_data
;
194 if (index
> VIRTIO_PCI_QUEUE_MAX
) {
198 /* Current code in virtio.c relies on 4K alignment. */
199 if (addr
&& (align
!= 4096)) {
207 virtio_queue_set_addr(dev
->vdev
, index
, addr
);
209 virtio_queue_set_vector(dev
->vdev
, index
, 0);
211 /* Fail if we don't have a big enough queue. */
212 /* TODO: Add interface to handle vring.num changing */
213 if (virtio_queue_get_num(dev
->vdev
, index
) > num
) {
216 virtio_queue_set_vector(dev
->vdev
, index
, index
);
218 /* tell notify handler in case of config change */
219 dev
->vdev
->config_vector
= VIRTIO_PCI_QUEUE_MAX
;
223 static int virtio_ccw_cb(SubchDev
*sch
, CCW1 ccw
)
228 VirtioFeatDesc features
;
231 VqConfigBlock vq_config
;
232 VirtioCcwDevice
*dev
= sch
->driver_data
;
241 trace_virtio_ccw_interpret_ccw(sch
->cssid
, sch
->ssid
, sch
->schid
,
243 check_len
= !((ccw
.flags
& CCW_FLAG_SLI
) && !(ccw
.flags
& CCW_FLAG_DC
));
245 /* Look at the command. */
246 switch (ccw
.cmd_code
) {
249 if (ccw
.count
!= sizeof(info
)) {
253 } else if (ccw
.count
< sizeof(info
)) {
254 /* Can't execute command. */
261 info
.queue
= ldq_phys(ccw
.cda
);
262 info
.align
= ldl_phys(ccw
.cda
+ sizeof(info
.queue
));
263 info
.index
= lduw_phys(ccw
.cda
+ sizeof(info
.queue
)
264 + sizeof(info
.align
));
265 info
.num
= lduw_phys(ccw
.cda
+ sizeof(info
.queue
)
267 + sizeof(info
.index
));
268 ret
= virtio_ccw_set_vqs(sch
, info
.queue
, info
.align
, info
.index
,
270 sch
->curr_status
.scsw
.count
= 0;
273 case CCW_CMD_VDEV_RESET
:
274 virtio_ccw_stop_ioeventfd(dev
);
275 virtio_reset(dev
->vdev
);
278 case CCW_CMD_READ_FEAT
:
280 if (ccw
.count
!= sizeof(features
)) {
284 } else if (ccw
.count
< sizeof(features
)) {
285 /* Can't execute command. */
292 features
.index
= ldub_phys(ccw
.cda
+ sizeof(features
.features
));
293 if (features
.index
< ARRAY_SIZE(dev
->host_features
)) {
294 features
.features
= dev
->host_features
[features
.index
];
296 /* Return zeroes if the guest supports more feature bits. */
297 features
.features
= 0;
299 stl_le_phys(ccw
.cda
, features
.features
);
300 sch
->curr_status
.scsw
.count
= ccw
.count
- sizeof(features
);
304 case CCW_CMD_WRITE_FEAT
:
306 if (ccw
.count
!= sizeof(features
)) {
310 } else if (ccw
.count
< sizeof(features
)) {
311 /* Can't execute command. */
318 features
.index
= ldub_phys(ccw
.cda
+ sizeof(features
.features
));
319 features
.features
= ldl_le_phys(ccw
.cda
);
320 if (features
.index
< ARRAY_SIZE(dev
->host_features
)) {
321 virtio_bus_set_vdev_features(&dev
->bus
, features
.features
);
322 dev
->vdev
->guest_features
= features
.features
;
325 * If the guest supports more feature bits, assert that it
326 * passes us zeroes for those we don't support.
328 if (features
.features
) {
329 fprintf(stderr
, "Guest bug: features[%i]=%x (expected 0)\n",
330 features
.index
, features
.features
);
331 /* XXX: do a unit check here? */
334 sch
->curr_status
.scsw
.count
= ccw
.count
- sizeof(features
);
338 case CCW_CMD_READ_CONF
:
340 if (ccw
.count
> dev
->vdev
->config_len
) {
345 len
= MIN(ccw
.count
, dev
->vdev
->config_len
);
349 virtio_bus_get_vdev_config(&dev
->bus
, dev
->vdev
->config
);
350 /* XXX config space endianness */
351 cpu_physical_memory_write(ccw
.cda
, dev
->vdev
->config
, len
);
352 sch
->curr_status
.scsw
.count
= ccw
.count
- len
;
356 case CCW_CMD_WRITE_CONF
:
358 if (ccw
.count
> dev
->vdev
->config_len
) {
363 len
= MIN(ccw
.count
, dev
->vdev
->config_len
);
368 config
= cpu_physical_memory_map(ccw
.cda
, &hw_len
, 0);
373 /* XXX config space endianness */
374 memcpy(dev
->vdev
->config
, config
, len
);
375 cpu_physical_memory_unmap(config
, hw_len
, 0, hw_len
);
376 virtio_bus_set_vdev_config(&dev
->bus
, dev
->vdev
->config
);
377 sch
->curr_status
.scsw
.count
= ccw
.count
- len
;
382 case CCW_CMD_WRITE_STATUS
:
384 if (ccw
.count
!= sizeof(status
)) {
388 } else if (ccw
.count
< sizeof(status
)) {
389 /* Can't execute command. */
396 status
= ldub_phys(ccw
.cda
);
397 if (!(status
& VIRTIO_CONFIG_S_DRIVER_OK
)) {
398 virtio_ccw_stop_ioeventfd(dev
);
400 virtio_set_status(dev
->vdev
, status
);
401 if (dev
->vdev
->status
== 0) {
402 virtio_reset(dev
->vdev
);
404 if (status
& VIRTIO_CONFIG_S_DRIVER_OK
) {
405 virtio_ccw_start_ioeventfd(dev
);
407 sch
->curr_status
.scsw
.count
= ccw
.count
- sizeof(status
);
411 case CCW_CMD_SET_IND
:
413 if (ccw
.count
!= sizeof(indicators
)) {
417 } else if (ccw
.count
< sizeof(indicators
)) {
418 /* Can't execute command. */
425 indicators
= ldq_phys(ccw
.cda
);
426 dev
->indicators
= indicators
;
427 sch
->curr_status
.scsw
.count
= ccw
.count
- sizeof(indicators
);
431 case CCW_CMD_SET_CONF_IND
:
433 if (ccw
.count
!= sizeof(indicators
)) {
437 } else if (ccw
.count
< sizeof(indicators
)) {
438 /* Can't execute command. */
445 indicators
= ldq_phys(ccw
.cda
);
446 dev
->indicators2
= indicators
;
447 sch
->curr_status
.scsw
.count
= ccw
.count
- sizeof(indicators
);
451 case CCW_CMD_READ_VQ_CONF
:
453 if (ccw
.count
!= sizeof(vq_config
)) {
457 } else if (ccw
.count
< sizeof(vq_config
)) {
458 /* Can't execute command. */
465 vq_config
.index
= lduw_phys(ccw
.cda
);
466 vq_config
.num_max
= virtio_queue_get_num(dev
->vdev
,
468 stw_phys(ccw
.cda
+ sizeof(vq_config
.index
), vq_config
.num_max
);
469 sch
->curr_status
.scsw
.count
= ccw
.count
- sizeof(vq_config
);
480 static int virtio_ccw_device_init(VirtioCcwDevice
*dev
, VirtIODevice
*vdev
)
482 unsigned int cssid
= 0;
483 unsigned int ssid
= 0;
486 bool have_devno
= false;
491 DeviceState
*parent
= DEVICE(dev
);
493 sch
= g_malloc0(sizeof(SubchDev
));
495 sch
->driver_data
= dev
;
501 /* Initialize subchannel structure. */
502 sch
->channel_prog
= 0x0;
503 sch
->last_cmd_valid
= false;
506 * Use a device number if provided. Otherwise, fall back to subchannel
510 num
= sscanf(dev
->bus_id
, "%x.%x.%04x", &cssid
, &ssid
, &devno
);
512 if ((cssid
> MAX_CSSID
) || (ssid
> MAX_SSID
)) {
514 error_report("Invalid cssid or ssid: cssid %x, ssid %x",
518 /* Enforce use of virtual cssid. */
519 if (cssid
!= VIRTUAL_CSSID
) {
521 error_report("cssid %x not valid for virtio devices", cssid
);
524 if (css_devno_used(cssid
, ssid
, devno
)) {
526 error_report("Device %x.%x.%04x already exists", cssid
, ssid
,
536 error_report("Malformed devno parameter '%s'", dev
->bus_id
);
541 /* Find the next free id. */
543 for (schid
= 0; schid
<= MAX_SCHID
; schid
++) {
544 if (!css_find_subch(1, cssid
, ssid
, schid
)) {
546 css_subch_assign(cssid
, ssid
, schid
, devno
, sch
);
553 error_report("No free subchannel found for %x.%x.%04x", cssid
, ssid
,
557 trace_virtio_ccw_new_device(cssid
, ssid
, schid
, devno
,
560 cssid
= VIRTUAL_CSSID
;
561 for (ssid
= 0; ssid
<= MAX_SSID
; ssid
++) {
562 for (schid
= 0; schid
<= MAX_SCHID
; schid
++) {
563 if (!css_find_subch(1, cssid
, ssid
, schid
)) {
569 * If the devno is already taken, look further in this
572 while (css_devno_used(cssid
, ssid
, devno
)) {
573 if (devno
== MAX_SCHID
) {
575 } else if (devno
== schid
- 1) {
577 error_report("No free devno found");
584 css_subch_assign(cssid
, ssid
, schid
, devno
, sch
);
595 error_report("Virtual channel subsystem is full!");
598 trace_virtio_ccw_new_device(cssid
, ssid
, schid
, devno
,
602 /* Build initial schib. */
603 css_sch_build_virtual_schib(sch
, 0, VIRTIO_CCW_CHPID_TYPE
);
605 sch
->ccw_cb
= virtio_ccw_cb
;
607 /* Build senseid data. */
608 memset(&sch
->id
, 0, sizeof(SenseId
));
609 sch
->id
.reserved
= 0xff;
610 sch
->id
.cu_type
= VIRTIO_CCW_CU_TYPE
;
611 sch
->id
.cu_model
= dev
->vdev
->device_id
;
613 /* Only the first 32 feature bits are used. */
614 dev
->host_features
[0] = virtio_bus_get_vdev_features(&dev
->bus
,
615 dev
->host_features
[0]);
617 dev
->host_features
[0] |= 0x1 << VIRTIO_F_NOTIFY_ON_EMPTY
;
618 dev
->host_features
[0] |= 0x1 << VIRTIO_F_BAD_FEATURE
;
620 css_generate_sch_crws(sch
->cssid
, sch
->ssid
, sch
->schid
,
621 parent
->hotplugged
, 1);
630 static int virtio_ccw_exit(VirtioCcwDevice
*dev
)
632 SubchDev
*sch
= dev
->sch
;
634 virtio_ccw_stop_ioeventfd(dev
);
636 css_subch_assign(sch
->cssid
, sch
->ssid
, sch
->schid
, sch
->devno
, NULL
);
643 static int virtio_ccw_net_init(VirtioCcwDevice
*ccw_dev
)
645 DeviceState
*qdev
= DEVICE(ccw_dev
);
646 VirtIONetCcw
*dev
= VIRTIO_NET_CCW(ccw_dev
);
647 DeviceState
*vdev
= DEVICE(&dev
->vdev
);
649 virtio_net_set_config_size(&dev
->vdev
, ccw_dev
->host_features
[0]);
650 virtio_net_set_netclient_name(&dev
->vdev
, qdev
->id
,
651 object_get_typename(OBJECT(qdev
)));
652 qdev_set_parent_bus(vdev
, BUS(&ccw_dev
->bus
));
653 if (qdev_init(vdev
) < 0) {
657 return virtio_ccw_device_init(ccw_dev
, VIRTIO_DEVICE(vdev
));
660 static void virtio_ccw_net_instance_init(Object
*obj
)
662 VirtIONetCcw
*dev
= VIRTIO_NET_CCW(obj
);
663 object_initialize(&dev
->vdev
, TYPE_VIRTIO_NET
);
664 object_property_add_child(obj
, "virtio-backend", OBJECT(&dev
->vdev
), NULL
);
667 static int virtio_ccw_blk_init(VirtioCcwDevice
*ccw_dev
)
669 VirtIOBlkCcw
*dev
= VIRTIO_BLK_CCW(ccw_dev
);
670 DeviceState
*vdev
= DEVICE(&dev
->vdev
);
671 virtio_blk_set_conf(vdev
, &(dev
->blk
));
672 qdev_set_parent_bus(vdev
, BUS(&ccw_dev
->bus
));
673 if (qdev_init(vdev
) < 0) {
677 return virtio_ccw_device_init(ccw_dev
, VIRTIO_DEVICE(vdev
));
680 static void virtio_ccw_blk_instance_init(Object
*obj
)
682 VirtIOBlkCcw
*dev
= VIRTIO_BLK_CCW(obj
);
683 object_initialize(&dev
->vdev
, TYPE_VIRTIO_BLK
);
684 object_property_add_child(obj
, "virtio-backend", OBJECT(&dev
->vdev
), NULL
);
687 static int virtio_ccw_serial_init(VirtioCcwDevice
*ccw_dev
)
689 VirtioSerialCcw
*dev
= VIRTIO_SERIAL_CCW(ccw_dev
);
690 DeviceState
*vdev
= DEVICE(&dev
->vdev
);
691 DeviceState
*proxy
= DEVICE(ccw_dev
);
695 * For command line compatibility, this sets the virtio-serial-device bus
699 bus_name
= g_strdup_printf("%s.0", proxy
->id
);
700 virtio_device_set_child_bus_name(VIRTIO_DEVICE(vdev
), bus_name
);
704 qdev_set_parent_bus(vdev
, BUS(&ccw_dev
->bus
));
705 if (qdev_init(vdev
) < 0) {
709 return virtio_ccw_device_init(ccw_dev
, VIRTIO_DEVICE(vdev
));
713 static void virtio_ccw_serial_instance_init(Object
*obj
)
715 VirtioSerialCcw
*dev
= VIRTIO_SERIAL_CCW(obj
);
716 object_initialize(&dev
->vdev
, TYPE_VIRTIO_SERIAL
);
717 object_property_add_child(obj
, "virtio-backend", OBJECT(&dev
->vdev
), NULL
);
720 static int virtio_ccw_balloon_init(VirtioCcwDevice
*ccw_dev
)
722 VirtIOBalloonCcw
*dev
= VIRTIO_BALLOON_CCW(ccw_dev
);
723 DeviceState
*vdev
= DEVICE(&dev
->vdev
);
725 qdev_set_parent_bus(vdev
, BUS(&ccw_dev
->bus
));
726 if (qdev_init(vdev
) < 0) {
730 return virtio_ccw_device_init(ccw_dev
, VIRTIO_DEVICE(vdev
));
733 static void balloon_ccw_stats_get_all(Object
*obj
, struct Visitor
*v
,
734 void *opaque
, const char *name
,
737 VirtIOBalloonCcw
*dev
= opaque
;
738 object_property_get(OBJECT(&dev
->vdev
), v
, "guest-stats", errp
);
741 static void balloon_ccw_stats_get_poll_interval(Object
*obj
, struct Visitor
*v
,
742 void *opaque
, const char *name
,
745 VirtIOBalloonCcw
*dev
= opaque
;
746 object_property_get(OBJECT(&dev
->vdev
), v
, "guest-stats-polling-interval",
750 static void balloon_ccw_stats_set_poll_interval(Object
*obj
, struct Visitor
*v
,
751 void *opaque
, const char *name
,
754 VirtIOBalloonCcw
*dev
= opaque
;
755 object_property_set(OBJECT(&dev
->vdev
), v
, "guest-stats-polling-interval",
759 static void virtio_ccw_balloon_instance_init(Object
*obj
)
761 VirtIOBalloonCcw
*dev
= VIRTIO_BALLOON_CCW(obj
);
762 object_initialize(&dev
->vdev
, TYPE_VIRTIO_BALLOON
);
763 object_property_add_child(obj
, "virtio-backend", OBJECT(&dev
->vdev
), NULL
);
765 object_property_add(obj
, "guest-stats", "guest statistics",
766 balloon_ccw_stats_get_all
, NULL
, NULL
, dev
, NULL
);
768 object_property_add(obj
, "guest-stats-polling-interval", "int",
769 balloon_ccw_stats_get_poll_interval
,
770 balloon_ccw_stats_set_poll_interval
,
774 static int virtio_ccw_scsi_init(VirtioCcwDevice
*ccw_dev
)
776 VirtIOSCSICcw
*dev
= VIRTIO_SCSI_CCW(ccw_dev
);
777 DeviceState
*vdev
= DEVICE(&dev
->vdev
);
778 DeviceState
*qdev
= DEVICE(ccw_dev
);
782 * For command line compatibility, this sets the virtio-scsi-device bus
786 bus_name
= g_strdup_printf("%s.0", qdev
->id
);
787 virtio_device_set_child_bus_name(VIRTIO_DEVICE(vdev
), bus_name
);
791 qdev_set_parent_bus(vdev
, BUS(&ccw_dev
->bus
));
792 if (qdev_init(vdev
) < 0) {
796 return virtio_ccw_device_init(ccw_dev
, VIRTIO_DEVICE(vdev
));
799 static void virtio_ccw_scsi_instance_init(Object
*obj
)
801 VirtIOSCSICcw
*dev
= VIRTIO_SCSI_CCW(obj
);
802 object_initialize(&dev
->vdev
, TYPE_VIRTIO_SCSI
);
803 object_property_add_child(obj
, "virtio-backend", OBJECT(&dev
->vdev
), NULL
);
806 #ifdef CONFIG_VHOST_SCSI
807 static int vhost_ccw_scsi_init(VirtioCcwDevice
*ccw_dev
)
809 VHostSCSICcw
*dev
= VHOST_SCSI_CCW(ccw_dev
);
810 DeviceState
*vdev
= DEVICE(&dev
->vdev
);
812 qdev_set_parent_bus(vdev
, BUS(&ccw_dev
->bus
));
813 if (qdev_init(vdev
) < 0) {
817 return virtio_ccw_device_init(ccw_dev
, VIRTIO_DEVICE(vdev
));
820 static void vhost_ccw_scsi_instance_init(Object
*obj
)
822 VHostSCSICcw
*dev
= VHOST_SCSI_CCW(obj
);
823 object_initialize(&dev
->vdev
, TYPE_VHOST_SCSI
);
824 object_property_add_child(obj
, "virtio-backend", OBJECT(&dev
->vdev
), NULL
);
828 static int virtio_ccw_rng_init(VirtioCcwDevice
*ccw_dev
)
830 VirtIORNGCcw
*dev
= VIRTIO_RNG_CCW(ccw_dev
);
831 DeviceState
*vdev
= DEVICE(&dev
->vdev
);
833 qdev_set_parent_bus(vdev
, BUS(&ccw_dev
->bus
));
834 if (qdev_init(vdev
) < 0) {
838 object_property_set_link(OBJECT(dev
),
839 OBJECT(dev
->vdev
.conf
.rng
), "rng",
842 return virtio_ccw_device_init(ccw_dev
, VIRTIO_DEVICE(vdev
));
845 /* DeviceState to VirtioCcwDevice. Note: used on datapath,
846 * be careful and test performance if you change this.
848 static inline VirtioCcwDevice
*to_virtio_ccw_dev_fast(DeviceState
*d
)
850 return container_of(d
, VirtioCcwDevice
, parent_obj
);
853 static void virtio_ccw_notify(DeviceState
*d
, uint16_t vector
)
855 VirtioCcwDevice
*dev
= to_virtio_ccw_dev_fast(d
);
856 SubchDev
*sch
= dev
->sch
;
863 if (vector
< VIRTIO_PCI_QUEUE_MAX
) {
864 if (!dev
->indicators
) {
867 indicators
= ldq_phys(dev
->indicators
);
868 indicators
|= 1ULL << vector
;
869 stq_phys(dev
->indicators
, indicators
);
871 if (!dev
->indicators2
) {
875 indicators
= ldq_phys(dev
->indicators2
);
876 indicators
|= 1ULL << vector
;
877 stq_phys(dev
->indicators2
, indicators
);
880 css_conditional_io_interrupt(sch
);
884 static unsigned virtio_ccw_get_features(DeviceState
*d
)
886 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
888 /* Only the first 32 feature bits are used. */
889 return dev
->host_features
[0];
892 static void virtio_ccw_reset(DeviceState
*d
)
894 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
896 virtio_ccw_stop_ioeventfd(dev
);
897 virtio_reset(dev
->vdev
);
898 css_reset_sch(dev
->sch
);
900 dev
->indicators2
= 0;
903 static void virtio_ccw_vmstate_change(DeviceState
*d
, bool running
)
905 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
908 virtio_ccw_start_ioeventfd(dev
);
910 virtio_ccw_stop_ioeventfd(dev
);
914 static bool virtio_ccw_query_guest_notifiers(DeviceState
*d
)
916 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
918 return !!(dev
->sch
->curr_status
.pmcw
.flags
& PMCW_FLAGS_MASK_ENA
);
921 static int virtio_ccw_set_host_notifier(DeviceState
*d
, int n
, bool assign
)
923 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
925 /* Stop using the generic ioeventfd, we are doing eventfd handling
927 dev
->ioeventfd_disabled
= assign
;
929 virtio_ccw_stop_ioeventfd(dev
);
931 return virtio_ccw_set_guest2host_notifier(dev
, n
, assign
, false);
934 static int virtio_ccw_set_guest_notifier(VirtioCcwDevice
*dev
, int n
,
935 bool assign
, bool with_irqfd
)
937 VirtQueue
*vq
= virtio_get_queue(dev
->vdev
, n
);
938 EventNotifier
*notifier
= virtio_queue_get_guest_notifier(vq
);
939 VirtioDeviceClass
*k
= VIRTIO_DEVICE_GET_CLASS(dev
->vdev
);
942 int r
= event_notifier_init(notifier
, 0);
947 virtio_queue_set_guest_notifier_fd_handler(vq
, true, with_irqfd
);
948 /* We do not support irqfd for classic I/O interrupts, because the
949 * classic interrupts are intermixed with the subchannel status, that
950 * is queried with test subchannel. We want to use vhost, though.
951 * Lets make sure to have vhost running and wire up the irq fd to
952 * land in qemu (and only the irq fd) in this code.
954 if (k
->guest_notifier_mask
) {
955 k
->guest_notifier_mask(dev
->vdev
, n
, false);
957 /* get lost events and re-inject */
958 if (k
->guest_notifier_pending
&&
959 k
->guest_notifier_pending(dev
->vdev
, n
)) {
960 event_notifier_set(notifier
);
963 if (k
->guest_notifier_mask
) {
964 k
->guest_notifier_mask(dev
->vdev
, n
, true);
966 virtio_queue_set_guest_notifier_fd_handler(vq
, false, with_irqfd
);
967 event_notifier_cleanup(notifier
);
972 static int virtio_ccw_set_guest_notifiers(DeviceState
*d
, int nvqs
,
975 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
976 VirtIODevice
*vdev
= dev
->vdev
;
979 for (n
= 0; n
< nvqs
; n
++) {
980 if (!virtio_queue_get_num(vdev
, n
)) {
983 /* false -> true, as soon as irqfd works */
984 r
= virtio_ccw_set_guest_notifier(dev
, n
, assigned
, false);
993 virtio_ccw_set_guest_notifier(dev
, n
, !assigned
, false);
998 /**************** Virtio-ccw Bus Device Descriptions *******************/
1000 static Property virtio_ccw_net_properties
[] = {
1001 DEFINE_PROP_STRING("devno", VirtioCcwDevice
, bus_id
),
1002 DEFINE_VIRTIO_NET_FEATURES(VirtioCcwDevice
, host_features
[0]),
1003 DEFINE_VIRTIO_NET_PROPERTIES(VirtIONetCcw
, vdev
.net_conf
),
1004 DEFINE_NIC_PROPERTIES(VirtIONetCcw
, vdev
.nic_conf
),
1005 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice
, flags
,
1006 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT
, true),
1007 DEFINE_PROP_END_OF_LIST(),
1010 static void virtio_ccw_net_class_init(ObjectClass
*klass
, void *data
)
1012 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1013 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_CLASS(klass
);
1015 k
->init
= virtio_ccw_net_init
;
1016 k
->exit
= virtio_ccw_exit
;
1017 dc
->reset
= virtio_ccw_reset
;
1018 dc
->props
= virtio_ccw_net_properties
;
1021 static const TypeInfo virtio_ccw_net
= {
1022 .name
= TYPE_VIRTIO_NET_CCW
,
1023 .parent
= TYPE_VIRTIO_CCW_DEVICE
,
1024 .instance_size
= sizeof(VirtIONetCcw
),
1025 .instance_init
= virtio_ccw_net_instance_init
,
1026 .class_init
= virtio_ccw_net_class_init
,
1029 static Property virtio_ccw_blk_properties
[] = {
1030 DEFINE_PROP_STRING("devno", VirtioCcwDevice
, bus_id
),
1031 DEFINE_VIRTIO_BLK_FEATURES(VirtioCcwDevice
, host_features
[0]),
1032 DEFINE_VIRTIO_BLK_PROPERTIES(VirtIOBlkCcw
, blk
),
1033 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice
, flags
,
1034 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT
, true),
1035 #ifdef CONFIG_VIRTIO_BLK_DATA_PLANE
1036 DEFINE_PROP_BIT("x-data-plane", VirtIOBlkCcw
, blk
.data_plane
, 0, false),
1038 DEFINE_PROP_END_OF_LIST(),
1041 static void virtio_ccw_blk_class_init(ObjectClass
*klass
, void *data
)
1043 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1044 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_CLASS(klass
);
1046 k
->init
= virtio_ccw_blk_init
;
1047 k
->exit
= virtio_ccw_exit
;
1048 dc
->reset
= virtio_ccw_reset
;
1049 dc
->props
= virtio_ccw_blk_properties
;
1052 static const TypeInfo virtio_ccw_blk
= {
1053 .name
= TYPE_VIRTIO_BLK_CCW
,
1054 .parent
= TYPE_VIRTIO_CCW_DEVICE
,
1055 .instance_size
= sizeof(VirtIOBlkCcw
),
1056 .instance_init
= virtio_ccw_blk_instance_init
,
1057 .class_init
= virtio_ccw_blk_class_init
,
1060 static Property virtio_ccw_serial_properties
[] = {
1061 DEFINE_PROP_STRING("devno", VirtioCcwDevice
, bus_id
),
1062 DEFINE_VIRTIO_SERIAL_PROPERTIES(VirtioSerialCcw
, vdev
.serial
),
1063 DEFINE_VIRTIO_COMMON_FEATURES(VirtioCcwDevice
, host_features
[0]),
1064 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice
, flags
,
1065 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT
, true),
1066 DEFINE_PROP_END_OF_LIST(),
1069 static void virtio_ccw_serial_class_init(ObjectClass
*klass
, void *data
)
1071 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1072 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_CLASS(klass
);
1074 k
->init
= virtio_ccw_serial_init
;
1075 k
->exit
= virtio_ccw_exit
;
1076 dc
->reset
= virtio_ccw_reset
;
1077 dc
->props
= virtio_ccw_serial_properties
;
1080 static const TypeInfo virtio_ccw_serial
= {
1081 .name
= TYPE_VIRTIO_SERIAL_CCW
,
1082 .parent
= TYPE_VIRTIO_CCW_DEVICE
,
1083 .instance_size
= sizeof(VirtioSerialCcw
),
1084 .instance_init
= virtio_ccw_serial_instance_init
,
1085 .class_init
= virtio_ccw_serial_class_init
,
1088 static Property virtio_ccw_balloon_properties
[] = {
1089 DEFINE_PROP_STRING("devno", VirtioCcwDevice
, bus_id
),
1090 DEFINE_VIRTIO_COMMON_FEATURES(VirtioCcwDevice
, host_features
[0]),
1091 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice
, flags
,
1092 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT
, true),
1093 DEFINE_PROP_END_OF_LIST(),
1096 static void virtio_ccw_balloon_class_init(ObjectClass
*klass
, void *data
)
1098 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1099 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_CLASS(klass
);
1101 k
->init
= virtio_ccw_balloon_init
;
1102 k
->exit
= virtio_ccw_exit
;
1103 dc
->reset
= virtio_ccw_reset
;
1104 dc
->props
= virtio_ccw_balloon_properties
;
1107 static const TypeInfo virtio_ccw_balloon
= {
1108 .name
= TYPE_VIRTIO_BALLOON_CCW
,
1109 .parent
= TYPE_VIRTIO_CCW_DEVICE
,
1110 .instance_size
= sizeof(VirtIOBalloonCcw
),
1111 .instance_init
= virtio_ccw_balloon_instance_init
,
1112 .class_init
= virtio_ccw_balloon_class_init
,
1115 static Property virtio_ccw_scsi_properties
[] = {
1116 DEFINE_PROP_STRING("devno", VirtioCcwDevice
, bus_id
),
1117 DEFINE_VIRTIO_SCSI_PROPERTIES(VirtIOSCSICcw
, vdev
.parent_obj
.conf
),
1118 DEFINE_VIRTIO_SCSI_FEATURES(VirtioCcwDevice
, host_features
[0]),
1119 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice
, flags
,
1120 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT
, true),
1121 DEFINE_PROP_END_OF_LIST(),
1124 static void virtio_ccw_scsi_class_init(ObjectClass
*klass
, void *data
)
1126 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1127 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_CLASS(klass
);
1129 k
->init
= virtio_ccw_scsi_init
;
1130 k
->exit
= virtio_ccw_exit
;
1131 dc
->reset
= virtio_ccw_reset
;
1132 dc
->props
= virtio_ccw_scsi_properties
;
1135 static const TypeInfo virtio_ccw_scsi
= {
1136 .name
= TYPE_VIRTIO_SCSI_CCW
,
1137 .parent
= TYPE_VIRTIO_CCW_DEVICE
,
1138 .instance_size
= sizeof(VirtIOSCSICcw
),
1139 .instance_init
= virtio_ccw_scsi_instance_init
,
1140 .class_init
= virtio_ccw_scsi_class_init
,
1143 #ifdef CONFIG_VHOST_SCSI
1144 static Property vhost_ccw_scsi_properties
[] = {
1145 DEFINE_PROP_STRING("devno", VirtioCcwDevice
, bus_id
),
1146 DEFINE_VHOST_SCSI_PROPERTIES(VirtIOSCSICcw
, vdev
.parent_obj
.conf
),
1147 DEFINE_VIRTIO_COMMON_FEATURES(VirtioCcwDevice
, host_features
[0]),
1148 DEFINE_PROP_END_OF_LIST(),
1151 static void vhost_ccw_scsi_class_init(ObjectClass
*klass
, void *data
)
1153 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1154 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_CLASS(klass
);
1156 k
->init
= vhost_ccw_scsi_init
;
1157 k
->exit
= virtio_ccw_exit
;
1158 dc
->reset
= virtio_ccw_reset
;
1159 dc
->props
= vhost_ccw_scsi_properties
;
1162 static const TypeInfo vhost_ccw_scsi
= {
1163 .name
= TYPE_VHOST_SCSI_CCW
,
1164 .parent
= TYPE_VIRTIO_CCW_DEVICE
,
1165 .instance_size
= sizeof(VirtIOSCSICcw
),
1166 .instance_init
= vhost_ccw_scsi_instance_init
,
1167 .class_init
= vhost_ccw_scsi_class_init
,
1171 static void virtio_ccw_rng_instance_init(Object
*obj
)
1173 VirtIORNGCcw
*dev
= VIRTIO_RNG_CCW(obj
);
1174 object_initialize(&dev
->vdev
, TYPE_VIRTIO_RNG
);
1175 object_property_add_child(obj
, "virtio-backend", OBJECT(&dev
->vdev
), NULL
);
1176 object_property_add_link(obj
, "rng", TYPE_RNG_BACKEND
,
1177 (Object
**)&dev
->vdev
.conf
.rng
, NULL
);
1180 static Property virtio_ccw_rng_properties
[] = {
1181 DEFINE_PROP_STRING("devno", VirtioCcwDevice
, bus_id
),
1182 DEFINE_VIRTIO_COMMON_FEATURES(VirtioCcwDevice
, host_features
[0]),
1183 DEFINE_VIRTIO_RNG_PROPERTIES(VirtIORNGCcw
, vdev
.conf
),
1184 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice
, flags
,
1185 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT
, true),
1186 DEFINE_PROP_END_OF_LIST(),
1189 static void virtio_ccw_rng_class_init(ObjectClass
*klass
, void *data
)
1191 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1192 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_CLASS(klass
);
1194 k
->init
= virtio_ccw_rng_init
;
1195 k
->exit
= virtio_ccw_exit
;
1196 dc
->reset
= virtio_ccw_reset
;
1197 dc
->props
= virtio_ccw_rng_properties
;
1200 static const TypeInfo virtio_ccw_rng
= {
1201 .name
= TYPE_VIRTIO_RNG_CCW
,
1202 .parent
= TYPE_VIRTIO_CCW_DEVICE
,
1203 .instance_size
= sizeof(VirtIORNGCcw
),
1204 .instance_init
= virtio_ccw_rng_instance_init
,
1205 .class_init
= virtio_ccw_rng_class_init
,
1208 static int virtio_ccw_busdev_init(DeviceState
*dev
)
1210 VirtioCcwDevice
*_dev
= (VirtioCcwDevice
*)dev
;
1211 VirtIOCCWDeviceClass
*_info
= VIRTIO_CCW_DEVICE_GET_CLASS(dev
);
1213 virtio_ccw_bus_new(&_dev
->bus
, sizeof(_dev
->bus
), _dev
);
1215 return _info
->init(_dev
);
1218 static int virtio_ccw_busdev_exit(DeviceState
*dev
)
1220 VirtioCcwDevice
*_dev
= (VirtioCcwDevice
*)dev
;
1221 VirtIOCCWDeviceClass
*_info
= VIRTIO_CCW_DEVICE_GET_CLASS(dev
);
1223 return _info
->exit(_dev
);
1226 static int virtio_ccw_busdev_unplug(DeviceState
*dev
)
1228 VirtioCcwDevice
*_dev
= (VirtioCcwDevice
*)dev
;
1229 SubchDev
*sch
= _dev
->sch
;
1232 * We should arrive here only for device_del, since we don't support
1233 * direct hot(un)plug of channels, but only through virtio.
1235 assert(sch
!= NULL
);
1236 /* Subchannel is now disabled and no longer valid. */
1237 sch
->curr_status
.pmcw
.flags
&= ~(PMCW_FLAGS_MASK_ENA
|
1238 PMCW_FLAGS_MASK_DNV
);
1240 css_generate_sch_crws(sch
->cssid
, sch
->ssid
, sch
->schid
, 1, 0);
1246 static void virtio_ccw_device_class_init(ObjectClass
*klass
, void *data
)
1248 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1250 dc
->init
= virtio_ccw_busdev_init
;
1251 dc
->exit
= virtio_ccw_busdev_exit
;
1252 dc
->unplug
= virtio_ccw_busdev_unplug
;
1253 dc
->bus_type
= TYPE_VIRTUAL_CSS_BUS
;
1257 static const TypeInfo virtio_ccw_device_info
= {
1258 .name
= TYPE_VIRTIO_CCW_DEVICE
,
1259 .parent
= TYPE_DEVICE
,
1260 .instance_size
= sizeof(VirtioCcwDevice
),
1261 .class_init
= virtio_ccw_device_class_init
,
1262 .class_size
= sizeof(VirtIOCCWDeviceClass
),
1266 /***************** Virtual-css Bus Bridge Device ********************/
1267 /* Only required to have the virtio bus as child in the system bus */
1269 static int virtual_css_bridge_init(SysBusDevice
*dev
)
1275 static void virtual_css_bridge_class_init(ObjectClass
*klass
, void *data
)
1277 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1278 SysBusDeviceClass
*k
= SYS_BUS_DEVICE_CLASS(klass
);
1280 k
->init
= virtual_css_bridge_init
;
1284 static const TypeInfo virtual_css_bridge_info
= {
1285 .name
= "virtual-css-bridge",
1286 .parent
= TYPE_SYS_BUS_DEVICE
,
1287 .instance_size
= sizeof(SysBusDevice
),
1288 .class_init
= virtual_css_bridge_class_init
,
1291 /* virtio-ccw-bus */
1293 static void virtio_ccw_bus_new(VirtioBusState
*bus
, size_t bus_size
,
1294 VirtioCcwDevice
*dev
)
1296 DeviceState
*qdev
= DEVICE(dev
);
1298 char virtio_bus_name
[] = "virtio-bus";
1300 qbus_create_inplace(bus
, bus_size
, TYPE_VIRTIO_CCW_BUS
,
1301 qdev
, virtio_bus_name
);
1303 qbus
->allow_hotplug
= 1;
1306 static void virtio_ccw_bus_class_init(ObjectClass
*klass
, void *data
)
1308 VirtioBusClass
*k
= VIRTIO_BUS_CLASS(klass
);
1309 BusClass
*bus_class
= BUS_CLASS(klass
);
1311 bus_class
->max_dev
= 1;
1312 k
->notify
= virtio_ccw_notify
;
1313 k
->get_features
= virtio_ccw_get_features
;
1314 k
->vmstate_change
= virtio_ccw_vmstate_change
;
1315 k
->query_guest_notifiers
= virtio_ccw_query_guest_notifiers
;
1316 k
->set_host_notifier
= virtio_ccw_set_host_notifier
;
1317 k
->set_guest_notifiers
= virtio_ccw_set_guest_notifiers
;
1320 static const TypeInfo virtio_ccw_bus_info
= {
1321 .name
= TYPE_VIRTIO_CCW_BUS
,
1322 .parent
= TYPE_VIRTIO_BUS
,
1323 .instance_size
= sizeof(VirtioCcwBusState
),
1324 .class_init
= virtio_ccw_bus_class_init
,
1327 static void virtio_ccw_register(void)
1329 type_register_static(&virtio_ccw_bus_info
);
1330 type_register_static(&virtual_css_bus_info
);
1331 type_register_static(&virtio_ccw_device_info
);
1332 type_register_static(&virtio_ccw_serial
);
1333 type_register_static(&virtio_ccw_blk
);
1334 type_register_static(&virtio_ccw_net
);
1335 type_register_static(&virtio_ccw_balloon
);
1336 type_register_static(&virtio_ccw_scsi
);
1337 #ifdef CONFIG_VHOST_SCSI
1338 type_register_static(&vhost_ccw_scsi
);
1340 type_register_static(&virtio_ccw_rng
);
1341 type_register_static(&virtual_css_bridge_info
);
1344 type_init(virtio_ccw_register
)