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