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 "qapi/error.h"
26 #include "sysemu/sysemu.h"
27 #include "hw/boards.h"
28 #include "hw/loader.h"
30 #include "hw/sysbus.h"
31 #include "sysemu/kvm.h"
32 #include "sysemu/device_tree.h"
35 #include "hw/ppc/spapr.h"
36 #include "hw/ppc/spapr_vio.h"
37 #include "hw/ppc/xics.h"
41 /* #define DEBUG_SPAPR */
44 #define DPRINTF(fmt, ...) \
45 do { fprintf(stderr, fmt, ## __VA_ARGS__); } while (0)
47 #define DPRINTF(fmt, ...) \
51 static Property spapr_vio_props
[] = {
52 DEFINE_PROP_UINT32("irq", VIOsPAPRDevice
, irq
, 0), \
53 DEFINE_PROP_END_OF_LIST(),
56 static char *spapr_vio_get_dev_name(DeviceState
*qdev
)
58 VIOsPAPRDevice
*dev
= VIO_SPAPR_DEVICE(qdev
);
59 VIOsPAPRDeviceClass
*pc
= VIO_SPAPR_DEVICE_GET_CLASS(dev
);
61 /* Device tree style name device@reg */
62 return g_strdup_printf("%s@%x", pc
->dt_name
, dev
->reg
);
65 static void spapr_vio_bus_class_init(ObjectClass
*klass
, void *data
)
67 BusClass
*k
= BUS_CLASS(klass
);
69 k
->get_dev_path
= spapr_vio_get_dev_name
;
70 k
->get_fw_dev_path
= spapr_vio_get_dev_name
;
73 static const TypeInfo spapr_vio_bus_info
= {
74 .name
= TYPE_SPAPR_VIO_BUS
,
76 .class_init
= spapr_vio_bus_class_init
,
77 .instance_size
= sizeof(VIOsPAPRBus
),
80 VIOsPAPRDevice
*spapr_vio_find_by_reg(VIOsPAPRBus
*bus
, uint32_t reg
)
83 VIOsPAPRDevice
*dev
= NULL
;
85 QTAILQ_FOREACH(kid
, &bus
->bus
.children
, sibling
) {
86 dev
= (VIOsPAPRDevice
*)kid
->child
;
87 if (dev
->reg
== reg
) {
95 static int vio_make_devnode(VIOsPAPRDevice
*dev
,
98 VIOsPAPRDeviceClass
*pc
= VIO_SPAPR_DEVICE_GET_CLASS(dev
);
99 int vdevice_off
, node_off
, ret
;
102 vdevice_off
= fdt_path_offset(fdt
, "/vdevice");
103 if (vdevice_off
< 0) {
107 dt_name
= spapr_vio_get_dev_name(DEVICE(dev
));
108 node_off
= fdt_add_subnode(fdt
, vdevice_off
, dt_name
);
114 ret
= fdt_setprop_cell(fdt
, node_off
, "reg", dev
->reg
);
120 ret
= fdt_setprop_string(fdt
, node_off
, "device_type",
127 if (pc
->dt_compatible
) {
128 ret
= fdt_setprop_string(fdt
, node_off
, "compatible",
136 uint32_t ints_prop
[] = {cpu_to_be32(dev
->irq
), 0};
138 ret
= fdt_setprop(fdt
, node_off
, "interrupts", ints_prop
,
145 ret
= spapr_tcet_dma_dt(fdt
, node_off
, "ibm,my-dma-window", dev
->tcet
);
151 ret
= (pc
->devnode
)(dev
, fdt
, node_off
);
163 static target_ulong
h_reg_crq(PowerPCCPU
*cpu
, sPAPRMachineState
*spapr
,
164 target_ulong opcode
, target_ulong
*args
)
166 target_ulong reg
= args
[0];
167 target_ulong queue_addr
= args
[1];
168 target_ulong queue_len
= args
[2];
169 VIOsPAPRDevice
*dev
= spapr_vio_find_by_reg(spapr
->vio_bus
, reg
);
172 hcall_dprintf("Unit 0x" TARGET_FMT_lx
" does not exist\n", reg
);
176 /* We can't grok a queue size bigger than 256M for now */
177 if (queue_len
< 0x1000 || queue_len
> 0x10000000) {
178 hcall_dprintf("Queue size too small or too big (0x" TARGET_FMT_lx
183 /* Check queue alignment */
184 if (queue_addr
& 0xfff) {
185 hcall_dprintf("Queue not aligned (0x" TARGET_FMT_lx
")\n", queue_addr
);
189 /* Check if device supports CRQs */
190 if (!dev
->crq
.SendFunc
) {
191 hcall_dprintf("Device does not support CRQ\n");
195 /* Already a queue ? */
196 if (dev
->crq
.qsize
) {
197 hcall_dprintf("CRQ already registered\n");
200 dev
->crq
.qladdr
= queue_addr
;
201 dev
->crq
.qsize
= queue_len
;
204 DPRINTF("CRQ for dev 0x" TARGET_FMT_lx
" registered at 0x"
205 TARGET_FMT_lx
"/0x" TARGET_FMT_lx
"\n",
206 reg
, queue_addr
, queue_len
);
210 static target_ulong
free_crq(VIOsPAPRDevice
*dev
)
216 DPRINTF("CRQ for dev 0x%" PRIx32
" freed\n", dev
->reg
);
221 static target_ulong
h_free_crq(PowerPCCPU
*cpu
, sPAPRMachineState
*spapr
,
222 target_ulong opcode
, target_ulong
*args
)
224 target_ulong reg
= args
[0];
225 VIOsPAPRDevice
*dev
= spapr_vio_find_by_reg(spapr
->vio_bus
, reg
);
228 hcall_dprintf("Unit 0x" TARGET_FMT_lx
" does not exist\n", reg
);
232 return free_crq(dev
);
235 static target_ulong
h_send_crq(PowerPCCPU
*cpu
, sPAPRMachineState
*spapr
,
236 target_ulong opcode
, target_ulong
*args
)
238 target_ulong reg
= args
[0];
239 target_ulong msg_hi
= args
[1];
240 target_ulong msg_lo
= args
[2];
241 VIOsPAPRDevice
*dev
= spapr_vio_find_by_reg(spapr
->vio_bus
, reg
);
242 uint64_t crq_mangle
[2];
245 hcall_dprintf("Unit 0x" TARGET_FMT_lx
" does not exist\n", reg
);
248 crq_mangle
[0] = cpu_to_be64(msg_hi
);
249 crq_mangle
[1] = cpu_to_be64(msg_lo
);
251 if (dev
->crq
.SendFunc
) {
252 return dev
->crq
.SendFunc(dev
, (uint8_t *)crq_mangle
);
258 static target_ulong
h_enable_crq(PowerPCCPU
*cpu
, sPAPRMachineState
*spapr
,
259 target_ulong opcode
, target_ulong
*args
)
261 target_ulong reg
= args
[0];
262 VIOsPAPRDevice
*dev
= spapr_vio_find_by_reg(spapr
->vio_bus
, reg
);
265 hcall_dprintf("Unit 0x" TARGET_FMT_lx
" does not exist\n", reg
);
272 /* Returns negative error, 0 success, or positive: queue full */
273 int spapr_vio_send_crq(VIOsPAPRDevice
*dev
, uint8_t *crq
)
278 if (!dev
->crq
.qsize
) {
279 fprintf(stderr
, "spapr_vio_send_creq on uninitialized queue\n");
283 /* Maybe do a fast path for KVM just writing to the pages */
284 rc
= spapr_vio_dma_read(dev
, dev
->crq
.qladdr
+ dev
->crq
.qnext
, &byte
, 1);
292 rc
= spapr_vio_dma_write(dev
, dev
->crq
.qladdr
+ dev
->crq
.qnext
+ 8,
300 rc
= spapr_vio_dma_write(dev
, dev
->crq
.qladdr
+ dev
->crq
.qnext
, crq
, 8);
305 dev
->crq
.qnext
= (dev
->crq
.qnext
+ 16) % dev
->crq
.qsize
;
307 if (dev
->signal_state
& 1) {
308 qemu_irq_pulse(spapr_vio_qirq(dev
));
314 /* "quiesce" handling */
316 static void spapr_vio_quiesce_one(VIOsPAPRDevice
*dev
)
319 device_reset(DEVICE(dev
->tcet
));
324 void spapr_vio_set_bypass(VIOsPAPRDevice
*dev
, bool bypass
)
330 memory_region_set_enabled(&dev
->mrbypass
, bypass
);
331 memory_region_set_enabled(spapr_tce_get_iommu(dev
->tcet
), !bypass
);
333 dev
->tcet
->bypass
= bypass
;
336 static void rtas_set_tce_bypass(PowerPCCPU
*cpu
, sPAPRMachineState
*spapr
,
338 uint32_t nargs
, target_ulong args
,
339 uint32_t nret
, target_ulong rets
)
341 VIOsPAPRBus
*bus
= spapr
->vio_bus
;
343 uint32_t unit
, enable
;
346 rtas_st(rets
, 0, RTAS_OUT_PARAM_ERROR
);
349 unit
= rtas_ld(args
, 0);
350 enable
= rtas_ld(args
, 1);
351 dev
= spapr_vio_find_by_reg(bus
, unit
);
353 rtas_st(rets
, 0, RTAS_OUT_PARAM_ERROR
);
358 rtas_st(rets
, 0, RTAS_OUT_PARAM_ERROR
);
362 spapr_vio_set_bypass(dev
, !!enable
);
364 rtas_st(rets
, 0, RTAS_OUT_SUCCESS
);
367 static void rtas_quiesce(PowerPCCPU
*cpu
, sPAPRMachineState
*spapr
,
369 uint32_t nargs
, target_ulong args
,
370 uint32_t nret
, target_ulong rets
)
372 VIOsPAPRBus
*bus
= spapr
->vio_bus
;
374 VIOsPAPRDevice
*dev
= NULL
;
377 rtas_st(rets
, 0, RTAS_OUT_PARAM_ERROR
);
381 QTAILQ_FOREACH(kid
, &bus
->bus
.children
, sibling
) {
382 dev
= (VIOsPAPRDevice
*)kid
->child
;
383 spapr_vio_quiesce_one(dev
);
386 rtas_st(rets
, 0, RTAS_OUT_SUCCESS
);
389 static VIOsPAPRDevice
*reg_conflict(VIOsPAPRDevice
*dev
)
391 VIOsPAPRBus
*bus
= SPAPR_VIO_BUS(dev
->qdev
.parent_bus
);
393 VIOsPAPRDevice
*other
;
396 * Check for a device other than the given one which is already
397 * using the requested address. We have to open code this because
398 * the given dev might already be in the list.
400 QTAILQ_FOREACH(kid
, &bus
->bus
.children
, sibling
) {
401 other
= VIO_SPAPR_DEVICE(kid
->child
);
403 if (other
!= dev
&& other
->reg
== dev
->reg
) {
411 static void spapr_vio_busdev_reset(DeviceState
*qdev
)
413 VIOsPAPRDevice
*dev
= VIO_SPAPR_DEVICE(qdev
);
414 VIOsPAPRDeviceClass
*pc
= VIO_SPAPR_DEVICE_GET_CLASS(dev
);
416 /* Shut down the request queue and TCEs if necessary */
417 spapr_vio_quiesce_one(dev
);
419 dev
->signal_state
= 0;
421 spapr_vio_set_bypass(dev
, false);
427 static void spapr_vio_busdev_realize(DeviceState
*qdev
, Error
**errp
)
429 sPAPRMachineState
*spapr
= SPAPR_MACHINE(qdev_get_machine());
430 VIOsPAPRDevice
*dev
= (VIOsPAPRDevice
*)qdev
;
431 VIOsPAPRDeviceClass
*pc
= VIO_SPAPR_DEVICE_GET_CLASS(dev
);
433 Error
*local_err
= NULL
;
435 if (dev
->reg
!= -1) {
437 * Explicitly assigned address, just verify that no-one else
438 * is using it. other mechanism). We have to open code this
439 * rather than using spapr_vio_find_by_reg() because sdev
440 * itself is already in the list.
442 VIOsPAPRDevice
*other
= reg_conflict(dev
);
445 error_setg(errp
, "%s and %s devices conflict at address %#x",
446 object_get_typename(OBJECT(qdev
)),
447 object_get_typename(OBJECT(&other
->qdev
)),
452 /* Need to assign an address */
453 VIOsPAPRBus
*bus
= SPAPR_VIO_BUS(dev
->qdev
.parent_bus
);
456 dev
->reg
= bus
->next_reg
++;
457 } while (reg_conflict(dev
));
460 /* Don't overwrite ids assigned on the command line */
462 id
= spapr_vio_get_dev_name(DEVICE(dev
));
466 dev
->irq
= xics_spapr_alloc(spapr
->xics
, 0, dev
->irq
, false, &local_err
);
468 error_propagate(errp
, local_err
);
472 if (pc
->rtce_window_size
) {
473 uint32_t liobn
= SPAPR_VIO_LIOBN(dev
->reg
);
475 memory_region_init(&dev
->mrroot
, OBJECT(dev
), "iommu-spapr-root",
477 memory_region_init_alias(&dev
->mrbypass
, OBJECT(dev
),
478 "iommu-spapr-bypass", get_system_memory(),
480 memory_region_add_subregion_overlap(&dev
->mrroot
, 0, &dev
->mrbypass
, 1);
481 address_space_init(&dev
->as
, &dev
->mrroot
, qdev
->id
);
483 dev
->tcet
= spapr_tce_new_table(qdev
, liobn
);
484 spapr_tce_table_enable(dev
->tcet
, SPAPR_TCE_PAGE_SHIFT
, 0,
485 pc
->rtce_window_size
>> SPAPR_TCE_PAGE_SHIFT
);
486 dev
->tcet
->vdev
= dev
;
487 memory_region_add_subregion_overlap(&dev
->mrroot
, 0,
488 spapr_tce_get_iommu(dev
->tcet
), 2);
491 pc
->realize(dev
, errp
);
494 static target_ulong
h_vio_signal(PowerPCCPU
*cpu
, sPAPRMachineState
*spapr
,
498 target_ulong reg
= args
[0];
499 target_ulong mode
= args
[1];
500 VIOsPAPRDevice
*dev
= spapr_vio_find_by_reg(spapr
->vio_bus
, reg
);
501 VIOsPAPRDeviceClass
*pc
;
507 pc
= VIO_SPAPR_DEVICE_GET_CLASS(dev
);
509 if (mode
& ~pc
->signal_mask
) {
513 dev
->signal_state
= mode
;
518 VIOsPAPRBus
*spapr_vio_bus_init(void)
524 /* Create bridge device */
525 dev
= qdev_create(NULL
, TYPE_SPAPR_VIO_BRIDGE
);
526 qdev_init_nofail(dev
);
528 /* Create bus on bridge device */
529 qbus
= qbus_create(TYPE_SPAPR_VIO_BUS
, dev
, "spapr-vio");
530 bus
= SPAPR_VIO_BUS(qbus
);
531 bus
->next_reg
= 0x71000000;
534 spapr_register_hypercall(H_VIO_SIGNAL
, h_vio_signal
);
537 spapr_register_hypercall(H_REG_CRQ
, h_reg_crq
);
538 spapr_register_hypercall(H_FREE_CRQ
, h_free_crq
);
539 spapr_register_hypercall(H_SEND_CRQ
, h_send_crq
);
540 spapr_register_hypercall(H_ENABLE_CRQ
, h_enable_crq
);
543 spapr_rtas_register(RTAS_IBM_SET_TCE_BYPASS
, "ibm,set-tce-bypass",
544 rtas_set_tce_bypass
);
545 spapr_rtas_register(RTAS_QUIESCE
, "quiesce", rtas_quiesce
);
550 /* Represents sPAPR hcall VIO devices */
552 static int spapr_vio_bridge_init(SysBusDevice
*dev
)
558 static void spapr_vio_bridge_class_init(ObjectClass
*klass
, void *data
)
560 SysBusDeviceClass
*k
= SYS_BUS_DEVICE_CLASS(klass
);
561 DeviceClass
*dc
= DEVICE_CLASS(klass
);
563 dc
->fw_name
= "vdevice";
564 k
->init
= spapr_vio_bridge_init
;
567 static const TypeInfo spapr_vio_bridge_info
= {
568 .name
= TYPE_SPAPR_VIO_BRIDGE
,
569 .parent
= TYPE_SYS_BUS_DEVICE
,
570 .class_init
= spapr_vio_bridge_class_init
,
573 const VMStateDescription vmstate_spapr_vio
= {
576 .minimum_version_id
= 1,
577 .fields
= (VMStateField
[]) {
579 VMSTATE_UINT32_EQUAL(reg
, VIOsPAPRDevice
),
580 VMSTATE_UINT32_EQUAL(irq
, VIOsPAPRDevice
),
582 /* General VIO device state */
583 VMSTATE_UINT64(signal_state
, VIOsPAPRDevice
),
584 VMSTATE_UINT64(crq
.qladdr
, VIOsPAPRDevice
),
585 VMSTATE_UINT32(crq
.qsize
, VIOsPAPRDevice
),
586 VMSTATE_UINT32(crq
.qnext
, VIOsPAPRDevice
),
588 VMSTATE_END_OF_LIST()
592 static void vio_spapr_device_class_init(ObjectClass
*klass
, void *data
)
594 DeviceClass
*k
= DEVICE_CLASS(klass
);
595 k
->realize
= spapr_vio_busdev_realize
;
596 k
->reset
= spapr_vio_busdev_reset
;
597 k
->bus_type
= TYPE_SPAPR_VIO_BUS
;
598 k
->props
= spapr_vio_props
;
601 static const TypeInfo spapr_vio_type_info
= {
602 .name
= TYPE_VIO_SPAPR_DEVICE
,
603 .parent
= TYPE_DEVICE
,
604 .instance_size
= sizeof(VIOsPAPRDevice
),
606 .class_size
= sizeof(VIOsPAPRDeviceClass
),
607 .class_init
= vio_spapr_device_class_init
,
610 static void spapr_vio_register_types(void)
612 type_register_static(&spapr_vio_bus_info
);
613 type_register_static(&spapr_vio_bridge_info
);
614 type_register_static(&spapr_vio_type_info
);
617 type_init(spapr_vio_register_types
)
619 static int compare_reg(const void *p1
, const void *p2
)
621 VIOsPAPRDevice
const *dev1
, *dev2
;
623 dev1
= (VIOsPAPRDevice
*)*(DeviceState
**)p1
;
624 dev2
= (VIOsPAPRDevice
*)*(DeviceState
**)p2
;
626 if (dev1
->reg
< dev2
->reg
) {
629 if (dev1
->reg
== dev2
->reg
) {
633 /* dev1->reg > dev2->reg */
637 int spapr_populate_vdevice(VIOsPAPRBus
*bus
, void *fdt
)
639 DeviceState
*qdev
, **qdevs
;
643 /* Count qdevs on the bus list */
645 QTAILQ_FOREACH(kid
, &bus
->bus
.children
, sibling
) {
649 /* Copy out into an array of pointers */
650 qdevs
= g_malloc(sizeof(qdev
) * num
);
652 QTAILQ_FOREACH(kid
, &bus
->bus
.children
, sibling
) {
653 qdevs
[num
++] = kid
->child
;
657 qsort(qdevs
, num
, sizeof(qdev
), compare_reg
);
659 /* Hack alert. Give the devices to libfdt in reverse order, we happen
660 * to know that will mean they are in forward order in the tree. */
661 for (i
= num
- 1; i
>= 0; i
--) {
662 VIOsPAPRDevice
*dev
= (VIOsPAPRDevice
*)(qdevs
[i
]);
664 ret
= vio_make_devnode(dev
, fdt
);
678 int spapr_populate_chosen_stdout(void *fdt
, VIOsPAPRBus
*bus
)
684 dev
= spapr_vty_get_default(bus
);
688 offset
= fdt_path_offset(fdt
, "/chosen");
693 name
= spapr_vio_get_dev_name(DEVICE(dev
));
694 path
= g_strdup_printf("/vdevice/%s", name
);
696 ret
= fdt_setprop_string(fdt
, offset
, "linux,stdout-path", path
);