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