virtio-rng: hardware random number generator device
[qemu.git] / hw / s390-virtio-bus.c
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
20 #include "hw.h"
21 #include "block.h"
22 #include "sysemu.h"
23 #include "net.h"
24 #include "boards.h"
25 #include "monitor.h"
26 #include "loader.h"
27 #include "elf.h"
28 #include "hw/virtio.h"
29 #include "hw/virtio-rng.h"
30 #include "hw/virtio-serial.h"
31 #include "hw/virtio-net.h"
32 #include "hw/sysbus.h"
33 #include "kvm.h"
34
35 #include "hw/s390-virtio-bus.h"
36
37 /* #define DEBUG_S390 */
38
39 #ifdef DEBUG_S390
40 #define dprintf(fmt, ...) \
41 do { fprintf(stderr, fmt, ## __VA_ARGS__); } while (0)
42 #else
43 #define dprintf(fmt, ...) \
44 do { } while (0)
45 #endif
46
47 #define VIRTIO_EXT_CODE 0x2603
48
49 static const TypeInfo s390_virtio_bus_info = {
50 .name = TYPE_S390_VIRTIO_BUS,
51 .parent = TYPE_BUS,
52 .instance_size = sizeof(VirtIOS390Bus),
53 };
54
55 static const VirtIOBindings virtio_s390_bindings;
56
57 static ram_addr_t s390_virtio_device_num_vq(VirtIOS390Device *dev);
58
59 /* length of VirtIO device pages */
60 const hwaddr virtio_size = S390_DEVICE_PAGES * TARGET_PAGE_SIZE;
61
62 static void s390_virtio_bus_reset(void *opaque)
63 {
64 VirtIOS390Bus *bus = opaque;
65 bus->next_ring = bus->dev_page + TARGET_PAGE_SIZE;
66 }
67
68 void s390_virtio_reset_idx(VirtIOS390Device *dev)
69 {
70 int i;
71 hwaddr idx_addr;
72 uint8_t num_vq;
73
74 num_vq = s390_virtio_device_num_vq(dev);
75 for (i = 0; i < num_vq; i++) {
76 idx_addr = virtio_queue_get_avail_addr(dev->vdev, i) +
77 VIRTIO_VRING_AVAIL_IDX_OFFS;
78 stw_phys(idx_addr, 0);
79 idx_addr = virtio_queue_get_used_addr(dev->vdev, i) +
80 VIRTIO_VRING_USED_IDX_OFFS;
81 stw_phys(idx_addr, 0);
82 }
83 }
84
85 VirtIOS390Bus *s390_virtio_bus_init(ram_addr_t *ram_size)
86 {
87 VirtIOS390Bus *bus;
88 BusState *_bus;
89 DeviceState *dev;
90
91 /* Create bridge device */
92 dev = qdev_create(NULL, "s390-virtio-bridge");
93 qdev_init_nofail(dev);
94
95 /* Create bus on bridge device */
96
97 _bus = qbus_create(TYPE_S390_VIRTIO_BUS, dev, "s390-virtio");
98 bus = DO_UPCAST(VirtIOS390Bus, bus, _bus);
99
100 bus->dev_page = *ram_size;
101 bus->dev_offs = bus->dev_page;
102 bus->next_ring = bus->dev_page + TARGET_PAGE_SIZE;
103
104 /* Enable hotplugging */
105 _bus->allow_hotplug = 1;
106
107 /* Allocate RAM for VirtIO device pages (descriptors, queues, rings) */
108 *ram_size += S390_DEVICE_PAGES * TARGET_PAGE_SIZE;
109
110 qemu_register_reset(s390_virtio_bus_reset, bus);
111 return bus;
112 }
113
114 static void s390_virtio_irq(CPUS390XState *env, int config_change, uint64_t token)
115 {
116 if (kvm_enabled()) {
117 kvm_s390_virtio_irq(env, config_change, token);
118 } else {
119 cpu_inject_ext(env, VIRTIO_EXT_CODE, config_change, token);
120 }
121 }
122
123 static int s390_virtio_device_init(VirtIOS390Device *dev, VirtIODevice *vdev)
124 {
125 VirtIOS390Bus *bus;
126 int dev_len;
127
128 bus = DO_UPCAST(VirtIOS390Bus, bus, dev->qdev.parent_bus);
129 dev->vdev = vdev;
130 dev->dev_offs = bus->dev_offs;
131 dev->feat_len = sizeof(uint32_t); /* always keep 32 bits features */
132
133 dev_len = VIRTIO_DEV_OFFS_CONFIG;
134 dev_len += s390_virtio_device_num_vq(dev) * VIRTIO_VQCONFIG_LEN;
135 dev_len += dev->feat_len * 2;
136 dev_len += vdev->config_len;
137
138 bus->dev_offs += dev_len;
139
140 virtio_bind_device(vdev, &virtio_s390_bindings, dev);
141 dev->host_features = vdev->get_features(vdev, dev->host_features);
142 s390_virtio_device_sync(dev);
143 s390_virtio_reset_idx(dev);
144 if (dev->qdev.hotplugged) {
145 S390CPU *cpu = s390_cpu_addr2state(0);
146 CPUS390XState *env = &cpu->env;
147 s390_virtio_irq(env, VIRTIO_PARAM_DEV_ADD, dev->dev_offs);
148 }
149
150 return 0;
151 }
152
153 static int s390_virtio_net_init(VirtIOS390Device *dev)
154 {
155 VirtIODevice *vdev;
156
157 vdev = virtio_net_init((DeviceState *)dev, &dev->nic, &dev->net);
158 if (!vdev) {
159 return -1;
160 }
161
162 return s390_virtio_device_init(dev, vdev);
163 }
164
165 static int s390_virtio_blk_init(VirtIOS390Device *dev)
166 {
167 VirtIODevice *vdev;
168
169 vdev = virtio_blk_init((DeviceState *)dev, &dev->blk);
170 if (!vdev) {
171 return -1;
172 }
173
174 return s390_virtio_device_init(dev, vdev);
175 }
176
177 static int s390_virtio_serial_init(VirtIOS390Device *dev)
178 {
179 VirtIOS390Bus *bus;
180 VirtIODevice *vdev;
181 int r;
182
183 bus = DO_UPCAST(VirtIOS390Bus, bus, dev->qdev.parent_bus);
184
185 vdev = virtio_serial_init((DeviceState *)dev, &dev->serial);
186 if (!vdev) {
187 return -1;
188 }
189
190 r = s390_virtio_device_init(dev, vdev);
191 if (!r) {
192 bus->console = dev;
193 }
194
195 return r;
196 }
197
198 static int s390_virtio_scsi_init(VirtIOS390Device *dev)
199 {
200 VirtIODevice *vdev;
201
202 vdev = virtio_scsi_init((DeviceState *)dev, &dev->scsi);
203 if (!vdev) {
204 return -1;
205 }
206
207 return s390_virtio_device_init(dev, vdev);
208 }
209
210 static int s390_virtio_rng_init(VirtIOS390Device *dev)
211 {
212 VirtIODevice *vdev;
213
214 vdev = virtio_rng_init((DeviceState *)dev, &dev->rng);
215 if (!vdev) {
216 return -1;
217 }
218
219 return s390_virtio_device_init(dev, vdev);
220 }
221
222 static uint64_t s390_virtio_device_vq_token(VirtIOS390Device *dev, int vq)
223 {
224 ram_addr_t token_off;
225
226 token_off = (dev->dev_offs + VIRTIO_DEV_OFFS_CONFIG) +
227 (vq * VIRTIO_VQCONFIG_LEN) +
228 VIRTIO_VQCONFIG_OFFS_TOKEN;
229
230 return ldq_be_phys(token_off);
231 }
232
233 static ram_addr_t s390_virtio_device_num_vq(VirtIOS390Device *dev)
234 {
235 VirtIODevice *vdev = dev->vdev;
236 int num_vq;
237
238 for (num_vq = 0; num_vq < VIRTIO_PCI_QUEUE_MAX; num_vq++) {
239 if (!virtio_queue_get_num(vdev, num_vq)) {
240 break;
241 }
242 }
243
244 return num_vq;
245 }
246
247 static ram_addr_t s390_virtio_next_ring(VirtIOS390Bus *bus)
248 {
249 ram_addr_t r = bus->next_ring;
250
251 bus->next_ring += VIRTIO_RING_LEN;
252 return r;
253 }
254
255 void s390_virtio_device_sync(VirtIOS390Device *dev)
256 {
257 VirtIOS390Bus *bus = DO_UPCAST(VirtIOS390Bus, bus, dev->qdev.parent_bus);
258 ram_addr_t cur_offs;
259 uint8_t num_vq;
260 int i;
261
262 virtio_reset(dev->vdev);
263
264 /* Sync dev space */
265 stb_phys(dev->dev_offs + VIRTIO_DEV_OFFS_TYPE, dev->vdev->device_id);
266
267 stb_phys(dev->dev_offs + VIRTIO_DEV_OFFS_NUM_VQ, s390_virtio_device_num_vq(dev));
268 stb_phys(dev->dev_offs + VIRTIO_DEV_OFFS_FEATURE_LEN, dev->feat_len);
269
270 stb_phys(dev->dev_offs + VIRTIO_DEV_OFFS_CONFIG_LEN, dev->vdev->config_len);
271
272 num_vq = s390_virtio_device_num_vq(dev);
273 stb_phys(dev->dev_offs + VIRTIO_DEV_OFFS_NUM_VQ, num_vq);
274
275 /* Sync virtqueues */
276 for (i = 0; i < num_vq; i++) {
277 ram_addr_t vq = (dev->dev_offs + VIRTIO_DEV_OFFS_CONFIG) +
278 (i * VIRTIO_VQCONFIG_LEN);
279 ram_addr_t vring;
280
281 vring = s390_virtio_next_ring(bus);
282 virtio_queue_set_addr(dev->vdev, i, vring);
283 virtio_queue_set_vector(dev->vdev, i, i);
284 stq_be_phys(vq + VIRTIO_VQCONFIG_OFFS_ADDRESS, vring);
285 stw_be_phys(vq + VIRTIO_VQCONFIG_OFFS_NUM, virtio_queue_get_num(dev->vdev, i));
286 }
287
288 cur_offs = dev->dev_offs;
289 cur_offs += VIRTIO_DEV_OFFS_CONFIG;
290 cur_offs += num_vq * VIRTIO_VQCONFIG_LEN;
291
292 /* Sync feature bitmap */
293 stl_le_phys(cur_offs, dev->host_features);
294
295 dev->feat_offs = cur_offs + dev->feat_len;
296 cur_offs += dev->feat_len * 2;
297
298 /* Sync config space */
299 if (dev->vdev->get_config) {
300 dev->vdev->get_config(dev->vdev, dev->vdev->config);
301 }
302
303 cpu_physical_memory_write(cur_offs,
304 dev->vdev->config, dev->vdev->config_len);
305 cur_offs += dev->vdev->config_len;
306 }
307
308 void s390_virtio_device_update_status(VirtIOS390Device *dev)
309 {
310 VirtIODevice *vdev = dev->vdev;
311 uint32_t features;
312
313 virtio_set_status(vdev, ldub_phys(dev->dev_offs + VIRTIO_DEV_OFFS_STATUS));
314
315 /* Update guest supported feature bitmap */
316
317 features = bswap32(ldl_be_phys(dev->feat_offs));
318 virtio_set_features(vdev, features);
319 }
320
321 VirtIOS390Device *s390_virtio_bus_console(VirtIOS390Bus *bus)
322 {
323 return bus->console;
324 }
325
326 /* Find a device by vring address */
327 VirtIOS390Device *s390_virtio_bus_find_vring(VirtIOS390Bus *bus,
328 ram_addr_t mem,
329 int *vq_num)
330 {
331 BusChild *kid;
332 int i;
333
334 QTAILQ_FOREACH(kid, &bus->bus.children, sibling) {
335 VirtIOS390Device *dev = (VirtIOS390Device *)kid->child;
336
337 for(i = 0; i < VIRTIO_PCI_QUEUE_MAX; i++) {
338 if (!virtio_queue_get_addr(dev->vdev, i))
339 break;
340 if (virtio_queue_get_addr(dev->vdev, i) == mem) {
341 if (vq_num) {
342 *vq_num = i;
343 }
344 return dev;
345 }
346 }
347 }
348
349 return NULL;
350 }
351
352 /* Find a device by device descriptor location */
353 VirtIOS390Device *s390_virtio_bus_find_mem(VirtIOS390Bus *bus, ram_addr_t mem)
354 {
355 BusChild *kid;
356
357 QTAILQ_FOREACH(kid, &bus->bus.children, sibling) {
358 VirtIOS390Device *dev = (VirtIOS390Device *)kid->child;
359 if (dev->dev_offs == mem) {
360 return dev;
361 }
362 }
363
364 return NULL;
365 }
366
367 static void virtio_s390_notify(void *opaque, uint16_t vector)
368 {
369 VirtIOS390Device *dev = (VirtIOS390Device*)opaque;
370 uint64_t token = s390_virtio_device_vq_token(dev, vector);
371 S390CPU *cpu = s390_cpu_addr2state(0);
372 CPUS390XState *env = &cpu->env;
373
374 s390_virtio_irq(env, 0, token);
375 }
376
377 static unsigned virtio_s390_get_features(void *opaque)
378 {
379 VirtIOS390Device *dev = (VirtIOS390Device*)opaque;
380 return dev->host_features;
381 }
382
383 /**************** S390 Virtio Bus Device Descriptions *******************/
384
385 static const VirtIOBindings virtio_s390_bindings = {
386 .notify = virtio_s390_notify,
387 .get_features = virtio_s390_get_features,
388 };
389
390 static Property s390_virtio_net_properties[] = {
391 DEFINE_NIC_PROPERTIES(VirtIOS390Device, nic),
392 DEFINE_PROP_UINT32("x-txtimer", VirtIOS390Device,
393 net.txtimer, TX_TIMER_INTERVAL),
394 DEFINE_PROP_INT32("x-txburst", VirtIOS390Device,
395 net.txburst, TX_BURST),
396 DEFINE_PROP_STRING("tx", VirtIOS390Device, net.tx),
397 DEFINE_PROP_END_OF_LIST(),
398 };
399
400 static void s390_virtio_net_class_init(ObjectClass *klass, void *data)
401 {
402 DeviceClass *dc = DEVICE_CLASS(klass);
403 VirtIOS390DeviceClass *k = VIRTIO_S390_DEVICE_CLASS(klass);
404
405 k->init = s390_virtio_net_init;
406 dc->props = s390_virtio_net_properties;
407 }
408
409 static TypeInfo s390_virtio_net = {
410 .name = "virtio-net-s390",
411 .parent = TYPE_VIRTIO_S390_DEVICE,
412 .instance_size = sizeof(VirtIOS390Device),
413 .class_init = s390_virtio_net_class_init,
414 };
415
416 static Property s390_virtio_blk_properties[] = {
417 DEFINE_BLOCK_PROPERTIES(VirtIOS390Device, blk.conf),
418 DEFINE_BLOCK_CHS_PROPERTIES(VirtIOS390Device, blk.conf),
419 DEFINE_PROP_STRING("serial", VirtIOS390Device, blk.serial),
420 #ifdef __linux__
421 DEFINE_PROP_BIT("scsi", VirtIOS390Device, blk.scsi, 0, true),
422 #endif
423 DEFINE_PROP_END_OF_LIST(),
424 };
425
426 static void s390_virtio_blk_class_init(ObjectClass *klass, void *data)
427 {
428 DeviceClass *dc = DEVICE_CLASS(klass);
429 VirtIOS390DeviceClass *k = VIRTIO_S390_DEVICE_CLASS(klass);
430
431 k->init = s390_virtio_blk_init;
432 dc->props = s390_virtio_blk_properties;
433 }
434
435 static TypeInfo s390_virtio_blk = {
436 .name = "virtio-blk-s390",
437 .parent = TYPE_VIRTIO_S390_DEVICE,
438 .instance_size = sizeof(VirtIOS390Device),
439 .class_init = s390_virtio_blk_class_init,
440 };
441
442 static Property s390_virtio_serial_properties[] = {
443 DEFINE_PROP_UINT32("max_ports", VirtIOS390Device,
444 serial.max_virtserial_ports, 31),
445 DEFINE_PROP_END_OF_LIST(),
446 };
447
448 static void s390_virtio_serial_class_init(ObjectClass *klass, void *data)
449 {
450 DeviceClass *dc = DEVICE_CLASS(klass);
451 VirtIOS390DeviceClass *k = VIRTIO_S390_DEVICE_CLASS(klass);
452
453 k->init = s390_virtio_serial_init;
454 dc->props = s390_virtio_serial_properties;
455 }
456
457 static TypeInfo s390_virtio_serial = {
458 .name = "virtio-serial-s390",
459 .parent = TYPE_VIRTIO_S390_DEVICE,
460 .instance_size = sizeof(VirtIOS390Device),
461 .class_init = s390_virtio_serial_class_init,
462 };
463
464 static void s390_virtio_rng_initfn(Object *obj)
465 {
466 VirtIOS390Device *dev = VIRTIO_S390_DEVICE(obj);
467
468 object_property_add_link(obj, "rng", TYPE_RNG_BACKEND,
469 (Object **)&dev->rng.rng, NULL);
470 }
471
472 static void s390_virtio_rng_class_init(ObjectClass *klass, void *data)
473 {
474 VirtIOS390DeviceClass *k = VIRTIO_S390_DEVICE_CLASS(klass);
475
476 k->init = s390_virtio_rng_init;
477 }
478
479 static TypeInfo s390_virtio_rng = {
480 .name = "virtio-rng-s390",
481 .parent = TYPE_VIRTIO_S390_DEVICE,
482 .instance_size = sizeof(VirtIOS390Device),
483 .instance_init = s390_virtio_rng_initfn,
484 .class_init = s390_virtio_rng_class_init,
485 };
486
487 static int s390_virtio_busdev_init(DeviceState *dev)
488 {
489 VirtIOS390Device *_dev = (VirtIOS390Device *)dev;
490 VirtIOS390DeviceClass *_info = VIRTIO_S390_DEVICE_GET_CLASS(dev);
491
492 return _info->init(_dev);
493 }
494
495 static void virtio_s390_device_class_init(ObjectClass *klass, void *data)
496 {
497 DeviceClass *dc = DEVICE_CLASS(klass);
498
499 dc->init = s390_virtio_busdev_init;
500 dc->bus_type = TYPE_S390_VIRTIO_BUS;
501 dc->unplug = qdev_simple_unplug_cb;
502 }
503
504 static TypeInfo virtio_s390_device_info = {
505 .name = TYPE_VIRTIO_S390_DEVICE,
506 .parent = TYPE_DEVICE,
507 .instance_size = sizeof(VirtIOS390Device),
508 .class_init = virtio_s390_device_class_init,
509 .class_size = sizeof(VirtIOS390DeviceClass),
510 .abstract = true,
511 };
512
513 static Property s390_virtio_scsi_properties[] = {
514 DEFINE_VIRTIO_SCSI_PROPERTIES(VirtIOS390Device, host_features, scsi),
515 DEFINE_PROP_END_OF_LIST(),
516 };
517
518 static void s390_virtio_scsi_class_init(ObjectClass *klass, void *data)
519 {
520 DeviceClass *dc = DEVICE_CLASS(klass);
521 VirtIOS390DeviceClass *k = VIRTIO_S390_DEVICE_CLASS(klass);
522
523 k->init = s390_virtio_scsi_init;
524 dc->props = s390_virtio_scsi_properties;
525 }
526
527 static TypeInfo s390_virtio_scsi = {
528 .name = "virtio-scsi-s390",
529 .parent = TYPE_VIRTIO_S390_DEVICE,
530 .instance_size = sizeof(VirtIOS390Device),
531 .class_init = s390_virtio_scsi_class_init,
532 };
533
534 /***************** S390 Virtio Bus Bridge Device *******************/
535 /* Only required to have the virtio bus as child in the system bus */
536
537 static int s390_virtio_bridge_init(SysBusDevice *dev)
538 {
539 /* nothing */
540 return 0;
541 }
542
543 static void s390_virtio_bridge_class_init(ObjectClass *klass, void *data)
544 {
545 DeviceClass *dc = DEVICE_CLASS(klass);
546 SysBusDeviceClass *k = SYS_BUS_DEVICE_CLASS(klass);
547
548 k->init = s390_virtio_bridge_init;
549 dc->no_user = 1;
550 }
551
552 static TypeInfo s390_virtio_bridge_info = {
553 .name = "s390-virtio-bridge",
554 .parent = TYPE_SYS_BUS_DEVICE,
555 .instance_size = sizeof(SysBusDevice),
556 .class_init = s390_virtio_bridge_class_init,
557 };
558
559 static void s390_virtio_register_types(void)
560 {
561 type_register_static(&s390_virtio_bus_info);
562 type_register_static(&virtio_s390_device_info);
563 type_register_static(&s390_virtio_serial);
564 type_register_static(&s390_virtio_blk);
565 type_register_static(&s390_virtio_net);
566 type_register_static(&s390_virtio_scsi);
567 type_register_static(&s390_virtio_rng);
568 type_register_static(&s390_virtio_bridge_info);
569 }
570
571 type_init(s390_virtio_register_types)