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