2 * virtio ccw target implementation
4 * Copyright 2012,2014 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 void virtual_css_bus_reset(BusState
*qbus
)
35 /* This should actually be modelled via the generic css */
40 static void virtual_css_bus_class_init(ObjectClass
*klass
, void *data
)
42 BusClass
*k
= BUS_CLASS(klass
);
44 k
->reset
= virtual_css_bus_reset
;
47 static const TypeInfo virtual_css_bus_info
= {
48 .name
= TYPE_VIRTUAL_CSS_BUS
,
50 .instance_size
= sizeof(VirtualCssBus
),
51 .class_init
= virtual_css_bus_class_init
,
54 VirtIODevice
*virtio_ccw_get_vdev(SubchDev
*sch
)
56 VirtIODevice
*vdev
= NULL
;
57 VirtioCcwDevice
*dev
= sch
->driver_data
;
60 vdev
= virtio_bus_get_device(&dev
->bus
);
65 static int virtio_ccw_set_guest2host_notifier(VirtioCcwDevice
*dev
, int n
,
66 bool assign
, bool set_handler
)
68 VirtIODevice
*vdev
= virtio_bus_get_device(&dev
->bus
);
69 VirtQueue
*vq
= virtio_get_queue(vdev
, n
);
70 EventNotifier
*notifier
= virtio_queue_get_host_notifier(vq
);
72 SubchDev
*sch
= dev
->sch
;
73 uint32_t sch_id
= (css_build_subchannel_id(sch
) << 16) | sch
->schid
;
76 r
= event_notifier_init(notifier
, 1);
78 error_report("%s: unable to init event notifier: %d", __func__
, r
);
81 virtio_queue_set_host_notifier_fd_handler(vq
, true, set_handler
);
82 r
= s390_assign_subch_ioeventfd(notifier
, sch_id
, n
, assign
);
84 error_report("%s: unable to assign ioeventfd: %d", __func__
, r
);
85 virtio_queue_set_host_notifier_fd_handler(vq
, false, false);
86 event_notifier_cleanup(notifier
);
90 virtio_queue_set_host_notifier_fd_handler(vq
, false, false);
91 s390_assign_subch_ioeventfd(notifier
, sch_id
, n
, assign
);
92 event_notifier_cleanup(notifier
);
97 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 vdev
= virtio_bus_get_device(&dev
->bus
);
108 for (n
= 0; n
< VIRTIO_PCI_QUEUE_MAX
; n
++) {
109 if (!virtio_queue_get_num(vdev
, n
)) {
112 r
= virtio_ccw_set_guest2host_notifier(dev
, n
, true, true);
117 dev
->ioeventfd_started
= true;
122 if (!virtio_queue_get_num(vdev
, n
)) {
125 r
= virtio_ccw_set_guest2host_notifier(dev
, n
, false, false);
128 dev
->ioeventfd_started
= false;
129 /* Disable ioeventfd for this device. */
130 dev
->flags
&= ~VIRTIO_CCW_FLAG_USE_IOEVENTFD
;
131 error_report("%s: failed. Fallback to userspace (slower).", __func__
);
134 static void virtio_ccw_stop_ioeventfd(VirtioCcwDevice
*dev
)
139 if (!dev
->ioeventfd_started
) {
142 vdev
= virtio_bus_get_device(&dev
->bus
);
143 for (n
= 0; n
< VIRTIO_PCI_QUEUE_MAX
; n
++) {
144 if (!virtio_queue_get_num(vdev
, n
)) {
147 r
= virtio_ccw_set_guest2host_notifier(dev
, n
, false, false);
150 dev
->ioeventfd_started
= false;
153 VirtualCssBus
*virtual_css_bus_init(void)
159 /* Create bridge device */
160 dev
= qdev_create(NULL
, "virtual-css-bridge");
161 qdev_init_nofail(dev
);
163 /* Create bus on bridge device */
164 bus
= qbus_create(TYPE_VIRTUAL_CSS_BUS
, dev
, "virtual-css");
165 cbus
= VIRTUAL_CSS_BUS(bus
);
167 /* Enable hotplugging */
168 bus
->allow_hotplug
= 1;
173 /* Communication blocks used by several channel commands. */
174 typedef struct VqInfoBlock
{
179 } QEMU_PACKED VqInfoBlock
;
181 typedef struct VqConfigBlock
{
184 } QEMU_PACKED VqConfigBlock
;
186 typedef struct VirtioFeatDesc
{
189 } QEMU_PACKED VirtioFeatDesc
;
191 typedef struct VirtioThinintInfo
{
192 hwaddr summary_indicator
;
193 hwaddr device_indicator
;
196 } QEMU_PACKED VirtioThinintInfo
;
198 /* Specify where the virtqueues for the subchannel are in guest memory. */
199 static int virtio_ccw_set_vqs(SubchDev
*sch
, uint64_t addr
, uint32_t align
,
200 uint16_t index
, uint16_t num
)
202 VirtIODevice
*vdev
= virtio_ccw_get_vdev(sch
);
204 if (index
> VIRTIO_PCI_QUEUE_MAX
) {
208 /* Current code in virtio.c relies on 4K alignment. */
209 if (addr
&& (align
!= 4096)) {
217 virtio_queue_set_addr(vdev
, index
, addr
);
219 virtio_queue_set_vector(vdev
, index
, 0);
221 /* Fail if we don't have a big enough queue. */
222 /* TODO: Add interface to handle vring.num changing */
223 if (virtio_queue_get_num(vdev
, index
) > num
) {
226 virtio_queue_set_vector(vdev
, index
, index
);
228 /* tell notify handler in case of config change */
229 vdev
->config_vector
= VIRTIO_PCI_QUEUE_MAX
;
233 static int virtio_ccw_cb(SubchDev
*sch
, CCW1 ccw
)
238 VirtioFeatDesc features
;
241 VqConfigBlock vq_config
;
242 VirtioCcwDevice
*dev
= sch
->driver_data
;
243 VirtIODevice
*vdev
= virtio_ccw_get_vdev(sch
);
247 VirtioThinintInfo
*thinint
;
253 trace_virtio_ccw_interpret_ccw(sch
->cssid
, sch
->ssid
, sch
->schid
,
255 check_len
= !((ccw
.flags
& CCW_FLAG_SLI
) && !(ccw
.flags
& CCW_FLAG_DC
));
257 /* Look at the command. */
258 switch (ccw
.cmd_code
) {
261 if (ccw
.count
!= sizeof(info
)) {
265 } else if (ccw
.count
< sizeof(info
)) {
266 /* Can't execute command. */
273 info
.queue
= ldq_phys(&address_space_memory
, ccw
.cda
);
274 info
.align
= ldl_phys(&address_space_memory
,
275 ccw
.cda
+ sizeof(info
.queue
));
276 info
.index
= lduw_phys(&address_space_memory
,
277 ccw
.cda
+ sizeof(info
.queue
)
278 + sizeof(info
.align
));
279 info
.num
= lduw_phys(&address_space_memory
,
280 ccw
.cda
+ sizeof(info
.queue
)
282 + sizeof(info
.index
));
283 ret
= virtio_ccw_set_vqs(sch
, info
.queue
, info
.align
, info
.index
,
285 sch
->curr_status
.scsw
.count
= 0;
288 case CCW_CMD_VDEV_RESET
:
289 virtio_ccw_stop_ioeventfd(dev
);
293 case CCW_CMD_READ_FEAT
:
295 if (ccw
.count
!= sizeof(features
)) {
299 } else if (ccw
.count
< sizeof(features
)) {
300 /* Can't execute command. */
307 features
.index
= ldub_phys(&address_space_memory
,
308 ccw
.cda
+ sizeof(features
.features
));
309 if (features
.index
< ARRAY_SIZE(dev
->host_features
)) {
310 features
.features
= dev
->host_features
[features
.index
];
312 /* Return zeroes if the guest supports more feature bits. */
313 features
.features
= 0;
315 stl_le_phys(&address_space_memory
, ccw
.cda
, features
.features
);
316 sch
->curr_status
.scsw
.count
= ccw
.count
- sizeof(features
);
320 case CCW_CMD_WRITE_FEAT
:
322 if (ccw
.count
!= sizeof(features
)) {
326 } else if (ccw
.count
< sizeof(features
)) {
327 /* Can't execute command. */
334 features
.index
= ldub_phys(&address_space_memory
,
335 ccw
.cda
+ sizeof(features
.features
));
336 features
.features
= ldl_le_phys(&address_space_memory
, ccw
.cda
);
337 if (features
.index
< ARRAY_SIZE(dev
->host_features
)) {
338 virtio_bus_set_vdev_features(&dev
->bus
, features
.features
);
339 vdev
->guest_features
= features
.features
;
342 * If the guest supports more feature bits, assert that it
343 * passes us zeroes for those we don't support.
345 if (features
.features
) {
346 fprintf(stderr
, "Guest bug: features[%i]=%x (expected 0)\n",
347 features
.index
, features
.features
);
348 /* XXX: do a unit check here? */
351 sch
->curr_status
.scsw
.count
= ccw
.count
- sizeof(features
);
355 case CCW_CMD_READ_CONF
:
357 if (ccw
.count
> vdev
->config_len
) {
362 len
= MIN(ccw
.count
, vdev
->config_len
);
366 virtio_bus_get_vdev_config(&dev
->bus
, vdev
->config
);
367 /* XXX config space endianness */
368 cpu_physical_memory_write(ccw
.cda
, vdev
->config
, len
);
369 sch
->curr_status
.scsw
.count
= ccw
.count
- len
;
373 case CCW_CMD_WRITE_CONF
:
375 if (ccw
.count
> vdev
->config_len
) {
380 len
= MIN(ccw
.count
, vdev
->config_len
);
385 config
= cpu_physical_memory_map(ccw
.cda
, &hw_len
, 0);
390 /* XXX config space endianness */
391 memcpy(vdev
->config
, config
, len
);
392 cpu_physical_memory_unmap(config
, hw_len
, 0, hw_len
);
393 virtio_bus_set_vdev_config(&dev
->bus
, vdev
->config
);
394 sch
->curr_status
.scsw
.count
= ccw
.count
- len
;
399 case CCW_CMD_WRITE_STATUS
:
401 if (ccw
.count
!= sizeof(status
)) {
405 } else if (ccw
.count
< sizeof(status
)) {
406 /* Can't execute command. */
413 status
= ldub_phys(&address_space_memory
, ccw
.cda
);
414 if (!(status
& VIRTIO_CONFIG_S_DRIVER_OK
)) {
415 virtio_ccw_stop_ioeventfd(dev
);
417 virtio_set_status(vdev
, status
);
418 if (vdev
->status
== 0) {
421 if (status
& VIRTIO_CONFIG_S_DRIVER_OK
) {
422 virtio_ccw_start_ioeventfd(dev
);
424 sch
->curr_status
.scsw
.count
= ccw
.count
- sizeof(status
);
428 case CCW_CMD_SET_IND
:
430 if (ccw
.count
!= sizeof(indicators
)) {
434 } else if (ccw
.count
< sizeof(indicators
)) {
435 /* Can't execute command. */
439 if (sch
->thinint_active
) {
440 /* Trigger a command reject. */
447 indicators
= ldq_phys(&address_space_memory
, ccw
.cda
);
448 dev
->indicators
= indicators
;
449 sch
->curr_status
.scsw
.count
= ccw
.count
- sizeof(indicators
);
453 case CCW_CMD_SET_CONF_IND
:
455 if (ccw
.count
!= sizeof(indicators
)) {
459 } else if (ccw
.count
< sizeof(indicators
)) {
460 /* Can't execute command. */
467 indicators
= ldq_phys(&address_space_memory
, ccw
.cda
);
468 dev
->indicators2
= indicators
;
469 sch
->curr_status
.scsw
.count
= ccw
.count
- sizeof(indicators
);
473 case CCW_CMD_READ_VQ_CONF
:
475 if (ccw
.count
!= sizeof(vq_config
)) {
479 } else if (ccw
.count
< sizeof(vq_config
)) {
480 /* Can't execute command. */
487 vq_config
.index
= lduw_phys(&address_space_memory
, ccw
.cda
);
488 vq_config
.num_max
= virtio_queue_get_num(vdev
,
490 stw_phys(&address_space_memory
,
491 ccw
.cda
+ sizeof(vq_config
.index
), vq_config
.num_max
);
492 sch
->curr_status
.scsw
.count
= ccw
.count
- sizeof(vq_config
);
496 case CCW_CMD_SET_IND_ADAPTER
:
498 if (ccw
.count
!= sizeof(*thinint
)) {
502 } else if (ccw
.count
< sizeof(*thinint
)) {
503 /* Can't execute command. */
507 len
= sizeof(*thinint
);
511 } else if (dev
->indicators
&& !sch
->thinint_active
) {
512 /* Trigger a command reject. */
515 thinint
= cpu_physical_memory_map(ccw
.cda
, &hw_len
, 0);
520 dev
->summary_indicator
= thinint
->summary_indicator
;
521 dev
->indicators
= thinint
->device_indicator
;
522 dev
->thinint_isc
= thinint
->isc
;
523 dev
->ind_bit
= thinint
->ind_bit
;
524 cpu_physical_memory_unmap(thinint
, hw_len
, 0, hw_len
);
525 sch
->thinint_active
= ((dev
->indicators
!= 0) &&
526 (dev
->summary_indicator
!= 0));
527 sch
->curr_status
.scsw
.count
= ccw
.count
- len
;
539 static int virtio_ccw_device_init(VirtioCcwDevice
*dev
, VirtIODevice
*vdev
)
541 unsigned int cssid
= 0;
542 unsigned int ssid
= 0;
545 bool have_devno
= false;
550 DeviceState
*parent
= DEVICE(dev
);
552 sch
= g_malloc0(sizeof(SubchDev
));
554 sch
->driver_data
= dev
;
559 /* Initialize subchannel structure. */
560 sch
->channel_prog
= 0x0;
561 sch
->last_cmd_valid
= false;
563 sch
->thinint_active
= false;
565 * Use a device number if provided. Otherwise, fall back to subchannel
569 num
= sscanf(dev
->bus_id
, "%x.%x.%04x", &cssid
, &ssid
, &devno
);
571 if ((cssid
> MAX_CSSID
) || (ssid
> MAX_SSID
)) {
573 error_report("Invalid cssid or ssid: cssid %x, ssid %x",
577 /* Enforce use of virtual cssid. */
578 if (cssid
!= VIRTUAL_CSSID
) {
580 error_report("cssid %x not valid for virtio devices", cssid
);
583 if (css_devno_used(cssid
, ssid
, devno
)) {
585 error_report("Device %x.%x.%04x already exists", cssid
, ssid
,
595 error_report("Malformed devno parameter '%s'", dev
->bus_id
);
600 /* Find the next free id. */
602 for (schid
= 0; schid
<= MAX_SCHID
; schid
++) {
603 if (!css_find_subch(1, cssid
, ssid
, schid
)) {
605 css_subch_assign(cssid
, ssid
, schid
, devno
, sch
);
612 error_report("No free subchannel found for %x.%x.%04x", cssid
, ssid
,
616 trace_virtio_ccw_new_device(cssid
, ssid
, schid
, devno
,
619 cssid
= VIRTUAL_CSSID
;
620 for (ssid
= 0; ssid
<= MAX_SSID
; ssid
++) {
621 for (schid
= 0; schid
<= MAX_SCHID
; schid
++) {
622 if (!css_find_subch(1, cssid
, ssid
, schid
)) {
628 * If the devno is already taken, look further in this
631 while (css_devno_used(cssid
, ssid
, devno
)) {
632 if (devno
== MAX_SCHID
) {
634 } else if (devno
== schid
- 1) {
636 error_report("No free devno found");
643 css_subch_assign(cssid
, ssid
, schid
, devno
, sch
);
654 error_report("Virtual channel subsystem is full!");
657 trace_virtio_ccw_new_device(cssid
, ssid
, schid
, devno
,
661 /* Build initial schib. */
662 css_sch_build_virtual_schib(sch
, 0, VIRTIO_CCW_CHPID_TYPE
);
664 sch
->ccw_cb
= virtio_ccw_cb
;
666 /* Build senseid data. */
667 memset(&sch
->id
, 0, sizeof(SenseId
));
668 sch
->id
.reserved
= 0xff;
669 sch
->id
.cu_type
= VIRTIO_CCW_CU_TYPE
;
670 sch
->id
.cu_model
= vdev
->device_id
;
672 /* Only the first 32 feature bits are used. */
673 dev
->host_features
[0] = virtio_bus_get_vdev_features(&dev
->bus
,
674 dev
->host_features
[0]);
676 dev
->host_features
[0] |= 0x1 << VIRTIO_F_NOTIFY_ON_EMPTY
;
677 dev
->host_features
[0] |= 0x1 << VIRTIO_F_BAD_FEATURE
;
679 css_generate_sch_crws(sch
->cssid
, sch
->ssid
, sch
->schid
,
680 parent
->hotplugged
, 1);
689 static int virtio_ccw_exit(VirtioCcwDevice
*dev
)
691 SubchDev
*sch
= dev
->sch
;
694 css_subch_assign(sch
->cssid
, sch
->ssid
, sch
->schid
, sch
->devno
, NULL
);
701 static int virtio_ccw_net_init(VirtioCcwDevice
*ccw_dev
)
703 DeviceState
*qdev
= DEVICE(ccw_dev
);
704 VirtIONetCcw
*dev
= VIRTIO_NET_CCW(ccw_dev
);
705 DeviceState
*vdev
= DEVICE(&dev
->vdev
);
707 virtio_net_set_config_size(&dev
->vdev
, ccw_dev
->host_features
[0]);
708 virtio_net_set_netclient_name(&dev
->vdev
, qdev
->id
,
709 object_get_typename(OBJECT(qdev
)));
710 qdev_set_parent_bus(vdev
, BUS(&ccw_dev
->bus
));
711 if (qdev_init(vdev
) < 0) {
715 return virtio_ccw_device_init(ccw_dev
, VIRTIO_DEVICE(vdev
));
718 static void virtio_ccw_net_instance_init(Object
*obj
)
720 VirtIONetCcw
*dev
= VIRTIO_NET_CCW(obj
);
721 object_initialize(&dev
->vdev
, sizeof(dev
->vdev
), TYPE_VIRTIO_NET
);
722 object_property_add_child(obj
, "virtio-backend", OBJECT(&dev
->vdev
), NULL
);
725 static int virtio_ccw_blk_init(VirtioCcwDevice
*ccw_dev
)
727 VirtIOBlkCcw
*dev
= VIRTIO_BLK_CCW(ccw_dev
);
728 DeviceState
*vdev
= DEVICE(&dev
->vdev
);
729 virtio_blk_set_conf(vdev
, &(dev
->blk
));
730 qdev_set_parent_bus(vdev
, BUS(&ccw_dev
->bus
));
731 if (qdev_init(vdev
) < 0) {
735 return virtio_ccw_device_init(ccw_dev
, VIRTIO_DEVICE(vdev
));
738 static void virtio_ccw_blk_instance_init(Object
*obj
)
740 VirtIOBlkCcw
*dev
= VIRTIO_BLK_CCW(obj
);
741 object_initialize(&dev
->vdev
, sizeof(dev
->vdev
), TYPE_VIRTIO_BLK
);
742 object_property_add_child(obj
, "virtio-backend", OBJECT(&dev
->vdev
), NULL
);
745 static int virtio_ccw_serial_init(VirtioCcwDevice
*ccw_dev
)
747 VirtioSerialCcw
*dev
= VIRTIO_SERIAL_CCW(ccw_dev
);
748 DeviceState
*vdev
= DEVICE(&dev
->vdev
);
749 DeviceState
*proxy
= DEVICE(ccw_dev
);
753 * For command line compatibility, this sets the virtio-serial-device bus
757 bus_name
= g_strdup_printf("%s.0", proxy
->id
);
758 virtio_device_set_child_bus_name(VIRTIO_DEVICE(vdev
), bus_name
);
762 qdev_set_parent_bus(vdev
, BUS(&ccw_dev
->bus
));
763 if (qdev_init(vdev
) < 0) {
767 return virtio_ccw_device_init(ccw_dev
, VIRTIO_DEVICE(vdev
));
771 static void virtio_ccw_serial_instance_init(Object
*obj
)
773 VirtioSerialCcw
*dev
= VIRTIO_SERIAL_CCW(obj
);
774 object_initialize(&dev
->vdev
, sizeof(dev
->vdev
), TYPE_VIRTIO_SERIAL
);
775 object_property_add_child(obj
, "virtio-backend", OBJECT(&dev
->vdev
), NULL
);
778 static int virtio_ccw_balloon_init(VirtioCcwDevice
*ccw_dev
)
780 VirtIOBalloonCcw
*dev
= VIRTIO_BALLOON_CCW(ccw_dev
);
781 DeviceState
*vdev
= DEVICE(&dev
->vdev
);
783 qdev_set_parent_bus(vdev
, BUS(&ccw_dev
->bus
));
784 if (qdev_init(vdev
) < 0) {
788 return virtio_ccw_device_init(ccw_dev
, VIRTIO_DEVICE(vdev
));
791 static void balloon_ccw_stats_get_all(Object
*obj
, struct Visitor
*v
,
792 void *opaque
, const char *name
,
795 VirtIOBalloonCcw
*dev
= opaque
;
796 object_property_get(OBJECT(&dev
->vdev
), v
, "guest-stats", errp
);
799 static void balloon_ccw_stats_get_poll_interval(Object
*obj
, struct Visitor
*v
,
800 void *opaque
, const char *name
,
803 VirtIOBalloonCcw
*dev
= opaque
;
804 object_property_get(OBJECT(&dev
->vdev
), v
, "guest-stats-polling-interval",
808 static void balloon_ccw_stats_set_poll_interval(Object
*obj
, struct Visitor
*v
,
809 void *opaque
, const char *name
,
812 VirtIOBalloonCcw
*dev
= opaque
;
813 object_property_set(OBJECT(&dev
->vdev
), v
, "guest-stats-polling-interval",
817 static void virtio_ccw_balloon_instance_init(Object
*obj
)
819 VirtIOBalloonCcw
*dev
= VIRTIO_BALLOON_CCW(obj
);
820 object_initialize(&dev
->vdev
, sizeof(dev
->vdev
), TYPE_VIRTIO_BALLOON
);
821 object_property_add_child(obj
, "virtio-backend", OBJECT(&dev
->vdev
), NULL
);
823 object_property_add(obj
, "guest-stats", "guest statistics",
824 balloon_ccw_stats_get_all
, NULL
, NULL
, dev
, NULL
);
826 object_property_add(obj
, "guest-stats-polling-interval", "int",
827 balloon_ccw_stats_get_poll_interval
,
828 balloon_ccw_stats_set_poll_interval
,
832 static int virtio_ccw_scsi_init(VirtioCcwDevice
*ccw_dev
)
834 VirtIOSCSICcw
*dev
= VIRTIO_SCSI_CCW(ccw_dev
);
835 DeviceState
*vdev
= DEVICE(&dev
->vdev
);
836 DeviceState
*qdev
= DEVICE(ccw_dev
);
840 * For command line compatibility, this sets the virtio-scsi-device bus
844 bus_name
= g_strdup_printf("%s.0", qdev
->id
);
845 virtio_device_set_child_bus_name(VIRTIO_DEVICE(vdev
), bus_name
);
849 qdev_set_parent_bus(vdev
, BUS(&ccw_dev
->bus
));
850 if (qdev_init(vdev
) < 0) {
854 return virtio_ccw_device_init(ccw_dev
, VIRTIO_DEVICE(vdev
));
857 static void virtio_ccw_scsi_instance_init(Object
*obj
)
859 VirtIOSCSICcw
*dev
= VIRTIO_SCSI_CCW(obj
);
860 object_initialize(&dev
->vdev
, sizeof(dev
->vdev
), TYPE_VIRTIO_SCSI
);
861 object_property_add_child(obj
, "virtio-backend", OBJECT(&dev
->vdev
), NULL
);
864 #ifdef CONFIG_VHOST_SCSI
865 static int vhost_ccw_scsi_init(VirtioCcwDevice
*ccw_dev
)
867 VHostSCSICcw
*dev
= VHOST_SCSI_CCW(ccw_dev
);
868 DeviceState
*vdev
= DEVICE(&dev
->vdev
);
870 qdev_set_parent_bus(vdev
, BUS(&ccw_dev
->bus
));
871 if (qdev_init(vdev
) < 0) {
875 return virtio_ccw_device_init(ccw_dev
, VIRTIO_DEVICE(vdev
));
878 static void vhost_ccw_scsi_instance_init(Object
*obj
)
880 VHostSCSICcw
*dev
= VHOST_SCSI_CCW(obj
);
881 object_initialize(&dev
->vdev
, sizeof(dev
->vdev
), TYPE_VHOST_SCSI
);
882 object_property_add_child(obj
, "virtio-backend", OBJECT(&dev
->vdev
), NULL
);
886 static int virtio_ccw_rng_init(VirtioCcwDevice
*ccw_dev
)
888 VirtIORNGCcw
*dev
= VIRTIO_RNG_CCW(ccw_dev
);
889 DeviceState
*vdev
= DEVICE(&dev
->vdev
);
891 qdev_set_parent_bus(vdev
, BUS(&ccw_dev
->bus
));
892 if (qdev_init(vdev
) < 0) {
896 object_property_set_link(OBJECT(dev
),
897 OBJECT(dev
->vdev
.conf
.rng
), "rng",
900 return virtio_ccw_device_init(ccw_dev
, VIRTIO_DEVICE(vdev
));
903 /* DeviceState to VirtioCcwDevice. Note: used on datapath,
904 * be careful and test performance if you change this.
906 static inline VirtioCcwDevice
*to_virtio_ccw_dev_fast(DeviceState
*d
)
908 return container_of(d
, VirtioCcwDevice
, parent_obj
);
911 static uint8_t virtio_set_ind_atomic(SubchDev
*sch
, uint64_t ind_loc
,
914 uint8_t ind_old
, ind_new
;
918 ind_addr
= cpu_physical_memory_map(ind_loc
, &len
, 1);
920 error_report("%s(%x.%x.%04x): unable to access indicator",
921 __func__
, sch
->cssid
, sch
->ssid
, sch
->schid
);
926 ind_new
= ind_old
| to_be_set
;
927 } while (atomic_cmpxchg(ind_addr
, ind_old
, ind_new
) != ind_old
);
928 cpu_physical_memory_unmap(ind_addr
, len
, 1, len
);
933 static void virtio_ccw_notify(DeviceState
*d
, uint16_t vector
)
935 VirtioCcwDevice
*dev
= to_virtio_ccw_dev_fast(d
);
936 SubchDev
*sch
= dev
->sch
;
943 if (vector
< VIRTIO_PCI_QUEUE_MAX
) {
944 if (!dev
->indicators
) {
947 if (sch
->thinint_active
) {
949 * In the adapter interrupt case, indicators points to a
950 * memory area that may be (way) larger than 64 bit and
951 * ind_bit indicates the start of the indicators in a big
954 virtio_set_ind_atomic(sch
, dev
->indicators
+
955 (dev
->ind_bit
+ vector
) / 8,
956 0x80 >> ((dev
->ind_bit
+ vector
) % 8));
957 if (!virtio_set_ind_atomic(sch
, dev
->summary_indicator
,
959 css_adapter_interrupt(dev
->thinint_isc
);
962 indicators
= ldq_phys(&address_space_memory
, dev
->indicators
);
963 indicators
|= 1ULL << vector
;
964 stq_phys(&address_space_memory
, dev
->indicators
, indicators
);
965 css_conditional_io_interrupt(sch
);
968 if (!dev
->indicators2
) {
972 indicators
= ldq_phys(&address_space_memory
, dev
->indicators2
);
973 indicators
|= 1ULL << vector
;
974 stq_phys(&address_space_memory
, dev
->indicators2
, indicators
);
975 css_conditional_io_interrupt(sch
);
979 static unsigned virtio_ccw_get_features(DeviceState
*d
)
981 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
983 /* Only the first 32 feature bits are used. */
984 return dev
->host_features
[0];
987 static void virtio_ccw_reset(DeviceState
*d
)
989 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
990 VirtIODevice
*vdev
= virtio_bus_get_device(&dev
->bus
);
992 virtio_ccw_stop_ioeventfd(dev
);
994 css_reset_sch(dev
->sch
);
996 dev
->indicators2
= 0;
997 dev
->summary_indicator
= 0;
1000 static void virtio_ccw_vmstate_change(DeviceState
*d
, bool running
)
1002 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
1005 virtio_ccw_start_ioeventfd(dev
);
1007 virtio_ccw_stop_ioeventfd(dev
);
1011 static bool virtio_ccw_query_guest_notifiers(DeviceState
*d
)
1013 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
1015 return !!(dev
->sch
->curr_status
.pmcw
.flags
& PMCW_FLAGS_MASK_ENA
);
1018 static int virtio_ccw_set_host_notifier(DeviceState
*d
, int n
, bool assign
)
1020 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
1022 /* Stop using the generic ioeventfd, we are doing eventfd handling
1023 * ourselves below */
1024 dev
->ioeventfd_disabled
= assign
;
1026 virtio_ccw_stop_ioeventfd(dev
);
1028 return virtio_ccw_set_guest2host_notifier(dev
, n
, assign
, false);
1031 static int virtio_ccw_set_guest_notifier(VirtioCcwDevice
*dev
, int n
,
1032 bool assign
, bool with_irqfd
)
1034 VirtIODevice
*vdev
= virtio_bus_get_device(&dev
->bus
);
1035 VirtQueue
*vq
= virtio_get_queue(vdev
, n
);
1036 EventNotifier
*notifier
= virtio_queue_get_guest_notifier(vq
);
1037 VirtioDeviceClass
*k
= VIRTIO_DEVICE_GET_CLASS(vdev
);
1040 int r
= event_notifier_init(notifier
, 0);
1045 virtio_queue_set_guest_notifier_fd_handler(vq
, true, with_irqfd
);
1046 /* We do not support irqfd for classic I/O interrupts, because the
1047 * classic interrupts are intermixed with the subchannel status, that
1048 * is queried with test subchannel. We want to use vhost, though.
1049 * Lets make sure to have vhost running and wire up the irq fd to
1050 * land in qemu (and only the irq fd) in this code.
1052 if (k
->guest_notifier_mask
) {
1053 k
->guest_notifier_mask(vdev
, n
, false);
1055 /* get lost events and re-inject */
1056 if (k
->guest_notifier_pending
&&
1057 k
->guest_notifier_pending(vdev
, n
)) {
1058 event_notifier_set(notifier
);
1061 if (k
->guest_notifier_mask
) {
1062 k
->guest_notifier_mask(vdev
, n
, true);
1064 virtio_queue_set_guest_notifier_fd_handler(vq
, false, with_irqfd
);
1065 event_notifier_cleanup(notifier
);
1070 static int virtio_ccw_set_guest_notifiers(DeviceState
*d
, int nvqs
,
1073 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
1074 VirtIODevice
*vdev
= virtio_bus_get_device(&dev
->bus
);
1077 for (n
= 0; n
< nvqs
; n
++) {
1078 if (!virtio_queue_get_num(vdev
, n
)) {
1081 /* false -> true, as soon as irqfd works */
1082 r
= virtio_ccw_set_guest_notifier(dev
, n
, assigned
, false);
1091 virtio_ccw_set_guest_notifier(dev
, n
, !assigned
, false);
1096 /**************** Virtio-ccw Bus Device Descriptions *******************/
1098 static Property virtio_ccw_net_properties
[] = {
1099 DEFINE_PROP_STRING("devno", VirtioCcwDevice
, bus_id
),
1100 DEFINE_VIRTIO_NET_FEATURES(VirtioCcwDevice
, host_features
[0]),
1101 DEFINE_VIRTIO_NET_PROPERTIES(VirtIONetCcw
, vdev
.net_conf
),
1102 DEFINE_NIC_PROPERTIES(VirtIONetCcw
, vdev
.nic_conf
),
1103 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice
, flags
,
1104 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT
, true),
1105 DEFINE_PROP_END_OF_LIST(),
1108 static void virtio_ccw_net_class_init(ObjectClass
*klass
, void *data
)
1110 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1111 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_CLASS(klass
);
1113 k
->init
= virtio_ccw_net_init
;
1114 k
->exit
= virtio_ccw_exit
;
1115 dc
->reset
= virtio_ccw_reset
;
1116 dc
->props
= virtio_ccw_net_properties
;
1119 static const TypeInfo virtio_ccw_net
= {
1120 .name
= TYPE_VIRTIO_NET_CCW
,
1121 .parent
= TYPE_VIRTIO_CCW_DEVICE
,
1122 .instance_size
= sizeof(VirtIONetCcw
),
1123 .instance_init
= virtio_ccw_net_instance_init
,
1124 .class_init
= virtio_ccw_net_class_init
,
1127 static Property virtio_ccw_blk_properties
[] = {
1128 DEFINE_PROP_STRING("devno", VirtioCcwDevice
, bus_id
),
1129 DEFINE_VIRTIO_BLK_FEATURES(VirtioCcwDevice
, host_features
[0]),
1130 DEFINE_VIRTIO_BLK_PROPERTIES(VirtIOBlkCcw
, blk
),
1131 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice
, flags
,
1132 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT
, true),
1133 #ifdef CONFIG_VIRTIO_BLK_DATA_PLANE
1134 DEFINE_PROP_BIT("x-data-plane", VirtIOBlkCcw
, blk
.data_plane
, 0, false),
1136 DEFINE_PROP_END_OF_LIST(),
1139 static void virtio_ccw_blk_class_init(ObjectClass
*klass
, void *data
)
1141 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1142 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_CLASS(klass
);
1144 k
->init
= virtio_ccw_blk_init
;
1145 k
->exit
= virtio_ccw_exit
;
1146 dc
->reset
= virtio_ccw_reset
;
1147 dc
->props
= virtio_ccw_blk_properties
;
1150 static const TypeInfo virtio_ccw_blk
= {
1151 .name
= TYPE_VIRTIO_BLK_CCW
,
1152 .parent
= TYPE_VIRTIO_CCW_DEVICE
,
1153 .instance_size
= sizeof(VirtIOBlkCcw
),
1154 .instance_init
= virtio_ccw_blk_instance_init
,
1155 .class_init
= virtio_ccw_blk_class_init
,
1158 static Property virtio_ccw_serial_properties
[] = {
1159 DEFINE_PROP_STRING("devno", VirtioCcwDevice
, bus_id
),
1160 DEFINE_VIRTIO_SERIAL_PROPERTIES(VirtioSerialCcw
, vdev
.serial
),
1161 DEFINE_VIRTIO_COMMON_FEATURES(VirtioCcwDevice
, host_features
[0]),
1162 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice
, flags
,
1163 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT
, true),
1164 DEFINE_PROP_END_OF_LIST(),
1167 static void virtio_ccw_serial_class_init(ObjectClass
*klass
, void *data
)
1169 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1170 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_CLASS(klass
);
1172 k
->init
= virtio_ccw_serial_init
;
1173 k
->exit
= virtio_ccw_exit
;
1174 dc
->reset
= virtio_ccw_reset
;
1175 dc
->props
= virtio_ccw_serial_properties
;
1178 static const TypeInfo virtio_ccw_serial
= {
1179 .name
= TYPE_VIRTIO_SERIAL_CCW
,
1180 .parent
= TYPE_VIRTIO_CCW_DEVICE
,
1181 .instance_size
= sizeof(VirtioSerialCcw
),
1182 .instance_init
= virtio_ccw_serial_instance_init
,
1183 .class_init
= virtio_ccw_serial_class_init
,
1186 static Property virtio_ccw_balloon_properties
[] = {
1187 DEFINE_PROP_STRING("devno", VirtioCcwDevice
, bus_id
),
1188 DEFINE_VIRTIO_COMMON_FEATURES(VirtioCcwDevice
, host_features
[0]),
1189 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice
, flags
,
1190 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT
, true),
1191 DEFINE_PROP_END_OF_LIST(),
1194 static void virtio_ccw_balloon_class_init(ObjectClass
*klass
, void *data
)
1196 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1197 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_CLASS(klass
);
1199 k
->init
= virtio_ccw_balloon_init
;
1200 k
->exit
= virtio_ccw_exit
;
1201 dc
->reset
= virtio_ccw_reset
;
1202 dc
->props
= virtio_ccw_balloon_properties
;
1205 static const TypeInfo virtio_ccw_balloon
= {
1206 .name
= TYPE_VIRTIO_BALLOON_CCW
,
1207 .parent
= TYPE_VIRTIO_CCW_DEVICE
,
1208 .instance_size
= sizeof(VirtIOBalloonCcw
),
1209 .instance_init
= virtio_ccw_balloon_instance_init
,
1210 .class_init
= virtio_ccw_balloon_class_init
,
1213 static Property virtio_ccw_scsi_properties
[] = {
1214 DEFINE_PROP_STRING("devno", VirtioCcwDevice
, bus_id
),
1215 DEFINE_VIRTIO_SCSI_PROPERTIES(VirtIOSCSICcw
, vdev
.parent_obj
.conf
),
1216 DEFINE_VIRTIO_SCSI_FEATURES(VirtioCcwDevice
, host_features
[0]),
1217 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice
, flags
,
1218 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT
, true),
1219 DEFINE_PROP_END_OF_LIST(),
1222 static void virtio_ccw_scsi_class_init(ObjectClass
*klass
, void *data
)
1224 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1225 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_CLASS(klass
);
1227 k
->init
= virtio_ccw_scsi_init
;
1228 k
->exit
= virtio_ccw_exit
;
1229 dc
->reset
= virtio_ccw_reset
;
1230 dc
->props
= virtio_ccw_scsi_properties
;
1233 static const TypeInfo virtio_ccw_scsi
= {
1234 .name
= TYPE_VIRTIO_SCSI_CCW
,
1235 .parent
= TYPE_VIRTIO_CCW_DEVICE
,
1236 .instance_size
= sizeof(VirtIOSCSICcw
),
1237 .instance_init
= virtio_ccw_scsi_instance_init
,
1238 .class_init
= virtio_ccw_scsi_class_init
,
1241 #ifdef CONFIG_VHOST_SCSI
1242 static Property vhost_ccw_scsi_properties
[] = {
1243 DEFINE_PROP_STRING("devno", VirtioCcwDevice
, bus_id
),
1244 DEFINE_VHOST_SCSI_PROPERTIES(VirtIOSCSICcw
, vdev
.parent_obj
.conf
),
1245 DEFINE_VIRTIO_COMMON_FEATURES(VirtioCcwDevice
, host_features
[0]),
1246 DEFINE_PROP_END_OF_LIST(),
1249 static void vhost_ccw_scsi_class_init(ObjectClass
*klass
, void *data
)
1251 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1252 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_CLASS(klass
);
1254 k
->init
= vhost_ccw_scsi_init
;
1255 k
->exit
= virtio_ccw_exit
;
1256 dc
->reset
= virtio_ccw_reset
;
1257 dc
->props
= vhost_ccw_scsi_properties
;
1260 static const TypeInfo vhost_ccw_scsi
= {
1261 .name
= TYPE_VHOST_SCSI_CCW
,
1262 .parent
= TYPE_VIRTIO_CCW_DEVICE
,
1263 .instance_size
= sizeof(VirtIOSCSICcw
),
1264 .instance_init
= vhost_ccw_scsi_instance_init
,
1265 .class_init
= vhost_ccw_scsi_class_init
,
1269 static void virtio_ccw_rng_instance_init(Object
*obj
)
1271 VirtIORNGCcw
*dev
= VIRTIO_RNG_CCW(obj
);
1272 object_initialize(&dev
->vdev
, sizeof(dev
->vdev
), TYPE_VIRTIO_RNG
);
1273 object_property_add_child(obj
, "virtio-backend", OBJECT(&dev
->vdev
), NULL
);
1274 object_property_add_link(obj
, "rng", TYPE_RNG_BACKEND
,
1275 (Object
**)&dev
->vdev
.conf
.rng
,
1276 qdev_prop_allow_set_link_before_realize
,
1277 OBJ_PROP_LINK_UNREF_ON_RELEASE
, NULL
);
1280 static Property virtio_ccw_rng_properties
[] = {
1281 DEFINE_PROP_STRING("devno", VirtioCcwDevice
, bus_id
),
1282 DEFINE_VIRTIO_COMMON_FEATURES(VirtioCcwDevice
, host_features
[0]),
1283 DEFINE_VIRTIO_RNG_PROPERTIES(VirtIORNGCcw
, vdev
.conf
),
1284 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice
, flags
,
1285 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT
, true),
1286 DEFINE_PROP_END_OF_LIST(),
1289 static void virtio_ccw_rng_class_init(ObjectClass
*klass
, void *data
)
1291 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1292 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_CLASS(klass
);
1294 k
->init
= virtio_ccw_rng_init
;
1295 k
->exit
= virtio_ccw_exit
;
1296 dc
->reset
= virtio_ccw_reset
;
1297 dc
->props
= virtio_ccw_rng_properties
;
1300 static const TypeInfo virtio_ccw_rng
= {
1301 .name
= TYPE_VIRTIO_RNG_CCW
,
1302 .parent
= TYPE_VIRTIO_CCW_DEVICE
,
1303 .instance_size
= sizeof(VirtIORNGCcw
),
1304 .instance_init
= virtio_ccw_rng_instance_init
,
1305 .class_init
= virtio_ccw_rng_class_init
,
1308 static int virtio_ccw_busdev_init(DeviceState
*dev
)
1310 VirtioCcwDevice
*_dev
= (VirtioCcwDevice
*)dev
;
1311 VirtIOCCWDeviceClass
*_info
= VIRTIO_CCW_DEVICE_GET_CLASS(dev
);
1313 virtio_ccw_bus_new(&_dev
->bus
, sizeof(_dev
->bus
), _dev
);
1315 return _info
->init(_dev
);
1318 static int virtio_ccw_busdev_exit(DeviceState
*dev
)
1320 VirtioCcwDevice
*_dev
= (VirtioCcwDevice
*)dev
;
1321 VirtIOCCWDeviceClass
*_info
= VIRTIO_CCW_DEVICE_GET_CLASS(dev
);
1323 return _info
->exit(_dev
);
1326 static int virtio_ccw_busdev_unplug(DeviceState
*dev
)
1328 VirtioCcwDevice
*_dev
= (VirtioCcwDevice
*)dev
;
1329 SubchDev
*sch
= _dev
->sch
;
1331 virtio_ccw_stop_ioeventfd(_dev
);
1334 * We should arrive here only for device_del, since we don't support
1335 * direct hot(un)plug of channels, but only through virtio.
1337 assert(sch
!= NULL
);
1338 /* Subchannel is now disabled and no longer valid. */
1339 sch
->curr_status
.pmcw
.flags
&= ~(PMCW_FLAGS_MASK_ENA
|
1340 PMCW_FLAGS_MASK_DNV
);
1342 css_generate_sch_crws(sch
->cssid
, sch
->ssid
, sch
->schid
, 1, 0);
1344 object_unparent(OBJECT(dev
));
1348 static void virtio_ccw_device_class_init(ObjectClass
*klass
, void *data
)
1350 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1352 dc
->init
= virtio_ccw_busdev_init
;
1353 dc
->exit
= virtio_ccw_busdev_exit
;
1354 dc
->unplug
= virtio_ccw_busdev_unplug
;
1355 dc
->bus_type
= TYPE_VIRTUAL_CSS_BUS
;
1359 static const TypeInfo virtio_ccw_device_info
= {
1360 .name
= TYPE_VIRTIO_CCW_DEVICE
,
1361 .parent
= TYPE_DEVICE
,
1362 .instance_size
= sizeof(VirtioCcwDevice
),
1363 .class_init
= virtio_ccw_device_class_init
,
1364 .class_size
= sizeof(VirtIOCCWDeviceClass
),
1368 /***************** Virtual-css Bus Bridge Device ********************/
1369 /* Only required to have the virtio bus as child in the system bus */
1371 static int virtual_css_bridge_init(SysBusDevice
*dev
)
1377 static void virtual_css_bridge_class_init(ObjectClass
*klass
, void *data
)
1379 SysBusDeviceClass
*k
= SYS_BUS_DEVICE_CLASS(klass
);
1381 k
->init
= virtual_css_bridge_init
;
1384 static const TypeInfo virtual_css_bridge_info
= {
1385 .name
= "virtual-css-bridge",
1386 .parent
= TYPE_SYS_BUS_DEVICE
,
1387 .instance_size
= sizeof(SysBusDevice
),
1388 .class_init
= virtual_css_bridge_class_init
,
1391 /* virtio-ccw-bus */
1393 static void virtio_ccw_bus_new(VirtioBusState
*bus
, size_t bus_size
,
1394 VirtioCcwDevice
*dev
)
1396 DeviceState
*qdev
= DEVICE(dev
);
1398 char virtio_bus_name
[] = "virtio-bus";
1400 qbus_create_inplace(bus
, bus_size
, TYPE_VIRTIO_CCW_BUS
,
1401 qdev
, virtio_bus_name
);
1403 qbus
->allow_hotplug
= 1;
1406 static void virtio_ccw_bus_class_init(ObjectClass
*klass
, void *data
)
1408 VirtioBusClass
*k
= VIRTIO_BUS_CLASS(klass
);
1409 BusClass
*bus_class
= BUS_CLASS(klass
);
1411 bus_class
->max_dev
= 1;
1412 k
->notify
= virtio_ccw_notify
;
1413 k
->get_features
= virtio_ccw_get_features
;
1414 k
->vmstate_change
= virtio_ccw_vmstate_change
;
1415 k
->query_guest_notifiers
= virtio_ccw_query_guest_notifiers
;
1416 k
->set_host_notifier
= virtio_ccw_set_host_notifier
;
1417 k
->set_guest_notifiers
= virtio_ccw_set_guest_notifiers
;
1420 static const TypeInfo virtio_ccw_bus_info
= {
1421 .name
= TYPE_VIRTIO_CCW_BUS
,
1422 .parent
= TYPE_VIRTIO_BUS
,
1423 .instance_size
= sizeof(VirtioCcwBusState
),
1424 .class_init
= virtio_ccw_bus_class_init
,
1427 static void virtio_ccw_register(void)
1429 type_register_static(&virtio_ccw_bus_info
);
1430 type_register_static(&virtual_css_bus_info
);
1431 type_register_static(&virtio_ccw_device_info
);
1432 type_register_static(&virtio_ccw_serial
);
1433 type_register_static(&virtio_ccw_blk
);
1434 type_register_static(&virtio_ccw_net
);
1435 type_register_static(&virtio_ccw_balloon
);
1436 type_register_static(&virtio_ccw_scsi
);
1437 #ifdef CONFIG_VHOST_SCSI
1438 type_register_static(&vhost_ccw_scsi
);
1440 type_register_static(&virtio_ccw_rng
);
1441 type_register_static(&virtual_css_bridge_info
);
1444 type_init(virtio_ccw_register
)