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