blob: 96747318d2a2a47246be6de72ce976a858c185d6 [file] [log] [blame]
Cornelia Hucka5cf2bb2013-01-24 06:08:55 +00001/*
2 * virtio ccw target implementation
3 *
Pierre Morelde6a9212015-05-27 13:11:59 +02004 * Copyright 2012,2015 IBM Corp.
Cornelia Hucka5cf2bb2013-01-24 06:08:55 +00005 * Author(s): Cornelia Huck <cornelia.huck@de.ibm.com>
Pierre Morelde6a9212015-05-27 13:11:59 +02006 * Pierre Morel <pmorel@linux.vnet.ibm.com>
Cornelia Hucka5cf2bb2013-01-24 06:08:55 +00007 *
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
Peter Maydell96154952016-01-26 18:17:00 +000013#include "qemu/osdep.h"
Markus Armbrusterda34e652016-03-14 09:01:28 +010014#include "qapi/error.h"
Paolo Bonzinia43de792022-03-28 13:41:29 +020015#include "exec/address-spaces.h"
Paolo Bonzinibd3f16a2015-12-04 12:06:26 +010016#include "sysemu/kvm.h"
Cornelia Hucka5cf2bb2013-01-24 06:08:55 +000017#include "net/net.h"
Paolo Bonzini0d09e412013-02-05 17:06:20 +010018#include "hw/virtio/virtio.h"
Markus Armbrusterca77ee22019-08-12 07:23:39 +020019#include "migration/qemu-file-types.h"
Paolo Bonzini0d09e412013-02-05 17:06:20 +010020#include "hw/virtio/virtio-net.h"
Cornelia Hucka5cf2bb2013-01-24 06:08:55 +000021#include "qemu/bitops.h"
Markus Armbrusterd49b6832015-03-17 18:29:20 +010022#include "qemu/error-report.h"
Paolo Bonzinia43de792022-03-28 13:41:29 +020023#include "qemu/log.h"
Markus Armbruster0b8fa322019-05-23 16:35:07 +020024#include "qemu/module.h"
Paolo Bonzini0d09e412013-02-05 17:06:20 +010025#include "hw/virtio/virtio-bus.h"
Cornelia Huckd426d9f2013-07-15 17:45:03 +020026#include "hw/s390x/adapter.h"
27#include "hw/s390x/s390_flic.h"
Cornelia Hucka5cf2bb2013-01-24 06:08:55 +000028
Paolo Bonzinibd3f16a2015-12-04 12:06:26 +010029#include "hw/s390x/ioinst.h"
30#include "hw/s390x/css.h"
Cornelia Hucka5cf2bb2013-01-24 06:08:55 +000031#include "virtio-ccw.h"
32#include "trace.h"
Jing Liudd70bd02015-11-06 12:32:40 +010033#include "hw/s390x/css-bridge.h"
Halil Pasic517ff122017-07-03 23:34:14 +020034#include "hw/s390x/s390-virtio-ccw.h"
Pavel Dovgalyuk3909c072021-05-17 16:06:28 +030035#include "sysemu/replay.h"
Cornelia Hucka5cf2bb2013-01-24 06:08:55 +000036
Halil Pasic797b6082015-12-10 12:55:06 +010037#define NR_CLASSIC_INDICATOR_BITS 64
38
Gerd Hoffmann2dd9d8c2021-03-17 10:56:21 +010039bool have_virtio_ccw = true;
40
Halil Pasic517ff122017-07-03 23:34:14 +020041static int virtio_ccw_dev_post_load(void *opaque, int version_id)
42{
43 VirtioCcwDevice *dev = VIRTIO_CCW_DEVICE(opaque);
44 CcwDevice *ccw_dev = CCW_DEVICE(dev);
45 CCWDeviceClass *ck = CCW_DEVICE_GET_CLASS(ccw_dev);
46
47 ccw_dev->sch->driver_data = dev;
48 if (ccw_dev->sch->thinint_active) {
49 dev->routes.adapter.adapter_id = css_get_adapter_id(
50 CSS_IO_ADAPTER_VIRTIO,
51 dev->thinint_isc);
52 }
53 /* Re-fill subch_id after loading the subchannel states.*/
54 if (ck->refill_ids) {
55 ck->refill_ids(ccw_dev);
56 }
57 return 0;
58}
59
60typedef struct VirtioCcwDeviceTmp {
61 VirtioCcwDevice *parent;
62 uint16_t config_vector;
63} VirtioCcwDeviceTmp;
64
Dr. David Alan Gilbert44b1ff32017-09-25 12:29:12 +010065static int virtio_ccw_dev_tmp_pre_save(void *opaque)
Halil Pasic517ff122017-07-03 23:34:14 +020066{
67 VirtioCcwDeviceTmp *tmp = opaque;
68 VirtioCcwDevice *dev = tmp->parent;
69 VirtIODevice *vdev = virtio_bus_get_device(&dev->bus);
70
71 tmp->config_vector = vdev->config_vector;
Dr. David Alan Gilbert44b1ff32017-09-25 12:29:12 +010072
73 return 0;
Halil Pasic517ff122017-07-03 23:34:14 +020074}
75
76static int virtio_ccw_dev_tmp_post_load(void *opaque, int version_id)
77{
78 VirtioCcwDeviceTmp *tmp = opaque;
79 VirtioCcwDevice *dev = tmp->parent;
80 VirtIODevice *vdev = virtio_bus_get_device(&dev->bus);
81
82 vdev->config_vector = tmp->config_vector;
83 return 0;
84}
85
86const VMStateDescription vmstate_virtio_ccw_dev_tmp = {
87 .name = "s390_virtio_ccw_dev_tmp",
88 .pre_save = virtio_ccw_dev_tmp_pre_save,
89 .post_load = virtio_ccw_dev_tmp_post_load,
Richard Hendersonb9b59a32023-12-21 14:16:31 +110090 .fields = (const VMStateField[]) {
Halil Pasic517ff122017-07-03 23:34:14 +020091 VMSTATE_UINT16(config_vector, VirtioCcwDeviceTmp),
92 VMSTATE_END_OF_LIST()
93 }
94};
95
96const VMStateDescription vmstate_virtio_ccw_dev = {
97 .name = "s390_virtio_ccw_dev",
98 .version_id = 1,
99 .minimum_version_id = 1,
100 .post_load = virtio_ccw_dev_post_load,
Richard Hendersonb9b59a32023-12-21 14:16:31 +1100101 .fields = (const VMStateField[]) {
Halil Pasic517ff122017-07-03 23:34:14 +0200102 VMSTATE_CCW_DEVICE(parent_obj, VirtioCcwDevice),
103 VMSTATE_PTR_TO_IND_ADDR(indicators, VirtioCcwDevice),
104 VMSTATE_PTR_TO_IND_ADDR(indicators2, VirtioCcwDevice),
105 VMSTATE_PTR_TO_IND_ADDR(summary_indicator, VirtioCcwDevice),
106 /*
107 * Ugly hack because VirtIODevice does not migrate itself.
108 * This also makes legacy via vmstate_save_state possible.
109 */
110 VMSTATE_WITH_TMP(VirtioCcwDevice, VirtioCcwDeviceTmp,
111 vmstate_virtio_ccw_dev_tmp),
112 VMSTATE_STRUCT(routes, VirtioCcwDevice, 1, vmstate_adapter_routes,
113 AdapterRoutes),
114 VMSTATE_UINT8(thinint_isc, VirtioCcwDevice),
115 VMSTATE_INT32(revision, VirtioCcwDevice),
116 VMSTATE_END_OF_LIST()
117 }
118};
119
Andreas Färber1bf4d7a2013-08-23 20:27:30 +0200120static void virtio_ccw_bus_new(VirtioBusState *bus, size_t bus_size,
121 VirtioCcwDevice *dev);
KONRAD Fredericd51fcfa2013-04-24 10:21:18 +0200122
Cornelia Hucka5cf2bb2013-01-24 06:08:55 +0000123VirtIODevice *virtio_ccw_get_vdev(SubchDev *sch)
124{
125 VirtIODevice *vdev = NULL;
Paolo Bonzinif24a6842013-09-20 13:51:52 +0200126 VirtioCcwDevice *dev = sch->driver_data;
Cornelia Hucka5cf2bb2013-01-24 06:08:55 +0000127
Paolo Bonzinif24a6842013-09-20 13:51:52 +0200128 if (dev) {
129 vdev = virtio_bus_get_device(&dev->bus);
Cornelia Hucka5cf2bb2013-01-24 06:08:55 +0000130 }
131 return vdev;
132}
133
Cornelia Huckb4436a02013-02-15 10:18:43 +0100134static void virtio_ccw_start_ioeventfd(VirtioCcwDevice *dev)
135{
Cornelia Huck7c55f682016-06-10 11:04:11 +0200136 virtio_bus_start_ioeventfd(&dev->bus);
Cornelia Huckb4436a02013-02-15 10:18:43 +0100137}
138
139static void virtio_ccw_stop_ioeventfd(VirtioCcwDevice *dev)
140{
Cornelia Huck7c55f682016-06-10 11:04:11 +0200141 virtio_bus_stop_ioeventfd(&dev->bus);
142}
Cornelia Huckb4436a02013-02-15 10:18:43 +0100143
Paolo Bonzini8e93cef2016-10-21 22:48:08 +0200144static bool virtio_ccw_ioeventfd_enabled(DeviceState *d)
Cornelia Huck7c55f682016-06-10 11:04:11 +0200145{
146 VirtioCcwDevice *dev = VIRTIO_CCW_DEVICE(d);
147
Paolo Bonzini8e93cef2016-10-21 22:48:08 +0200148 return (dev->flags & VIRTIO_CCW_FLAG_USE_IOEVENTFD) != 0;
Cornelia Huck7c55f682016-06-10 11:04:11 +0200149}
150
151static int virtio_ccw_ioeventfd_assign(DeviceState *d, EventNotifier *notifier,
152 int n, bool assign)
153{
154 VirtioCcwDevice *dev = VIRTIO_CCW_DEVICE(d);
Jing Liub804e8a2016-02-26 06:46:12 +0100155 CcwDevice *ccw_dev = CCW_DEVICE(dev);
156 SubchDev *sch = ccw_dev->sch;
Cornelia Huck7c55f682016-06-10 11:04:11 +0200157 uint32_t sch_id = (css_build_subchannel_id(sch) << 16) | sch->schid;
158
159 return s390_assign_subch_ioeventfd(notifier, sch_id, n, assign);
Cornelia Huckb4436a02013-02-15 10:18:43 +0100160}
161
Cornelia Hucka5cf2bb2013-01-24 06:08:55 +0000162/* Communication blocks used by several channel commands. */
Cornelia Huck0db87e02014-12-11 14:25:13 +0100163typedef struct VqInfoBlockLegacy {
Cornelia Hucka5cf2bb2013-01-24 06:08:55 +0000164 uint64_t queue;
165 uint32_t align;
166 uint16_t index;
167 uint16_t num;
Cornelia Huck0db87e02014-12-11 14:25:13 +0100168} QEMU_PACKED VqInfoBlockLegacy;
169
170typedef struct VqInfoBlock {
171 uint64_t desc;
172 uint32_t res0;
173 uint16_t index;
174 uint16_t num;
175 uint64_t avail;
176 uint64_t used;
Cornelia Hucka5cf2bb2013-01-24 06:08:55 +0000177} QEMU_PACKED VqInfoBlock;
178
179typedef struct VqConfigBlock {
180 uint16_t index;
181 uint16_t num_max;
182} QEMU_PACKED VqConfigBlock;
183
184typedef struct VirtioFeatDesc {
185 uint32_t features;
186 uint8_t index;
187} QEMU_PACKED VirtioFeatDesc;
188
Cornelia Huck7e749462013-02-06 10:31:37 +0100189typedef struct VirtioThinintInfo {
190 hwaddr summary_indicator;
191 hwaddr device_indicator;
192 uint64_t ind_bit;
193 uint8_t isc;
194} QEMU_PACKED VirtioThinintInfo;
195
Thomas Huthc42767f2014-12-11 14:25:12 +0100196typedef struct VirtioRevInfo {
197 uint16_t revision;
198 uint16_t length;
Philippe Mathieu-Daudé880a7812020-03-04 16:38:16 +0100199 uint8_t data[];
Thomas Huthc42767f2014-12-11 14:25:12 +0100200} QEMU_PACKED VirtioRevInfo;
201
Cornelia Hucka5cf2bb2013-01-24 06:08:55 +0000202/* Specify where the virtqueues for the subchannel are in guest memory. */
Cornelia Huck0db87e02014-12-11 14:25:13 +0100203static int virtio_ccw_set_vqs(SubchDev *sch, VqInfoBlock *info,
204 VqInfoBlockLegacy *linfo)
Cornelia Hucka5cf2bb2013-01-24 06:08:55 +0000205{
Paolo Bonzinif24a6842013-09-20 13:51:52 +0200206 VirtIODevice *vdev = virtio_ccw_get_vdev(sch);
Cornelia Huck0db87e02014-12-11 14:25:13 +0100207 uint16_t index = info ? info->index : linfo->index;
208 uint16_t num = info ? info->num : linfo->num;
209 uint64_t desc = info ? info->desc : linfo->queue;
Cornelia Hucka5cf2bb2013-01-24 06:08:55 +0000210
Halil Pasicb1914b82015-12-07 16:45:17 +0100211 if (index >= VIRTIO_QUEUE_MAX) {
Cornelia Hucka5cf2bb2013-01-24 06:08:55 +0000212 return -EINVAL;
213 }
214
215 /* Current code in virtio.c relies on 4K alignment. */
Cornelia Huck0db87e02014-12-11 14:25:13 +0100216 if (linfo && desc && (linfo->align != 4096)) {
Cornelia Hucka5cf2bb2013-01-24 06:08:55 +0000217 return -EINVAL;
218 }
219
Paolo Bonzinif24a6842013-09-20 13:51:52 +0200220 if (!vdev) {
Cornelia Hucka5cf2bb2013-01-24 06:08:55 +0000221 return -EINVAL;
222 }
223
Cornelia Huck0db87e02014-12-11 14:25:13 +0100224 if (info) {
225 virtio_queue_set_rings(vdev, index, desc, info->avail, info->used);
226 } else {
227 virtio_queue_set_addr(vdev, index, desc);
228 }
229 if (!desc) {
Jason Wang955cc8c2015-04-23 14:21:40 +0800230 virtio_queue_set_vector(vdev, index, VIRTIO_NO_VECTOR);
Cornelia Hucka5cf2bb2013-01-24 06:08:55 +0000231 } else {
Cornelia Huck79cd0c82015-09-11 15:16:42 +0200232 if (info) {
233 /* virtio-1 allows changing the ring size. */
Michael S. Tsirkin8c797e72017-01-12 23:26:22 +0200234 if (virtio_queue_get_max_num(vdev, index) < num) {
Cornelia Huck79cd0c82015-09-11 15:16:42 +0200235 /* Fail if we exceed the maximum number. */
236 return -EINVAL;
237 }
238 virtio_queue_set_num(vdev, index, num);
Carlos Lópezf0d634e2023-03-17 01:27:51 +0100239 virtio_init_region_cache(vdev, index);
Cornelia Huck79cd0c82015-09-11 15:16:42 +0200240 } else if (virtio_queue_get_num(vdev, index) > num) {
241 /* Fail if we don't have a big enough queue. */
Cornelia Hucka5cf2bb2013-01-24 06:08:55 +0000242 return -EINVAL;
243 }
Cornelia Huck79cd0c82015-09-11 15:16:42 +0200244 /* We ignore possible increased num for legacy for compatibility. */
Paolo Bonzinif24a6842013-09-20 13:51:52 +0200245 virtio_queue_set_vector(vdev, index, index);
Cornelia Hucka5cf2bb2013-01-24 06:08:55 +0000246 }
247 /* tell notify handler in case of config change */
Halil Pasicb1914b82015-12-07 16:45:17 +0100248 vdev->config_vector = VIRTIO_QUEUE_MAX;
Cornelia Hucka5cf2bb2013-01-24 06:08:55 +0000249 return 0;
250}
251
Paolo Bonzini997340f2022-06-09 08:35:45 +0200252static void virtio_ccw_reset_virtio(VirtioCcwDevice *dev)
Cornelia Huckfa8b0ca2015-06-23 15:46:31 +0200253{
Jing Liub804e8a2016-02-26 06:46:12 +0100254 CcwDevice *ccw_dev = CCW_DEVICE(dev);
255
Paolo Bonzini997340f2022-06-09 08:35:45 +0200256 virtio_bus_reset(&dev->bus);
Cornelia Huckfa8b0ca2015-06-23 15:46:31 +0200257 if (dev->indicators) {
258 release_indicator(&dev->routes.adapter, dev->indicators);
259 dev->indicators = NULL;
260 }
261 if (dev->indicators2) {
262 release_indicator(&dev->routes.adapter, dev->indicators2);
263 dev->indicators2 = NULL;
264 }
265 if (dev->summary_indicator) {
266 release_indicator(&dev->routes.adapter, dev->summary_indicator);
267 dev->summary_indicator = NULL;
268 }
Jing Liub804e8a2016-02-26 06:46:12 +0100269 ccw_dev->sch->thinint_active = false;
Cornelia Huckfa8b0ca2015-06-23 15:46:31 +0200270}
271
Cornelia Huck0db87e02014-12-11 14:25:13 +0100272static int virtio_ccw_handle_set_vq(SubchDev *sch, CCW1 ccw, bool check_len,
273 bool is_legacy)
Cornelia Hucka5cf2bb2013-01-24 06:08:55 +0000274{
275 int ret;
276 VqInfoBlock info;
Cornelia Huck0db87e02014-12-11 14:25:13 +0100277 VqInfoBlockLegacy linfo;
278 size_t info_len = is_legacy ? sizeof(linfo) : sizeof(info);
279
280 if (check_len) {
281 if (ccw.count != info_len) {
282 return -EINVAL;
283 }
284 } else if (ccw.count < info_len) {
285 /* Can't execute command. */
286 return -EINVAL;
287 }
288 if (!ccw.cda) {
289 return -EFAULT;
290 }
291 if (is_legacy) {
Pierre Moreld895d252021-04-08 18:32:09 +0200292 ret = ccw_dstream_read(&sch->cds, linfo);
293 if (ret) {
294 return ret;
295 }
Peter Maydellc9aacaa2018-12-10 12:04:36 +0000296 linfo.queue = be64_to_cpu(linfo.queue);
297 linfo.align = be32_to_cpu(linfo.align);
298 linfo.index = be16_to_cpu(linfo.index);
299 linfo.num = be16_to_cpu(linfo.num);
Cornelia Huck0db87e02014-12-11 14:25:13 +0100300 ret = virtio_ccw_set_vqs(sch, NULL, &linfo);
301 } else {
Pierre Moreld895d252021-04-08 18:32:09 +0200302 ret = ccw_dstream_read(&sch->cds, info);
303 if (ret) {
304 return ret;
305 }
Peter Maydellc9aacaa2018-12-10 12:04:36 +0000306 info.desc = be64_to_cpu(info.desc);
307 info.index = be16_to_cpu(info.index);
308 info.num = be16_to_cpu(info.num);
309 info.avail = be64_to_cpu(info.avail);
310 info.used = be64_to_cpu(info.used);
Cornelia Huck0db87e02014-12-11 14:25:13 +0100311 ret = virtio_ccw_set_vqs(sch, &info, NULL);
312 }
313 sch->curr_status.scsw.count = 0;
314 return ret;
315}
316
317static int virtio_ccw_cb(SubchDev *sch, CCW1 ccw)
318{
319 int ret;
Thomas Huthc42767f2014-12-11 14:25:12 +0100320 VirtioRevInfo revinfo;
Cornelia Hucka5cf2bb2013-01-24 06:08:55 +0000321 uint8_t status;
322 VirtioFeatDesc features;
Cornelia Hucka5cf2bb2013-01-24 06:08:55 +0000323 hwaddr indicators;
324 VqConfigBlock vq_config;
325 VirtioCcwDevice *dev = sch->driver_data;
Paolo Bonzinif24a6842013-09-20 13:51:52 +0200326 VirtIODevice *vdev = virtio_ccw_get_vdev(sch);
Cornelia Hucka5cf2bb2013-01-24 06:08:55 +0000327 bool check_len;
328 int len;
Halil Pasicf57ba052017-09-21 20:08:39 +0200329 VirtioThinintInfo thinint;
Cornelia Hucka5cf2bb2013-01-24 06:08:55 +0000330
331 if (!dev) {
332 return -EINVAL;
333 }
334
335 trace_virtio_ccw_interpret_ccw(sch->cssid, sch->ssid, sch->schid,
336 ccw.cmd_code);
337 check_len = !((ccw.flags & CCW_FLAG_SLI) && !(ccw.flags & CCW_FLAG_DC));
338
Cornelia Huck151fcdf2021-02-16 12:18:30 +0100339 if (dev->revision < 0 && ccw.cmd_code != CCW_CMD_SET_VIRTIO_REV) {
340 if (dev->force_revision_1) {
341 /*
342 * virtio-1 drivers must start with negotiating to a revision >= 1,
343 * so post a command reject for all other commands
344 */
345 return -ENOSYS;
346 } else {
347 /*
348 * If the driver issues any command that is not SET_VIRTIO_REV,
349 * we'll have to operate the device in legacy mode.
350 */
351 dev->revision = 0;
352 }
Halil Pasic47e13df2017-02-14 14:06:07 +0100353 }
354
Cornelia Hucka5cf2bb2013-01-24 06:08:55 +0000355 /* Look at the command. */
356 switch (ccw.cmd_code) {
357 case CCW_CMD_SET_VQ:
Cornelia Huck0db87e02014-12-11 14:25:13 +0100358 ret = virtio_ccw_handle_set_vq(sch, ccw, check_len, dev->revision < 1);
Cornelia Hucka5cf2bb2013-01-24 06:08:55 +0000359 break;
360 case CCW_CMD_VDEV_RESET:
Paolo Bonzini997340f2022-06-09 08:35:45 +0200361 virtio_ccw_reset_virtio(dev);
Cornelia Hucka5cf2bb2013-01-24 06:08:55 +0000362 ret = 0;
363 break;
364 case CCW_CMD_READ_FEAT:
365 if (check_len) {
366 if (ccw.count != sizeof(features)) {
367 ret = -EINVAL;
368 break;
369 }
370 } else if (ccw.count < sizeof(features)) {
371 /* Can't execute command. */
372 ret = -EINVAL;
373 break;
374 }
375 if (!ccw.cda) {
376 ret = -EFAULT;
377 } else {
Michael S. Tsirkin9b706db2016-11-04 12:04:23 +0200378 VirtioDeviceClass *vdc = VIRTIO_DEVICE_GET_CLASS(vdev);
379
Halil Pasicf57ba052017-09-21 20:08:39 +0200380 ccw_dstream_advance(&sch->cds, sizeof(features.features));
Pierre Moreld895d252021-04-08 18:32:09 +0200381 ret = ccw_dstream_read(&sch->cds, features.index);
382 if (ret) {
383 break;
384 }
Cornelia Huck6b8f1022015-05-26 16:34:47 +0200385 if (features.index == 0) {
Cornelia Huck542571d2015-09-11 15:16:44 +0200386 if (dev->revision >= 1) {
387 /* Don't offer legacy features for modern devices. */
388 features.features = (uint32_t)
Michael S. Tsirkin9b706db2016-11-04 12:04:23 +0200389 (vdev->host_features & ~vdc->legacy_features);
Cornelia Huck542571d2015-09-11 15:16:44 +0200390 } else {
391 features.features = (uint32_t)vdev->host_features;
392 }
Cornelia Huckb4f8f9d2015-09-11 15:16:43 +0200393 } else if ((features.index == 1) && (dev->revision >= 1)) {
Thomas Huthc42767f2014-12-11 14:25:12 +0100394 /*
Cornelia Huckb4f8f9d2015-09-11 15:16:43 +0200395 * Only offer feature bits beyond 31 if the guest has
396 * negotiated at least revision 1.
Thomas Huthc42767f2014-12-11 14:25:12 +0100397 */
Cornelia Huckb4f8f9d2015-09-11 15:16:43 +0200398 features.features = (uint32_t)(vdev->host_features >> 32);
Cornelia Hucka5cf2bb2013-01-24 06:08:55 +0000399 } else {
400 /* Return zeroes if the guest supports more feature bits. */
401 features.features = 0;
402 }
Halil Pasicf57ba052017-09-21 20:08:39 +0200403 ccw_dstream_rewind(&sch->cds);
Peter Maydellc9aacaa2018-12-10 12:04:36 +0000404 features.features = cpu_to_le32(features.features);
Pierre Moreld895d252021-04-08 18:32:09 +0200405 ret = ccw_dstream_write(&sch->cds, features.features);
406 if (!ret) {
407 sch->curr_status.scsw.count = ccw.count - sizeof(features);
408 }
Cornelia Hucka5cf2bb2013-01-24 06:08:55 +0000409 }
410 break;
411 case CCW_CMD_WRITE_FEAT:
412 if (check_len) {
413 if (ccw.count != sizeof(features)) {
414 ret = -EINVAL;
415 break;
416 }
417 } else if (ccw.count < sizeof(features)) {
418 /* Can't execute command. */
419 ret = -EINVAL;
420 break;
421 }
422 if (!ccw.cda) {
423 ret = -EFAULT;
424 } else {
Pierre Moreld895d252021-04-08 18:32:09 +0200425 ret = ccw_dstream_read(&sch->cds, features);
426 if (ret) {
427 break;
428 }
Peter Maydellc9aacaa2018-12-10 12:04:36 +0000429 features.features = le32_to_cpu(features.features);
Cornelia Huck6b8f1022015-05-26 16:34:47 +0200430 if (features.index == 0) {
Thomas Huthc42767f2014-12-11 14:25:12 +0100431 virtio_set_features(vdev,
432 (vdev->guest_features & 0xffffffff00000000ULL) |
433 features.features);
Cornelia Huckb4f8f9d2015-09-11 15:16:43 +0200434 } else if ((features.index == 1) && (dev->revision >= 1)) {
Thomas Huthc42767f2014-12-11 14:25:12 +0100435 /*
Cornelia Huckb4f8f9d2015-09-11 15:16:43 +0200436 * If the guest did not negotiate at least revision 1,
437 * we did not offer it any feature bits beyond 31. Such a
438 * guest passing us any bit here is therefore buggy.
Thomas Huthc42767f2014-12-11 14:25:12 +0100439 */
Thomas Huthc42767f2014-12-11 14:25:12 +0100440 virtio_set_features(vdev,
441 (vdev->guest_features & 0x00000000ffffffffULL) |
442 ((uint64_t)features.features << 32));
Cornelia Hucka5cf2bb2013-01-24 06:08:55 +0000443 } else {
444 /*
445 * If the guest supports more feature bits, assert that it
446 * passes us zeroes for those we don't support.
447 */
448 if (features.features) {
Alistair Francis74a69e02017-12-20 09:24:41 -0800449 qemu_log_mask(LOG_GUEST_ERROR,
450 "Guest bug: features[%i]=%x (expected 0)",
451 features.index, features.features);
Cornelia Hucka5cf2bb2013-01-24 06:08:55 +0000452 /* XXX: do a unit check here? */
453 }
454 }
455 sch->curr_status.scsw.count = ccw.count - sizeof(features);
456 ret = 0;
457 }
458 break;
459 case CCW_CMD_READ_CONF:
460 if (check_len) {
Paolo Bonzinif24a6842013-09-20 13:51:52 +0200461 if (ccw.count > vdev->config_len) {
Cornelia Hucka5cf2bb2013-01-24 06:08:55 +0000462 ret = -EINVAL;
463 break;
464 }
465 }
Paolo Bonzinif24a6842013-09-20 13:51:52 +0200466 len = MIN(ccw.count, vdev->config_len);
Cornelia Hucka5cf2bb2013-01-24 06:08:55 +0000467 if (!ccw.cda) {
468 ret = -EFAULT;
469 } else {
Paolo Bonzinif24a6842013-09-20 13:51:52 +0200470 virtio_bus_get_vdev_config(&dev->bus, vdev->config);
Pierre Moreld895d252021-04-08 18:32:09 +0200471 ret = ccw_dstream_write_buf(&sch->cds, vdev->config, len);
472 if (ret) {
473 sch->curr_status.scsw.count = ccw.count - len;
474 }
Cornelia Hucka5cf2bb2013-01-24 06:08:55 +0000475 }
476 break;
477 case CCW_CMD_WRITE_CONF:
478 if (check_len) {
Paolo Bonzinif24a6842013-09-20 13:51:52 +0200479 if (ccw.count > vdev->config_len) {
Cornelia Hucka5cf2bb2013-01-24 06:08:55 +0000480 ret = -EINVAL;
481 break;
482 }
483 }
Paolo Bonzinif24a6842013-09-20 13:51:52 +0200484 len = MIN(ccw.count, vdev->config_len);
Cornelia Hucka5cf2bb2013-01-24 06:08:55 +0000485 if (!ccw.cda) {
486 ret = -EFAULT;
487 } else {
Halil Pasicf57ba052017-09-21 20:08:39 +0200488 ret = ccw_dstream_read_buf(&sch->cds, vdev->config, len);
489 if (!ret) {
Paolo Bonzinif24a6842013-09-20 13:51:52 +0200490 virtio_bus_set_vdev_config(&dev->bus, vdev->config);
Cornelia Hucka5cf2bb2013-01-24 06:08:55 +0000491 sch->curr_status.scsw.count = ccw.count - len;
Cornelia Hucka5cf2bb2013-01-24 06:08:55 +0000492 }
493 }
494 break;
Pierre Morele32652f2016-09-07 12:58:40 +0200495 case CCW_CMD_READ_STATUS:
496 if (check_len) {
497 if (ccw.count != sizeof(status)) {
498 ret = -EINVAL;
499 break;
500 }
501 } else if (ccw.count < sizeof(status)) {
502 /* Can't execute command. */
503 ret = -EINVAL;
504 break;
505 }
506 if (!ccw.cda) {
507 ret = -EFAULT;
508 } else {
509 address_space_stb(&address_space_memory, ccw.cda, vdev->status,
510 MEMTXATTRS_UNSPECIFIED, NULL);
Ladi Prosek3c254ab2017-10-17 16:40:51 +0200511 sch->curr_status.scsw.count = ccw.count - sizeof(vdev->status);
Pierre Morele32652f2016-09-07 12:58:40 +0200512 ret = 0;
513 }
514 break;
Cornelia Hucka5cf2bb2013-01-24 06:08:55 +0000515 case CCW_CMD_WRITE_STATUS:
516 if (check_len) {
517 if (ccw.count != sizeof(status)) {
518 ret = -EINVAL;
519 break;
520 }
521 } else if (ccw.count < sizeof(status)) {
522 /* Can't execute command. */
523 ret = -EINVAL;
524 break;
525 }
526 if (!ccw.cda) {
527 ret = -EFAULT;
528 } else {
Pierre Moreld895d252021-04-08 18:32:09 +0200529 ret = ccw_dstream_read(&sch->cds, status);
530 if (ret) {
531 break;
532 }
Cornelia Huckb4436a02013-02-15 10:18:43 +0100533 if (!(status & VIRTIO_CONFIG_S_DRIVER_OK)) {
534 virtio_ccw_stop_ioeventfd(dev);
535 }
Cornelia Huck0b352fd2015-06-04 12:34:15 +0200536 if (virtio_set_status(vdev, status) == 0) {
537 if (vdev->status == 0) {
Paolo Bonzini997340f2022-06-09 08:35:45 +0200538 virtio_ccw_reset_virtio(dev);
Cornelia Huck0b352fd2015-06-04 12:34:15 +0200539 }
540 if (status & VIRTIO_CONFIG_S_DRIVER_OK) {
541 virtio_ccw_start_ioeventfd(dev);
542 }
543 sch->curr_status.scsw.count = ccw.count - sizeof(status);
544 ret = 0;
545 } else {
546 /* Trigger a command reject. */
547 ret = -ENOSYS;
Cornelia Hucka5cf2bb2013-01-24 06:08:55 +0000548 }
Cornelia Hucka5cf2bb2013-01-24 06:08:55 +0000549 }
550 break;
551 case CCW_CMD_SET_IND:
552 if (check_len) {
553 if (ccw.count != sizeof(indicators)) {
554 ret = -EINVAL;
555 break;
556 }
557 } else if (ccw.count < sizeof(indicators)) {
558 /* Can't execute command. */
559 ret = -EINVAL;
560 break;
561 }
Cornelia Huck7e749462013-02-06 10:31:37 +0100562 if (sch->thinint_active) {
563 /* Trigger a command reject. */
564 ret = -ENOSYS;
565 break;
566 }
Halil Pasic797b6082015-12-10 12:55:06 +0100567 if (virtio_get_num_queues(vdev) > NR_CLASSIC_INDICATOR_BITS) {
568 /* More queues than indicator bits --> trigger a reject */
569 ret = -ENOSYS;
570 break;
571 }
Cornelia Huckd1db1fa2013-06-05 17:13:05 +0200572 if (!ccw.cda) {
Cornelia Hucka5cf2bb2013-01-24 06:08:55 +0000573 ret = -EFAULT;
574 } else {
Pierre Moreld895d252021-04-08 18:32:09 +0200575 ret = ccw_dstream_read(&sch->cds, indicators);
576 if (ret) {
577 break;
578 }
Peter Maydellc9aacaa2018-12-10 12:04:36 +0000579 indicators = be64_to_cpu(indicators);
Cornelia Huck7bca3892013-08-01 17:27:00 +0200580 dev->indicators = get_indicator(indicators, sizeof(uint64_t));
Cornelia Hucka5cf2bb2013-01-24 06:08:55 +0000581 sch->curr_status.scsw.count = ccw.count - sizeof(indicators);
582 ret = 0;
583 }
584 break;
585 case CCW_CMD_SET_CONF_IND:
586 if (check_len) {
587 if (ccw.count != sizeof(indicators)) {
588 ret = -EINVAL;
589 break;
590 }
591 } else if (ccw.count < sizeof(indicators)) {
592 /* Can't execute command. */
593 ret = -EINVAL;
594 break;
595 }
Cornelia Huckd1db1fa2013-06-05 17:13:05 +0200596 if (!ccw.cda) {
Cornelia Hucka5cf2bb2013-01-24 06:08:55 +0000597 ret = -EFAULT;
598 } else {
Pierre Moreld895d252021-04-08 18:32:09 +0200599 ret = ccw_dstream_read(&sch->cds, indicators);
600 if (ret) {
601 break;
602 }
Peter Maydellc9aacaa2018-12-10 12:04:36 +0000603 indicators = be64_to_cpu(indicators);
Cornelia Huck7bca3892013-08-01 17:27:00 +0200604 dev->indicators2 = get_indicator(indicators, sizeof(uint64_t));
Cornelia Hucka5cf2bb2013-01-24 06:08:55 +0000605 sch->curr_status.scsw.count = ccw.count - sizeof(indicators);
606 ret = 0;
607 }
608 break;
609 case CCW_CMD_READ_VQ_CONF:
610 if (check_len) {
611 if (ccw.count != sizeof(vq_config)) {
612 ret = -EINVAL;
613 break;
614 }
615 } else if (ccw.count < sizeof(vq_config)) {
616 /* Can't execute command. */
617 ret = -EINVAL;
618 break;
619 }
620 if (!ccw.cda) {
621 ret = -EFAULT;
622 } else {
Pierre Moreld895d252021-04-08 18:32:09 +0200623 ret = ccw_dstream_read(&sch->cds, vq_config.index);
624 if (ret) {
625 break;
626 }
Peter Maydellc9aacaa2018-12-10 12:04:36 +0000627 vq_config.index = be16_to_cpu(vq_config.index);
Halil Pasicb1914b82015-12-07 16:45:17 +0100628 if (vq_config.index >= VIRTIO_QUEUE_MAX) {
Cornelia Huckd03a3632015-03-20 13:16:20 +0100629 ret = -EINVAL;
630 break;
631 }
Paolo Bonzinif24a6842013-09-20 13:51:52 +0200632 vq_config.num_max = virtio_queue_get_num(vdev,
Cornelia Hucka5cf2bb2013-01-24 06:08:55 +0000633 vq_config.index);
Peter Maydellc9aacaa2018-12-10 12:04:36 +0000634 vq_config.num_max = cpu_to_be16(vq_config.num_max);
Pierre Moreld895d252021-04-08 18:32:09 +0200635 ret = ccw_dstream_write(&sch->cds, vq_config.num_max);
636 if (!ret) {
637 sch->curr_status.scsw.count = ccw.count - sizeof(vq_config);
638 }
Cornelia Hucka5cf2bb2013-01-24 06:08:55 +0000639 }
640 break;
Cornelia Huck7e749462013-02-06 10:31:37 +0100641 case CCW_CMD_SET_IND_ADAPTER:
642 if (check_len) {
Halil Pasicf57ba052017-09-21 20:08:39 +0200643 if (ccw.count != sizeof(thinint)) {
Cornelia Huck7e749462013-02-06 10:31:37 +0100644 ret = -EINVAL;
645 break;
646 }
Halil Pasicf57ba052017-09-21 20:08:39 +0200647 } else if (ccw.count < sizeof(thinint)) {
Cornelia Huck7e749462013-02-06 10:31:37 +0100648 /* Can't execute command. */
649 ret = -EINVAL;
650 break;
651 }
Cornelia Huck7e749462013-02-06 10:31:37 +0100652 if (!ccw.cda) {
653 ret = -EFAULT;
654 } else if (dev->indicators && !sch->thinint_active) {
655 /* Trigger a command reject. */
656 ret = -ENOSYS;
657 } else {
Halil Pasicf57ba052017-09-21 20:08:39 +0200658 if (ccw_dstream_read(&sch->cds, thinint)) {
Cornelia Huck7e749462013-02-06 10:31:37 +0100659 ret = -EFAULT;
660 } else {
Peter Maydellc9aacaa2018-12-10 12:04:36 +0000661 thinint.ind_bit = be64_to_cpu(thinint.ind_bit);
662 thinint.summary_indicator =
663 be64_to_cpu(thinint.summary_indicator);
664 thinint.device_indicator =
665 be64_to_cpu(thinint.device_indicator);
Cornelia Huck7d452852015-03-11 10:57:50 +0100666
Cornelia Huck7bca3892013-08-01 17:27:00 +0200667 dev->summary_indicator =
Halil Pasicf57ba052017-09-21 20:08:39 +0200668 get_indicator(thinint.summary_indicator, sizeof(uint8_t));
Cornelia Huck7d452852015-03-11 10:57:50 +0100669 dev->indicators =
Halil Pasicf57ba052017-09-21 20:08:39 +0200670 get_indicator(thinint.device_indicator,
671 thinint.ind_bit / 8 + 1);
672 dev->thinint_isc = thinint.isc;
673 dev->routes.adapter.ind_offset = thinint.ind_bit;
Cornelia Huckd426d9f2013-07-15 17:45:03 +0200674 dev->routes.adapter.summary_offset = 7;
Fei Lidde522b2016-11-24 11:10:39 +0100675 dev->routes.adapter.adapter_id = css_get_adapter_id(
676 CSS_IO_ADAPTER_VIRTIO,
677 dev->thinint_isc);
Cornelia Huck7bca3892013-08-01 17:27:00 +0200678 sch->thinint_active = ((dev->indicators != NULL) &&
679 (dev->summary_indicator != NULL));
Halil Pasicf57ba052017-09-21 20:08:39 +0200680 sch->curr_status.scsw.count = ccw.count - sizeof(thinint);
Cornelia Huck7e749462013-02-06 10:31:37 +0100681 ret = 0;
682 }
683 }
684 break;
Thomas Huthc42767f2014-12-11 14:25:12 +0100685 case CCW_CMD_SET_VIRTIO_REV:
686 len = sizeof(revinfo);
687 if (ccw.count < len) {
688 ret = -EINVAL;
689 break;
690 }
691 if (!ccw.cda) {
692 ret = -EFAULT;
693 break;
694 }
Pierre Moreld895d252021-04-08 18:32:09 +0200695 ret = ccw_dstream_read_buf(&sch->cds, &revinfo, 4);
696 if (ret < 0) {
697 break;
698 }
Peter Maydellc9aacaa2018-12-10 12:04:36 +0000699 revinfo.revision = be16_to_cpu(revinfo.revision);
700 revinfo.length = be16_to_cpu(revinfo.length);
Thomas Huthc42767f2014-12-11 14:25:12 +0100701 if (ccw.count < len + revinfo.length ||
702 (check_len && ccw.count > len + revinfo.length)) {
703 ret = -EINVAL;
704 break;
705 }
706 /*
707 * Once we start to support revisions with additional data, we'll
708 * need to fetch it here. Nothing to do for now, though.
709 */
710 if (dev->revision >= 0 ||
Halil Pasic47e13df2017-02-14 14:06:07 +0100711 revinfo.revision > virtio_ccw_rev_max(dev) ||
712 (dev->force_revision_1 && !revinfo.revision)) {
Thomas Huthc42767f2014-12-11 14:25:12 +0100713 ret = -ENOSYS;
714 break;
715 }
716 ret = 0;
717 dev->revision = revinfo.revision;
718 break;
Cornelia Hucka5cf2bb2013-01-24 06:08:55 +0000719 default:
Cornelia Huck8d034a62013-01-28 17:01:30 +0100720 ret = -ENOSYS;
Cornelia Hucka5cf2bb2013-01-24 06:08:55 +0000721 break;
722 }
723 return ret;
724}
725
Thomas Huthc42767f2014-12-11 14:25:12 +0100726static void virtio_sch_disable_cb(SubchDev *sch)
727{
728 VirtioCcwDevice *dev = sch->driver_data;
729
730 dev->revision = -1;
731}
732
Cornelia Huck1fa75522015-04-21 16:36:55 +0200733static void virtio_ccw_device_realize(VirtioCcwDevice *dev, Error **errp)
Cornelia Hucka5cf2bb2013-01-24 06:08:55 +0000734{
Cornelia Huck1fa75522015-04-21 16:36:55 +0200735 VirtIOCCWDeviceClass *k = VIRTIO_CCW_DEVICE_GET_CLASS(dev);
Jing Liub804e8a2016-02-26 06:46:12 +0100736 CcwDevice *ccw_dev = CCW_DEVICE(dev);
Dong Jia Shid8d98db2017-02-22 03:10:30 +0100737 CCWDeviceClass *ck = CCW_DEVICE_GET_CLASS(ccw_dev);
Dong Jia Shi817d4a62017-05-17 02:48:05 +0200738 SubchDev *sch;
Sascha Silbecf249932016-06-15 17:16:05 +0200739 Error *err = NULL;
Cornelia Huck3c5fd802020-01-16 13:10:35 +0100740 int i;
Cornelia Hucka5cf2bb2013-01-24 06:08:55 +0000741
Cornelia Huck36699ab2018-07-23 18:32:21 +0200742 sch = css_create_sch(ccw_dev->devno, errp);
Sascha Silbecf249932016-06-15 17:16:05 +0200743 if (!sch) {
744 return;
Cornelia Hucka5cf2bb2013-01-24 06:08:55 +0000745 }
Halil Pasic47e13df2017-02-14 14:06:07 +0100746 if (!virtio_ccw_rev_max(dev) && dev->force_revision_1) {
747 error_setg(&err, "Invalid value of property max_rev "
748 "(is %d expected >= 1)", virtio_ccw_rev_max(dev));
Dong Jia Shid8d98db2017-02-22 03:10:30 +0100749 goto out_err;
Halil Pasic47e13df2017-02-14 14:06:07 +0100750 }
Cornelia Hucka5cf2bb2013-01-24 06:08:55 +0000751
Sascha Silbecf249932016-06-15 17:16:05 +0200752 sch->driver_data = dev;
Cornelia Hucka5cf2bb2013-01-24 06:08:55 +0000753 sch->ccw_cb = virtio_ccw_cb;
Thomas Huthc42767f2014-12-11 14:25:12 +0100754 sch->disable_cb = virtio_sch_disable_cb;
Cornelia Hucka5cf2bb2013-01-24 06:08:55 +0000755 sch->id.reserved = 0xff;
756 sch->id.cu_type = VIRTIO_CCW_CU_TYPE;
Xiao Feng Renbab482d2017-05-17 02:48:11 +0200757 sch->do_subchannel_work = do_subchannel_work_virtual;
Eric Farman0599a042021-06-18 01:25:36 +0200758 sch->irb_cb = build_irb_virtual;
Jing Liub804e8a2016-02-26 06:46:12 +0100759 ccw_dev->sch = sch;
Sascha Silbecf249932016-06-15 17:16:05 +0200760 dev->indicators = NULL;
Thomas Huthc42767f2014-12-11 14:25:12 +0100761 dev->revision = -1;
Cornelia Huck3c5fd802020-01-16 13:10:35 +0100762 for (i = 0; i < ADAPTER_ROUTES_MAX_GSI; i++) {
763 dev->routes.gsi[i] = -1;
764 }
Sascha Silbecf249932016-06-15 17:16:05 +0200765 css_sch_build_virtual_schib(sch, 0, VIRTIO_CCW_CHPID_TYPE);
766
767 trace_virtio_ccw_new_device(
768 sch->cssid, sch->ssid, sch->schid, sch->devno,
Dong Jia Shi2a78ac62017-02-15 06:33:03 +0100769 ccw_dev->devno.valid ? "user-configured" : "auto-configured");
Thomas Huthc42767f2014-12-11 14:25:12 +0100770
Pavel Dovgalyuk3909c072021-05-17 16:06:28 +0300771 /* fd-based ioevents can't be synchronized in record/replay */
772 if (replay_mode != REPLAY_MODE_NONE) {
773 dev->flags &= ~VIRTIO_CCW_FLAG_USE_IOEVENTFD;
774 }
775
Cornelia Huck1fa75522015-04-21 16:36:55 +0200776 if (k->realize) {
777 k->realize(dev, &err);
Dong Jia Shid8d98db2017-02-22 03:10:30 +0100778 if (err) {
779 goto out_err;
780 }
Cornelia Huck1fa75522015-04-21 16:36:55 +0200781 }
Dong Jia Shid8d98db2017-02-22 03:10:30 +0100782
783 ck->realize(ccw_dev, &err);
Cornelia Huck1fa75522015-04-21 16:36:55 +0200784 if (err) {
Dong Jia Shid8d98db2017-02-22 03:10:30 +0100785 goto out_err;
Cornelia Huck1fa75522015-04-21 16:36:55 +0200786 }
Dong Jia Shid8d98db2017-02-22 03:10:30 +0100787
788 return;
789
790out_err:
791 error_propagate(errp, err);
792 css_subch_assign(sch->cssid, sch->ssid, sch->schid, sch->devno, NULL);
793 ccw_dev->sch = NULL;
794 g_free(sch);
Cornelia Hucka5cf2bb2013-01-24 06:08:55 +0000795}
796
Markus Armbrusterb69c3c22020-05-05 17:29:24 +0200797static void virtio_ccw_device_unrealize(VirtioCcwDevice *dev)
Cornelia Hucka5cf2bb2013-01-24 06:08:55 +0000798{
Thomas Huth2d6ff332018-07-25 14:20:15 +0200799 VirtIOCCWDeviceClass *dc = VIRTIO_CCW_DEVICE_GET_CLASS(dev);
Jing Liub804e8a2016-02-26 06:46:12 +0100800 CcwDevice *ccw_dev = CCW_DEVICE(dev);
801 SubchDev *sch = ccw_dev->sch;
Cornelia Hucka5cf2bb2013-01-24 06:08:55 +0000802
Thomas Huth2d6ff332018-07-25 14:20:15 +0200803 if (dc->unrealize) {
Markus Armbrusterb69c3c22020-05-05 17:29:24 +0200804 dc->unrealize(dev);
Thomas Huth2d6ff332018-07-25 14:20:15 +0200805 }
806
Cornelia Hucka5cf2bb2013-01-24 06:08:55 +0000807 if (sch) {
808 css_subch_assign(sch->cssid, sch->ssid, sch->schid, sch->devno, NULL);
809 g_free(sch);
Nia Alarie24118af2018-03-07 16:29:58 +0000810 ccw_dev->sch = NULL;
Cornelia Hucka5cf2bb2013-01-24 06:08:55 +0000811 }
Cornelia Huck7bca3892013-08-01 17:27:00 +0200812 if (dev->indicators) {
Cornelia Huckd426d9f2013-07-15 17:45:03 +0200813 release_indicator(&dev->routes.adapter, dev->indicators);
Cornelia Huck7bca3892013-08-01 17:27:00 +0200814 dev->indicators = NULL;
815 }
Cornelia Hucka5cf2bb2013-01-24 06:08:55 +0000816}
817
Cornelia Hucka5cf2bb2013-01-24 06:08:55 +0000818/* DeviceState to VirtioCcwDevice. Note: used on datapath,
819 * be careful and test performance if you change this.
820 */
821static inline VirtioCcwDevice *to_virtio_ccw_dev_fast(DeviceState *d)
822{
Jing Liub804e8a2016-02-26 06:46:12 +0100823 CcwDevice *ccw_dev = to_ccw_dev_fast(d);
824
825 return container_of(ccw_dev, VirtioCcwDevice, parent_obj);
Cornelia Hucka5cf2bb2013-01-24 06:08:55 +0000826}
827
Cornelia Huck7e749462013-02-06 10:31:37 +0100828static uint8_t virtio_set_ind_atomic(SubchDev *sch, uint64_t ind_loc,
829 uint8_t to_be_set)
830{
Halil Pasic1a8242f2020-06-16 06:50:34 +0200831 uint8_t expected, actual;
Cornelia Huck7e749462013-02-06 10:31:37 +0100832 hwaddr len = 1;
Halil Pasic1a8242f2020-06-16 06:50:34 +0200833 /* avoid multiple fetches */
834 uint8_t volatile *ind_addr;
Cornelia Huck7e749462013-02-06 10:31:37 +0100835
Philippe Mathieu-Daudé85eb7c12020-02-19 20:20:42 +0100836 ind_addr = cpu_physical_memory_map(ind_loc, &len, true);
Cornelia Huck7e749462013-02-06 10:31:37 +0100837 if (!ind_addr) {
838 error_report("%s(%x.%x.%04x): unable to access indicator",
839 __func__, sch->cssid, sch->ssid, sch->schid);
840 return -1;
841 }
Halil Pasic1a8242f2020-06-16 06:50:34 +0200842 actual = *ind_addr;
Cornelia Huck7e749462013-02-06 10:31:37 +0100843 do {
Halil Pasic1a8242f2020-06-16 06:50:34 +0200844 expected = actual;
Stefan Hajnoczid73415a2020-09-23 11:56:46 +0100845 actual = qatomic_cmpxchg(ind_addr, expected, expected | to_be_set);
Halil Pasic1a8242f2020-06-16 06:50:34 +0200846 } while (actual != expected);
847 trace_virtio_ccw_set_ind(ind_loc, actual, actual | to_be_set);
848 cpu_physical_memory_unmap((void *)ind_addr, len, 1, len);
Cornelia Huck7e749462013-02-06 10:31:37 +0100849
Halil Pasic1a8242f2020-06-16 06:50:34 +0200850 return actual;
Cornelia Huck7e749462013-02-06 10:31:37 +0100851}
852
Cornelia Hucka5cf2bb2013-01-24 06:08:55 +0000853static void virtio_ccw_notify(DeviceState *d, uint16_t vector)
854{
855 VirtioCcwDevice *dev = to_virtio_ccw_dev_fast(d);
Jing Liub804e8a2016-02-26 06:46:12 +0100856 CcwDevice *ccw_dev = to_ccw_dev_fast(d);
857 SubchDev *sch = ccw_dev->sch;
Cornelia Hucka5cf2bb2013-01-24 06:08:55 +0000858 uint64_t indicators;
859
Halil Pasic7a5342e2018-05-16 15:27:57 +0200860 if (vector == VIRTIO_NO_VECTOR) {
Cornelia Hucka5cf2bb2013-01-24 06:08:55 +0000861 return;
862 }
Halil Pasic7a5342e2018-05-16 15:27:57 +0200863 /*
864 * vector < VIRTIO_QUEUE_MAX: notification for a virtqueue
865 * vector == VIRTIO_QUEUE_MAX: configuration change notification
866 * bits beyond that are unused and should never be notified for
867 */
868 assert(vector <= VIRTIO_QUEUE_MAX);
Cornelia Hucka5cf2bb2013-01-24 06:08:55 +0000869
Halil Pasicb1914b82015-12-07 16:45:17 +0100870 if (vector < VIRTIO_QUEUE_MAX) {
Cornelia Huck7c486972013-04-23 17:15:19 +0200871 if (!dev->indicators) {
872 return;
873 }
Cornelia Huck7e749462013-02-06 10:31:37 +0100874 if (sch->thinint_active) {
875 /*
876 * In the adapter interrupt case, indicators points to a
877 * memory area that may be (way) larger than 64 bit and
878 * ind_bit indicates the start of the indicators in a big
879 * endian notation.
880 */
Cornelia Huckd426d9f2013-07-15 17:45:03 +0200881 uint64_t ind_bit = dev->routes.adapter.ind_offset;
882
Cornelia Huck7bca3892013-08-01 17:27:00 +0200883 virtio_set_ind_atomic(sch, dev->indicators->addr +
Cornelia Huckd426d9f2013-07-15 17:45:03 +0200884 (ind_bit + vector) / 8,
885 0x80 >> ((ind_bit + vector) % 8));
Cornelia Huck7bca3892013-08-01 17:27:00 +0200886 if (!virtio_set_ind_atomic(sch, dev->summary_indicator->addr,
Cornelia Huck7e749462013-02-06 10:31:37 +0100887 0x01)) {
Yi Min Zhao25a08b82017-02-17 15:26:48 +0800888 css_adapter_interrupt(CSS_IO_ADAPTER_VIRTIO, dev->thinint_isc);
Cornelia Huck7e749462013-02-06 10:31:37 +0100889 }
890 } else {
Halil Pasic7a5342e2018-05-16 15:27:57 +0200891 assert(vector < NR_CLASSIC_INDICATOR_BITS);
Peter Maydell42874d32015-04-26 16:49:24 +0100892 indicators = address_space_ldq(&address_space_memory,
893 dev->indicators->addr,
894 MEMTXATTRS_UNSPECIFIED,
895 NULL);
Cornelia Huck7e749462013-02-06 10:31:37 +0100896 indicators |= 1ULL << vector;
Peter Maydell42874d32015-04-26 16:49:24 +0100897 address_space_stq(&address_space_memory, dev->indicators->addr,
898 indicators, MEMTXATTRS_UNSPECIFIED, NULL);
Cornelia Huck7e749462013-02-06 10:31:37 +0100899 css_conditional_io_interrupt(sch);
900 }
Cornelia Hucka5cf2bb2013-01-24 06:08:55 +0000901 } else {
Cornelia Huck7c486972013-04-23 17:15:19 +0200902 if (!dev->indicators2) {
903 return;
904 }
Peter Maydell42874d32015-04-26 16:49:24 +0100905 indicators = address_space_ldq(&address_space_memory,
906 dev->indicators2->addr,
907 MEMTXATTRS_UNSPECIFIED,
908 NULL);
Halil Pasic7a5342e2018-05-16 15:27:57 +0200909 indicators |= 1ULL;
Peter Maydell42874d32015-04-26 16:49:24 +0100910 address_space_stq(&address_space_memory, dev->indicators2->addr,
911 indicators, MEMTXATTRS_UNSPECIFIED, NULL);
Cornelia Huck7e749462013-02-06 10:31:37 +0100912 css_conditional_io_interrupt(sch);
Cornelia Hucka5cf2bb2013-01-24 06:08:55 +0000913 }
Cornelia Hucka5cf2bb2013-01-24 06:08:55 +0000914}
915
Peter Maydell6affa002024-09-13 15:31:43 +0100916static void virtio_ccw_reset_hold(Object *obj, ResetType type)
Cornelia Hucka5cf2bb2013-01-24 06:08:55 +0000917{
Peter Maydell6affa002024-09-13 15:31:43 +0100918 VirtioCcwDevice *dev = VIRTIO_CCW_DEVICE(obj);
Cornelia Huck838fb842018-05-07 15:27:57 +0200919 VirtIOCCWDeviceClass *vdc = VIRTIO_CCW_DEVICE_GET_CLASS(dev);
Cornelia Hucka5cf2bb2013-01-24 06:08:55 +0000920
Paolo Bonzini997340f2022-06-09 08:35:45 +0200921 virtio_ccw_reset_virtio(dev);
Peter Maydell6affa002024-09-13 15:31:43 +0100922
923 if (vdc->parent_phases.hold) {
924 vdc->parent_phases.hold(obj, type);
Cornelia Huck838fb842018-05-07 15:27:57 +0200925 }
Cornelia Hucka5cf2bb2013-01-24 06:08:55 +0000926}
927
Cornelia Huckb4436a02013-02-15 10:18:43 +0100928static void virtio_ccw_vmstate_change(DeviceState *d, bool running)
929{
930 VirtioCcwDevice *dev = VIRTIO_CCW_DEVICE(d);
931
932 if (running) {
933 virtio_ccw_start_ioeventfd(dev);
934 } else {
935 virtio_ccw_stop_ioeventfd(dev);
936 }
937}
938
Cornelia Huck320ce852013-02-19 13:48:17 +0100939static bool virtio_ccw_query_guest_notifiers(DeviceState *d)
940{
Jing Liub804e8a2016-02-26 06:46:12 +0100941 CcwDevice *dev = CCW_DEVICE(d);
Cornelia Huck320ce852013-02-19 13:48:17 +0100942
943 return !!(dev->sch->curr_status.pmcw.flags & PMCW_FLAGS_MASK_ENA);
944}
945
Cornelia Huckd426d9f2013-07-15 17:45:03 +0200946static int virtio_ccw_get_mappings(VirtioCcwDevice *dev)
947{
948 int r;
Jing Liub804e8a2016-02-26 06:46:12 +0100949 CcwDevice *ccw_dev = CCW_DEVICE(dev);
Cornelia Huckd426d9f2013-07-15 17:45:03 +0200950
Jing Liub804e8a2016-02-26 06:46:12 +0100951 if (!ccw_dev->sch->thinint_active) {
Cornelia Huckd426d9f2013-07-15 17:45:03 +0200952 return -EINVAL;
953 }
954
955 r = map_indicator(&dev->routes.adapter, dev->summary_indicator);
956 if (r) {
957 return r;
958 }
959 r = map_indicator(&dev->routes.adapter, dev->indicators);
960 if (r) {
961 return r;
962 }
963 dev->routes.adapter.summary_addr = dev->summary_indicator->map;
964 dev->routes.adapter.ind_addr = dev->indicators->map;
965
966 return 0;
967}
968
969static int virtio_ccw_setup_irqroutes(VirtioCcwDevice *dev, int nvqs)
970{
971 int i;
972 VirtIODevice *vdev = virtio_bus_get_device(&dev->bus);
973 int ret;
974 S390FLICState *fs = s390_get_flic();
David Hildenbrand67628082018-01-29 13:56:23 +0100975 S390FLICStateClass *fsc = s390_get_flic_class(fs);
Cornelia Huckd426d9f2013-07-15 17:45:03 +0200976
977 ret = virtio_ccw_get_mappings(dev);
978 if (ret) {
979 return ret;
980 }
981 for (i = 0; i < nvqs; i++) {
982 if (!virtio_queue_get_num(vdev, i)) {
983 break;
984 }
985 }
986 dev->routes.num_routes = i;
987 return fsc->add_adapter_routes(fs, &dev->routes);
988}
989
990static void virtio_ccw_release_irqroutes(VirtioCcwDevice *dev, int nvqs)
991{
992 S390FLICState *fs = s390_get_flic();
David Hildenbrand67628082018-01-29 13:56:23 +0100993 S390FLICStateClass *fsc = s390_get_flic_class(fs);
Cornelia Huckd426d9f2013-07-15 17:45:03 +0200994
995 fsc->release_adapter_routes(fs, &dev->routes);
996}
997
998static int virtio_ccw_add_irqfd(VirtioCcwDevice *dev, int n)
999{
1000 VirtIODevice *vdev = virtio_bus_get_device(&dev->bus);
1001 VirtQueue *vq = virtio_get_queue(vdev, n);
1002 EventNotifier *notifier = virtio_queue_get_guest_notifier(vq);
1003
Eric Auger1c9b71a2015-07-06 12:15:13 -06001004 return kvm_irqchip_add_irqfd_notifier_gsi(kvm_state, notifier, NULL,
1005 dev->routes.gsi[n]);
Cornelia Huckd426d9f2013-07-15 17:45:03 +02001006}
1007
1008static void virtio_ccw_remove_irqfd(VirtioCcwDevice *dev, int n)
1009{
1010 VirtIODevice *vdev = virtio_bus_get_device(&dev->bus);
1011 VirtQueue *vq = virtio_get_queue(vdev, n);
1012 EventNotifier *notifier = virtio_queue_get_guest_notifier(vq);
1013 int ret;
1014
Eric Auger1c9b71a2015-07-06 12:15:13 -06001015 ret = kvm_irqchip_remove_irqfd_notifier_gsi(kvm_state, notifier,
1016 dev->routes.gsi[n]);
Cornelia Huckd426d9f2013-07-15 17:45:03 +02001017 assert(ret == 0);
1018}
1019
Cornelia Huck320ce852013-02-19 13:48:17 +01001020static int virtio_ccw_set_guest_notifier(VirtioCcwDevice *dev, int n,
1021 bool assign, bool with_irqfd)
1022{
Paolo Bonzinif24a6842013-09-20 13:51:52 +02001023 VirtIODevice *vdev = virtio_bus_get_device(&dev->bus);
1024 VirtQueue *vq = virtio_get_queue(vdev, n);
Cornelia Huck320ce852013-02-19 13:48:17 +01001025 EventNotifier *notifier = virtio_queue_get_guest_notifier(vq);
Paolo Bonzinif24a6842013-09-20 13:51:52 +02001026 VirtioDeviceClass *k = VIRTIO_DEVICE_GET_CLASS(vdev);
Cornelia Huck320ce852013-02-19 13:48:17 +01001027
1028 if (assign) {
1029 int r = event_notifier_init(notifier, 0);
1030
1031 if (r < 0) {
1032 return r;
1033 }
1034 virtio_queue_set_guest_notifier_fd_handler(vq, true, with_irqfd);
Cornelia Huckd426d9f2013-07-15 17:45:03 +02001035 if (with_irqfd) {
1036 r = virtio_ccw_add_irqfd(dev, n);
1037 if (r) {
1038 virtio_queue_set_guest_notifier_fd_handler(vq, false,
1039 with_irqfd);
1040 return r;
1041 }
1042 }
1043 /*
1044 * We do not support individual masking for channel devices, so we
1045 * need to manually trigger any guest masking callbacks here.
Cornelia Huck320ce852013-02-19 13:48:17 +01001046 */
Wei Huang2858bc62016-12-15 12:23:24 -06001047 if (k->guest_notifier_mask && vdev->use_guest_notifier_mask) {
Paolo Bonzinif24a6842013-09-20 13:51:52 +02001048 k->guest_notifier_mask(vdev, n, false);
Cornelia Huck320ce852013-02-19 13:48:17 +01001049 }
1050 /* get lost events and re-inject */
1051 if (k->guest_notifier_pending &&
Paolo Bonzinif24a6842013-09-20 13:51:52 +02001052 k->guest_notifier_pending(vdev, n)) {
Cornelia Huck320ce852013-02-19 13:48:17 +01001053 event_notifier_set(notifier);
1054 }
1055 } else {
Wei Huang2858bc62016-12-15 12:23:24 -06001056 if (k->guest_notifier_mask && vdev->use_guest_notifier_mask) {
Paolo Bonzinif24a6842013-09-20 13:51:52 +02001057 k->guest_notifier_mask(vdev, n, true);
Cornelia Huck320ce852013-02-19 13:48:17 +01001058 }
Cornelia Huckd426d9f2013-07-15 17:45:03 +02001059 if (with_irqfd) {
1060 virtio_ccw_remove_irqfd(dev, n);
1061 }
Cornelia Huck320ce852013-02-19 13:48:17 +01001062 virtio_queue_set_guest_notifier_fd_handler(vq, false, with_irqfd);
1063 event_notifier_cleanup(notifier);
1064 }
1065 return 0;
1066}
1067
1068static int virtio_ccw_set_guest_notifiers(DeviceState *d, int nvqs,
1069 bool assigned)
1070{
1071 VirtioCcwDevice *dev = VIRTIO_CCW_DEVICE(d);
Paolo Bonzinif24a6842013-09-20 13:51:52 +02001072 VirtIODevice *vdev = virtio_bus_get_device(&dev->bus);
Jing Liub804e8a2016-02-26 06:46:12 +01001073 CcwDevice *ccw_dev = CCW_DEVICE(d);
1074 bool with_irqfd = ccw_dev->sch->thinint_active && kvm_irqfds_enabled();
Cornelia Huck320ce852013-02-19 13:48:17 +01001075 int r, n;
1076
Cornelia Huckd426d9f2013-07-15 17:45:03 +02001077 if (with_irqfd && assigned) {
1078 /* irq routes need to be set up before assigning irqfds */
1079 r = virtio_ccw_setup_irqroutes(dev, nvqs);
1080 if (r < 0) {
1081 goto irqroute_error;
1082 }
1083 }
Cornelia Huck320ce852013-02-19 13:48:17 +01001084 for (n = 0; n < nvqs; n++) {
1085 if (!virtio_queue_get_num(vdev, n)) {
1086 break;
1087 }
Cornelia Huckd426d9f2013-07-15 17:45:03 +02001088 r = virtio_ccw_set_guest_notifier(dev, n, assigned, with_irqfd);
Cornelia Huck320ce852013-02-19 13:48:17 +01001089 if (r < 0) {
1090 goto assign_error;
1091 }
1092 }
Cornelia Huckd426d9f2013-07-15 17:45:03 +02001093 if (with_irqfd && !assigned) {
1094 /* release irq routes after irqfds have been released */
1095 virtio_ccw_release_irqroutes(dev, nvqs);
1096 }
Cornelia Huck320ce852013-02-19 13:48:17 +01001097 return 0;
1098
1099assign_error:
1100 while (--n >= 0) {
1101 virtio_ccw_set_guest_notifier(dev, n, !assigned, false);
1102 }
Cornelia Huckd426d9f2013-07-15 17:45:03 +02001103irqroute_error:
1104 if (with_irqfd && assigned) {
1105 virtio_ccw_release_irqroutes(dev, nvqs);
1106 }
Cornelia Huck320ce852013-02-19 13:48:17 +01001107 return r;
1108}
1109
Jens Freimannbcb2b582014-02-11 13:29:44 +01001110static void virtio_ccw_save_queue(DeviceState *d, int n, QEMUFile *f)
1111{
1112 VirtioCcwDevice *dev = VIRTIO_CCW_DEVICE(d);
1113 VirtIODevice *vdev = virtio_bus_get_device(&dev->bus);
1114
1115 qemu_put_be16(f, virtio_queue_vector(vdev, n));
1116}
1117
1118static int virtio_ccw_load_queue(DeviceState *d, int n, QEMUFile *f)
1119{
1120 VirtioCcwDevice *dev = VIRTIO_CCW_DEVICE(d);
1121 VirtIODevice *vdev = virtio_bus_get_device(&dev->bus);
1122 uint16_t vector;
1123
1124 qemu_get_be16s(f, &vector);
1125 virtio_queue_set_vector(vdev, n , vector);
1126
1127 return 0;
1128}
1129
1130static void virtio_ccw_save_config(DeviceState *d, QEMUFile *f)
1131{
1132 VirtioCcwDevice *dev = VIRTIO_CCW_DEVICE(d);
Halil Pasic517ff122017-07-03 23:34:14 +02001133 vmstate_save_state(f, &vmstate_virtio_ccw_dev, dev, NULL);
Jens Freimannbcb2b582014-02-11 13:29:44 +01001134}
1135
1136static int virtio_ccw_load_config(DeviceState *d, QEMUFile *f)
1137{
1138 VirtioCcwDevice *dev = VIRTIO_CCW_DEVICE(d);
Halil Pasic517ff122017-07-03 23:34:14 +02001139 return vmstate_load_state(f, &vmstate_virtio_ccw_dev, dev, 1);
Jens Freimannbcb2b582014-02-11 13:29:44 +01001140}
1141
Maxime Coquelind1b42592016-09-13 15:30:30 +02001142static void virtio_ccw_pre_plugged(DeviceState *d, Error **errp)
1143{
1144 VirtioCcwDevice *dev = VIRTIO_CCW_DEVICE(d);
1145 VirtIODevice *vdev = virtio_bus_get_device(&dev->bus);
1146
1147 if (dev->max_rev >= 1) {
1148 virtio_add_feature(&vdev->host_features, VIRTIO_F_VERSION_1);
1149 }
1150}
1151
Cornelia Huckfb846a02015-04-21 16:36:56 +02001152/* This is called by virtio-bus just after the device is plugged. */
Jason Wange8398042015-05-29 14:15:25 +08001153static void virtio_ccw_device_plugged(DeviceState *d, Error **errp)
Cornelia Huckfb846a02015-04-21 16:36:56 +02001154{
1155 VirtioCcwDevice *dev = VIRTIO_CCW_DEVICE(d);
Jason Wang10ceaa12015-05-29 14:15:28 +08001156 VirtIODevice *vdev = virtio_bus_get_device(&dev->bus);
Jing Liub804e8a2016-02-26 06:46:12 +01001157 CcwDevice *ccw_dev = CCW_DEVICE(d);
1158 SubchDev *sch = ccw_dev->sch;
Jason Wang10ceaa12015-05-29 14:15:28 +08001159 int n = virtio_get_num_queues(vdev);
Halil Pasic0708afa2016-12-09 19:58:10 +01001160 S390FLICState *flic = s390_get_flic();
Jason Wang10ceaa12015-05-29 14:15:28 +08001161
Maxime Coquelind1b42592016-09-13 15:30:30 +02001162 if (!virtio_has_feature(vdev->host_features, VIRTIO_F_VERSION_1)) {
1163 dev->max_rev = 0;
1164 }
1165
Cornelia Huck9b3a35e2020-07-07 12:54:46 +02001166 if (!virtio_ccw_rev_max(dev) && !virtio_legacy_allowed(vdev)) {
Stefano Garzarellad55f5182020-09-21 14:25:03 +02001167 /*
1168 * To avoid migration issues, we allow legacy mode when legacy
1169 * check is disabled in the old machine types (< 5.1).
1170 */
1171 if (virtio_legacy_check_disabled(vdev)) {
1172 warn_report("device requires revision >= 1, but for backward "
1173 "compatibility max_revision=0 is allowed");
1174 } else {
1175 error_setg(errp, "Invalid value of property max_rev "
1176 "(is %d expected >= 1)", virtio_ccw_rev_max(dev));
1177 return;
1178 }
Cornelia Huck9b3a35e2020-07-07 12:54:46 +02001179 }
1180
Halil Pasicb1914b82015-12-07 16:45:17 +01001181 if (virtio_get_num_queues(vdev) > VIRTIO_QUEUE_MAX) {
Michael Tokarevb34aee52016-05-18 15:41:59 +03001182 error_setg(errp, "The number of virtqueues %d "
Halil Pasicb1914b82015-12-07 16:45:17 +01001183 "exceeds virtio limit %d", n,
1184 VIRTIO_QUEUE_MAX);
Jason Wang10ceaa12015-05-29 14:15:28 +08001185 return;
1186 }
Halil Pasic0708afa2016-12-09 19:58:10 +01001187 if (virtio_get_num_queues(vdev) > flic->adapter_routes_max_batch) {
1188 error_setg(errp, "The number of virtqueues %d "
1189 "exceeds flic adapter route limit %d", n,
1190 flic->adapter_routes_max_batch);
1191 return;
1192 }
Cornelia Huckfb846a02015-04-21 16:36:56 +02001193
1194 sch->id.cu_model = virtio_bus_get_vdev_id(&dev->bus);
1195
Cornelia Huck542571d2015-09-11 15:16:44 +02001196
Cornelia Huckfb846a02015-04-21 16:36:56 +02001197 css_generate_sch_crws(sch->cssid, sch->ssid, sch->schid,
1198 d->hotplugged, 1);
1199}
1200
1201static void virtio_ccw_device_unplugged(DeviceState *d)
1202{
1203 VirtioCcwDevice *dev = VIRTIO_CCW_DEVICE(d);
1204
1205 virtio_ccw_stop_ioeventfd(dev);
1206}
Cornelia Hucka5cf2bb2013-01-24 06:08:55 +00001207/**************** Virtio-ccw Bus Device Descriptions *******************/
1208
Markus Armbruster5e5ced32015-02-27 14:53:39 +01001209static void virtio_ccw_busdev_realize(DeviceState *dev, Error **errp)
Cornelia Hucka5cf2bb2013-01-24 06:08:55 +00001210{
1211 VirtioCcwDevice *_dev = (VirtioCcwDevice *)dev;
Cornelia Hucka5cf2bb2013-01-24 06:08:55 +00001212
Andreas Färber1bf4d7a2013-08-23 20:27:30 +02001213 virtio_ccw_bus_new(&_dev->bus, sizeof(_dev->bus), _dev);
Cornelia Huck1fa75522015-04-21 16:36:55 +02001214 virtio_ccw_device_realize(_dev, errp);
Cornelia Hucka5cf2bb2013-01-24 06:08:55 +00001215}
1216
Markus Armbrusterb69c3c22020-05-05 17:29:24 +02001217static void virtio_ccw_busdev_unrealize(DeviceState *dev)
Cornelia Hucka5cf2bb2013-01-24 06:08:55 +00001218{
1219 VirtioCcwDevice *_dev = (VirtioCcwDevice *)dev;
Cornelia Hucka5cf2bb2013-01-24 06:08:55 +00001220
Markus Armbrusterb69c3c22020-05-05 17:29:24 +02001221 virtio_ccw_device_unrealize(_dev);
Cornelia Hucka5cf2bb2013-01-24 06:08:55 +00001222}
1223
Jing Liub804e8a2016-02-26 06:46:12 +01001224static void virtio_ccw_busdev_unplug(HotplugHandler *hotplug_dev,
1225 DeviceState *dev, Error **errp)
Cornelia Hucka5cf2bb2013-01-24 06:08:55 +00001226{
Jing Liub804e8a2016-02-26 06:46:12 +01001227 VirtioCcwDevice *_dev = to_virtio_ccw_dev_fast(dev);
Cornelia Hucka5cf2bb2013-01-24 06:08:55 +00001228
Paolo Bonzini0b81c1e2013-10-15 16:47:16 +02001229 virtio_ccw_stop_ioeventfd(_dev);
Cornelia Hucka5cf2bb2013-01-24 06:08:55 +00001230}
1231
1232static void virtio_ccw_device_class_init(ObjectClass *klass, void *data)
1233{
1234 DeviceClass *dc = DEVICE_CLASS(klass);
Jing Liub804e8a2016-02-26 06:46:12 +01001235 CCWDeviceClass *k = CCW_DEVICE_CLASS(dc);
Cornelia Huck838fb842018-05-07 15:27:57 +02001236 VirtIOCCWDeviceClass *vdc = VIRTIO_CCW_DEVICE_CLASS(klass);
Peter Maydell6affa002024-09-13 15:31:43 +01001237 ResettableClass *rc = RESETTABLE_CLASS(klass);
Cornelia Hucka5cf2bb2013-01-24 06:08:55 +00001238
Jing Liub804e8a2016-02-26 06:46:12 +01001239 k->unplug = virtio_ccw_busdev_unplug;
Markus Armbruster5e5ced32015-02-27 14:53:39 +01001240 dc->realize = virtio_ccw_busdev_realize;
Nia Alarie24118af2018-03-07 16:29:58 +00001241 dc->unrealize = virtio_ccw_busdev_unrealize;
Peter Maydell6affa002024-09-13 15:31:43 +01001242 resettable_class_set_parent_phases(rc, NULL, virtio_ccw_reset_hold, NULL,
1243 &vdc->parent_phases);
Cornelia Hucka5cf2bb2013-01-24 06:08:55 +00001244}
1245
1246static const TypeInfo virtio_ccw_device_info = {
1247 .name = TYPE_VIRTIO_CCW_DEVICE,
Jing Liub804e8a2016-02-26 06:46:12 +01001248 .parent = TYPE_CCW_DEVICE,
Cornelia Hucka5cf2bb2013-01-24 06:08:55 +00001249 .instance_size = sizeof(VirtioCcwDevice),
1250 .class_init = virtio_ccw_device_class_init,
1251 .class_size = sizeof(VirtIOCCWDeviceClass),
1252 .abstract = true,
1253};
1254
Cornelia Hucka5cf2bb2013-01-24 06:08:55 +00001255/* virtio-ccw-bus */
1256
Andreas Färber1bf4d7a2013-08-23 20:27:30 +02001257static void virtio_ccw_bus_new(VirtioBusState *bus, size_t bus_size,
1258 VirtioCcwDevice *dev)
Cornelia Hucka5cf2bb2013-01-24 06:08:55 +00001259{
1260 DeviceState *qdev = DEVICE(dev);
KONRAD Fredericf4dd69a2013-04-30 16:08:47 +02001261 char virtio_bus_name[] = "virtio-bus";
Cornelia Hucka5cf2bb2013-01-24 06:08:55 +00001262
Peter Maydelld637e1d2021-09-23 13:11:51 +01001263 qbus_init(bus, bus_size, TYPE_VIRTIO_CCW_BUS, qdev, virtio_bus_name);
Cornelia Hucka5cf2bb2013-01-24 06:08:55 +00001264}
1265
1266static void virtio_ccw_bus_class_init(ObjectClass *klass, void *data)
1267{
1268 VirtioBusClass *k = VIRTIO_BUS_CLASS(klass);
1269 BusClass *bus_class = BUS_CLASS(klass);
1270
1271 bus_class->max_dev = 1;
1272 k->notify = virtio_ccw_notify;
Cornelia Huckb4436a02013-02-15 10:18:43 +01001273 k->vmstate_change = virtio_ccw_vmstate_change;
Cornelia Huck320ce852013-02-19 13:48:17 +01001274 k->query_guest_notifiers = virtio_ccw_query_guest_notifiers;
Cornelia Huck320ce852013-02-19 13:48:17 +01001275 k->set_guest_notifiers = virtio_ccw_set_guest_notifiers;
Jens Freimannbcb2b582014-02-11 13:29:44 +01001276 k->save_queue = virtio_ccw_save_queue;
1277 k->load_queue = virtio_ccw_load_queue;
1278 k->save_config = virtio_ccw_save_config;
1279 k->load_config = virtio_ccw_load_config;
Maxime Coquelind1b42592016-09-13 15:30:30 +02001280 k->pre_plugged = virtio_ccw_pre_plugged;
Cornelia Huckfb846a02015-04-21 16:36:56 +02001281 k->device_plugged = virtio_ccw_device_plugged;
1282 k->device_unplugged = virtio_ccw_device_unplugged;
Paolo Bonzini8e93cef2016-10-21 22:48:08 +02001283 k->ioeventfd_enabled = virtio_ccw_ioeventfd_enabled;
Cornelia Huck7c55f682016-06-10 11:04:11 +02001284 k->ioeventfd_assign = virtio_ccw_ioeventfd_assign;
Cornelia Hucka5cf2bb2013-01-24 06:08:55 +00001285}
1286
1287static const TypeInfo virtio_ccw_bus_info = {
1288 .name = TYPE_VIRTIO_CCW_BUS,
1289 .parent = TYPE_VIRTIO_BUS,
1290 .instance_size = sizeof(VirtioCcwBusState),
Cornelia Huck74ded8b2020-08-24 14:20:51 +02001291 .class_size = sizeof(VirtioCcwBusClass),
Cornelia Hucka5cf2bb2013-01-24 06:08:55 +00001292 .class_init = virtio_ccw_bus_class_init,
1293};
1294
1295static void virtio_ccw_register(void)
1296{
1297 type_register_static(&virtio_ccw_bus_info);
Cornelia Hucka5cf2bb2013-01-24 06:08:55 +00001298 type_register_static(&virtio_ccw_device_info);
Cornelia Hucka5cf2bb2013-01-24 06:08:55 +00001299}
1300
1301type_init(virtio_ccw_register)