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