?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
s390x/css: ccw translation infrastructure
[qemu.git] / hw / s390x / virtio-ccw.c
blobe6a6f74be3f3fdd8964352ad60e5b60cdd946f4d
1 /*
2 * virtio ccw target implementation
3 *
4 * Copyright 2012,2015 IBM Corp.
5 * Author(s): Cornelia Huck <cornelia.huck@de.ibm.com>
6 * Pierre Morel <pmorel@linux.vnet.ibm.com>
7 *
8 * This work is licensed under the terms of the GNU GPL, version 2 or (at
9 * your option) any later version. See the COPYING file in the top-level
10 * directory.
11 */
12
13 #include "qemu/osdep.h"
14 #include "qapi/error.h"
15 #include "hw/hw.h"
16 #include "sysemu/block-backend.h"
17 #include "sysemu/blockdev.h"
18 #include "sysemu/sysemu.h"
19 #include "sysemu/kvm.h"
20 #include "net/net.h"
21 #include "hw/virtio/virtio.h"
22 #include "hw/virtio/virtio-serial.h"
23 #include "hw/virtio/virtio-net.h"
24 #include "hw/sysbus.h"
25 #include "qemu/bitops.h"
26 #include "qemu/error-report.h"
27 #include "hw/virtio/virtio-access.h"
28 #include "hw/virtio/virtio-bus.h"
29 #include "hw/s390x/adapter.h"
30 #include "hw/s390x/s390_flic.h"
31
32 #include "hw/s390x/ioinst.h"
33 #include "hw/s390x/css.h"
34 #include "virtio-ccw.h"
35 #include "trace.h"
36 #include "hw/s390x/css-bridge.h"
37
38 #define NR_CLASSIC_INDICATOR_BITS 64
39
40 static void virtio_ccw_bus_new(VirtioBusState *bus, size_t bus_size,
41 VirtioCcwDevice *dev);
42
43 VirtIODevice *virtio_ccw_get_vdev(SubchDev *sch)
44 {
45 VirtIODevice *vdev = NULL;
46 VirtioCcwDevice *dev = sch->driver_data;
47
48 if (dev) {
49 vdev = virtio_bus_get_device(&dev->bus);
50 }
51 return vdev;
52 }
53
54 static void virtio_ccw_start_ioeventfd(VirtioCcwDevice *dev)
55 {
56 virtio_bus_start_ioeventfd(&dev->bus);
57 }
58
59 static void virtio_ccw_stop_ioeventfd(VirtioCcwDevice *dev)
60 {
61 virtio_bus_stop_ioeventfd(&dev->bus);
62 }
63
64 static bool virtio_ccw_ioeventfd_enabled(DeviceState *d)
65 {
66 VirtioCcwDevice *dev = VIRTIO_CCW_DEVICE(d);
67
68 return (dev->flags & VIRTIO_CCW_FLAG_USE_IOEVENTFD) != 0;
69 }
70
71 static int virtio_ccw_ioeventfd_assign(DeviceState *d, EventNotifier *notifier,
72 int n, bool assign)
73 {
74 VirtioCcwDevice *dev = VIRTIO_CCW_DEVICE(d);
75 CcwDevice *ccw_dev = CCW_DEVICE(dev);
76 SubchDev *sch = ccw_dev->sch;
77 uint32_t sch_id = (css_build_subchannel_id(sch) << 16) | sch->schid;
78
79 return s390_assign_subch_ioeventfd(notifier, sch_id, n, assign);
80 }
81
82 /* Communication blocks used by several channel commands. */
83 typedef struct VqInfoBlockLegacy {
84 uint64_t queue;
85 uint32_t align;
86 uint16_t index;
87 uint16_t num;
88 } QEMU_PACKED VqInfoBlockLegacy;
89
90 typedef struct VqInfoBlock {
91 uint64_t desc;
92 uint32_t res0;
93 uint16_t index;
94 uint16_t num;
95 uint64_t avail;
96 uint64_t used;
97 } QEMU_PACKED VqInfoBlock;
98
99 typedef struct VqConfigBlock {
100 uint16_t index;
101 uint16_t num_max;
102 } QEMU_PACKED VqConfigBlock;
103
104 typedef struct VirtioFeatDesc {
105 uint32_t features;
106 uint8_t index;
107 } QEMU_PACKED VirtioFeatDesc;
108
109 typedef struct VirtioThinintInfo {
110 hwaddr summary_indicator;
111 hwaddr device_indicator;
112 uint64_t ind_bit;
113 uint8_t isc;
114 } QEMU_PACKED VirtioThinintInfo;
115
116 typedef struct VirtioRevInfo {
117 uint16_t revision;
118 uint16_t length;
119 uint8_t data[0];
120 } QEMU_PACKED VirtioRevInfo;
121
122 /* Specify where the virtqueues for the subchannel are in guest memory. */
123 static int virtio_ccw_set_vqs(SubchDev *sch, VqInfoBlock *info,
124 VqInfoBlockLegacy *linfo)
125 {
126 VirtIODevice *vdev = virtio_ccw_get_vdev(sch);
127 uint16_t index = info ? info->index : linfo->index;
128 uint16_t num = info ? info->num : linfo->num;
129 uint64_t desc = info ? info->desc : linfo->queue;
130
131 if (index >= VIRTIO_QUEUE_MAX) {
132 return -EINVAL;
133 }
134
135 /* Current code in virtio.c relies on 4K alignment. */
136 if (linfo && desc && (linfo->align != 4096)) {
137 return -EINVAL;
138 }
139
140 if (!vdev) {
141 return -EINVAL;
142 }
143
144 if (info) {
145 virtio_queue_set_rings(vdev, index, desc, info->avail, info->used);
146 } else {
147 virtio_queue_set_addr(vdev, index, desc);
148 }
149 if (!desc) {
150 virtio_queue_set_vector(vdev, index, VIRTIO_NO_VECTOR);
151 } else {
152 if (info) {
153 /* virtio-1 allows changing the ring size. */
154 if (virtio_queue_get_max_num(vdev, index) < num) {
155 /* Fail if we exceed the maximum number. */
156 return -EINVAL;
157 }
158 virtio_queue_set_num(vdev, index, num);
159 } else if (virtio_queue_get_num(vdev, index) > num) {
160 /* Fail if we don't have a big enough queue. */
161 return -EINVAL;
162 }
163 /* We ignore possible increased num for legacy for compatibility. */
164 virtio_queue_set_vector(vdev, index, index);
165 }
166 /* tell notify handler in case of config change */
167 vdev->config_vector = VIRTIO_QUEUE_MAX;
168 return 0;
169 }
170
171 static void virtio_ccw_reset_virtio(VirtioCcwDevice *dev, VirtIODevice *vdev)
172 {
173 CcwDevice *ccw_dev = CCW_DEVICE(dev);
174
175 virtio_ccw_stop_ioeventfd(dev);
176 virtio_reset(vdev);
177 if (dev->indicators) {
178 release_indicator(&dev->routes.adapter, dev->indicators);
179 dev->indicators = NULL;
180 }
181 if (dev->indicators2) {
182 release_indicator(&dev->routes.adapter, dev->indicators2);
183 dev->indicators2 = NULL;
184 }
185 if (dev->summary_indicator) {
186 release_indicator(&dev->routes.adapter, dev->summary_indicator);
187 dev->summary_indicator = NULL;
188 }
189 ccw_dev->sch->thinint_active = false;
190 }
191
192 static int virtio_ccw_handle_set_vq(SubchDev *sch, CCW1 ccw, bool check_len,
193 bool is_legacy)
194 {
195 int ret;
196 VqInfoBlock info;
197 VqInfoBlockLegacy linfo;
198 size_t info_len = is_legacy ? sizeof(linfo) : sizeof(info);
199
200 if (check_len) {
201 if (ccw.count != info_len) {
202 return -EINVAL;
203 }
204 } else if (ccw.count < info_len) {
205 /* Can't execute command. */
206 return -EINVAL;
207 }
208 if (!ccw.cda) {
209 return -EFAULT;
210 }
211 if (is_legacy) {
212 linfo.queue = address_space_ldq_be(&address_space_memory, ccw.cda,
213 MEMTXATTRS_UNSPECIFIED, NULL);
214 linfo.align = address_space_ldl_be(&address_space_memory,
215 ccw.cda + sizeof(linfo.queue),
216 MEMTXATTRS_UNSPECIFIED,
217 NULL);
218 linfo.index = address_space_lduw_be(&address_space_memory,
219 ccw.cda + sizeof(linfo.queue)
220 + sizeof(linfo.align),
221 MEMTXATTRS_UNSPECIFIED,
222 NULL);
223 linfo.num = address_space_lduw_be(&address_space_memory,
224 ccw.cda + sizeof(linfo.queue)
225 + sizeof(linfo.align)
226 + sizeof(linfo.index),
227 MEMTXATTRS_UNSPECIFIED,
228 NULL);
229 ret = virtio_ccw_set_vqs(sch, NULL, &linfo);
230 } else {
231 info.desc = address_space_ldq_be(&address_space_memory, ccw.cda,
232 MEMTXATTRS_UNSPECIFIED, NULL);
233 info.index = address_space_lduw_be(&address_space_memory,
234 ccw.cda + sizeof(info.desc)
235 + sizeof(info.res0),
236 MEMTXATTRS_UNSPECIFIED, NULL);
237 info.num = address_space_lduw_be(&address_space_memory,
238 ccw.cda + sizeof(info.desc)
239 + sizeof(info.res0)
240 + sizeof(info.index),
241 MEMTXATTRS_UNSPECIFIED, NULL);
242 info.avail = address_space_ldq_be(&address_space_memory,
243 ccw.cda + sizeof(info.desc)
244 + sizeof(info.res0)
245 + sizeof(info.index)
246 + sizeof(info.num),
247 MEMTXATTRS_UNSPECIFIED, NULL);
248 info.used = address_space_ldq_be(&address_space_memory,
249 ccw.cda + sizeof(info.desc)
250 + sizeof(info.res0)
251 + sizeof(info.index)
252 + sizeof(info.num)
253 + sizeof(info.avail),
254 MEMTXATTRS_UNSPECIFIED, NULL);
255 ret = virtio_ccw_set_vqs(sch, &info, NULL);
256 }
257 sch->curr_status.scsw.count = 0;
258 return ret;
259 }
260
261 static int virtio_ccw_cb(SubchDev *sch, CCW1 ccw)
262 {
263 int ret;
264 VirtioRevInfo revinfo;
265 uint8_t status;
266 VirtioFeatDesc features;
267 void *config;
268 hwaddr indicators;
269 VqConfigBlock vq_config;
270 VirtioCcwDevice *dev = sch->driver_data;
271 VirtIODevice *vdev = virtio_ccw_get_vdev(sch);
272 bool check_len;
273 int len;
274 hwaddr hw_len;
275 VirtioThinintInfo *thinint;
276
277 if (!dev) {
278 return -EINVAL;
279 }
280
281 trace_virtio_ccw_interpret_ccw(sch->cssid, sch->ssid, sch->schid,
282 ccw.cmd_code);
283 check_len = !((ccw.flags & CCW_FLAG_SLI) && !(ccw.flags & CCW_FLAG_DC));
284
285 if (dev->force_revision_1 && dev->revision < 0 &&
286 ccw.cmd_code != CCW_CMD_SET_VIRTIO_REV) {
287 /*
288 * virtio-1 drivers must start with negotiating to a revision >= 1,
289 * so post a command reject for all other commands
290 */
291 return -ENOSYS;
292 }
293
294 /* Look at the command. */
295 switch (ccw.cmd_code) {
296 case CCW_CMD_SET_VQ:
297 ret = virtio_ccw_handle_set_vq(sch, ccw, check_len, dev->revision < 1);
298 break;
299 case CCW_CMD_VDEV_RESET:
300 virtio_ccw_reset_virtio(dev, vdev);
301 ret = 0;
302 break;
303 case CCW_CMD_READ_FEAT:
304 if (check_len) {
305 if (ccw.count != sizeof(features)) {
306 ret = -EINVAL;
307 break;
308 }
309 } else if (ccw.count < sizeof(features)) {
310 /* Can't execute command. */
311 ret = -EINVAL;
312 break;
313 }
314 if (!ccw.cda) {
315 ret = -EFAULT;
316 } else {
317 VirtioDeviceClass *vdc = VIRTIO_DEVICE_GET_CLASS(vdev);
318
319 features.index = address_space_ldub(&address_space_memory,
320 ccw.cda
321 + sizeof(features.features),
322 MEMTXATTRS_UNSPECIFIED,
323 NULL);
324 if (features.index == 0) {
325 if (dev->revision >= 1) {
326 /* Don't offer legacy features for modern devices. */
327 features.features = (uint32_t)
328 (vdev->host_features & ~vdc->legacy_features);
329 } else {
330 features.features = (uint32_t)vdev->host_features;
331 }
332 } else if ((features.index == 1) && (dev->revision >= 1)) {
333 /*
334 * Only offer feature bits beyond 31 if the guest has
335 * negotiated at least revision 1.
336 */
337 features.features = (uint32_t)(vdev->host_features >> 32);
338 } else {
339 /* Return zeroes if the guest supports more feature bits. */
340 features.features = 0;
341 }
342 address_space_stl_le(&address_space_memory, ccw.cda,
343 features.features, MEMTXATTRS_UNSPECIFIED,
344 NULL);
345 sch->curr_status.scsw.count = ccw.count - sizeof(features);
346 ret = 0;
347 }
348 break;
349 case CCW_CMD_WRITE_FEAT:
350 if (check_len) {
351 if (ccw.count != sizeof(features)) {
352 ret = -EINVAL;
353 break;
354 }
355 } else if (ccw.count < sizeof(features)) {
356 /* Can't execute command. */
357 ret = -EINVAL;
358 break;
359 }
360 if (!ccw.cda) {
361 ret = -EFAULT;
362 } else {
363 features.index = address_space_ldub(&address_space_memory,
364 ccw.cda
365 + sizeof(features.features),
366 MEMTXATTRS_UNSPECIFIED,
367 NULL);
368 features.features = address_space_ldl_le(&address_space_memory,
369 ccw.cda,
370 MEMTXATTRS_UNSPECIFIED,
371 NULL);
372 if (features.index == 0) {
373 virtio_set_features(vdev,
374 (vdev->guest_features & 0xffffffff00000000ULL) |
375 features.features);
376 } else if ((features.index == 1) && (dev->revision >= 1)) {
377 /*
378 * If the guest did not negotiate at least revision 1,
379 * we did not offer it any feature bits beyond 31. Such a
380 * guest passing us any bit here is therefore buggy.
381 */
382 virtio_set_features(vdev,
383 (vdev->guest_features & 0x00000000ffffffffULL) |
384 ((uint64_t)features.features << 32));
385 } else {
386 /*
387 * If the guest supports more feature bits, assert that it
388 * passes us zeroes for those we don't support.
389 */
390 if (features.features) {
391 fprintf(stderr, "Guest bug: features[%i]=%x (expected 0)\n",
392 features.index, features.features);
393 /* XXX: do a unit check here? */
394 }
395 }
396 sch->curr_status.scsw.count = ccw.count - sizeof(features);
397 ret = 0;
398 }
399 break;
400 case CCW_CMD_READ_CONF:
401 if (check_len) {
402 if (ccw.count > vdev->config_len) {
403 ret = -EINVAL;
404 break;
405 }
406 }
407 len = MIN(ccw.count, vdev->config_len);
408 if (!ccw.cda) {
409 ret = -EFAULT;
410 } else {
411 virtio_bus_get_vdev_config(&dev->bus, vdev->config);
412 /* XXX config space endianness */
413 cpu_physical_memory_write(ccw.cda, vdev->config, len);
414 sch->curr_status.scsw.count = ccw.count - len;
415 ret = 0;
416 }
417 break;
418 case CCW_CMD_WRITE_CONF:
419 if (check_len) {
420 if (ccw.count > vdev->config_len) {
421 ret = -EINVAL;
422 break;
423 }
424 }
425 len = MIN(ccw.count, vdev->config_len);
426 hw_len = len;
427 if (!ccw.cda) {
428 ret = -EFAULT;
429 } else {
430 config = cpu_physical_memory_map(ccw.cda, &hw_len, 0);
431 if (!config) {
432 ret = -EFAULT;
433 } else {
434 len = hw_len;
435 /* XXX config space endianness */
436 memcpy(vdev->config, config, len);
437 cpu_physical_memory_unmap(config, hw_len, 0, hw_len);
438 virtio_bus_set_vdev_config(&dev->bus, vdev->config);
439 sch->curr_status.scsw.count = ccw.count - len;
440 ret = 0;
441 }
442 }
443 break;
444 case CCW_CMD_READ_STATUS:
445 if (check_len) {
446 if (ccw.count != sizeof(status)) {
447 ret = -EINVAL;
448 break;
449 }
450 } else if (ccw.count < sizeof(status)) {
451 /* Can't execute command. */
452 ret = -EINVAL;
453 break;
454 }
455 if (!ccw.cda) {
456 ret = -EFAULT;
457 } else {
458 address_space_stb(&address_space_memory, ccw.cda, vdev->status,
459 MEMTXATTRS_UNSPECIFIED, NULL);
460 sch->curr_status.scsw.count = ccw.count - sizeof(vdev->status);;
461 ret = 0;
462 }
463 break;
464 case CCW_CMD_WRITE_STATUS:
465 if (check_len) {
466 if (ccw.count != sizeof(status)) {
467 ret = -EINVAL;
468 break;
469 }
470 } else if (ccw.count < sizeof(status)) {
471 /* Can't execute command. */
472 ret = -EINVAL;
473 break;
474 }
475 if (!ccw.cda) {
476 ret = -EFAULT;
477 } else {
478 status = address_space_ldub(&address_space_memory, ccw.cda,
479 MEMTXATTRS_UNSPECIFIED, NULL);
480 if (!(status & VIRTIO_CONFIG_S_DRIVER_OK)) {
481 virtio_ccw_stop_ioeventfd(dev);
482 }
483 if (virtio_set_status(vdev, status) == 0) {
484 if (vdev->status == 0) {
485 virtio_ccw_reset_virtio(dev, vdev);
486 }
487 if (status & VIRTIO_CONFIG_S_DRIVER_OK) {
488 virtio_ccw_start_ioeventfd(dev);
489 }
490 sch->curr_status.scsw.count = ccw.count - sizeof(status);
491 ret = 0;
492 } else {
493 /* Trigger a command reject. */
494 ret = -ENOSYS;
495 }
496 }
497 break;
498 case CCW_CMD_SET_IND:
499 if (check_len) {
500 if (ccw.count != sizeof(indicators)) {
501 ret = -EINVAL;
502 break;
503 }
504 } else if (ccw.count < sizeof(indicators)) {
505 /* Can't execute command. */
506 ret = -EINVAL;
507 break;
508 }
509 if (sch->thinint_active) {
510 /* Trigger a command reject. */
511 ret = -ENOSYS;
512 break;
513 }
514 if (virtio_get_num_queues(vdev) > NR_CLASSIC_INDICATOR_BITS) {
515 /* More queues than indicator bits --> trigger a reject */
516 ret = -ENOSYS;
517 break;
518 }
519 if (!ccw.cda) {
520 ret = -EFAULT;
521 } else {
522 indicators = address_space_ldq_be(&address_space_memory, ccw.cda,
523 MEMTXATTRS_UNSPECIFIED, NULL);
524 dev->indicators = get_indicator(indicators, sizeof(uint64_t));
525 sch->curr_status.scsw.count = ccw.count - sizeof(indicators);
526 ret = 0;
527 }
528 break;
529 case CCW_CMD_SET_CONF_IND:
530 if (check_len) {
531 if (ccw.count != sizeof(indicators)) {
532 ret = -EINVAL;
533 break;
534 }
535 } else if (ccw.count < sizeof(indicators)) {
536 /* Can't execute command. */
537 ret = -EINVAL;
538 break;
539 }
540 if (!ccw.cda) {
541 ret = -EFAULT;
542 } else {
543 indicators = address_space_ldq_be(&address_space_memory, ccw.cda,
544 MEMTXATTRS_UNSPECIFIED, NULL);
545 dev->indicators2 = get_indicator(indicators, sizeof(uint64_t));
546 sch->curr_status.scsw.count = ccw.count - sizeof(indicators);
547 ret = 0;
548 }
549 break;
550 case CCW_CMD_READ_VQ_CONF:
551 if (check_len) {
552 if (ccw.count != sizeof(vq_config)) {
553 ret = -EINVAL;
554 break;
555 }
556 } else if (ccw.count < sizeof(vq_config)) {
557 /* Can't execute command. */
558 ret = -EINVAL;
559 break;
560 }
561 if (!ccw.cda) {
562 ret = -EFAULT;
563 } else {
564 vq_config.index = address_space_lduw_be(&address_space_memory,
565 ccw.cda,
566 MEMTXATTRS_UNSPECIFIED,
567 NULL);
568 if (vq_config.index >= VIRTIO_QUEUE_MAX) {
569 ret = -EINVAL;
570 break;
571 }
572 vq_config.num_max = virtio_queue_get_num(vdev,
573 vq_config.index);
574 address_space_stw_be(&address_space_memory,
575 ccw.cda + sizeof(vq_config.index),
576 vq_config.num_max,
577 MEMTXATTRS_UNSPECIFIED,
578 NULL);
579 sch->curr_status.scsw.count = ccw.count - sizeof(vq_config);
580 ret = 0;
581 }
582 break;
583 case CCW_CMD_SET_IND_ADAPTER:
584 if (check_len) {
585 if (ccw.count != sizeof(*thinint)) {
586 ret = -EINVAL;
587 break;
588 }
589 } else if (ccw.count < sizeof(*thinint)) {
590 /* Can't execute command. */
591 ret = -EINVAL;
592 break;
593 }
594 len = sizeof(*thinint);
595 hw_len = len;
596 if (!ccw.cda) {
597 ret = -EFAULT;
598 } else if (dev->indicators && !sch->thinint_active) {
599 /* Trigger a command reject. */
600 ret = -ENOSYS;
601 } else {
602 thinint = cpu_physical_memory_map(ccw.cda, &hw_len, 0);
603 if (!thinint) {
604 ret = -EFAULT;
605 } else {
606 uint64_t ind_bit = ldq_be_p(&thinint->ind_bit);
607
608 len = hw_len;
609 dev->summary_indicator =
610 get_indicator(ldq_be_p(&thinint->summary_indicator),
611 sizeof(uint8_t));
612 dev->indicators =
613 get_indicator(ldq_be_p(&thinint->device_indicator),
614 ind_bit / 8 + 1);
615 dev->thinint_isc = thinint->isc;
616 dev->routes.adapter.ind_offset = ind_bit;
617 dev->routes.adapter.summary_offset = 7;
618 cpu_physical_memory_unmap(thinint, hw_len, 0, hw_len);
619 dev->routes.adapter.adapter_id = css_get_adapter_id(
620 CSS_IO_ADAPTER_VIRTIO,
621 dev->thinint_isc);
622 sch->thinint_active = ((dev->indicators != NULL) &&
623 (dev->summary_indicator != NULL));
624 sch->curr_status.scsw.count = ccw.count - len;
625 ret = 0;
626 }
627 }
628 break;
629 case CCW_CMD_SET_VIRTIO_REV:
630 len = sizeof(revinfo);
631 if (ccw.count < len) {
632 ret = -EINVAL;
633 break;
634 }
635 if (!ccw.cda) {
636 ret = -EFAULT;
637 break;
638 }
639 revinfo.revision =
640 address_space_lduw_be(&address_space_memory, ccw.cda,
641 MEMTXATTRS_UNSPECIFIED, NULL);
642 revinfo.length =
643 address_space_lduw_be(&address_space_memory,
644 ccw.cda + sizeof(revinfo.revision),
645 MEMTXATTRS_UNSPECIFIED, NULL);
646 if (ccw.count < len + revinfo.length ||
647 (check_len && ccw.count > len + revinfo.length)) {
648 ret = -EINVAL;
649 break;
650 }
651 /*
652 * Once we start to support revisions with additional data, we'll
653 * need to fetch it here. Nothing to do for now, though.
654 */
655 if (dev->revision >= 0 ||
656 revinfo.revision > virtio_ccw_rev_max(dev) ||
657 (dev->force_revision_1 && !revinfo.revision)) {
658 ret = -ENOSYS;
659 break;
660 }
661 ret = 0;
662 dev->revision = revinfo.revision;
663 break;
664 default:
665 ret = -ENOSYS;
666 break;
667 }
668 return ret;
669 }
670
671 static void virtio_sch_disable_cb(SubchDev *sch)
672 {
673 VirtioCcwDevice *dev = sch->driver_data;
674
675 dev->revision = -1;
676 }
677
678 static void virtio_ccw_device_realize(VirtioCcwDevice *dev, Error **errp)
679 {
680 VirtIOCCWDeviceClass *k = VIRTIO_CCW_DEVICE_GET_CLASS(dev);
681 CcwDevice *ccw_dev = CCW_DEVICE(dev);
682 CCWDeviceClass *ck = CCW_DEVICE_GET_CLASS(ccw_dev);
683 DeviceState *parent = DEVICE(ccw_dev);
684 BusState *qbus = qdev_get_parent_bus(parent);
685 VirtualCssBus *cbus = VIRTUAL_CSS_BUS(qbus);
686 SubchDev *sch;
687 Error *err = NULL;
688
689 sch = css_create_sch(ccw_dev->devno, true, cbus->squash_mcss, errp);
690 if (!sch) {
691 return;
692 }
693 if (!virtio_ccw_rev_max(dev) && dev->force_revision_1) {
694 error_setg(&err, "Invalid value of property max_rev "
695 "(is %d expected >= 1)", virtio_ccw_rev_max(dev));
696 goto out_err;
697 }
698
699 sch->driver_data = dev;
700 sch->ccw_cb = virtio_ccw_cb;
701 sch->disable_cb = virtio_sch_disable_cb;
702 sch->id.reserved = 0xff;
703 sch->id.cu_type = VIRTIO_CCW_CU_TYPE;
704 sch->do_subchannel_work = do_subchannel_work_virtual;
705 ccw_dev->sch = sch;
706 dev->indicators = NULL;
707 dev->revision = -1;
708 css_sch_build_virtual_schib(sch, 0, VIRTIO_CCW_CHPID_TYPE);
709
710 trace_virtio_ccw_new_device(
711 sch->cssid, sch->ssid, sch->schid, sch->devno,
712 ccw_dev->devno.valid ? "user-configured" : "auto-configured");
713
714 if (!kvm_eventfds_enabled()) {
715 dev->flags &= ~VIRTIO_CCW_FLAG_USE_IOEVENTFD;
716 }
717
718 if (k->realize) {
719 k->realize(dev, &err);
720 if (err) {
721 goto out_err;
722 }
723 }
724
725 ck->realize(ccw_dev, &err);
726 if (err) {
727 goto out_err;
728 }
729
730 return;
731
732 out_err:
733 error_propagate(errp, err);
734 css_subch_assign(sch->cssid, sch->ssid, sch->schid, sch->devno, NULL);
735 ccw_dev->sch = NULL;
736 g_free(sch);
737 }
738
739 static int virtio_ccw_exit(VirtioCcwDevice *dev)
740 {
741 CcwDevice *ccw_dev = CCW_DEVICE(dev);
742 SubchDev *sch = ccw_dev->sch;
743
744 if (sch) {
745 css_subch_assign(sch->cssid, sch->ssid, sch->schid, sch->devno, NULL);
746 g_free(sch);
747 }
748 if (dev->indicators) {
749 release_indicator(&dev->routes.adapter, dev->indicators);
750 dev->indicators = NULL;
751 }
752 return 0;
753 }
754
755 static void virtio_ccw_net_realize(VirtioCcwDevice *ccw_dev, Error **errp)
756 {
757 DeviceState *qdev = DEVICE(ccw_dev);
758 VirtIONetCcw *dev = VIRTIO_NET_CCW(ccw_dev);
759 DeviceState *vdev = DEVICE(&dev->vdev);
760
761 virtio_net_set_netclient_name(&dev->vdev, qdev->id,
762 object_get_typename(OBJECT(qdev)));
763 qdev_set_parent_bus(vdev, BUS(&ccw_dev->bus));
764 object_property_set_bool(OBJECT(vdev), true, "realized", errp);
765 }
766
767 static void virtio_ccw_net_instance_init(Object *obj)
768 {
769 VirtIONetCcw *dev = VIRTIO_NET_CCW(obj);
770
771 virtio_instance_init_common(obj, &dev->vdev, sizeof(dev->vdev),
772 TYPE_VIRTIO_NET);
773 object_property_add_alias(obj, "bootindex", OBJECT(&dev->vdev),
774 "bootindex", &error_abort);
775 }
776
777 static void virtio_ccw_blk_realize(VirtioCcwDevice *ccw_dev, Error **errp)
778 {
779 VirtIOBlkCcw *dev = VIRTIO_BLK_CCW(ccw_dev);
780 DeviceState *vdev = DEVICE(&dev->vdev);
781
782 qdev_set_parent_bus(vdev, BUS(&ccw_dev->bus));
783 object_property_set_bool(OBJECT(vdev), true, "realized", errp);
784 }
785
786 static void virtio_ccw_blk_instance_init(Object *obj)
787 {
788 VirtIOBlkCcw *dev = VIRTIO_BLK_CCW(obj);
789
790 virtio_instance_init_common(obj, &dev->vdev, sizeof(dev->vdev),
791 TYPE_VIRTIO_BLK);
792 object_property_add_alias(obj, "iothread", OBJECT(&dev->vdev),"iothread",
793 &error_abort);
794 object_property_add_alias(obj, "bootindex", OBJECT(&dev->vdev),
795 "bootindex", &error_abort);
796 }
797
798 static void virtio_ccw_serial_realize(VirtioCcwDevice *ccw_dev, Error **errp)
799 {
800 VirtioSerialCcw *dev = VIRTIO_SERIAL_CCW(ccw_dev);
801 DeviceState *vdev = DEVICE(&dev->vdev);
802 DeviceState *proxy = DEVICE(ccw_dev);
803 char *bus_name;
804
805 /*
806 * For command line compatibility, this sets the virtio-serial-device bus
807 * name as before.
808 */
809 if (proxy->id) {
810 bus_name = g_strdup_printf("%s.0", proxy->id);
811 virtio_device_set_child_bus_name(VIRTIO_DEVICE(vdev), bus_name);
812 g_free(bus_name);
813 }
814
815 qdev_set_parent_bus(vdev, BUS(&ccw_dev->bus));
816 object_property_set_bool(OBJECT(vdev), true, "realized", errp);
817 }
818
819
820 static void virtio_ccw_serial_instance_init(Object *obj)
821 {
822 VirtioSerialCcw *dev = VIRTIO_SERIAL_CCW(obj);
823
824 virtio_instance_init_common(obj, &dev->vdev, sizeof(dev->vdev),
825 TYPE_VIRTIO_SERIAL);
826 }
827
828 static void virtio_ccw_balloon_realize(VirtioCcwDevice *ccw_dev, Error **errp)
829 {
830 VirtIOBalloonCcw *dev = VIRTIO_BALLOON_CCW(ccw_dev);
831 DeviceState *vdev = DEVICE(&dev->vdev);
832
833 qdev_set_parent_bus(vdev, BUS(&ccw_dev->bus));
834 object_property_set_bool(OBJECT(vdev), true, "realized", errp);
835 }
836
837 static void virtio_ccw_balloon_instance_init(Object *obj)
838 {
839 VirtIOBalloonCcw *dev = VIRTIO_BALLOON_CCW(obj);
840
841 virtio_instance_init_common(obj, &dev->vdev, sizeof(dev->vdev),
842 TYPE_VIRTIO_BALLOON);
843 object_property_add_alias(obj, "guest-stats", OBJECT(&dev->vdev),
844 "guest-stats", &error_abort);
845 object_property_add_alias(obj, "guest-stats-polling-interval",
846 OBJECT(&dev->vdev),
847 "guest-stats-polling-interval", &error_abort);
848 }
849
850 static void virtio_ccw_scsi_realize(VirtioCcwDevice *ccw_dev, Error **errp)
851 {
852 VirtIOSCSICcw *dev = VIRTIO_SCSI_CCW(ccw_dev);
853 DeviceState *vdev = DEVICE(&dev->vdev);
854 DeviceState *qdev = DEVICE(ccw_dev);
855 char *bus_name;
856
857 /*
858 * For command line compatibility, this sets the virtio-scsi-device bus
859 * name as before.
860 */
861 if (qdev->id) {
862 bus_name = g_strdup_printf("%s.0", qdev->id);
863 virtio_device_set_child_bus_name(VIRTIO_DEVICE(vdev), bus_name);
864 g_free(bus_name);
865 }
866
867 qdev_set_parent_bus(vdev, BUS(&ccw_dev->bus));
868 object_property_set_bool(OBJECT(vdev), true, "realized", errp);
869 }
870
871 static void virtio_ccw_scsi_instance_init(Object *obj)
872 {
873 VirtIOSCSICcw *dev = VIRTIO_SCSI_CCW(obj);
874
875 virtio_instance_init_common(obj, &dev->vdev, sizeof(dev->vdev),
876 TYPE_VIRTIO_SCSI);
877 object_property_add_alias(obj, "iothread", OBJECT(&dev->vdev), "iothread",
878 &error_abort);
879 }
880
881 #ifdef CONFIG_VHOST_SCSI
882 static void vhost_ccw_scsi_realize(VirtioCcwDevice *ccw_dev, Error **errp)
883 {
884 VHostSCSICcw *dev = VHOST_SCSI_CCW(ccw_dev);
885 DeviceState *vdev = DEVICE(&dev->vdev);
886
887 qdev_set_parent_bus(vdev, BUS(&ccw_dev->bus));
888 object_property_set_bool(OBJECT(vdev), true, "realized", errp);
889 }
890
891 static void vhost_ccw_scsi_instance_init(Object *obj)
892 {
893 VHostSCSICcw *dev = VHOST_SCSI_CCW(obj);
894
895 virtio_instance_init_common(obj, &dev->vdev, sizeof(dev->vdev),
896 TYPE_VHOST_SCSI);
897 }
898 #endif
899
900 static void virtio_ccw_rng_realize(VirtioCcwDevice *ccw_dev, Error **errp)
901 {
902 VirtIORNGCcw *dev = VIRTIO_RNG_CCW(ccw_dev);
903 DeviceState *vdev = DEVICE(&dev->vdev);
904 Error *err = NULL;
905
906 qdev_set_parent_bus(vdev, BUS(&ccw_dev->bus));
907 object_property_set_bool(OBJECT(vdev), true, "realized", &err);
908 if (err) {
909 error_propagate(errp, err);
910 return;
911 }
912
913 object_property_set_link(OBJECT(dev),
914 OBJECT(dev->vdev.conf.rng), "rng",
915 NULL);
916 }
917
918 static void virtio_ccw_crypto_realize(VirtioCcwDevice *ccw_dev, Error **errp)
919 {
920 VirtIOCryptoCcw *dev = VIRTIO_CRYPTO_CCW(ccw_dev);
921 DeviceState *vdev = DEVICE(&dev->vdev);
922 Error *err = NULL;
923
924 qdev_set_parent_bus(vdev, BUS(&ccw_dev->bus));
925 object_property_set_bool(OBJECT(vdev), true, "realized", &err);
926 if (err) {
927 error_propagate(errp, err);
928 return;
929 }
930
931 object_property_set_link(OBJECT(vdev),
932 OBJECT(dev->vdev.conf.cryptodev), "cryptodev",
933 NULL);
934 }
935
936 /* DeviceState to VirtioCcwDevice. Note: used on datapath,
937 * be careful and test performance if you change this.
938 */
939 static inline VirtioCcwDevice *to_virtio_ccw_dev_fast(DeviceState *d)
940 {
941 CcwDevice *ccw_dev = to_ccw_dev_fast(d);
942
943 return container_of(ccw_dev, VirtioCcwDevice, parent_obj);
944 }
945
946 static uint8_t virtio_set_ind_atomic(SubchDev *sch, uint64_t ind_loc,
947 uint8_t to_be_set)
948 {
949 uint8_t ind_old, ind_new;
950 hwaddr len = 1;
951 uint8_t *ind_addr;
952
953 ind_addr = cpu_physical_memory_map(ind_loc, &len, 1);
954 if (!ind_addr) {
955 error_report("%s(%x.%x.%04x): unable to access indicator",
956 __func__, sch->cssid, sch->ssid, sch->schid);
957 return -1;
958 }
959 do {
960 ind_old = *ind_addr;
961 ind_new = ind_old | to_be_set;
962 } while (atomic_cmpxchg(ind_addr, ind_old, ind_new) != ind_old);
963 trace_virtio_ccw_set_ind(ind_loc, ind_old, ind_new);
964 cpu_physical_memory_unmap(ind_addr, len, 1, len);
965
966 return ind_old;
967 }
968
969 static void virtio_ccw_notify(DeviceState *d, uint16_t vector)
970 {
971 VirtioCcwDevice *dev = to_virtio_ccw_dev_fast(d);
972 CcwDevice *ccw_dev = to_ccw_dev_fast(d);
973 SubchDev *sch = ccw_dev->sch;
974 uint64_t indicators;
975
976 /* queue indicators + secondary indicators */
977 if (vector >= VIRTIO_QUEUE_MAX + 64) {
978 return;
979 }
980
981 if (vector < VIRTIO_QUEUE_MAX) {
982 if (!dev->indicators) {
983 return;
984 }
985 if (sch->thinint_active) {
986 /*
987 * In the adapter interrupt case, indicators points to a
988 * memory area that may be (way) larger than 64 bit and
989 * ind_bit indicates the start of the indicators in a big
990 * endian notation.
991 */
992 uint64_t ind_bit = dev->routes.adapter.ind_offset;
993
994 virtio_set_ind_atomic(sch, dev->indicators->addr +
995 (ind_bit + vector) / 8,
996 0x80 >> ((ind_bit + vector) % 8));
997 if (!virtio_set_ind_atomic(sch, dev->summary_indicator->addr,
998 0x01)) {
999 css_adapter_interrupt(dev->thinint_isc);
1000 }
1001 } else {
1002 indicators = address_space_ldq(&address_space_memory,
1003 dev->indicators->addr,
1004 MEMTXATTRS_UNSPECIFIED,
1005 NULL);
1006 indicators |= 1ULL << vector;
1007 address_space_stq(&address_space_memory, dev->indicators->addr,
1008 indicators, MEMTXATTRS_UNSPECIFIED, NULL);
1009 css_conditional_io_interrupt(sch);
1010 }
1011 } else {
1012 if (!dev->indicators2) {
1013 return;
1014 }
1015 vector = 0;
1016 indicators = address_space_ldq(&address_space_memory,
1017 dev->indicators2->addr,
1018 MEMTXATTRS_UNSPECIFIED,
1019 NULL);
1020 indicators |= 1ULL << vector;
1021 address_space_stq(&address_space_memory, dev->indicators2->addr,
1022 indicators, MEMTXATTRS_UNSPECIFIED, NULL);
1023 css_conditional_io_interrupt(sch);
1024 }
1025 }
1026
1027 static void virtio_ccw_reset(DeviceState *d)
1028 {
1029 VirtioCcwDevice *dev = VIRTIO_CCW_DEVICE(d);
1030 VirtIODevice *vdev = virtio_bus_get_device(&dev->bus);
1031 CcwDevice *ccw_dev = CCW_DEVICE(d);
1032
1033 virtio_ccw_reset_virtio(dev, vdev);
1034 css_reset_sch(ccw_dev->sch);
1035 }
1036
1037 static void virtio_ccw_vmstate_change(DeviceState *d, bool running)
1038 {
1039 VirtioCcwDevice *dev = VIRTIO_CCW_DEVICE(d);
1040
1041 if (running) {
1042 virtio_ccw_start_ioeventfd(dev);
1043 } else {
1044 virtio_ccw_stop_ioeventfd(dev);
1045 }
1046 }
1047
1048 static bool virtio_ccw_query_guest_notifiers(DeviceState *d)
1049 {
1050 CcwDevice *dev = CCW_DEVICE(d);
1051
1052 return !!(dev->sch->curr_status.pmcw.flags & PMCW_FLAGS_MASK_ENA);
1053 }
1054
1055 static int virtio_ccw_get_mappings(VirtioCcwDevice *dev)
1056 {
1057 int r;
1058 CcwDevice *ccw_dev = CCW_DEVICE(dev);
1059
1060 if (!ccw_dev->sch->thinint_active) {
1061 return -EINVAL;
1062 }
1063
1064 r = map_indicator(&dev->routes.adapter, dev->summary_indicator);
1065 if (r) {
1066 return r;
1067 }
1068 r = map_indicator(&dev->routes.adapter, dev->indicators);
1069 if (r) {
1070 return r;
1071 }
1072 dev->routes.adapter.summary_addr = dev->summary_indicator->map;
1073 dev->routes.adapter.ind_addr = dev->indicators->map;
1074
1075 return 0;
1076 }
1077
1078 static int virtio_ccw_setup_irqroutes(VirtioCcwDevice *dev, int nvqs)
1079 {
1080 int i;
1081 VirtIODevice *vdev = virtio_bus_get_device(&dev->bus);
1082 int ret;
1083 S390FLICState *fs = s390_get_flic();
1084 S390FLICStateClass *fsc = S390_FLIC_COMMON_GET_CLASS(fs);
1085
1086 ret = virtio_ccw_get_mappings(dev);
1087 if (ret) {
1088 return ret;
1089 }
1090 for (i = 0; i < nvqs; i++) {
1091 if (!virtio_queue_get_num(vdev, i)) {
1092 break;
1093 }
1094 }
1095 dev->routes.num_routes = i;
1096 return fsc->add_adapter_routes(fs, &dev->routes);
1097 }
1098
1099 static void virtio_ccw_release_irqroutes(VirtioCcwDevice *dev, int nvqs)
1100 {
1101 S390FLICState *fs = s390_get_flic();
1102 S390FLICStateClass *fsc = S390_FLIC_COMMON_GET_CLASS(fs);
1103
1104 fsc->release_adapter_routes(fs, &dev->routes);
1105 }
1106
1107 static int virtio_ccw_add_irqfd(VirtioCcwDevice *dev, int n)
1108 {
1109 VirtIODevice *vdev = virtio_bus_get_device(&dev->bus);
1110 VirtQueue *vq = virtio_get_queue(vdev, n);
1111 EventNotifier *notifier = virtio_queue_get_guest_notifier(vq);
1112
1113 return kvm_irqchip_add_irqfd_notifier_gsi(kvm_state, notifier, NULL,
1114 dev->routes.gsi[n]);
1115 }
1116
1117 static void virtio_ccw_remove_irqfd(VirtioCcwDevice *dev, int n)
1118 {
1119 VirtIODevice *vdev = virtio_bus_get_device(&dev->bus);
1120 VirtQueue *vq = virtio_get_queue(vdev, n);
1121 EventNotifier *notifier = virtio_queue_get_guest_notifier(vq);
1122 int ret;
1123
1124 ret = kvm_irqchip_remove_irqfd_notifier_gsi(kvm_state, notifier,
1125 dev->routes.gsi[n]);
1126 assert(ret == 0);
1127 }
1128
1129 static int virtio_ccw_set_guest_notifier(VirtioCcwDevice *dev, int n,
1130 bool assign, bool with_irqfd)
1131 {
1132 VirtIODevice *vdev = virtio_bus_get_device(&dev->bus);
1133 VirtQueue *vq = virtio_get_queue(vdev, n);
1134 EventNotifier *notifier = virtio_queue_get_guest_notifier(vq);
1135 VirtioDeviceClass *k = VIRTIO_DEVICE_GET_CLASS(vdev);
1136
1137 if (assign) {
1138 int r = event_notifier_init(notifier, 0);
1139
1140 if (r < 0) {
1141 return r;
1142 }
1143 virtio_queue_set_guest_notifier_fd_handler(vq, true, with_irqfd);
1144 if (with_irqfd) {
1145 r = virtio_ccw_add_irqfd(dev, n);
1146 if (r) {
1147 virtio_queue_set_guest_notifier_fd_handler(vq, false,
1148 with_irqfd);
1149 return r;
1150 }
1151 }
1152 /*
1153 * We do not support individual masking for channel devices, so we
1154 * need to manually trigger any guest masking callbacks here.
1155 */
1156 if (k->guest_notifier_mask && vdev->use_guest_notifier_mask) {
1157 k->guest_notifier_mask(vdev, n, false);
1158 }
1159 /* get lost events and re-inject */
1160 if (k->guest_notifier_pending &&
1161 k->guest_notifier_pending(vdev, n)) {
1162 event_notifier_set(notifier);
1163 }
1164 } else {
1165 if (k->guest_notifier_mask && vdev->use_guest_notifier_mask) {
1166 k->guest_notifier_mask(vdev, n, true);
1167 }
1168 if (with_irqfd) {
1169 virtio_ccw_remove_irqfd(dev, n);
1170 }
1171 virtio_queue_set_guest_notifier_fd_handler(vq, false, with_irqfd);
1172 event_notifier_cleanup(notifier);
1173 }
1174 return 0;
1175 }
1176
1177 static int virtio_ccw_set_guest_notifiers(DeviceState *d, int nvqs,
1178 bool assigned)
1179 {
1180 VirtioCcwDevice *dev = VIRTIO_CCW_DEVICE(d);
1181 VirtIODevice *vdev = virtio_bus_get_device(&dev->bus);
1182 CcwDevice *ccw_dev = CCW_DEVICE(d);
1183 bool with_irqfd = ccw_dev->sch->thinint_active && kvm_irqfds_enabled();
1184 int r, n;
1185
1186 if (with_irqfd && assigned) {
1187 /* irq routes need to be set up before assigning irqfds */
1188 r = virtio_ccw_setup_irqroutes(dev, nvqs);
1189 if (r < 0) {
1190 goto irqroute_error;
1191 }
1192 }
1193 for (n = 0; n < nvqs; n++) {
1194 if (!virtio_queue_get_num(vdev, n)) {
1195 break;
1196 }
1197 r = virtio_ccw_set_guest_notifier(dev, n, assigned, with_irqfd);
1198 if (r < 0) {
1199 goto assign_error;
1200 }
1201 }
1202 if (with_irqfd && !assigned) {
1203 /* release irq routes after irqfds have been released */
1204 virtio_ccw_release_irqroutes(dev, nvqs);
1205 }
1206 return 0;
1207
1208 assign_error:
1209 while (--n >= 0) {
1210 virtio_ccw_set_guest_notifier(dev, n, !assigned, false);
1211 }
1212 irqroute_error:
1213 if (with_irqfd && assigned) {
1214 virtio_ccw_release_irqroutes(dev, nvqs);
1215 }
1216 return r;
1217 }
1218
1219 static void virtio_ccw_save_queue(DeviceState *d, int n, QEMUFile *f)
1220 {
1221 VirtioCcwDevice *dev = VIRTIO_CCW_DEVICE(d);
1222 VirtIODevice *vdev = virtio_bus_get_device(&dev->bus);
1223
1224 qemu_put_be16(f, virtio_queue_vector(vdev, n));
1225 }
1226
1227 static int virtio_ccw_load_queue(DeviceState *d, int n, QEMUFile *f)
1228 {
1229 VirtioCcwDevice *dev = VIRTIO_CCW_DEVICE(d);
1230 VirtIODevice *vdev = virtio_bus_get_device(&dev->bus);
1231 uint16_t vector;
1232
1233 qemu_get_be16s(f, &vector);
1234 virtio_queue_set_vector(vdev, n , vector);
1235
1236 return 0;
1237 }
1238
1239 static void virtio_ccw_save_config(DeviceState *d, QEMUFile *f)
1240 {
1241 VirtioCcwDevice *dev = VIRTIO_CCW_DEVICE(d);
1242 CcwDevice *ccw_dev = CCW_DEVICE(d);
1243 SubchDev *s = ccw_dev->sch;
1244 VirtIODevice *vdev = virtio_ccw_get_vdev(s);
1245
1246 subch_device_save(s, f);
1247 if (dev->indicators != NULL) {
1248 qemu_put_be32(f, dev->indicators->len);
1249 qemu_put_be64(f, dev->indicators->addr);
1250 } else {
1251 qemu_put_be32(f, 0);
1252 qemu_put_be64(f, 0UL);
1253 }
1254 if (dev->indicators2 != NULL) {
1255 qemu_put_be32(f, dev->indicators2->len);
1256 qemu_put_be64(f, dev->indicators2->addr);
1257 } else {
1258 qemu_put_be32(f, 0);
1259 qemu_put_be64(f, 0UL);
1260 }
1261 if (dev->summary_indicator != NULL) {
1262 qemu_put_be32(f, dev->summary_indicator->len);
1263 qemu_put_be64(f, dev->summary_indicator->addr);
1264 } else {
1265 qemu_put_be32(f, 0);
1266 qemu_put_be64(f, 0UL);
1267 }
1268 qemu_put_be16(f, vdev->config_vector);
1269 qemu_put_be64(f, dev->routes.adapter.ind_offset);
1270 qemu_put_byte(f, dev->thinint_isc);
1271 qemu_put_be32(f, dev->revision);
1272 }
1273
1274 static int virtio_ccw_load_config(DeviceState *d, QEMUFile *f)
1275 {
1276 VirtioCcwDevice *dev = VIRTIO_CCW_DEVICE(d);
1277 CcwDevice *ccw_dev = CCW_DEVICE(d);
1278 CCWDeviceClass *ck = CCW_DEVICE_GET_CLASS(ccw_dev);
1279 SubchDev *s = ccw_dev->sch;
1280 VirtIODevice *vdev = virtio_ccw_get_vdev(s);
1281 int len;
1282
1283 s->driver_data = dev;
1284 subch_device_load(s, f);
1285 /* Re-fill subch_id after loading the subchannel states.*/
1286 if (ck->refill_ids) {
1287 ck->refill_ids(ccw_dev);
1288 }
1289 len = qemu_get_be32(f);
1290 if (len != 0) {
1291 dev->indicators = get_indicator(qemu_get_be64(f), len);
1292 } else {
1293 qemu_get_be64(f);
1294 dev->indicators = NULL;
1295 }
1296 len = qemu_get_be32(f);
1297 if (len != 0) {
1298 dev->indicators2 = get_indicator(qemu_get_be64(f), len);
1299 } else {
1300 qemu_get_be64(f);
1301 dev->indicators2 = NULL;
1302 }
1303 len = qemu_get_be32(f);
1304 if (len != 0) {
1305 dev->summary_indicator = get_indicator(qemu_get_be64(f), len);
1306 } else {
1307 qemu_get_be64(f);
1308 dev->summary_indicator = NULL;
1309 }
1310 qemu_get_be16s(f, &vdev->config_vector);
1311 dev->routes.adapter.ind_offset = qemu_get_be64(f);
1312 dev->thinint_isc = qemu_get_byte(f);
1313 dev->revision = qemu_get_be32(f);
1314 if (s->thinint_active) {
1315 dev->routes.adapter.adapter_id = css_get_adapter_id(
1316 CSS_IO_ADAPTER_VIRTIO,
1317 dev->thinint_isc);
1318 }
1319
1320 return 0;
1321 }
1322
1323 static void virtio_ccw_pre_plugged(DeviceState *d, Error **errp)
1324 {
1325 VirtioCcwDevice *dev = VIRTIO_CCW_DEVICE(d);
1326 VirtIODevice *vdev = virtio_bus_get_device(&dev->bus);
1327
1328 if (dev->max_rev >= 1) {
1329 virtio_add_feature(&vdev->host_features, VIRTIO_F_VERSION_1);
1330 }
1331 }
1332
1333 /* This is called by virtio-bus just after the device is plugged. */
1334 static void virtio_ccw_device_plugged(DeviceState *d, Error **errp)
1335 {
1336 VirtioCcwDevice *dev = VIRTIO_CCW_DEVICE(d);
1337 VirtIODevice *vdev = virtio_bus_get_device(&dev->bus);
1338 CcwDevice *ccw_dev = CCW_DEVICE(d);
1339 SubchDev *sch = ccw_dev->sch;
1340 int n = virtio_get_num_queues(vdev);
1341 S390FLICState *flic = s390_get_flic();
1342
1343 if (!virtio_has_feature(vdev->host_features, VIRTIO_F_VERSION_1)) {
1344 dev->max_rev = 0;
1345 }
1346
1347 if (virtio_get_num_queues(vdev) > VIRTIO_QUEUE_MAX) {
1348 error_setg(errp, "The number of virtqueues %d "
1349 "exceeds virtio limit %d", n,
1350 VIRTIO_QUEUE_MAX);
1351 return;
1352 }
1353 if (virtio_get_num_queues(vdev) > flic->adapter_routes_max_batch) {
1354 error_setg(errp, "The number of virtqueues %d "
1355 "exceeds flic adapter route limit %d", n,
1356 flic->adapter_routes_max_batch);
1357 return;
1358 }
1359
1360 sch->id.cu_model = virtio_bus_get_vdev_id(&dev->bus);
1361
1362
1363 css_generate_sch_crws(sch->cssid, sch->ssid, sch->schid,
1364 d->hotplugged, 1);
1365 }
1366
1367 static void virtio_ccw_device_unplugged(DeviceState *d)
1368 {
1369 VirtioCcwDevice *dev = VIRTIO_CCW_DEVICE(d);
1370
1371 virtio_ccw_stop_ioeventfd(dev);
1372 }
1373 /**************** Virtio-ccw Bus Device Descriptions *******************/
1374
1375 static Property virtio_ccw_net_properties[] = {
1376 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice, flags,
1377 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT, true),
1378 DEFINE_PROP_UINT32("max_revision", VirtioCcwDevice, max_rev,
1379 VIRTIO_CCW_MAX_REV),
1380 DEFINE_PROP_END_OF_LIST(),
1381 };
1382
1383 static void virtio_ccw_net_class_init(ObjectClass *klass, void *data)
1384 {
1385 DeviceClass *dc = DEVICE_CLASS(klass);
1386 VirtIOCCWDeviceClass *k = VIRTIO_CCW_DEVICE_CLASS(klass);
1387
1388 k->realize = virtio_ccw_net_realize;
1389 k->exit = virtio_ccw_exit;
1390 dc->reset = virtio_ccw_reset;
1391 dc->props = virtio_ccw_net_properties;
1392 set_bit(DEVICE_CATEGORY_NETWORK, dc->categories);
1393 }
1394
1395 static const TypeInfo virtio_ccw_net = {
1396 .name = TYPE_VIRTIO_NET_CCW,
1397 .parent = TYPE_VIRTIO_CCW_DEVICE,
1398 .instance_size = sizeof(VirtIONetCcw),
1399 .instance_init = virtio_ccw_net_instance_init,
1400 .class_init = virtio_ccw_net_class_init,
1401 };
1402
1403 static Property virtio_ccw_blk_properties[] = {
1404 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice, flags,
1405 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT, true),
1406 DEFINE_PROP_UINT32("max_revision", VirtioCcwDevice, max_rev,
1407 VIRTIO_CCW_MAX_REV),
1408 DEFINE_PROP_END_OF_LIST(),
1409 };
1410
1411 static void virtio_ccw_blk_class_init(ObjectClass *klass, void *data)
1412 {
1413 DeviceClass *dc = DEVICE_CLASS(klass);
1414 VirtIOCCWDeviceClass *k = VIRTIO_CCW_DEVICE_CLASS(klass);
1415
1416 k->realize = virtio_ccw_blk_realize;
1417 k->exit = virtio_ccw_exit;
1418 dc->reset = virtio_ccw_reset;
1419 dc->props = virtio_ccw_blk_properties;
1420 set_bit(DEVICE_CATEGORY_STORAGE, dc->categories);
1421 }
1422
1423 static const TypeInfo virtio_ccw_blk = {
1424 .name = TYPE_VIRTIO_BLK_CCW,
1425 .parent = TYPE_VIRTIO_CCW_DEVICE,
1426 .instance_size = sizeof(VirtIOBlkCcw),
1427 .instance_init = virtio_ccw_blk_instance_init,
1428 .class_init = virtio_ccw_blk_class_init,
1429 };
1430
1431 static Property virtio_ccw_serial_properties[] = {
1432 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice, flags,
1433 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT, true),
1434 DEFINE_PROP_UINT32("max_revision", VirtioCcwDevice, max_rev,
1435 VIRTIO_CCW_MAX_REV),
1436 DEFINE_PROP_END_OF_LIST(),
1437 };
1438
1439 static void virtio_ccw_serial_class_init(ObjectClass *klass, void *data)
1440 {
1441 DeviceClass *dc = DEVICE_CLASS(klass);
1442 VirtIOCCWDeviceClass *k = VIRTIO_CCW_DEVICE_CLASS(klass);
1443
1444 k->realize = virtio_ccw_serial_realize;
1445 k->exit = virtio_ccw_exit;
1446 dc->reset = virtio_ccw_reset;
1447 dc->props = virtio_ccw_serial_properties;
1448 set_bit(DEVICE_CATEGORY_INPUT, dc->categories);
1449 }
1450
1451 static const TypeInfo virtio_ccw_serial = {
1452 .name = TYPE_VIRTIO_SERIAL_CCW,
1453 .parent = TYPE_VIRTIO_CCW_DEVICE,
1454 .instance_size = sizeof(VirtioSerialCcw),
1455 .instance_init = virtio_ccw_serial_instance_init,
1456 .class_init = virtio_ccw_serial_class_init,
1457 };
1458
1459 static Property virtio_ccw_balloon_properties[] = {
1460 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice, flags,
1461 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT, true),
1462 DEFINE_PROP_UINT32("max_revision", VirtioCcwDevice, max_rev,
1463 VIRTIO_CCW_MAX_REV),
1464 DEFINE_PROP_END_OF_LIST(),
1465 };
1466
1467 static void virtio_ccw_balloon_class_init(ObjectClass *klass, void *data)
1468 {
1469 DeviceClass *dc = DEVICE_CLASS(klass);
1470 VirtIOCCWDeviceClass *k = VIRTIO_CCW_DEVICE_CLASS(klass);
1471
1472 k->realize = virtio_ccw_balloon_realize;
1473 k->exit = virtio_ccw_exit;
1474 dc->reset = virtio_ccw_reset;
1475 dc->props = virtio_ccw_balloon_properties;
1476 set_bit(DEVICE_CATEGORY_MISC, dc->categories);
1477 }
1478
1479 static const TypeInfo virtio_ccw_balloon = {
1480 .name = TYPE_VIRTIO_BALLOON_CCW,
1481 .parent = TYPE_VIRTIO_CCW_DEVICE,
1482 .instance_size = sizeof(VirtIOBalloonCcw),
1483 .instance_init = virtio_ccw_balloon_instance_init,
1484 .class_init = virtio_ccw_balloon_class_init,
1485 };
1486
1487 static Property virtio_ccw_scsi_properties[] = {
1488 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice, flags,
1489 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT, true),
1490 DEFINE_PROP_UINT32("max_revision", VirtioCcwDevice, max_rev,
1491 VIRTIO_CCW_MAX_REV),
1492 DEFINE_PROP_END_OF_LIST(),
1493 };
1494
1495 static void virtio_ccw_scsi_class_init(ObjectClass *klass, void *data)
1496 {
1497 DeviceClass *dc = DEVICE_CLASS(klass);
1498 VirtIOCCWDeviceClass *k = VIRTIO_CCW_DEVICE_CLASS(klass);
1499
1500 k->realize = virtio_ccw_scsi_realize;
1501 k->exit = virtio_ccw_exit;
1502 dc->reset = virtio_ccw_reset;
1503 dc->props = virtio_ccw_scsi_properties;
1504 set_bit(DEVICE_CATEGORY_STORAGE, dc->categories);
1505 }
1506
1507 static const TypeInfo virtio_ccw_scsi = {
1508 .name = TYPE_VIRTIO_SCSI_CCW,
1509 .parent = TYPE_VIRTIO_CCW_DEVICE,
1510 .instance_size = sizeof(VirtIOSCSICcw),
1511 .instance_init = virtio_ccw_scsi_instance_init,
1512 .class_init = virtio_ccw_scsi_class_init,
1513 };
1514
1515 #ifdef CONFIG_VHOST_SCSI
1516 static Property vhost_ccw_scsi_properties[] = {
1517 DEFINE_PROP_UINT32("max_revision", VirtioCcwDevice, max_rev,
1518 VIRTIO_CCW_MAX_REV),
1519 DEFINE_PROP_END_OF_LIST(),
1520 };
1521
1522 static void vhost_ccw_scsi_class_init(ObjectClass *klass, void *data)
1523 {
1524 DeviceClass *dc = DEVICE_CLASS(klass);
1525 VirtIOCCWDeviceClass *k = VIRTIO_CCW_DEVICE_CLASS(klass);
1526
1527 k->realize = vhost_ccw_scsi_realize;
1528 k->exit = virtio_ccw_exit;
1529 dc->reset = virtio_ccw_reset;
1530 dc->props = vhost_ccw_scsi_properties;
1531 set_bit(DEVICE_CATEGORY_STORAGE, dc->categories);
1532 }
1533
1534 static const TypeInfo vhost_ccw_scsi = {
1535 .name = TYPE_VHOST_SCSI_CCW,
1536 .parent = TYPE_VIRTIO_CCW_DEVICE,
1537 .instance_size = sizeof(VHostSCSICcw),
1538 .instance_init = vhost_ccw_scsi_instance_init,
1539 .class_init = vhost_ccw_scsi_class_init,
1540 };
1541 #endif
1542
1543 static void virtio_ccw_rng_instance_init(Object *obj)
1544 {
1545 VirtIORNGCcw *dev = VIRTIO_RNG_CCW(obj);
1546
1547 virtio_instance_init_common(obj, &dev->vdev, sizeof(dev->vdev),
1548 TYPE_VIRTIO_RNG);
1549 object_property_add_alias(obj, "rng", OBJECT(&dev->vdev),
1550 "rng", &error_abort);
1551 }
1552
1553 static Property virtio_ccw_rng_properties[] = {
1554 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice, flags,
1555 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT, true),
1556 DEFINE_PROP_UINT32("max_revision", VirtioCcwDevice, max_rev,
1557 VIRTIO_CCW_MAX_REV),
1558 DEFINE_PROP_END_OF_LIST(),
1559 };
1560
1561 static void virtio_ccw_rng_class_init(ObjectClass *klass, void *data)
1562 {
1563 DeviceClass *dc = DEVICE_CLASS(klass);
1564 VirtIOCCWDeviceClass *k = VIRTIO_CCW_DEVICE_CLASS(klass);
1565
1566 k->realize = virtio_ccw_rng_realize;
1567 k->exit = virtio_ccw_exit;
1568 dc->reset = virtio_ccw_reset;
1569 dc->props = virtio_ccw_rng_properties;
1570 set_bit(DEVICE_CATEGORY_MISC, dc->categories);
1571 }
1572
1573 static const TypeInfo virtio_ccw_rng = {
1574 .name = TYPE_VIRTIO_RNG_CCW,
1575 .parent = TYPE_VIRTIO_CCW_DEVICE,
1576 .instance_size = sizeof(VirtIORNGCcw),
1577 .instance_init = virtio_ccw_rng_instance_init,
1578 .class_init = virtio_ccw_rng_class_init,
1579 };
1580
1581 static Property virtio_ccw_crypto_properties[] = {
1582 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice, flags,
1583 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT, true),
1584 DEFINE_PROP_UINT32("max_revision", VirtioCcwDevice, max_rev,
1585 VIRTIO_CCW_MAX_REV),
1586 DEFINE_PROP_END_OF_LIST(),
1587 };
1588
1589 static void virtio_ccw_crypto_instance_init(Object *obj)
1590 {
1591 VirtIOCryptoCcw *dev = VIRTIO_CRYPTO_CCW(obj);
1592 VirtioCcwDevice *ccw_dev = VIRTIO_CCW_DEVICE(obj);
1593
1594 ccw_dev->force_revision_1 = true;
1595 virtio_instance_init_common(obj, &dev->vdev, sizeof(dev->vdev),
1596 TYPE_VIRTIO_CRYPTO);
1597
1598 object_property_add_alias(obj, "cryptodev", OBJECT(&dev->vdev),
1599 "cryptodev", &error_abort);
1600 }
1601
1602 static void virtio_ccw_crypto_class_init(ObjectClass *klass, void *data)
1603 {
1604 DeviceClass *dc = DEVICE_CLASS(klass);
1605 VirtIOCCWDeviceClass *k = VIRTIO_CCW_DEVICE_CLASS(klass);
1606
1607 k->realize = virtio_ccw_crypto_realize;
1608 k->exit = virtio_ccw_exit;
1609 dc->reset = virtio_ccw_reset;
1610 dc->props = virtio_ccw_crypto_properties;
1611 set_bit(DEVICE_CATEGORY_MISC, dc->categories);
1612 }
1613
1614 static const TypeInfo virtio_ccw_crypto = {
1615 .name = TYPE_VIRTIO_CRYPTO_CCW,
1616 .parent = TYPE_VIRTIO_CCW_DEVICE,
1617 .instance_size = sizeof(VirtIOCryptoCcw),
1618 .instance_init = virtio_ccw_crypto_instance_init,
1619 .class_init = virtio_ccw_crypto_class_init,
1620 };
1621
1622 static void virtio_ccw_busdev_realize(DeviceState *dev, Error **errp)
1623 {
1624 VirtioCcwDevice *_dev = (VirtioCcwDevice *)dev;
1625
1626 virtio_ccw_bus_new(&_dev->bus, sizeof(_dev->bus), _dev);
1627 virtio_ccw_device_realize(_dev, errp);
1628 }
1629
1630 static int virtio_ccw_busdev_exit(DeviceState *dev)
1631 {
1632 VirtioCcwDevice *_dev = (VirtioCcwDevice *)dev;
1633 VirtIOCCWDeviceClass *_info = VIRTIO_CCW_DEVICE_GET_CLASS(dev);
1634
1635 return _info->exit(_dev);
1636 }
1637
1638 static void virtio_ccw_busdev_unplug(HotplugHandler *hotplug_dev,
1639 DeviceState *dev, Error **errp)
1640 {
1641 VirtioCcwDevice *_dev = to_virtio_ccw_dev_fast(dev);
1642
1643 virtio_ccw_stop_ioeventfd(_dev);
1644 }
1645
1646 static void virtio_ccw_device_class_init(ObjectClass *klass, void *data)
1647 {
1648 DeviceClass *dc = DEVICE_CLASS(klass);
1649 CCWDeviceClass *k = CCW_DEVICE_CLASS(dc);
1650
1651 k->unplug = virtio_ccw_busdev_unplug;
1652 dc->realize = virtio_ccw_busdev_realize;
1653 dc->exit = virtio_ccw_busdev_exit;
1654 dc->bus_type = TYPE_VIRTUAL_CSS_BUS;
1655 }
1656
1657 static const TypeInfo virtio_ccw_device_info = {
1658 .name = TYPE_VIRTIO_CCW_DEVICE,
1659 .parent = TYPE_CCW_DEVICE,
1660 .instance_size = sizeof(VirtioCcwDevice),
1661 .class_init = virtio_ccw_device_class_init,
1662 .class_size = sizeof(VirtIOCCWDeviceClass),
1663 .abstract = true,
1664 };
1665
1666 /* virtio-ccw-bus */
1667
1668 static void virtio_ccw_bus_new(VirtioBusState *bus, size_t bus_size,
1669 VirtioCcwDevice *dev)
1670 {
1671 DeviceState *qdev = DEVICE(dev);
1672 char virtio_bus_name[] = "virtio-bus";
1673
1674 qbus_create_inplace(bus, bus_size, TYPE_VIRTIO_CCW_BUS,
1675 qdev, virtio_bus_name);
1676 }
1677
1678 static void virtio_ccw_bus_class_init(ObjectClass *klass, void *data)
1679 {
1680 VirtioBusClass *k = VIRTIO_BUS_CLASS(klass);
1681 BusClass *bus_class = BUS_CLASS(klass);
1682
1683 bus_class->max_dev = 1;
1684 k->notify = virtio_ccw_notify;
1685 k->vmstate_change = virtio_ccw_vmstate_change;
1686 k->query_guest_notifiers = virtio_ccw_query_guest_notifiers;
1687 k->set_guest_notifiers = virtio_ccw_set_guest_notifiers;
1688 k->save_queue = virtio_ccw_save_queue;
1689 k->load_queue = virtio_ccw_load_queue;
1690 k->save_config = virtio_ccw_save_config;
1691 k->load_config = virtio_ccw_load_config;
1692 k->pre_plugged = virtio_ccw_pre_plugged;
1693 k->device_plugged = virtio_ccw_device_plugged;
1694 k->device_unplugged = virtio_ccw_device_unplugged;
1695 k->ioeventfd_enabled = virtio_ccw_ioeventfd_enabled;
1696 k->ioeventfd_assign = virtio_ccw_ioeventfd_assign;
1697 }
1698
1699 static const TypeInfo virtio_ccw_bus_info = {
1700 .name = TYPE_VIRTIO_CCW_BUS,
1701 .parent = TYPE_VIRTIO_BUS,
1702 .instance_size = sizeof(VirtioCcwBusState),
1703 .class_init = virtio_ccw_bus_class_init,
1704 };
1705
1706 #ifdef CONFIG_VIRTFS
1707 static Property virtio_ccw_9p_properties[] = {
1708 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice, flags,
1709 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT, true),
1710 DEFINE_PROP_UINT32("max_revision", VirtioCcwDevice, max_rev,
1711 VIRTIO_CCW_MAX_REV),
1712 DEFINE_PROP_END_OF_LIST(),
1713 };
1714
1715 static void virtio_ccw_9p_realize(VirtioCcwDevice *ccw_dev, Error **errp)
1716 {
1717 V9fsCCWState *dev = VIRTIO_9P_CCW(ccw_dev);
1718 DeviceState *vdev = DEVICE(&dev->vdev);
1719
1720 qdev_set_parent_bus(vdev, BUS(&ccw_dev->bus));
1721 object_property_set_bool(OBJECT(vdev), true, "realized", errp);
1722 }
1723
1724 static void virtio_ccw_9p_class_init(ObjectClass *klass, void *data)
1725 {
1726 DeviceClass *dc = DEVICE_CLASS(klass);
1727 VirtIOCCWDeviceClass *k = VIRTIO_CCW_DEVICE_CLASS(klass);
1728
1729 k->exit = virtio_ccw_exit;
1730 k->realize = virtio_ccw_9p_realize;
1731 dc->reset = virtio_ccw_reset;
1732 dc->props = virtio_ccw_9p_properties;
1733 set_bit(DEVICE_CATEGORY_STORAGE, dc->categories);
1734 }
1735
1736 static void virtio_ccw_9p_instance_init(Object *obj)
1737 {
1738 V9fsCCWState *dev = VIRTIO_9P_CCW(obj);
1739
1740 virtio_instance_init_common(obj, &dev->vdev, sizeof(dev->vdev),
1741 TYPE_VIRTIO_9P);
1742 }
1743
1744 static const TypeInfo virtio_ccw_9p_info = {
1745 .name = TYPE_VIRTIO_9P_CCW,
1746 .parent = TYPE_VIRTIO_CCW_DEVICE,
1747 .instance_size = sizeof(V9fsCCWState),
1748 .instance_init = virtio_ccw_9p_instance_init,
1749 .class_init = virtio_ccw_9p_class_init,
1750 };
1751 #endif
1752
1753 #ifdef CONFIG_VHOST_VSOCK
1754
1755 static Property vhost_vsock_ccw_properties[] = {
1756 DEFINE_PROP_UINT32("max_revision", VirtioCcwDevice, max_rev,
1757 VIRTIO_CCW_MAX_REV),
1758 DEFINE_PROP_END_OF_LIST(),
1759 };
1760
1761 static void vhost_vsock_ccw_realize(VirtioCcwDevice *ccw_dev, Error **errp)
1762 {
1763 VHostVSockCCWState *dev = VHOST_VSOCK_CCW(ccw_dev);
1764 DeviceState *vdev = DEVICE(&dev->vdev);
1765 Error *err = NULL;
1766
1767 qdev_set_parent_bus(vdev, BUS(&ccw_dev->bus));
1768 object_property_set_bool(OBJECT(vdev), true, "realized", &err);
1769 error_propagate(errp, err);
1770 }
1771
1772 static void vhost_vsock_ccw_class_init(ObjectClass *klass, void *data)
1773 {
1774 DeviceClass *dc = DEVICE_CLASS(klass);
1775 VirtIOCCWDeviceClass *k = VIRTIO_CCW_DEVICE_CLASS(klass);
1776
1777 k->realize = vhost_vsock_ccw_realize;
1778 k->exit = virtio_ccw_exit;
1779 set_bit(DEVICE_CATEGORY_MISC, dc->categories);
1780 dc->props = vhost_vsock_ccw_properties;
1781 dc->reset = virtio_ccw_reset;
1782 }
1783
1784 static void vhost_vsock_ccw_instance_init(Object *obj)
1785 {
1786 VHostVSockCCWState *dev = VHOST_VSOCK_CCW(obj);
1787
1788 virtio_instance_init_common(obj, &dev->vdev, sizeof(dev->vdev),
1789 TYPE_VHOST_VSOCK);
1790 }
1791
1792 static const TypeInfo vhost_vsock_ccw_info = {
1793 .name = TYPE_VHOST_VSOCK_CCW,
1794 .parent = TYPE_VIRTIO_CCW_DEVICE,
1795 .instance_size = sizeof(VHostVSockCCWState),
1796 .instance_init = vhost_vsock_ccw_instance_init,
1797 .class_init = vhost_vsock_ccw_class_init,
1798 };
1799 #endif
1800
1801 static void virtio_ccw_register(void)
1802 {
1803 type_register_static(&virtio_ccw_bus_info);
1804 type_register_static(&virtio_ccw_device_info);
1805 type_register_static(&virtio_ccw_serial);
1806 type_register_static(&virtio_ccw_blk);
1807 type_register_static(&virtio_ccw_net);
1808 type_register_static(&virtio_ccw_balloon);
1809 type_register_static(&virtio_ccw_scsi);
1810 #ifdef CONFIG_VHOST_SCSI
1811 type_register_static(&vhost_ccw_scsi);
1812 #endif
1813 type_register_static(&virtio_ccw_rng);
1814 #ifdef CONFIG_VIRTFS
1815 type_register_static(&virtio_ccw_9p_info);
1816 #endif
1817 #ifdef CONFIG_VHOST_VSOCK
1818 type_register_static(&vhost_vsock_ccw_info);
1819 #endif
1820 type_register_static(&virtio_ccw_crypto);
1821 }
1822
1823 type_init(virtio_ccw_register)
QEmu