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
, VirtioCcwDevice
*dev
);
32 static int virtual_css_bus_reset(BusState
*qbus
)
34 /* This should actually be modelled via the generic css */
37 /* we dont traverse ourself, return 0 */
42 static void virtual_css_bus_class_init(ObjectClass
*klass
, void *data
)
44 BusClass
*k
= BUS_CLASS(klass
);
46 k
->reset
= virtual_css_bus_reset
;
49 static const TypeInfo virtual_css_bus_info
= {
50 .name
= TYPE_VIRTUAL_CSS_BUS
,
52 .instance_size
= sizeof(VirtualCssBus
),
53 .class_init
= virtual_css_bus_class_init
,
56 VirtIODevice
*virtio_ccw_get_vdev(SubchDev
*sch
)
58 VirtIODevice
*vdev
= NULL
;
60 if (sch
->driver_data
) {
61 vdev
= ((VirtioCcwDevice
*)sch
->driver_data
)->vdev
;
66 VirtualCssBus
*virtual_css_bus_init(void)
72 /* Create bridge device */
73 dev
= qdev_create(NULL
, "virtual-css-bridge");
74 qdev_init_nofail(dev
);
76 /* Create bus on bridge device */
77 bus
= qbus_create(TYPE_VIRTUAL_CSS_BUS
, dev
, "virtual-css");
78 cbus
= VIRTUAL_CSS_BUS(bus
);
80 /* Enable hotplugging */
81 bus
->allow_hotplug
= 1;
86 /* Communication blocks used by several channel commands. */
87 typedef struct VqInfoBlock
{
92 } QEMU_PACKED VqInfoBlock
;
94 typedef struct VqConfigBlock
{
97 } QEMU_PACKED VqConfigBlock
;
99 typedef struct VirtioFeatDesc
{
102 } QEMU_PACKED VirtioFeatDesc
;
104 /* Specify where the virtqueues for the subchannel are in guest memory. */
105 static int virtio_ccw_set_vqs(SubchDev
*sch
, uint64_t addr
, uint32_t align
,
106 uint16_t index
, uint16_t num
)
108 VirtioCcwDevice
*dev
= sch
->driver_data
;
110 if (index
> VIRTIO_PCI_QUEUE_MAX
) {
114 /* Current code in virtio.c relies on 4K alignment. */
115 if (addr
&& (align
!= 4096)) {
123 virtio_queue_set_addr(dev
->vdev
, index
, addr
);
125 virtio_queue_set_vector(dev
->vdev
, index
, 0);
127 /* Fail if we don't have a big enough queue. */
128 /* TODO: Add interface to handle vring.num changing */
129 if (virtio_queue_get_num(dev
->vdev
, index
) > num
) {
132 virtio_queue_set_vector(dev
->vdev
, index
, index
);
134 /* tell notify handler in case of config change */
135 dev
->vdev
->config_vector
= VIRTIO_PCI_QUEUE_MAX
;
139 static int virtio_ccw_cb(SubchDev
*sch
, CCW1 ccw
)
144 VirtioFeatDesc features
;
147 VqConfigBlock vq_config
;
148 VirtioCcwDevice
*dev
= sch
->driver_data
;
157 trace_virtio_ccw_interpret_ccw(sch
->cssid
, sch
->ssid
, sch
->schid
,
159 check_len
= !((ccw
.flags
& CCW_FLAG_SLI
) && !(ccw
.flags
& CCW_FLAG_DC
));
161 /* Look at the command. */
162 switch (ccw
.cmd_code
) {
165 if (ccw
.count
!= sizeof(info
)) {
169 } else if (ccw
.count
< sizeof(info
)) {
170 /* Can't execute command. */
177 info
.queue
= ldq_phys(ccw
.cda
);
178 info
.align
= ldl_phys(ccw
.cda
+ sizeof(info
.queue
));
179 info
.index
= lduw_phys(ccw
.cda
+ sizeof(info
.queue
)
180 + sizeof(info
.align
));
181 info
.num
= lduw_phys(ccw
.cda
+ sizeof(info
.queue
)
183 + sizeof(info
.index
));
184 ret
= virtio_ccw_set_vqs(sch
, info
.queue
, info
.align
, info
.index
,
186 sch
->curr_status
.scsw
.count
= 0;
189 case CCW_CMD_VDEV_RESET
:
190 virtio_reset(dev
->vdev
);
193 case CCW_CMD_READ_FEAT
:
195 if (ccw
.count
!= sizeof(features
)) {
199 } else if (ccw
.count
< sizeof(features
)) {
200 /* Can't execute command. */
207 features
.index
= ldub_phys(ccw
.cda
+ sizeof(features
.features
));
208 if (features
.index
< ARRAY_SIZE(dev
->host_features
)) {
209 features
.features
= dev
->host_features
[features
.index
];
211 /* Return zeroes if the guest supports more feature bits. */
212 features
.features
= 0;
214 stl_le_phys(ccw
.cda
, features
.features
);
215 sch
->curr_status
.scsw
.count
= ccw
.count
- sizeof(features
);
219 case CCW_CMD_WRITE_FEAT
:
221 if (ccw
.count
!= sizeof(features
)) {
225 } else if (ccw
.count
< sizeof(features
)) {
226 /* Can't execute command. */
233 features
.index
= ldub_phys(ccw
.cda
+ sizeof(features
.features
));
234 features
.features
= ldl_le_phys(ccw
.cda
);
235 if (features
.index
< ARRAY_SIZE(dev
->host_features
)) {
236 virtio_bus_set_vdev_features(&dev
->bus
, features
.features
);
237 dev
->vdev
->guest_features
= features
.features
;
240 * If the guest supports more feature bits, assert that it
241 * passes us zeroes for those we don't support.
243 if (features
.features
) {
244 fprintf(stderr
, "Guest bug: features[%i]=%x (expected 0)\n",
245 features
.index
, features
.features
);
246 /* XXX: do a unit check here? */
249 sch
->curr_status
.scsw
.count
= ccw
.count
- sizeof(features
);
253 case CCW_CMD_READ_CONF
:
255 if (ccw
.count
> dev
->vdev
->config_len
) {
260 len
= MIN(ccw
.count
, dev
->vdev
->config_len
);
264 virtio_bus_get_vdev_config(&dev
->bus
, dev
->vdev
->config
);
265 /* XXX config space endianness */
266 cpu_physical_memory_write(ccw
.cda
, dev
->vdev
->config
, len
);
267 sch
->curr_status
.scsw
.count
= ccw
.count
- len
;
271 case CCW_CMD_WRITE_CONF
:
273 if (ccw
.count
> dev
->vdev
->config_len
) {
278 len
= MIN(ccw
.count
, dev
->vdev
->config_len
);
283 config
= cpu_physical_memory_map(ccw
.cda
, &hw_len
, 0);
288 /* XXX config space endianness */
289 memcpy(dev
->vdev
->config
, config
, len
);
290 cpu_physical_memory_unmap(config
, hw_len
, 0, hw_len
);
291 virtio_bus_set_vdev_config(&dev
->bus
, dev
->vdev
->config
);
292 sch
->curr_status
.scsw
.count
= ccw
.count
- len
;
297 case CCW_CMD_WRITE_STATUS
:
299 if (ccw
.count
!= sizeof(status
)) {
303 } else if (ccw
.count
< sizeof(status
)) {
304 /* Can't execute command. */
311 status
= ldub_phys(ccw
.cda
);
312 virtio_set_status(dev
->vdev
, status
);
313 if (dev
->vdev
->status
== 0) {
314 virtio_reset(dev
->vdev
);
316 sch
->curr_status
.scsw
.count
= ccw
.count
- sizeof(status
);
320 case CCW_CMD_SET_IND
:
322 if (ccw
.count
!= sizeof(indicators
)) {
326 } else if (ccw
.count
< sizeof(indicators
)) {
327 /* Can't execute command. */
331 indicators
= ldq_phys(ccw
.cda
);
335 dev
->indicators
= indicators
;
336 sch
->curr_status
.scsw
.count
= ccw
.count
- sizeof(indicators
);
340 case CCW_CMD_SET_CONF_IND
:
342 if (ccw
.count
!= sizeof(indicators
)) {
346 } else if (ccw
.count
< sizeof(indicators
)) {
347 /* Can't execute command. */
351 indicators
= ldq_phys(ccw
.cda
);
355 dev
->indicators2
= indicators
;
356 sch
->curr_status
.scsw
.count
= ccw
.count
- sizeof(indicators
);
360 case CCW_CMD_READ_VQ_CONF
:
362 if (ccw
.count
!= sizeof(vq_config
)) {
366 } else if (ccw
.count
< sizeof(vq_config
)) {
367 /* Can't execute command. */
374 vq_config
.index
= lduw_phys(ccw
.cda
);
375 vq_config
.num_max
= virtio_queue_get_num(dev
->vdev
,
377 stw_phys(ccw
.cda
+ sizeof(vq_config
.index
), vq_config
.num_max
);
378 sch
->curr_status
.scsw
.count
= ccw
.count
- sizeof(vq_config
);
389 static int virtio_ccw_device_init(VirtioCcwDevice
*dev
, VirtIODevice
*vdev
)
391 unsigned int cssid
= 0;
392 unsigned int ssid
= 0;
395 bool have_devno
= false;
400 DeviceState
*parent
= DEVICE(dev
);
402 sch
= g_malloc0(sizeof(SubchDev
));
404 sch
->driver_data
= dev
;
410 /* Initialize subchannel structure. */
411 sch
->channel_prog
= 0x0;
412 sch
->last_cmd_valid
= false;
415 * Use a device number if provided. Otherwise, fall back to subchannel
419 num
= sscanf(dev
->bus_id
, "%x.%x.%04x", &cssid
, &ssid
, &devno
);
421 if ((cssid
> MAX_CSSID
) || (ssid
> MAX_SSID
)) {
423 error_report("Invalid cssid or ssid: cssid %x, ssid %x",
427 /* Enforce use of virtual cssid. */
428 if (cssid
!= VIRTUAL_CSSID
) {
430 error_report("cssid %x not valid for virtio devices", cssid
);
433 if (css_devno_used(cssid
, ssid
, devno
)) {
435 error_report("Device %x.%x.%04x already exists", cssid
, ssid
,
445 error_report("Malformed devno parameter '%s'", dev
->bus_id
);
450 /* Find the next free id. */
452 for (schid
= 0; schid
<= MAX_SCHID
; schid
++) {
453 if (!css_find_subch(1, cssid
, ssid
, schid
)) {
455 css_subch_assign(cssid
, ssid
, schid
, devno
, sch
);
462 error_report("No free subchannel found for %x.%x.%04x", cssid
, ssid
,
466 trace_virtio_ccw_new_device(cssid
, ssid
, schid
, devno
,
469 cssid
= VIRTUAL_CSSID
;
470 for (ssid
= 0; ssid
<= MAX_SSID
; ssid
++) {
471 for (schid
= 0; schid
<= MAX_SCHID
; schid
++) {
472 if (!css_find_subch(1, cssid
, ssid
, schid
)) {
478 * If the devno is already taken, look further in this
481 while (css_devno_used(cssid
, ssid
, devno
)) {
482 if (devno
== MAX_SCHID
) {
484 } else if (devno
== schid
- 1) {
486 error_report("No free devno found");
493 css_subch_assign(cssid
, ssid
, schid
, devno
, sch
);
504 error_report("Virtual channel subsystem is full!");
507 trace_virtio_ccw_new_device(cssid
, ssid
, schid
, devno
,
511 /* Build initial schib. */
512 css_sch_build_virtual_schib(sch
, 0, VIRTIO_CCW_CHPID_TYPE
);
514 sch
->ccw_cb
= virtio_ccw_cb
;
516 /* Build senseid data. */
517 memset(&sch
->id
, 0, sizeof(SenseId
));
518 sch
->id
.reserved
= 0xff;
519 sch
->id
.cu_type
= VIRTIO_CCW_CU_TYPE
;
520 sch
->id
.cu_model
= dev
->vdev
->device_id
;
522 /* Only the first 32 feature bits are used. */
523 dev
->host_features
[0] = virtio_bus_get_vdev_features(&dev
->bus
,
524 dev
->host_features
[0]);
526 dev
->host_features
[0] |= 0x1 << VIRTIO_F_NOTIFY_ON_EMPTY
;
527 dev
->host_features
[0] |= 0x1 << VIRTIO_F_BAD_FEATURE
;
529 css_generate_sch_crws(sch
->cssid
, sch
->ssid
, sch
->schid
,
530 parent
->hotplugged
, 1);
539 static int virtio_ccw_exit(VirtioCcwDevice
*dev
)
541 SubchDev
*sch
= dev
->sch
;
544 css_subch_assign(sch
->cssid
, sch
->ssid
, sch
->schid
, sch
->devno
, NULL
);
551 static int virtio_ccw_net_init(VirtioCcwDevice
*ccw_dev
)
553 VirtIONetCcw
*dev
= VIRTIO_NET_CCW(ccw_dev
);
554 DeviceState
*vdev
= DEVICE(&dev
->vdev
);
556 virtio_net_set_config_size(&dev
->vdev
, ccw_dev
->host_features
[0]);
557 qdev_set_parent_bus(vdev
, BUS(&ccw_dev
->bus
));
558 if (qdev_init(vdev
) < 0) {
562 return virtio_ccw_device_init(ccw_dev
, VIRTIO_DEVICE(vdev
));
565 static void virtio_ccw_net_instance_init(Object
*obj
)
567 VirtIONetCcw
*dev
= VIRTIO_NET_CCW(obj
);
568 object_initialize(OBJECT(&dev
->vdev
), TYPE_VIRTIO_NET
);
569 object_property_add_child(obj
, "virtio-backend", OBJECT(&dev
->vdev
), NULL
);
572 static int virtio_ccw_blk_init(VirtioCcwDevice
*ccw_dev
)
574 VirtIOBlkCcw
*dev
= VIRTIO_BLK_CCW(ccw_dev
);
575 DeviceState
*vdev
= DEVICE(&dev
->vdev
);
576 virtio_blk_set_conf(vdev
, &(dev
->blk
));
577 qdev_set_parent_bus(vdev
, BUS(&ccw_dev
->bus
));
578 if (qdev_init(vdev
) < 0) {
582 return virtio_ccw_device_init(ccw_dev
, VIRTIO_DEVICE(vdev
));
585 static void virtio_ccw_blk_instance_init(Object
*obj
)
587 VirtIOBlkCcw
*dev
= VIRTIO_BLK_CCW(obj
);
588 object_initialize(OBJECT(&dev
->vdev
), TYPE_VIRTIO_BLK
);
589 object_property_add_child(obj
, "virtio-backend", OBJECT(&dev
->vdev
), NULL
);
592 static int virtio_ccw_serial_init(VirtioCcwDevice
*ccw_dev
)
594 VirtioSerialCcw
*dev
= VIRTIO_SERIAL_CCW(ccw_dev
);
595 DeviceState
*vdev
= DEVICE(&dev
->vdev
);
596 DeviceState
*proxy
= DEVICE(ccw_dev
);
600 * For command line compatibility, this sets the virtio-serial-device bus
604 bus_name
= g_strdup_printf("%s.0", proxy
->id
);
605 virtio_device_set_child_bus_name(VIRTIO_DEVICE(vdev
), bus_name
);
609 qdev_set_parent_bus(vdev
, BUS(&ccw_dev
->bus
));
610 if (qdev_init(vdev
) < 0) {
614 return virtio_ccw_device_init(ccw_dev
, VIRTIO_DEVICE(vdev
));
618 static void virtio_ccw_serial_instance_init(Object
*obj
)
620 VirtioSerialCcw
*dev
= VIRTIO_SERIAL_CCW(obj
);
621 object_initialize(OBJECT(&dev
->vdev
), TYPE_VIRTIO_SERIAL
);
622 object_property_add_child(obj
, "virtio-backend", OBJECT(&dev
->vdev
), NULL
);
625 static int virtio_ccw_balloon_init(VirtioCcwDevice
*ccw_dev
)
627 VirtIOBalloonCcw
*dev
= VIRTIO_BALLOON_CCW(ccw_dev
);
628 DeviceState
*vdev
= DEVICE(&dev
->vdev
);
630 qdev_set_parent_bus(vdev
, BUS(&ccw_dev
->bus
));
631 if (qdev_init(vdev
) < 0) {
635 return virtio_ccw_device_init(ccw_dev
, VIRTIO_DEVICE(vdev
));
638 static void balloon_ccw_stats_get_all(Object
*obj
, struct Visitor
*v
,
639 void *opaque
, const char *name
,
642 VirtIOBalloonCcw
*dev
= opaque
;
643 object_property_get(OBJECT(&dev
->vdev
), v
, "guest-stats", errp
);
646 static void balloon_ccw_stats_get_poll_interval(Object
*obj
, struct Visitor
*v
,
647 void *opaque
, const char *name
,
650 VirtIOBalloonCcw
*dev
= opaque
;
651 object_property_get(OBJECT(&dev
->vdev
), v
, "guest-stats-polling-interval",
655 static void balloon_ccw_stats_set_poll_interval(Object
*obj
, struct Visitor
*v
,
656 void *opaque
, const char *name
,
659 VirtIOBalloonCcw
*dev
= opaque
;
660 object_property_set(OBJECT(&dev
->vdev
), v
, "guest-stats-polling-interval",
664 static void virtio_ccw_balloon_instance_init(Object
*obj
)
666 VirtIOBalloonCcw
*dev
= VIRTIO_BALLOON_CCW(obj
);
667 object_initialize(OBJECT(&dev
->vdev
), TYPE_VIRTIO_BALLOON
);
668 object_property_add_child(obj
, "virtio-backend", OBJECT(&dev
->vdev
), NULL
);
670 object_property_add(obj
, "guest-stats", "guest statistics",
671 balloon_ccw_stats_get_all
, NULL
, NULL
, dev
, NULL
);
673 object_property_add(obj
, "guest-stats-polling-interval", "int",
674 balloon_ccw_stats_get_poll_interval
,
675 balloon_ccw_stats_set_poll_interval
,
679 static int virtio_ccw_scsi_init(VirtioCcwDevice
*ccw_dev
)
681 VirtIOSCSICcw
*dev
= VIRTIO_SCSI_CCW(ccw_dev
);
682 DeviceState
*vdev
= DEVICE(&dev
->vdev
);
684 qdev_set_parent_bus(vdev
, BUS(&ccw_dev
->bus
));
685 if (qdev_init(vdev
) < 0) {
689 return virtio_ccw_device_init(ccw_dev
, VIRTIO_DEVICE(vdev
));
692 static void virtio_ccw_scsi_instance_init(Object
*obj
)
694 VirtIOSCSICcw
*dev
= VIRTIO_SCSI_CCW(obj
);
695 object_initialize(OBJECT(&dev
->vdev
), TYPE_VIRTIO_SCSI
);
696 object_property_add_child(obj
, "virtio-backend", OBJECT(&dev
->vdev
), NULL
);
699 #ifdef CONFIG_VHOST_SCSI
700 static int vhost_ccw_scsi_init(VirtioCcwDevice
*ccw_dev
)
702 VHostSCSICcw
*dev
= VHOST_SCSI_CCW(ccw_dev
);
703 DeviceState
*vdev
= DEVICE(&dev
->vdev
);
705 qdev_set_parent_bus(vdev
, BUS(&ccw_dev
->bus
));
706 if (qdev_init(vdev
) < 0) {
710 return virtio_ccw_device_init(ccw_dev
, VIRTIO_DEVICE(vdev
));
713 static void vhost_ccw_scsi_instance_init(Object
*obj
)
715 VHostSCSICcw
*dev
= VHOST_SCSI_CCW(obj
);
716 object_initialize(OBJECT(&dev
->vdev
), TYPE_VHOST_SCSI
);
717 object_property_add_child(obj
, "virtio-backend", OBJECT(&dev
->vdev
), NULL
);
721 static int virtio_ccw_rng_init(VirtioCcwDevice
*ccw_dev
)
723 VirtIORNGCcw
*dev
= VIRTIO_RNG_CCW(ccw_dev
);
724 DeviceState
*vdev
= DEVICE(&dev
->vdev
);
726 qdev_set_parent_bus(vdev
, BUS(&ccw_dev
->bus
));
727 if (qdev_init(vdev
) < 0) {
731 object_property_set_link(OBJECT(dev
),
732 OBJECT(dev
->vdev
.conf
.default_backend
), "rng",
735 return virtio_ccw_device_init(ccw_dev
, VIRTIO_DEVICE(vdev
));
738 /* DeviceState to VirtioCcwDevice. Note: used on datapath,
739 * be careful and test performance if you change this.
741 static inline VirtioCcwDevice
*to_virtio_ccw_dev_fast(DeviceState
*d
)
743 return container_of(d
, VirtioCcwDevice
, parent_obj
);
746 static void virtio_ccw_notify(DeviceState
*d
, uint16_t vector
)
748 VirtioCcwDevice
*dev
= to_virtio_ccw_dev_fast(d
);
749 SubchDev
*sch
= dev
->sch
;
756 if (vector
< VIRTIO_PCI_QUEUE_MAX
) {
757 if (!dev
->indicators
) {
760 indicators
= ldq_phys(dev
->indicators
);
761 indicators
|= 1ULL << vector
;
762 stq_phys(dev
->indicators
, indicators
);
764 if (!dev
->indicators2
) {
768 indicators
= ldq_phys(dev
->indicators2
);
769 indicators
|= 1ULL << vector
;
770 stq_phys(dev
->indicators2
, indicators
);
773 css_conditional_io_interrupt(sch
);
777 static unsigned virtio_ccw_get_features(DeviceState
*d
)
779 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
781 /* Only the first 32 feature bits are used. */
782 return dev
->host_features
[0];
785 static void virtio_ccw_reset(DeviceState
*d
)
787 VirtioCcwDevice
*dev
= VIRTIO_CCW_DEVICE(d
);
789 virtio_reset(dev
->vdev
);
790 css_reset_sch(dev
->sch
);
793 /**************** Virtio-ccw Bus Device Descriptions *******************/
795 static Property virtio_ccw_net_properties
[] = {
796 DEFINE_PROP_STRING("devno", VirtioCcwDevice
, bus_id
),
797 DEFINE_VIRTIO_NET_FEATURES(VirtioCcwDevice
, host_features
[0]),
798 DEFINE_VIRTIO_NET_PROPERTIES(VirtIONetCcw
, vdev
.net_conf
),
799 DEFINE_NIC_PROPERTIES(VirtIONetCcw
, vdev
.nic_conf
),
800 DEFINE_PROP_END_OF_LIST(),
803 static void virtio_ccw_net_class_init(ObjectClass
*klass
, void *data
)
805 DeviceClass
*dc
= DEVICE_CLASS(klass
);
806 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_CLASS(klass
);
808 k
->init
= virtio_ccw_net_init
;
809 k
->exit
= virtio_ccw_exit
;
810 dc
->reset
= virtio_ccw_reset
;
811 dc
->props
= virtio_ccw_net_properties
;
814 static const TypeInfo virtio_ccw_net
= {
815 .name
= TYPE_VIRTIO_NET_CCW
,
816 .parent
= TYPE_VIRTIO_CCW_DEVICE
,
817 .instance_size
= sizeof(VirtIONetCcw
),
818 .instance_init
= virtio_ccw_net_instance_init
,
819 .class_init
= virtio_ccw_net_class_init
,
822 static Property virtio_ccw_blk_properties
[] = {
823 DEFINE_PROP_STRING("devno", VirtioCcwDevice
, bus_id
),
824 DEFINE_VIRTIO_BLK_FEATURES(VirtioCcwDevice
, host_features
[0]),
825 DEFINE_VIRTIO_BLK_PROPERTIES(VirtIOBlkCcw
, blk
),
826 DEFINE_PROP_END_OF_LIST(),
829 static void virtio_ccw_blk_class_init(ObjectClass
*klass
, void *data
)
831 DeviceClass
*dc
= DEVICE_CLASS(klass
);
832 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_CLASS(klass
);
834 k
->init
= virtio_ccw_blk_init
;
835 k
->exit
= virtio_ccw_exit
;
836 dc
->reset
= virtio_ccw_reset
;
837 dc
->props
= virtio_ccw_blk_properties
;
840 static const TypeInfo virtio_ccw_blk
= {
841 .name
= TYPE_VIRTIO_BLK_CCW
,
842 .parent
= TYPE_VIRTIO_CCW_DEVICE
,
843 .instance_size
= sizeof(VirtIOBlkCcw
),
844 .instance_init
= virtio_ccw_blk_instance_init
,
845 .class_init
= virtio_ccw_blk_class_init
,
848 static Property virtio_ccw_serial_properties
[] = {
849 DEFINE_PROP_STRING("devno", VirtioCcwDevice
, bus_id
),
850 DEFINE_VIRTIO_SERIAL_PROPERTIES(VirtioSerialCcw
, vdev
.serial
),
851 DEFINE_VIRTIO_COMMON_FEATURES(VirtioCcwDevice
, host_features
[0]),
852 DEFINE_PROP_END_OF_LIST(),
855 static void virtio_ccw_serial_class_init(ObjectClass
*klass
, void *data
)
857 DeviceClass
*dc
= DEVICE_CLASS(klass
);
858 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_CLASS(klass
);
860 k
->init
= virtio_ccw_serial_init
;
861 k
->exit
= virtio_ccw_exit
;
862 dc
->reset
= virtio_ccw_reset
;
863 dc
->props
= virtio_ccw_serial_properties
;
866 static const TypeInfo virtio_ccw_serial
= {
867 .name
= TYPE_VIRTIO_SERIAL_CCW
,
868 .parent
= TYPE_VIRTIO_CCW_DEVICE
,
869 .instance_size
= sizeof(VirtioSerialCcw
),
870 .instance_init
= virtio_ccw_serial_instance_init
,
871 .class_init
= virtio_ccw_serial_class_init
,
874 static Property virtio_ccw_balloon_properties
[] = {
875 DEFINE_PROP_STRING("devno", VirtioCcwDevice
, bus_id
),
876 DEFINE_VIRTIO_COMMON_FEATURES(VirtioCcwDevice
, host_features
[0]),
877 DEFINE_PROP_END_OF_LIST(),
880 static void virtio_ccw_balloon_class_init(ObjectClass
*klass
, void *data
)
882 DeviceClass
*dc
= DEVICE_CLASS(klass
);
883 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_CLASS(klass
);
885 k
->init
= virtio_ccw_balloon_init
;
886 k
->exit
= virtio_ccw_exit
;
887 dc
->reset
= virtio_ccw_reset
;
888 dc
->props
= virtio_ccw_balloon_properties
;
891 static const TypeInfo virtio_ccw_balloon
= {
892 .name
= TYPE_VIRTIO_BALLOON_CCW
,
893 .parent
= TYPE_VIRTIO_CCW_DEVICE
,
894 .instance_size
= sizeof(VirtIOBalloonCcw
),
895 .instance_init
= virtio_ccw_balloon_instance_init
,
896 .class_init
= virtio_ccw_balloon_class_init
,
899 static Property virtio_ccw_scsi_properties
[] = {
900 DEFINE_PROP_STRING("devno", VirtioCcwDevice
, bus_id
),
901 DEFINE_VIRTIO_SCSI_PROPERTIES(VirtIOSCSICcw
, vdev
.parent_obj
.conf
),
902 DEFINE_VIRTIO_SCSI_FEATURES(VirtioCcwDevice
, host_features
[0]),
903 DEFINE_PROP_END_OF_LIST(),
906 static void virtio_ccw_scsi_class_init(ObjectClass
*klass
, void *data
)
908 DeviceClass
*dc
= DEVICE_CLASS(klass
);
909 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_CLASS(klass
);
911 k
->init
= virtio_ccw_scsi_init
;
912 k
->exit
= virtio_ccw_exit
;
913 dc
->reset
= virtio_ccw_reset
;
914 dc
->props
= virtio_ccw_scsi_properties
;
917 static const TypeInfo virtio_ccw_scsi
= {
918 .name
= TYPE_VIRTIO_SCSI_CCW
,
919 .parent
= TYPE_VIRTIO_CCW_DEVICE
,
920 .instance_size
= sizeof(VirtIOSCSICcw
),
921 .instance_init
= virtio_ccw_scsi_instance_init
,
922 .class_init
= virtio_ccw_scsi_class_init
,
925 #ifdef CONFIG_VHOST_SCSI
926 static Property vhost_ccw_scsi_properties
[] = {
927 DEFINE_PROP_STRING("devno", VirtioCcwDevice
, bus_id
),
928 DEFINE_VHOST_SCSI_PROPERTIES(VirtIOSCSICcw
, vdev
.parent_obj
.conf
),
929 DEFINE_VIRTIO_COMMON_FEATURES(VirtioCcwDevice
, host_features
[0]),
930 DEFINE_PROP_END_OF_LIST(),
933 static void vhost_ccw_scsi_class_init(ObjectClass
*klass
, void *data
)
935 DeviceClass
*dc
= DEVICE_CLASS(klass
);
936 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_CLASS(klass
);
938 k
->init
= vhost_ccw_scsi_init
;
939 k
->exit
= virtio_ccw_exit
;
940 dc
->reset
= virtio_ccw_reset
;
941 dc
->props
= vhost_ccw_scsi_properties
;
944 static const TypeInfo vhost_ccw_scsi
= {
945 .name
= TYPE_VHOST_SCSI_CCW
,
946 .parent
= TYPE_VIRTIO_CCW_DEVICE
,
947 .instance_size
= sizeof(VirtIOSCSICcw
),
948 .instance_init
= vhost_ccw_scsi_instance_init
,
949 .class_init
= vhost_ccw_scsi_class_init
,
953 static void virtio_ccw_rng_instance_init(Object
*obj
)
955 VirtIORNGCcw
*dev
= VIRTIO_RNG_CCW(obj
);
956 object_initialize(OBJECT(&dev
->vdev
), TYPE_VIRTIO_RNG
);
957 object_property_add_child(obj
, "virtio-backend", OBJECT(&dev
->vdev
), NULL
);
958 object_property_add_link(obj
, "rng", TYPE_RNG_BACKEND
,
959 (Object
**)&dev
->vdev
.conf
.rng
, NULL
);
962 static Property virtio_ccw_rng_properties
[] = {
963 DEFINE_PROP_STRING("devno", VirtioCcwDevice
, bus_id
),
964 DEFINE_VIRTIO_COMMON_FEATURES(VirtioCcwDevice
, host_features
[0]),
965 DEFINE_VIRTIO_RNG_PROPERTIES(VirtIORNGCcw
, vdev
.conf
),
966 DEFINE_PROP_END_OF_LIST(),
969 static void virtio_ccw_rng_class_init(ObjectClass
*klass
, void *data
)
971 DeviceClass
*dc
= DEVICE_CLASS(klass
);
972 VirtIOCCWDeviceClass
*k
= VIRTIO_CCW_DEVICE_CLASS(klass
);
974 k
->init
= virtio_ccw_rng_init
;
975 k
->exit
= virtio_ccw_exit
;
976 dc
->reset
= virtio_ccw_reset
;
977 dc
->props
= virtio_ccw_rng_properties
;
980 static const TypeInfo virtio_ccw_rng
= {
981 .name
= TYPE_VIRTIO_RNG_CCW
,
982 .parent
= TYPE_VIRTIO_CCW_DEVICE
,
983 .instance_size
= sizeof(VirtIORNGCcw
),
984 .instance_init
= virtio_ccw_rng_instance_init
,
985 .class_init
= virtio_ccw_rng_class_init
,
988 static int virtio_ccw_busdev_init(DeviceState
*dev
)
990 VirtioCcwDevice
*_dev
= (VirtioCcwDevice
*)dev
;
991 VirtIOCCWDeviceClass
*_info
= VIRTIO_CCW_DEVICE_GET_CLASS(dev
);
993 virtio_ccw_bus_new(&_dev
->bus
, _dev
);
995 return _info
->init(_dev
);
998 static int virtio_ccw_busdev_exit(DeviceState
*dev
)
1000 VirtioCcwDevice
*_dev
= (VirtioCcwDevice
*)dev
;
1001 VirtIOCCWDeviceClass
*_info
= VIRTIO_CCW_DEVICE_GET_CLASS(dev
);
1003 return _info
->exit(_dev
);
1006 static int virtio_ccw_busdev_unplug(DeviceState
*dev
)
1008 VirtioCcwDevice
*_dev
= (VirtioCcwDevice
*)dev
;
1009 SubchDev
*sch
= _dev
->sch
;
1012 * We should arrive here only for device_del, since we don't support
1013 * direct hot(un)plug of channels, but only through virtio.
1015 assert(sch
!= NULL
);
1016 /* Subchannel is now disabled and no longer valid. */
1017 sch
->curr_status
.pmcw
.flags
&= ~(PMCW_FLAGS_MASK_ENA
|
1018 PMCW_FLAGS_MASK_DNV
);
1020 css_generate_sch_crws(sch
->cssid
, sch
->ssid
, sch
->schid
, 1, 0);
1026 static void virtio_ccw_device_class_init(ObjectClass
*klass
, void *data
)
1028 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1030 dc
->init
= virtio_ccw_busdev_init
;
1031 dc
->exit
= virtio_ccw_busdev_exit
;
1032 dc
->unplug
= virtio_ccw_busdev_unplug
;
1033 dc
->bus_type
= TYPE_VIRTUAL_CSS_BUS
;
1037 static const TypeInfo virtio_ccw_device_info
= {
1038 .name
= TYPE_VIRTIO_CCW_DEVICE
,
1039 .parent
= TYPE_DEVICE
,
1040 .instance_size
= sizeof(VirtioCcwDevice
),
1041 .class_init
= virtio_ccw_device_class_init
,
1042 .class_size
= sizeof(VirtIOCCWDeviceClass
),
1046 /***************** Virtual-css Bus Bridge Device ********************/
1047 /* Only required to have the virtio bus as child in the system bus */
1049 static int virtual_css_bridge_init(SysBusDevice
*dev
)
1055 static void virtual_css_bridge_class_init(ObjectClass
*klass
, void *data
)
1057 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1058 SysBusDeviceClass
*k
= SYS_BUS_DEVICE_CLASS(klass
);
1060 k
->init
= virtual_css_bridge_init
;
1064 static const TypeInfo virtual_css_bridge_info
= {
1065 .name
= "virtual-css-bridge",
1066 .parent
= TYPE_SYS_BUS_DEVICE
,
1067 .instance_size
= sizeof(SysBusDevice
),
1068 .class_init
= virtual_css_bridge_class_init
,
1071 /* virtio-ccw-bus */
1073 static void virtio_ccw_bus_new(VirtioBusState
*bus
, VirtioCcwDevice
*dev
)
1075 DeviceState
*qdev
= DEVICE(dev
);
1077 char virtio_bus_name
[] = "virtio-bus";
1079 qbus_create_inplace((BusState
*)bus
, TYPE_VIRTIO_CCW_BUS
, qdev
,
1082 qbus
->allow_hotplug
= 1;
1085 static void virtio_ccw_bus_class_init(ObjectClass
*klass
, void *data
)
1087 VirtioBusClass
*k
= VIRTIO_BUS_CLASS(klass
);
1088 BusClass
*bus_class
= BUS_CLASS(klass
);
1090 bus_class
->max_dev
= 1;
1091 k
->notify
= virtio_ccw_notify
;
1092 k
->get_features
= virtio_ccw_get_features
;
1095 static const TypeInfo virtio_ccw_bus_info
= {
1096 .name
= TYPE_VIRTIO_CCW_BUS
,
1097 .parent
= TYPE_VIRTIO_BUS
,
1098 .instance_size
= sizeof(VirtioCcwBusState
),
1099 .class_init
= virtio_ccw_bus_class_init
,
1102 static void virtio_ccw_register(void)
1104 type_register_static(&virtio_ccw_bus_info
);
1105 type_register_static(&virtual_css_bus_info
);
1106 type_register_static(&virtio_ccw_device_info
);
1107 type_register_static(&virtio_ccw_serial
);
1108 type_register_static(&virtio_ccw_blk
);
1109 type_register_static(&virtio_ccw_net
);
1110 type_register_static(&virtio_ccw_balloon
);
1111 type_register_static(&virtio_ccw_scsi
);
1112 #ifdef CONFIG_VHOST_SCSI
1113 type_register_static(&vhost_ccw_scsi
);
1115 type_register_static(&virtio_ccw_rng
);
1116 type_register_static(&virtual_css_bridge_info
);
1119 type_init(virtio_ccw_register
)