]>
Commit | Line | Data |
---|---|---|
f3304eea AG |
1 | /* |
2 | * QEMU S390 virtio target | |
3 | * | |
4 | * Copyright (c) 2009 Alexander Graf <agraf@suse.de> | |
5 | * | |
6 | * This library is free software; you can redistribute it and/or | |
7 | * modify it under the terms of the GNU Lesser General Public | |
8 | * License as published by the Free Software Foundation; either | |
9 | * version 2 of the License, or (at your option) any later version. | |
10 | * | |
11 | * This library is distributed in the hope that it will be useful, | |
12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
14 | * Lesser General Public License for more details. | |
15 | * | |
16 | * You should have received a copy of the GNU Lesser General Public | |
17 | * License along with this library; if not, see <http://www.gnu.org/licenses/>. | |
18 | */ | |
19 | ||
b73d3531 | 20 | #include "hw/hw.h" |
737e150e | 21 | #include "block/block.h" |
9c17d615 | 22 | #include "sysemu/sysemu.h" |
b73d3531 | 23 | #include "hw/boards.h" |
83c9089e | 24 | #include "monitor/monitor.h" |
b73d3531 | 25 | #include "hw/loader.h" |
f3304eea | 26 | #include "elf.h" |
0d09e41a PB |
27 | #include "hw/virtio/virtio.h" |
28 | #include "hw/virtio/virtio-rng.h" | |
29 | #include "hw/virtio/virtio-serial.h" | |
30 | #include "hw/virtio/virtio-net.h" | |
d6e51919 | 31 | #include "hw/virtio/vhost-scsi.h" |
f3304eea | 32 | #include "hw/sysbus.h" |
9c17d615 | 33 | #include "sysemu/kvm.h" |
f3304eea | 34 | |
b73d3531 | 35 | #include "hw/s390x/s390-virtio-bus.h" |
0d09e41a | 36 | #include "hw/virtio/virtio-bus.h" |
f3304eea AG |
37 | |
38 | /* #define DEBUG_S390 */ | |
39 | ||
40 | #ifdef DEBUG_S390 | |
41 | #define dprintf(fmt, ...) \ | |
42 | do { fprintf(stderr, fmt, ## __VA_ARGS__); } while (0) | |
43 | #else | |
44 | #define dprintf(fmt, ...) \ | |
45 | do { } while (0) | |
46 | #endif | |
47 | ||
8103b4d1 AG |
48 | #define VIRTIO_EXT_CODE 0x2603 |
49 | ||
d51fcfac KF |
50 | static void virtio_s390_bus_new(VirtioBusState *bus, VirtIOS390Device *dev); |
51 | ||
0d936928 AL |
52 | static const TypeInfo s390_virtio_bus_info = { |
53 | .name = TYPE_S390_VIRTIO_BUS, | |
54 | .parent = TYPE_BUS, | |
55 | .instance_size = sizeof(VirtIOS390Bus), | |
f3304eea AG |
56 | }; |
57 | ||
f3304eea | 58 | static ram_addr_t s390_virtio_device_num_vq(VirtIOS390Device *dev); |
f3304eea | 59 | |
d1ff903c | 60 | /* length of VirtIO device pages */ |
a8170e5e | 61 | const hwaddr virtio_size = S390_DEVICE_PAGES * TARGET_PAGE_SIZE; |
d1ff903c | 62 | |
eb3caa44 JF |
63 | static void s390_virtio_bus_reset(void *opaque) |
64 | { | |
65 | VirtIOS390Bus *bus = opaque; | |
66 | bus->next_ring = bus->dev_page + TARGET_PAGE_SIZE; | |
67 | } | |
68 | ||
4170aea1 JF |
69 | void s390_virtio_reset_idx(VirtIOS390Device *dev) |
70 | { | |
71 | int i; | |
a8170e5e | 72 | hwaddr idx_addr; |
4170aea1 JF |
73 | uint8_t num_vq; |
74 | ||
75 | num_vq = s390_virtio_device_num_vq(dev); | |
76 | for (i = 0; i < num_vq; i++) { | |
77 | idx_addr = virtio_queue_get_avail_addr(dev->vdev, i) + | |
78 | VIRTIO_VRING_AVAIL_IDX_OFFS; | |
79 | stw_phys(idx_addr, 0); | |
80 | idx_addr = virtio_queue_get_used_addr(dev->vdev, i) + | |
81 | VIRTIO_VRING_USED_IDX_OFFS; | |
82 | stw_phys(idx_addr, 0); | |
83 | } | |
84 | } | |
85 | ||
f3304eea AG |
86 | VirtIOS390Bus *s390_virtio_bus_init(ram_addr_t *ram_size) |
87 | { | |
88 | VirtIOS390Bus *bus; | |
89 | BusState *_bus; | |
90 | DeviceState *dev; | |
91 | ||
92 | /* Create bridge device */ | |
93 | dev = qdev_create(NULL, "s390-virtio-bridge"); | |
94 | qdev_init_nofail(dev); | |
95 | ||
96 | /* Create bus on bridge device */ | |
97 | ||
0d936928 | 98 | _bus = qbus_create(TYPE_S390_VIRTIO_BUS, dev, "s390-virtio"); |
f3304eea AG |
99 | bus = DO_UPCAST(VirtIOS390Bus, bus, _bus); |
100 | ||
101 | bus->dev_page = *ram_size; | |
102 | bus->dev_offs = bus->dev_page; | |
103 | bus->next_ring = bus->dev_page + TARGET_PAGE_SIZE; | |
104 | ||
7fa41e53 AG |
105 | /* Enable hotplugging */ |
106 | _bus->allow_hotplug = 1; | |
107 | ||
f3304eea AG |
108 | /* Allocate RAM for VirtIO device pages (descriptors, queues, rings) */ |
109 | *ram_size += S390_DEVICE_PAGES * TARGET_PAGE_SIZE; | |
110 | ||
eb3caa44 | 111 | qemu_register_reset(s390_virtio_bus_reset, bus); |
f3304eea AG |
112 | return bus; |
113 | } | |
114 | ||
1bc22652 | 115 | static void s390_virtio_irq(S390CPU *cpu, int config_change, uint64_t token) |
7fa41e53 AG |
116 | { |
117 | if (kvm_enabled()) { | |
1bc22652 | 118 | kvm_s390_virtio_irq(cpu, config_change, token); |
7fa41e53 | 119 | } else { |
f9466733 | 120 | cpu_inject_ext(cpu, VIRTIO_EXT_CODE, config_change, token); |
7fa41e53 AG |
121 | } |
122 | } | |
123 | ||
f3304eea AG |
124 | static int s390_virtio_device_init(VirtIOS390Device *dev, VirtIODevice *vdev) |
125 | { | |
126 | VirtIOS390Bus *bus; | |
127 | int dev_len; | |
128 | ||
129 | bus = DO_UPCAST(VirtIOS390Bus, bus, dev->qdev.parent_bus); | |
130 | dev->vdev = vdev; | |
131 | dev->dev_offs = bus->dev_offs; | |
132 | dev->feat_len = sizeof(uint32_t); /* always keep 32 bits features */ | |
133 | ||
134 | dev_len = VIRTIO_DEV_OFFS_CONFIG; | |
135 | dev_len += s390_virtio_device_num_vq(dev) * VIRTIO_VQCONFIG_LEN; | |
136 | dev_len += dev->feat_len * 2; | |
181103cd | 137 | dev_len += virtio_bus_get_vdev_config_len(&dev->bus); |
f3304eea AG |
138 | |
139 | bus->dev_offs += dev_len; | |
140 | ||
181103cd KF |
141 | dev->host_features = virtio_bus_get_vdev_features(&dev->bus, |
142 | dev->host_features); | |
f3304eea | 143 | s390_virtio_device_sync(dev); |
4170aea1 | 144 | s390_virtio_reset_idx(dev); |
7fa41e53 | 145 | if (dev->qdev.hotplugged) { |
45fa769b | 146 | S390CPU *cpu = s390_cpu_addr2state(0); |
1bc22652 | 147 | s390_virtio_irq(cpu, VIRTIO_PARAM_DEV_ADD, dev->dev_offs); |
7fa41e53 AG |
148 | } |
149 | ||
f3304eea AG |
150 | return 0; |
151 | } | |
152 | ||
74b4fe3d | 153 | static int s390_virtio_net_init(VirtIOS390Device *s390_dev) |
f3304eea | 154 | { |
800ced8c | 155 | DeviceState *qdev = DEVICE(s390_dev); |
74b4fe3d KF |
156 | VirtIONetS390 *dev = VIRTIO_NET_S390(s390_dev); |
157 | DeviceState *vdev = DEVICE(&dev->vdev); | |
f3304eea | 158 | |
74b4fe3d | 159 | virtio_net_set_config_size(&dev->vdev, s390_dev->host_features); |
800ced8c KF |
160 | virtio_net_set_netclient_name(&dev->vdev, qdev->id, |
161 | object_get_typename(OBJECT(qdev))); | |
74b4fe3d KF |
162 | qdev_set_parent_bus(vdev, BUS(&s390_dev->bus)); |
163 | if (qdev_init(vdev) < 0) { | |
f3304eea AG |
164 | return -1; |
165 | } | |
166 | ||
74b4fe3d KF |
167 | return s390_virtio_device_init(s390_dev, VIRTIO_DEVICE(vdev)); |
168 | } | |
169 | ||
170 | static void s390_virtio_net_instance_init(Object *obj) | |
171 | { | |
172 | VirtIONetS390 *dev = VIRTIO_NET_S390(obj); | |
173 | object_initialize(OBJECT(&dev->vdev), TYPE_VIRTIO_NET); | |
174 | object_property_add_child(obj, "virtio-backend", OBJECT(&dev->vdev), NULL); | |
f3304eea AG |
175 | } |
176 | ||
55d11e01 | 177 | static int s390_virtio_blk_init(VirtIOS390Device *s390_dev) |
f3304eea | 178 | { |
55d11e01 KF |
179 | VirtIOBlkS390 *dev = VIRTIO_BLK_S390(s390_dev); |
180 | DeviceState *vdev = DEVICE(&dev->vdev); | |
181 | virtio_blk_set_conf(vdev, &(dev->blk)); | |
182 | qdev_set_parent_bus(vdev, BUS(&s390_dev->bus)); | |
183 | if (qdev_init(vdev) < 0) { | |
f3304eea AG |
184 | return -1; |
185 | } | |
55d11e01 KF |
186 | return s390_virtio_device_init(s390_dev, VIRTIO_DEVICE(vdev)); |
187 | } | |
f3304eea | 188 | |
55d11e01 KF |
189 | static void s390_virtio_blk_instance_init(Object *obj) |
190 | { | |
191 | VirtIOBlkS390 *dev = VIRTIO_BLK_S390(obj); | |
192 | object_initialize(OBJECT(&dev->vdev), TYPE_VIRTIO_BLK); | |
193 | object_property_add_child(obj, "virtio-backend", OBJECT(&dev->vdev), NULL); | |
f3304eea AG |
194 | } |
195 | ||
55169140 | 196 | static int s390_virtio_serial_init(VirtIOS390Device *s390_dev) |
f3304eea | 197 | { |
55169140 KF |
198 | VirtIOSerialS390 *dev = VIRTIO_SERIAL_S390(s390_dev); |
199 | DeviceState *vdev = DEVICE(&dev->vdev); | |
200 | DeviceState *qdev = DEVICE(s390_dev); | |
f3304eea | 201 | VirtIOS390Bus *bus; |
f3304eea | 202 | int r; |
80270a19 | 203 | char *bus_name; |
f3304eea | 204 | |
55169140 | 205 | bus = DO_UPCAST(VirtIOS390Bus, bus, qdev->parent_bus); |
f3304eea | 206 | |
80270a19 KF |
207 | /* |
208 | * For command line compatibility, this sets the virtio-serial-device bus | |
209 | * name as before. | |
210 | */ | |
211 | if (qdev->id) { | |
212 | bus_name = g_strdup_printf("%s.0", qdev->id); | |
213 | virtio_device_set_child_bus_name(VIRTIO_DEVICE(vdev), bus_name); | |
214 | g_free(bus_name); | |
215 | } | |
216 | ||
55169140 KF |
217 | qdev_set_parent_bus(vdev, BUS(&s390_dev->bus)); |
218 | if (qdev_init(vdev) < 0) { | |
f3304eea AG |
219 | return -1; |
220 | } | |
221 | ||
55169140 | 222 | r = s390_virtio_device_init(s390_dev, VIRTIO_DEVICE(vdev)); |
f3304eea | 223 | if (!r) { |
55169140 | 224 | bus->console = s390_dev; |
f3304eea AG |
225 | } |
226 | ||
227 | return r; | |
228 | } | |
229 | ||
55169140 KF |
230 | static void s390_virtio_serial_instance_init(Object *obj) |
231 | { | |
232 | VirtIOSerialS390 *dev = VIRTIO_SERIAL_S390(obj); | |
233 | object_initialize(OBJECT(&dev->vdev), TYPE_VIRTIO_SERIAL); | |
234 | object_property_add_child(obj, "virtio-backend", OBJECT(&dev->vdev), NULL); | |
235 | } | |
236 | ||
9ef13d8f | 237 | static int s390_virtio_scsi_init(VirtIOS390Device *s390_dev) |
973abc7f | 238 | { |
9ef13d8f KF |
239 | VirtIOSCSIS390 *dev = VIRTIO_SCSI_S390(s390_dev); |
240 | DeviceState *vdev = DEVICE(&dev->vdev); | |
6f32a6b4 KF |
241 | DeviceState *qdev = DEVICE(s390_dev); |
242 | char *bus_name; | |
243 | ||
244 | /* | |
245 | * For command line compatibility, this sets the virtio-scsi-device bus | |
246 | * name as before. | |
247 | */ | |
248 | if (qdev->id) { | |
249 | bus_name = g_strdup_printf("%s.0", qdev->id); | |
250 | virtio_device_set_child_bus_name(VIRTIO_DEVICE(vdev), bus_name); | |
251 | g_free(bus_name); | |
252 | } | |
973abc7f | 253 | |
9ef13d8f KF |
254 | qdev_set_parent_bus(vdev, BUS(&s390_dev->bus)); |
255 | if (qdev_init(vdev) < 0) { | |
973abc7f SH |
256 | return -1; |
257 | } | |
258 | ||
9ef13d8f KF |
259 | return s390_virtio_device_init(s390_dev, VIRTIO_DEVICE(vdev)); |
260 | } | |
261 | ||
262 | static void s390_virtio_scsi_instance_init(Object *obj) | |
263 | { | |
264 | VirtIOSCSIS390 *dev = VIRTIO_SCSI_S390(obj); | |
265 | object_initialize(OBJECT(&dev->vdev), TYPE_VIRTIO_SCSI); | |
266 | object_property_add_child(obj, "virtio-backend", OBJECT(&dev->vdev), NULL); | |
973abc7f SH |
267 | } |
268 | ||
d6e51919 PB |
269 | #ifdef CONFIG_VHOST_SCSI |
270 | static int s390_vhost_scsi_init(VirtIOS390Device *s390_dev) | |
271 | { | |
272 | VHostSCSIS390 *dev = VHOST_SCSI_S390(s390_dev); | |
273 | DeviceState *vdev = DEVICE(&dev->vdev); | |
274 | ||
275 | qdev_set_parent_bus(vdev, BUS(&s390_dev->bus)); | |
276 | if (qdev_init(vdev) < 0) { | |
277 | return -1; | |
278 | } | |
279 | ||
280 | return s390_virtio_device_init(s390_dev, VIRTIO_DEVICE(vdev)); | |
281 | } | |
282 | ||
283 | static void s390_vhost_scsi_instance_init(Object *obj) | |
284 | { | |
285 | VHostSCSIS390 *dev = VHOST_SCSI_S390(obj); | |
286 | object_initialize(OBJECT(&dev->vdev), TYPE_VHOST_SCSI); | |
287 | object_property_add_child(obj, "virtio-backend", OBJECT(&dev->vdev), NULL); | |
288 | } | |
289 | #endif | |
290 | ||
0bca1f53 KF |
291 | |
292 | static int s390_virtio_rng_init(VirtIOS390Device *s390_dev) | |
16c915ba | 293 | { |
0bca1f53 KF |
294 | VirtIORNGS390 *dev = VIRTIO_RNG_S390(s390_dev); |
295 | DeviceState *vdev = DEVICE(&dev->vdev); | |
16c915ba | 296 | |
0bca1f53 KF |
297 | qdev_set_parent_bus(vdev, BUS(&s390_dev->bus)); |
298 | if (qdev_init(vdev) < 0) { | |
16c915ba AS |
299 | return -1; |
300 | } | |
301 | ||
0bca1f53 KF |
302 | object_property_set_link(OBJECT(dev), |
303 | OBJECT(dev->vdev.conf.default_backend), "rng", | |
304 | NULL); | |
305 | ||
306 | return s390_virtio_device_init(s390_dev, VIRTIO_DEVICE(vdev)); | |
307 | } | |
308 | ||
309 | static void s390_virtio_rng_instance_init(Object *obj) | |
310 | { | |
311 | VirtIORNGS390 *dev = VIRTIO_RNG_S390(obj); | |
312 | object_initialize(OBJECT(&dev->vdev), TYPE_VIRTIO_RNG); | |
313 | object_property_add_child(obj, "virtio-backend", OBJECT(&dev->vdev), NULL); | |
314 | object_property_add_link(obj, "rng", TYPE_RNG_BACKEND, | |
315 | (Object **)&dev->vdev.conf.rng, NULL); | |
16c915ba AS |
316 | } |
317 | ||
f3304eea AG |
318 | static uint64_t s390_virtio_device_vq_token(VirtIOS390Device *dev, int vq) |
319 | { | |
320 | ram_addr_t token_off; | |
321 | ||
322 | token_off = (dev->dev_offs + VIRTIO_DEV_OFFS_CONFIG) + | |
323 | (vq * VIRTIO_VQCONFIG_LEN) + | |
324 | VIRTIO_VQCONFIG_OFFS_TOKEN; | |
325 | ||
04bc74ed | 326 | return ldq_be_phys(token_off); |
f3304eea AG |
327 | } |
328 | ||
329 | static ram_addr_t s390_virtio_device_num_vq(VirtIOS390Device *dev) | |
330 | { | |
331 | VirtIODevice *vdev = dev->vdev; | |
332 | int num_vq; | |
333 | ||
334 | for (num_vq = 0; num_vq < VIRTIO_PCI_QUEUE_MAX; num_vq++) { | |
335 | if (!virtio_queue_get_num(vdev, num_vq)) { | |
336 | break; | |
337 | } | |
338 | } | |
339 | ||
340 | return num_vq; | |
341 | } | |
342 | ||
343 | static ram_addr_t s390_virtio_next_ring(VirtIOS390Bus *bus) | |
344 | { | |
345 | ram_addr_t r = bus->next_ring; | |
346 | ||
347 | bus->next_ring += VIRTIO_RING_LEN; | |
348 | return r; | |
349 | } | |
350 | ||
baf0b55a | 351 | void s390_virtio_device_sync(VirtIOS390Device *dev) |
f3304eea AG |
352 | { |
353 | VirtIOS390Bus *bus = DO_UPCAST(VirtIOS390Bus, bus, dev->qdev.parent_bus); | |
354 | ram_addr_t cur_offs; | |
355 | uint8_t num_vq; | |
356 | int i; | |
357 | ||
358 | virtio_reset(dev->vdev); | |
359 | ||
360 | /* Sync dev space */ | |
361 | stb_phys(dev->dev_offs + VIRTIO_DEV_OFFS_TYPE, dev->vdev->device_id); | |
362 | ||
363 | stb_phys(dev->dev_offs + VIRTIO_DEV_OFFS_NUM_VQ, s390_virtio_device_num_vq(dev)); | |
364 | stb_phys(dev->dev_offs + VIRTIO_DEV_OFFS_FEATURE_LEN, dev->feat_len); | |
365 | ||
366 | stb_phys(dev->dev_offs + VIRTIO_DEV_OFFS_CONFIG_LEN, dev->vdev->config_len); | |
367 | ||
368 | num_vq = s390_virtio_device_num_vq(dev); | |
369 | stb_phys(dev->dev_offs + VIRTIO_DEV_OFFS_NUM_VQ, num_vq); | |
370 | ||
371 | /* Sync virtqueues */ | |
372 | for (i = 0; i < num_vq; i++) { | |
373 | ram_addr_t vq = (dev->dev_offs + VIRTIO_DEV_OFFS_CONFIG) + | |
374 | (i * VIRTIO_VQCONFIG_LEN); | |
375 | ram_addr_t vring; | |
376 | ||
377 | vring = s390_virtio_next_ring(bus); | |
378 | virtio_queue_set_addr(dev->vdev, i, vring); | |
379 | virtio_queue_set_vector(dev->vdev, i, i); | |
04bc74ed AG |
380 | stq_be_phys(vq + VIRTIO_VQCONFIG_OFFS_ADDRESS, vring); |
381 | stw_be_phys(vq + VIRTIO_VQCONFIG_OFFS_NUM, virtio_queue_get_num(dev->vdev, i)); | |
f3304eea AG |
382 | } |
383 | ||
384 | cur_offs = dev->dev_offs; | |
385 | cur_offs += VIRTIO_DEV_OFFS_CONFIG; | |
386 | cur_offs += num_vq * VIRTIO_VQCONFIG_LEN; | |
387 | ||
388 | /* Sync feature bitmap */ | |
04bc74ed | 389 | stl_le_phys(cur_offs, dev->host_features); |
f3304eea AG |
390 | |
391 | dev->feat_offs = cur_offs + dev->feat_len; | |
392 | cur_offs += dev->feat_len * 2; | |
393 | ||
394 | /* Sync config space */ | |
181103cd | 395 | virtio_bus_get_vdev_config(&dev->bus, dev->vdev->config); |
f3304eea | 396 | |
54f7b4a3 SW |
397 | cpu_physical_memory_write(cur_offs, |
398 | dev->vdev->config, dev->vdev->config_len); | |
f3304eea AG |
399 | cur_offs += dev->vdev->config_len; |
400 | } | |
401 | ||
402 | void s390_virtio_device_update_status(VirtIOS390Device *dev) | |
403 | { | |
404 | VirtIODevice *vdev = dev->vdev; | |
405 | uint32_t features; | |
406 | ||
3e607cb5 | 407 | virtio_set_status(vdev, ldub_phys(dev->dev_offs + VIRTIO_DEV_OFFS_STATUS)); |
f3304eea AG |
408 | |
409 | /* Update guest supported feature bitmap */ | |
410 | ||
04bc74ed | 411 | features = bswap32(ldl_be_phys(dev->feat_offs)); |
ad0c9332 | 412 | virtio_set_features(vdev, features); |
f3304eea AG |
413 | } |
414 | ||
415 | VirtIOS390Device *s390_virtio_bus_console(VirtIOS390Bus *bus) | |
416 | { | |
417 | return bus->console; | |
418 | } | |
419 | ||
420 | /* Find a device by vring address */ | |
421 | VirtIOS390Device *s390_virtio_bus_find_vring(VirtIOS390Bus *bus, | |
422 | ram_addr_t mem, | |
423 | int *vq_num) | |
424 | { | |
0866aca1 | 425 | BusChild *kid; |
f3304eea AG |
426 | int i; |
427 | ||
0866aca1 AL |
428 | QTAILQ_FOREACH(kid, &bus->bus.children, sibling) { |
429 | VirtIOS390Device *dev = (VirtIOS390Device *)kid->child; | |
430 | ||
f3304eea | 431 | for(i = 0; i < VIRTIO_PCI_QUEUE_MAX; i++) { |
0866aca1 | 432 | if (!virtio_queue_get_addr(dev->vdev, i)) |
f3304eea | 433 | break; |
0866aca1 | 434 | if (virtio_queue_get_addr(dev->vdev, i) == mem) { |
f3304eea AG |
435 | if (vq_num) { |
436 | *vq_num = i; | |
437 | } | |
0866aca1 | 438 | return dev; |
f3304eea AG |
439 | } |
440 | } | |
441 | } | |
442 | ||
443 | return NULL; | |
444 | } | |
445 | ||
446 | /* Find a device by device descriptor location */ | |
447 | VirtIOS390Device *s390_virtio_bus_find_mem(VirtIOS390Bus *bus, ram_addr_t mem) | |
448 | { | |
0866aca1 | 449 | BusChild *kid; |
f3304eea | 450 | |
0866aca1 AL |
451 | QTAILQ_FOREACH(kid, &bus->bus.children, sibling) { |
452 | VirtIOS390Device *dev = (VirtIOS390Device *)kid->child; | |
453 | if (dev->dev_offs == mem) { | |
454 | return dev; | |
f3304eea AG |
455 | } |
456 | } | |
457 | ||
458 | return NULL; | |
459 | } | |
460 | ||
d2a0ccc6 MT |
461 | /* DeviceState to VirtIOS390Device. Note: used on datapath, |
462 | * be careful and test performance if you change this. | |
463 | */ | |
464 | static inline VirtIOS390Device *to_virtio_s390_device_fast(DeviceState *d) | |
465 | { | |
466 | return container_of(d, VirtIOS390Device, qdev); | |
467 | } | |
468 | ||
469 | /* DeviceState to VirtIOS390Device. TODO: use QOM. */ | |
470 | static inline VirtIOS390Device *to_virtio_s390_device(DeviceState *d) | |
471 | { | |
472 | return container_of(d, VirtIOS390Device, qdev); | |
473 | } | |
474 | ||
475 | static void virtio_s390_notify(DeviceState *d, uint16_t vector) | |
f3304eea | 476 | { |
d2a0ccc6 | 477 | VirtIOS390Device *dev = to_virtio_s390_device_fast(d); |
f3304eea | 478 | uint64_t token = s390_virtio_device_vq_token(dev, vector); |
45fa769b | 479 | S390CPU *cpu = s390_cpu_addr2state(0); |
f3304eea | 480 | |
1bc22652 | 481 | s390_virtio_irq(cpu, 0, token); |
f3304eea AG |
482 | } |
483 | ||
d2a0ccc6 | 484 | static unsigned virtio_s390_get_features(DeviceState *d) |
8172539d | 485 | { |
d2a0ccc6 | 486 | VirtIOS390Device *dev = to_virtio_s390_device(d); |
8172539d MT |
487 | return dev->host_features; |
488 | } | |
489 | ||
f3304eea AG |
490 | /**************** S390 Virtio Bus Device Descriptions *******************/ |
491 | ||
39bffca2 | 492 | static Property s390_virtio_net_properties[] = { |
74b4fe3d | 493 | DEFINE_NIC_PROPERTIES(VirtIONetS390, vdev.nic_conf), |
35569cea | 494 | DEFINE_VIRTIO_NET_FEATURES(VirtIOS390Device, host_features), |
74b4fe3d | 495 | DEFINE_VIRTIO_NET_PROPERTIES(VirtIONetS390, vdev.net_conf), |
39bffca2 AL |
496 | DEFINE_PROP_END_OF_LIST(), |
497 | }; | |
498 | ||
19b6914a AL |
499 | static void s390_virtio_net_class_init(ObjectClass *klass, void *data) |
500 | { | |
39bffca2 AL |
501 | DeviceClass *dc = DEVICE_CLASS(klass); |
502 | VirtIOS390DeviceClass *k = VIRTIO_S390_DEVICE_CLASS(klass); | |
19b6914a | 503 | |
39bffca2 AL |
504 | k->init = s390_virtio_net_init; |
505 | dc->props = s390_virtio_net_properties; | |
19b6914a AL |
506 | } |
507 | ||
8c43a6f0 | 508 | static const TypeInfo s390_virtio_net = { |
74b4fe3d | 509 | .name = TYPE_VIRTIO_NET_S390, |
39bffca2 | 510 | .parent = TYPE_VIRTIO_S390_DEVICE, |
74b4fe3d KF |
511 | .instance_size = sizeof(VirtIONetS390), |
512 | .instance_init = s390_virtio_net_instance_init, | |
39bffca2 AL |
513 | .class_init = s390_virtio_net_class_init, |
514 | }; | |
515 | ||
516 | static Property s390_virtio_blk_properties[] = { | |
fe42d7fb | 517 | DEFINE_VIRTIO_BLK_PROPERTIES(VirtIOBlkS390, blk), |
39bffca2 | 518 | DEFINE_PROP_END_OF_LIST(), |
f3304eea AG |
519 | }; |
520 | ||
19b6914a AL |
521 | static void s390_virtio_blk_class_init(ObjectClass *klass, void *data) |
522 | { | |
39bffca2 AL |
523 | DeviceClass *dc = DEVICE_CLASS(klass); |
524 | VirtIOS390DeviceClass *k = VIRTIO_S390_DEVICE_CLASS(klass); | |
19b6914a | 525 | |
39bffca2 AL |
526 | k->init = s390_virtio_blk_init; |
527 | dc->props = s390_virtio_blk_properties; | |
19b6914a AL |
528 | } |
529 | ||
8c43a6f0 | 530 | static const TypeInfo s390_virtio_blk = { |
39bffca2 AL |
531 | .name = "virtio-blk-s390", |
532 | .parent = TYPE_VIRTIO_S390_DEVICE, | |
55d11e01 KF |
533 | .instance_size = sizeof(VirtIOBlkS390), |
534 | .instance_init = s390_virtio_blk_instance_init, | |
39bffca2 AL |
535 | .class_init = s390_virtio_blk_class_init, |
536 | }; | |
537 | ||
538 | static Property s390_virtio_serial_properties[] = { | |
55169140 | 539 | DEFINE_VIRTIO_SERIAL_PROPERTIES(VirtIOSerialS390, vdev.serial), |
39bffca2 | 540 | DEFINE_PROP_END_OF_LIST(), |
f3304eea AG |
541 | }; |
542 | ||
19b6914a AL |
543 | static void s390_virtio_serial_class_init(ObjectClass *klass, void *data) |
544 | { | |
39bffca2 AL |
545 | DeviceClass *dc = DEVICE_CLASS(klass); |
546 | VirtIOS390DeviceClass *k = VIRTIO_S390_DEVICE_CLASS(klass); | |
19b6914a | 547 | |
39bffca2 AL |
548 | k->init = s390_virtio_serial_init; |
549 | dc->props = s390_virtio_serial_properties; | |
19b6914a AL |
550 | } |
551 | ||
8c43a6f0 | 552 | static const TypeInfo s390_virtio_serial = { |
55169140 | 553 | .name = TYPE_VIRTIO_SERIAL_S390, |
39bffca2 | 554 | .parent = TYPE_VIRTIO_S390_DEVICE, |
55169140 KF |
555 | .instance_size = sizeof(VirtIOSerialS390), |
556 | .instance_init = s390_virtio_serial_instance_init, | |
39bffca2 | 557 | .class_init = s390_virtio_serial_class_init, |
f3304eea AG |
558 | }; |
559 | ||
75f6e8b0 KF |
560 | static Property s390_virtio_rng_properties[] = { |
561 | DEFINE_VIRTIO_COMMON_FEATURES(VirtIOS390Device, host_features), | |
562 | DEFINE_VIRTIO_RNG_PROPERTIES(VirtIORNGS390, vdev.conf), | |
563 | DEFINE_PROP_END_OF_LIST(), | |
564 | }; | |
565 | ||
16c915ba AS |
566 | static void s390_virtio_rng_class_init(ObjectClass *klass, void *data) |
567 | { | |
75f6e8b0 | 568 | DeviceClass *dc = DEVICE_CLASS(klass); |
16c915ba AS |
569 | VirtIOS390DeviceClass *k = VIRTIO_S390_DEVICE_CLASS(klass); |
570 | ||
571 | k->init = s390_virtio_rng_init; | |
75f6e8b0 | 572 | dc->props = s390_virtio_rng_properties; |
16c915ba AS |
573 | } |
574 | ||
8c43a6f0 | 575 | static const TypeInfo s390_virtio_rng = { |
0bca1f53 | 576 | .name = TYPE_VIRTIO_RNG_S390, |
16c915ba | 577 | .parent = TYPE_VIRTIO_S390_DEVICE, |
0bca1f53 KF |
578 | .instance_size = sizeof(VirtIORNGS390), |
579 | .instance_init = s390_virtio_rng_instance_init, | |
16c915ba AS |
580 | .class_init = s390_virtio_rng_class_init, |
581 | }; | |
582 | ||
d307af79 | 583 | static int s390_virtio_busdev_init(DeviceState *dev) |
f3304eea | 584 | { |
f3304eea | 585 | VirtIOS390Device *_dev = (VirtIOS390Device *)dev; |
19b6914a | 586 | VirtIOS390DeviceClass *_info = VIRTIO_S390_DEVICE_GET_CLASS(dev); |
f3304eea | 587 | |
11e9235b KF |
588 | virtio_s390_bus_new(&_dev->bus, _dev); |
589 | ||
f3304eea AG |
590 | return _info->init(_dev); |
591 | } | |
592 | ||
93726cb3 PB |
593 | static void s390_virtio_busdev_reset(DeviceState *dev) |
594 | { | |
595 | VirtIOS390Device *_dev = (VirtIOS390Device *)dev; | |
596 | ||
597 | virtio_reset(_dev->vdev); | |
598 | } | |
599 | ||
39bffca2 | 600 | static void virtio_s390_device_class_init(ObjectClass *klass, void *data) |
f3304eea | 601 | { |
39bffca2 | 602 | DeviceClass *dc = DEVICE_CLASS(klass); |
f3304eea | 603 | |
39bffca2 | 604 | dc->init = s390_virtio_busdev_init; |
0d936928 | 605 | dc->bus_type = TYPE_S390_VIRTIO_BUS; |
39bffca2 | 606 | dc->unplug = qdev_simple_unplug_cb; |
93726cb3 | 607 | dc->reset = s390_virtio_busdev_reset; |
f3304eea AG |
608 | } |
609 | ||
8c43a6f0 | 610 | static const TypeInfo virtio_s390_device_info = { |
19b6914a AL |
611 | .name = TYPE_VIRTIO_S390_DEVICE, |
612 | .parent = TYPE_DEVICE, | |
613 | .instance_size = sizeof(VirtIOS390Device), | |
39bffca2 | 614 | .class_init = virtio_s390_device_class_init, |
e87f7fc6 | 615 | .class_size = sizeof(VirtIOS390DeviceClass), |
19b6914a AL |
616 | .abstract = true, |
617 | }; | |
618 | ||
973abc7f | 619 | static Property s390_virtio_scsi_properties[] = { |
292c8e50 | 620 | DEFINE_VIRTIO_SCSI_PROPERTIES(VirtIOSCSIS390, vdev.parent_obj.conf), |
4bfeb18a | 621 | DEFINE_VIRTIO_SCSI_FEATURES(VirtIOS390Device, host_features), |
973abc7f SH |
622 | DEFINE_PROP_END_OF_LIST(), |
623 | }; | |
624 | ||
625 | static void s390_virtio_scsi_class_init(ObjectClass *klass, void *data) | |
626 | { | |
627 | DeviceClass *dc = DEVICE_CLASS(klass); | |
628 | VirtIOS390DeviceClass *k = VIRTIO_S390_DEVICE_CLASS(klass); | |
629 | ||
630 | k->init = s390_virtio_scsi_init; | |
631 | dc->props = s390_virtio_scsi_properties; | |
632 | } | |
633 | ||
8c43a6f0 | 634 | static const TypeInfo s390_virtio_scsi = { |
9ef13d8f | 635 | .name = TYPE_VIRTIO_SCSI_S390, |
973abc7f | 636 | .parent = TYPE_VIRTIO_S390_DEVICE, |
9ef13d8f KF |
637 | .instance_size = sizeof(VirtIOSCSIS390), |
638 | .instance_init = s390_virtio_scsi_instance_init, | |
973abc7f SH |
639 | .class_init = s390_virtio_scsi_class_init, |
640 | }; | |
f3304eea | 641 | |
d6e51919 PB |
642 | #ifdef CONFIG_VHOST_SCSI |
643 | static Property s390_vhost_scsi_properties[] = { | |
644 | DEFINE_VIRTIO_COMMON_FEATURES(VirtIOS390Device, host_features), | |
645 | DEFINE_VHOST_SCSI_PROPERTIES(VHostSCSIS390, vdev.parent_obj.conf), | |
646 | DEFINE_PROP_END_OF_LIST(), | |
647 | }; | |
648 | ||
649 | static void s390_vhost_scsi_class_init(ObjectClass *klass, void *data) | |
650 | { | |
651 | DeviceClass *dc = DEVICE_CLASS(klass); | |
652 | VirtIOS390DeviceClass *k = VIRTIO_S390_DEVICE_CLASS(klass); | |
653 | ||
654 | k->init = s390_vhost_scsi_init; | |
655 | dc->props = s390_vhost_scsi_properties; | |
656 | } | |
657 | ||
658 | static const TypeInfo s390_vhost_scsi = { | |
659 | .name = TYPE_VHOST_SCSI_S390, | |
660 | .parent = TYPE_VIRTIO_S390_DEVICE, | |
661 | .instance_size = sizeof(VHostSCSIS390), | |
662 | .instance_init = s390_vhost_scsi_instance_init, | |
663 | .class_init = s390_vhost_scsi_class_init, | |
664 | }; | |
665 | #endif | |
666 | ||
f3304eea AG |
667 | /***************** S390 Virtio Bus Bridge Device *******************/ |
668 | /* Only required to have the virtio bus as child in the system bus */ | |
669 | ||
670 | static int s390_virtio_bridge_init(SysBusDevice *dev) | |
671 | { | |
672 | /* nothing */ | |
673 | return 0; | |
674 | } | |
675 | ||
999e12bb AL |
676 | static void s390_virtio_bridge_class_init(ObjectClass *klass, void *data) |
677 | { | |
39bffca2 | 678 | DeviceClass *dc = DEVICE_CLASS(klass); |
999e12bb AL |
679 | SysBusDeviceClass *k = SYS_BUS_DEVICE_CLASS(klass); |
680 | ||
681 | k->init = s390_virtio_bridge_init; | |
39bffca2 | 682 | dc->no_user = 1; |
999e12bb AL |
683 | } |
684 | ||
8c43a6f0 | 685 | static const TypeInfo s390_virtio_bridge_info = { |
39bffca2 AL |
686 | .name = "s390-virtio-bridge", |
687 | .parent = TYPE_SYS_BUS_DEVICE, | |
688 | .instance_size = sizeof(SysBusDevice), | |
689 | .class_init = s390_virtio_bridge_class_init, | |
f3304eea AG |
690 | }; |
691 | ||
ea35d4f1 KF |
692 | /* virtio-s390-bus */ |
693 | ||
d51fcfac | 694 | static void virtio_s390_bus_new(VirtioBusState *bus, VirtIOS390Device *dev) |
ea35d4f1 KF |
695 | { |
696 | DeviceState *qdev = DEVICE(dev); | |
697 | BusState *qbus; | |
f4dd69aa KF |
698 | char virtio_bus_name[] = "virtio-bus"; |
699 | ||
700 | qbus_create_inplace((BusState *)bus, TYPE_VIRTIO_S390_BUS, qdev, | |
701 | virtio_bus_name); | |
ea35d4f1 | 702 | qbus = BUS(bus); |
cbd19063 | 703 | qbus->allow_hotplug = 1; |
ea35d4f1 KF |
704 | } |
705 | ||
706 | static void virtio_s390_bus_class_init(ObjectClass *klass, void *data) | |
707 | { | |
708 | VirtioBusClass *k = VIRTIO_BUS_CLASS(klass); | |
709 | BusClass *bus_class = BUS_CLASS(klass); | |
710 | bus_class->max_dev = 1; | |
711 | k->notify = virtio_s390_notify; | |
712 | k->get_features = virtio_s390_get_features; | |
713 | } | |
714 | ||
715 | static const TypeInfo virtio_s390_bus_info = { | |
716 | .name = TYPE_VIRTIO_S390_BUS, | |
717 | .parent = TYPE_VIRTIO_BUS, | |
718 | .instance_size = sizeof(VirtioS390BusState), | |
719 | .class_init = virtio_s390_bus_class_init, | |
720 | }; | |
721 | ||
83f7d43a | 722 | static void s390_virtio_register_types(void) |
f3304eea | 723 | { |
ea35d4f1 | 724 | type_register_static(&virtio_s390_bus_info); |
0d936928 | 725 | type_register_static(&s390_virtio_bus_info); |
83f7d43a AF |
726 | type_register_static(&virtio_s390_device_info); |
727 | type_register_static(&s390_virtio_serial); | |
728 | type_register_static(&s390_virtio_blk); | |
729 | type_register_static(&s390_virtio_net); | |
973abc7f | 730 | type_register_static(&s390_virtio_scsi); |
b702d2ae | 731 | #ifdef CONFIG_VHOST_SCSI |
d6e51919 | 732 | type_register_static(&s390_vhost_scsi); |
b702d2ae | 733 | #endif |
16c915ba | 734 | type_register_static(&s390_virtio_rng); |
39bffca2 | 735 | type_register_static(&s390_virtio_bridge_info); |
f3304eea AG |
736 | } |
737 | ||
83f7d43a | 738 | type_init(s390_virtio_register_types) |