4 * Copyright (c) 2010 David Gibson, IBM Corporation <dwg@au1.ibm.com>
5 * Based on the s390 virtio bus code:
6 * Copyright (c) 2009 Alexander Graf <agraf@suse.de>
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2 of the License, or (at your option) any later version.
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
22 #include "qemu/osdep.h"
23 #include "qemu/error-report.h"
24 #include "qapi/error.h"
25 #include "qapi/visitor.h"
29 #include "sysemu/sysemu.h"
30 #include "hw/boards.h"
31 #include "hw/loader.h"
33 #include "hw/sysbus.h"
34 #include "sysemu/kvm.h"
35 #include "sysemu/device_tree.h"
37 #include "migration/vmstate.h"
38 #include "sysemu/qtest.h"
40 #include "hw/ppc/spapr.h"
41 #include "hw/ppc/spapr_vio.h"
42 #include "hw/ppc/fdt.h"
47 #define SPAPR_VIO_REG_BASE 0x71000000
49 static char *spapr_vio_get_dev_name(DeviceState
*qdev
)
51 SpaprVioDevice
*dev
= VIO_SPAPR_DEVICE(qdev
);
52 SpaprVioDeviceClass
*pc
= VIO_SPAPR_DEVICE_GET_CLASS(dev
);
54 /* Device tree style name device@reg */
55 return g_strdup_printf("%s@%x", pc
->dt_name
, dev
->reg
);
58 static void spapr_vio_bus_class_init(ObjectClass
*klass
, void *data
)
60 BusClass
*k
= BUS_CLASS(klass
);
62 k
->get_dev_path
= spapr_vio_get_dev_name
;
63 k
->get_fw_dev_path
= spapr_vio_get_dev_name
;
66 static const TypeInfo spapr_vio_bus_info
= {
67 .name
= TYPE_SPAPR_VIO_BUS
,
69 .class_init
= spapr_vio_bus_class_init
,
70 .instance_size
= sizeof(SpaprVioBus
),
73 SpaprVioDevice
*spapr_vio_find_by_reg(SpaprVioBus
*bus
, uint32_t reg
)
76 SpaprVioDevice
*dev
= NULL
;
78 QTAILQ_FOREACH(kid
, &bus
->bus
.children
, sibling
) {
79 dev
= (SpaprVioDevice
*)kid
->child
;
80 if (dev
->reg
== reg
) {
88 static int vio_make_devnode(SpaprVioDevice
*dev
,
91 SpaprVioDeviceClass
*pc
= VIO_SPAPR_DEVICE_GET_CLASS(dev
);
92 int vdevice_off
, node_off
, ret
;
95 vdevice_off
= fdt_path_offset(fdt
, "/vdevice");
96 if (vdevice_off
< 0) {
100 dt_name
= spapr_vio_get_dev_name(DEVICE(dev
));
101 node_off
= fdt_add_subnode(fdt
, vdevice_off
, dt_name
);
107 ret
= fdt_setprop_cell(fdt
, node_off
, "reg", dev
->reg
);
113 ret
= fdt_setprop_string(fdt
, node_off
, "device_type",
120 if (pc
->dt_compatible
) {
121 ret
= fdt_setprop_string(fdt
, node_off
, "compatible",
129 uint32_t ints_prop
[2];
131 spapr_dt_irq(ints_prop
, dev
->irq
, false);
132 ret
= fdt_setprop(fdt
, node_off
, "interrupts", ints_prop
,
139 ret
= spapr_tcet_dma_dt(fdt
, node_off
, "ibm,my-dma-window", dev
->tcet
);
145 ret
= (pc
->devnode
)(dev
, fdt
, node_off
);
157 static target_ulong
h_reg_crq(PowerPCCPU
*cpu
, SpaprMachineState
*spapr
,
158 target_ulong opcode
, target_ulong
*args
)
160 target_ulong reg
= args
[0];
161 target_ulong queue_addr
= args
[1];
162 target_ulong queue_len
= args
[2];
163 SpaprVioDevice
*dev
= spapr_vio_find_by_reg(spapr
->vio_bus
, reg
);
166 hcall_dprintf("Unit 0x" TARGET_FMT_lx
" does not exist\n", reg
);
170 /* We can't grok a queue size bigger than 256M for now */
171 if (queue_len
< 0x1000 || queue_len
> 0x10000000) {
172 hcall_dprintf("Queue size too small or too big (0x" TARGET_FMT_lx
177 /* Check queue alignment */
178 if (queue_addr
& 0xfff) {
179 hcall_dprintf("Queue not aligned (0x" TARGET_FMT_lx
")\n", queue_addr
);
183 /* Check if device supports CRQs */
184 if (!dev
->crq
.SendFunc
) {
185 hcall_dprintf("Device does not support CRQ\n");
189 /* Already a queue ? */
190 if (dev
->crq
.qsize
) {
191 hcall_dprintf("CRQ already registered\n");
194 dev
->crq
.qladdr
= queue_addr
;
195 dev
->crq
.qsize
= queue_len
;
198 trace_spapr_vio_h_reg_crq(reg
, queue_addr
, queue_len
);
202 static target_ulong
free_crq(SpaprVioDevice
*dev
)
208 trace_spapr_vio_free_crq(dev
->reg
);
213 static target_ulong
h_free_crq(PowerPCCPU
*cpu
, SpaprMachineState
*spapr
,
214 target_ulong opcode
, target_ulong
*args
)
216 target_ulong reg
= args
[0];
217 SpaprVioDevice
*dev
= spapr_vio_find_by_reg(spapr
->vio_bus
, reg
);
220 hcall_dprintf("Unit 0x" TARGET_FMT_lx
" does not exist\n", reg
);
224 return free_crq(dev
);
227 static target_ulong
h_send_crq(PowerPCCPU
*cpu
, SpaprMachineState
*spapr
,
228 target_ulong opcode
, target_ulong
*args
)
230 target_ulong reg
= args
[0];
231 target_ulong msg_hi
= args
[1];
232 target_ulong msg_lo
= args
[2];
233 SpaprVioDevice
*dev
= spapr_vio_find_by_reg(spapr
->vio_bus
, reg
);
234 uint64_t crq_mangle
[2];
237 hcall_dprintf("Unit 0x" TARGET_FMT_lx
" does not exist\n", reg
);
240 crq_mangle
[0] = cpu_to_be64(msg_hi
);
241 crq_mangle
[1] = cpu_to_be64(msg_lo
);
243 if (dev
->crq
.SendFunc
) {
244 return dev
->crq
.SendFunc(dev
, (uint8_t *)crq_mangle
);
250 static target_ulong
h_enable_crq(PowerPCCPU
*cpu
, SpaprMachineState
*spapr
,
251 target_ulong opcode
, target_ulong
*args
)
253 target_ulong reg
= args
[0];
254 SpaprVioDevice
*dev
= spapr_vio_find_by_reg(spapr
->vio_bus
, reg
);
257 hcall_dprintf("Unit 0x" TARGET_FMT_lx
" does not exist\n", reg
);
264 /* Returns negative error, 0 success, or positive: queue full */
265 int spapr_vio_send_crq(SpaprVioDevice
*dev
, uint8_t *crq
)
270 if (!dev
->crq
.qsize
) {
271 error_report("spapr_vio_send_creq on uninitialized queue");
275 /* Maybe do a fast path for KVM just writing to the pages */
276 rc
= spapr_vio_dma_read(dev
, dev
->crq
.qladdr
+ dev
->crq
.qnext
, &byte
, 1);
284 rc
= spapr_vio_dma_write(dev
, dev
->crq
.qladdr
+ dev
->crq
.qnext
+ 8,
292 rc
= spapr_vio_dma_write(dev
, dev
->crq
.qladdr
+ dev
->crq
.qnext
, crq
, 8);
297 dev
->crq
.qnext
= (dev
->crq
.qnext
+ 16) % dev
->crq
.qsize
;
299 if (dev
->signal_state
& 1) {
300 qemu_irq_pulse(spapr_vio_qirq(dev
));
306 /* "quiesce" handling */
308 static void spapr_vio_quiesce_one(SpaprVioDevice
*dev
)
311 device_reset(DEVICE(dev
->tcet
));
316 void spapr_vio_set_bypass(SpaprVioDevice
*dev
, bool bypass
)
322 memory_region_set_enabled(&dev
->mrbypass
, bypass
);
323 memory_region_set_enabled(spapr_tce_get_iommu(dev
->tcet
), !bypass
);
325 dev
->tcet
->bypass
= bypass
;
328 static void rtas_set_tce_bypass(PowerPCCPU
*cpu
, SpaprMachineState
*spapr
,
330 uint32_t nargs
, target_ulong args
,
331 uint32_t nret
, target_ulong rets
)
333 SpaprVioBus
*bus
= spapr
->vio_bus
;
335 uint32_t unit
, enable
;
338 rtas_st(rets
, 0, RTAS_OUT_PARAM_ERROR
);
341 unit
= rtas_ld(args
, 0);
342 enable
= rtas_ld(args
, 1);
343 dev
= spapr_vio_find_by_reg(bus
, unit
);
345 rtas_st(rets
, 0, RTAS_OUT_PARAM_ERROR
);
350 rtas_st(rets
, 0, RTAS_OUT_PARAM_ERROR
);
354 spapr_vio_set_bypass(dev
, !!enable
);
356 rtas_st(rets
, 0, RTAS_OUT_SUCCESS
);
359 static void rtas_quiesce(PowerPCCPU
*cpu
, SpaprMachineState
*spapr
,
361 uint32_t nargs
, target_ulong args
,
362 uint32_t nret
, target_ulong rets
)
364 SpaprVioBus
*bus
= spapr
->vio_bus
;
366 SpaprVioDevice
*dev
= NULL
;
369 rtas_st(rets
, 0, RTAS_OUT_PARAM_ERROR
);
373 QTAILQ_FOREACH(kid
, &bus
->bus
.children
, sibling
) {
374 dev
= (SpaprVioDevice
*)kid
->child
;
375 spapr_vio_quiesce_one(dev
);
378 rtas_st(rets
, 0, RTAS_OUT_SUCCESS
);
381 static SpaprVioDevice
*reg_conflict(SpaprVioDevice
*dev
)
383 SpaprVioBus
*bus
= SPAPR_VIO_BUS(dev
->qdev
.parent_bus
);
385 SpaprVioDevice
*other
;
388 * Check for a device other than the given one which is already
389 * using the requested address. We have to open code this because
390 * the given dev might already be in the list.
392 QTAILQ_FOREACH(kid
, &bus
->bus
.children
, sibling
) {
393 other
= VIO_SPAPR_DEVICE(kid
->child
);
395 if (other
!= dev
&& other
->reg
== dev
->reg
) {
403 static void spapr_vio_busdev_reset(DeviceState
*qdev
)
405 SpaprVioDevice
*dev
= VIO_SPAPR_DEVICE(qdev
);
406 SpaprVioDeviceClass
*pc
= VIO_SPAPR_DEVICE_GET_CLASS(dev
);
408 /* Shut down the request queue and TCEs if necessary */
409 spapr_vio_quiesce_one(dev
);
411 dev
->signal_state
= 0;
413 spapr_vio_set_bypass(dev
, false);
420 * The register property of a VIO device is defined in livirt using
421 * 0x1000 as a base register number plus a 0x1000 increment. For the
422 * VIO tty device, the base number is changed to 0x30000000. QEMU uses
423 * a base register number of 0x71000000 and then a simple increment.
425 * The formula below tries to compute a unique index number from the
426 * register value that will be used to define the IRQ number of the
429 * A maximum of 256 VIO devices is covered. Collisions are possible
430 * but they will be detected when the IRQ is claimed.
432 static inline uint32_t spapr_vio_reg_to_irq(uint32_t reg
)
436 if (reg
>= SPAPR_VIO_REG_BASE
) {
438 * VIO device register values when allocated by QEMU. For
439 * these, we simply mask the high bits to fit the overall
440 * range: [0x00 - 0xff].
442 * The nvram VIO device (reg=0x71000000) is a static device of
443 * the pseries machine and so is always allocated by QEMU. Its
448 } else if (reg
>= 0x30000000) {
450 * VIO tty devices register values, when allocated by livirt,
451 * are mapped in range [0xf0 - 0xff], gives us a maximum of 16
454 irq
= 0xf0 | ((reg
>> 12) & 0xf);
458 * Other VIO devices register values, when allocated by
459 * livirt, should be mapped in range [0x00 - 0xef]. Conflicts
460 * will be detected when IRQ is claimed.
462 irq
= (reg
>> 12) & 0xff;
465 return SPAPR_IRQ_VIO
| irq
;
468 static void spapr_vio_busdev_realize(DeviceState
*qdev
, Error
**errp
)
470 SpaprMachineState
*spapr
= SPAPR_MACHINE(qdev_get_machine());
471 SpaprVioDevice
*dev
= (SpaprVioDevice
*)qdev
;
472 SpaprVioDeviceClass
*pc
= VIO_SPAPR_DEVICE_GET_CLASS(dev
);
474 Error
*local_err
= NULL
;
476 if (dev
->reg
!= -1) {
478 * Explicitly assigned address, just verify that no-one else
479 * is using it. other mechanism). We have to open code this
480 * rather than using spapr_vio_find_by_reg() because sdev
481 * itself is already in the list.
483 SpaprVioDevice
*other
= reg_conflict(dev
);
486 error_setg(errp
, "%s and %s devices conflict at address %#x",
487 object_get_typename(OBJECT(qdev
)),
488 object_get_typename(OBJECT(&other
->qdev
)),
493 /* Need to assign an address */
494 SpaprVioBus
*bus
= SPAPR_VIO_BUS(dev
->qdev
.parent_bus
);
497 dev
->reg
= bus
->next_reg
++;
498 } while (reg_conflict(dev
));
501 /* Don't overwrite ids assigned on the command line */
503 id
= spapr_vio_get_dev_name(DEVICE(dev
));
507 dev
->irq
= spapr_vio_reg_to_irq(dev
->reg
);
509 if (SPAPR_MACHINE_GET_CLASS(spapr
)->legacy_irq_allocation
) {
510 dev
->irq
= spapr_irq_findone(spapr
, &local_err
);
512 error_propagate(errp
, local_err
);
517 spapr_irq_claim(spapr
, dev
->irq
, false, &local_err
);
519 error_propagate(errp
, local_err
);
523 if (pc
->rtce_window_size
) {
524 uint32_t liobn
= SPAPR_VIO_LIOBN(dev
->reg
);
526 memory_region_init(&dev
->mrroot
, OBJECT(dev
), "iommu-spapr-root",
528 memory_region_init_alias(&dev
->mrbypass
, OBJECT(dev
),
529 "iommu-spapr-bypass", get_system_memory(),
531 memory_region_add_subregion_overlap(&dev
->mrroot
, 0, &dev
->mrbypass
, 1);
532 address_space_init(&dev
->as
, &dev
->mrroot
, qdev
->id
);
534 dev
->tcet
= spapr_tce_new_table(qdev
, liobn
);
535 spapr_tce_table_enable(dev
->tcet
, SPAPR_TCE_PAGE_SHIFT
, 0,
536 pc
->rtce_window_size
>> SPAPR_TCE_PAGE_SHIFT
);
537 dev
->tcet
->vdev
= dev
;
538 memory_region_add_subregion_overlap(&dev
->mrroot
, 0,
539 spapr_tce_get_iommu(dev
->tcet
), 2);
542 pc
->realize(dev
, errp
);
545 static target_ulong
h_vio_signal(PowerPCCPU
*cpu
, SpaprMachineState
*spapr
,
549 target_ulong reg
= args
[0];
550 target_ulong mode
= args
[1];
551 SpaprVioDevice
*dev
= spapr_vio_find_by_reg(spapr
->vio_bus
, reg
);
552 SpaprVioDeviceClass
*pc
;
558 pc
= VIO_SPAPR_DEVICE_GET_CLASS(dev
);
560 if (mode
& ~pc
->signal_mask
) {
564 dev
->signal_state
= mode
;
569 SpaprVioBus
*spapr_vio_bus_init(void)
575 /* Create bridge device */
576 dev
= qdev_create(NULL
, TYPE_SPAPR_VIO_BRIDGE
);
577 qdev_init_nofail(dev
);
579 /* Create bus on bridge device */
580 qbus
= qbus_create(TYPE_SPAPR_VIO_BUS
, dev
, "spapr-vio");
581 bus
= SPAPR_VIO_BUS(qbus
);
582 bus
->next_reg
= SPAPR_VIO_REG_BASE
;
585 spapr_register_hypercall(H_VIO_SIGNAL
, h_vio_signal
);
588 spapr_register_hypercall(H_REG_CRQ
, h_reg_crq
);
589 spapr_register_hypercall(H_FREE_CRQ
, h_free_crq
);
590 spapr_register_hypercall(H_SEND_CRQ
, h_send_crq
);
591 spapr_register_hypercall(H_ENABLE_CRQ
, h_enable_crq
);
594 spapr_rtas_register(RTAS_IBM_SET_TCE_BYPASS
, "ibm,set-tce-bypass",
595 rtas_set_tce_bypass
);
596 spapr_rtas_register(RTAS_QUIESCE
, "quiesce", rtas_quiesce
);
601 static void spapr_vio_bridge_class_init(ObjectClass
*klass
, void *data
)
603 DeviceClass
*dc
= DEVICE_CLASS(klass
);
605 dc
->fw_name
= "vdevice";
608 static const TypeInfo spapr_vio_bridge_info
= {
609 .name
= TYPE_SPAPR_VIO_BRIDGE
,
610 .parent
= TYPE_SYS_BUS_DEVICE
,
611 .class_init
= spapr_vio_bridge_class_init
,
614 const VMStateDescription vmstate_spapr_vio
= {
617 .minimum_version_id
= 1,
618 .fields
= (VMStateField
[]) {
620 VMSTATE_UINT32_EQUAL(reg
, SpaprVioDevice
, NULL
),
621 VMSTATE_UINT32_EQUAL(irq
, SpaprVioDevice
, NULL
),
623 /* General VIO device state */
624 VMSTATE_UINT64(signal_state
, SpaprVioDevice
),
625 VMSTATE_UINT64(crq
.qladdr
, SpaprVioDevice
),
626 VMSTATE_UINT32(crq
.qsize
, SpaprVioDevice
),
627 VMSTATE_UINT32(crq
.qnext
, SpaprVioDevice
),
629 VMSTATE_END_OF_LIST()
633 static void vio_spapr_device_class_init(ObjectClass
*klass
, void *data
)
635 DeviceClass
*k
= DEVICE_CLASS(klass
);
636 k
->realize
= spapr_vio_busdev_realize
;
637 k
->reset
= spapr_vio_busdev_reset
;
638 k
->bus_type
= TYPE_SPAPR_VIO_BUS
;
641 static const TypeInfo spapr_vio_type_info
= {
642 .name
= TYPE_VIO_SPAPR_DEVICE
,
643 .parent
= TYPE_DEVICE
,
644 .instance_size
= sizeof(SpaprVioDevice
),
646 .class_size
= sizeof(SpaprVioDeviceClass
),
647 .class_init
= vio_spapr_device_class_init
,
650 static void spapr_vio_register_types(void)
652 type_register_static(&spapr_vio_bus_info
);
653 type_register_static(&spapr_vio_bridge_info
);
654 type_register_static(&spapr_vio_type_info
);
657 type_init(spapr_vio_register_types
)
659 static int compare_reg(const void *p1
, const void *p2
)
661 SpaprVioDevice
const *dev1
, *dev2
;
663 dev1
= (SpaprVioDevice
*)*(DeviceState
**)p1
;
664 dev2
= (SpaprVioDevice
*)*(DeviceState
**)p2
;
666 if (dev1
->reg
< dev2
->reg
) {
669 if (dev1
->reg
== dev2
->reg
) {
673 /* dev1->reg > dev2->reg */
677 void spapr_dt_vdevice(SpaprVioBus
*bus
, void *fdt
)
679 DeviceState
*qdev
, **qdevs
;
684 _FDT(node
= fdt_add_subnode(fdt
, 0, "vdevice"));
686 _FDT(fdt_setprop_string(fdt
, node
, "device_type", "vdevice"));
687 _FDT(fdt_setprop_string(fdt
, node
, "compatible", "IBM,vdevice"));
688 _FDT(fdt_setprop_cell(fdt
, node
, "#address-cells", 1));
689 _FDT(fdt_setprop_cell(fdt
, node
, "#size-cells", 0));
690 _FDT(fdt_setprop_cell(fdt
, node
, "#interrupt-cells", 2));
691 _FDT(fdt_setprop(fdt
, node
, "interrupt-controller", NULL
, 0));
693 /* Count qdevs on the bus list */
695 QTAILQ_FOREACH(kid
, &bus
->bus
.children
, sibling
) {
699 /* Copy out into an array of pointers */
700 qdevs
= g_new(DeviceState
*, num
);
702 QTAILQ_FOREACH(kid
, &bus
->bus
.children
, sibling
) {
703 qdevs
[num
++] = kid
->child
;
707 qsort(qdevs
, num
, sizeof(qdev
), compare_reg
);
709 /* Hack alert. Give the devices to libfdt in reverse order, we happen
710 * to know that will mean they are in forward order in the tree. */
711 for (i
= num
- 1; i
>= 0; i
--) {
712 SpaprVioDevice
*dev
= (SpaprVioDevice
*)(qdevs
[i
]);
713 SpaprVioDeviceClass
*vdc
= VIO_SPAPR_DEVICE_GET_CLASS(dev
);
715 ret
= vio_make_devnode(dev
, fdt
);
717 error_report("Couldn't create device node /vdevice/%s@%"PRIx32
,
718 vdc
->dt_name
, dev
->reg
);
726 gchar
*spapr_vio_stdout_path(SpaprVioBus
*bus
)
731 dev
= spapr_vty_get_default(bus
);
736 name
= spapr_vio_get_dev_name(DEVICE(dev
));
737 path
= g_strdup_printf("/vdevice/%s", name
);