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/>.
28 #include "hw/sysbus.h"
30 #include "device_tree.h"
34 #include "hw/spapr_vio.h"
39 #endif /* CONFIG_FDT */
41 /* #define DEBUG_SPAPR */
42 /* #define DEBUG_TCE */
45 #define dprintf(fmt, ...) \
46 do { fprintf(stderr, fmt, ## __VA_ARGS__); } while (0)
48 #define dprintf(fmt, ...) \
52 static Property spapr_vio_props
[] = {
53 DEFINE_PROP_UINT32("irq", VIOsPAPRDevice
, vio_irq_num
, 0), \
54 DEFINE_PROP_END_OF_LIST(),
57 static const TypeInfo spapr_vio_bus_info
= {
58 .name
= TYPE_SPAPR_VIO_BUS
,
60 .instance_size
= sizeof(VIOsPAPRBus
),
63 VIOsPAPRDevice
*spapr_vio_find_by_reg(VIOsPAPRBus
*bus
, uint32_t reg
)
66 VIOsPAPRDevice
*dev
= NULL
;
68 QTAILQ_FOREACH(kid
, &bus
->bus
.children
, sibling
) {
69 dev
= (VIOsPAPRDevice
*)kid
->child
;
70 if (dev
->reg
== reg
) {
78 static char *vio_format_dev_name(VIOsPAPRDevice
*dev
)
80 VIOsPAPRDeviceClass
*pc
= VIO_SPAPR_DEVICE_GET_CLASS(dev
);
83 /* Device tree style name device@reg */
84 if (asprintf(&name
, "%s@%x", pc
->dt_name
, dev
->reg
) < 0) {
92 static int vio_make_devnode(VIOsPAPRDevice
*dev
,
95 VIOsPAPRDeviceClass
*pc
= VIO_SPAPR_DEVICE_GET_CLASS(dev
);
96 int vdevice_off
, node_off
, ret
;
99 vdevice_off
= fdt_path_offset(fdt
, "/vdevice");
100 if (vdevice_off
< 0) {
104 dt_name
= vio_format_dev_name(dev
);
109 node_off
= fdt_add_subnode(fdt
, vdevice_off
, dt_name
);
115 ret
= fdt_setprop_cell(fdt
, node_off
, "reg", dev
->reg
);
121 ret
= fdt_setprop_string(fdt
, node_off
, "device_type",
128 if (pc
->dt_compatible
) {
129 ret
= fdt_setprop_string(fdt
, node_off
, "compatible",
137 uint32_t ints_prop
[] = {cpu_to_be32(dev
->vio_irq_num
), 0};
139 ret
= fdt_setprop(fdt
, node_off
, "interrupts", ints_prop
,
146 if (dev
->rtce_window_size
) {
147 uint32_t dma_prop
[] = {cpu_to_be32(dev
->reg
),
149 0, cpu_to_be32(dev
->rtce_window_size
)};
151 ret
= fdt_setprop_cell(fdt
, node_off
, "ibm,#dma-address-cells", 2);
156 ret
= fdt_setprop_cell(fdt
, node_off
, "ibm,#dma-size-cells", 2);
161 ret
= fdt_setprop(fdt
, node_off
, "ibm,my-dma-window", dma_prop
,
169 ret
= (pc
->devnode
)(dev
, fdt
, node_off
);
177 #endif /* CONFIG_FDT */
183 static void rtce_init(VIOsPAPRDevice
*dev
)
185 size_t size
= (dev
->rtce_window_size
>> SPAPR_VIO_TCE_PAGE_SHIFT
)
186 * sizeof(VIOsPAPR_RTCE
);
189 dev
->rtce_table
= kvmppc_create_spapr_tce(dev
->reg
,
190 dev
->rtce_window_size
,
193 if (!dev
->rtce_table
) {
194 dev
->rtce_table
= g_malloc0(size
);
199 static target_ulong
h_put_tce(CPUPPCState
*env
, sPAPREnvironment
*spapr
,
200 target_ulong opcode
, target_ulong
*args
)
202 target_ulong liobn
= args
[0];
203 target_ulong ioba
= args
[1];
204 target_ulong tce
= args
[2];
205 VIOsPAPRDevice
*dev
= spapr_vio_find_by_reg(spapr
->vio_bus
, liobn
);
209 hcall_dprintf("LIOBN 0x" TARGET_FMT_lx
" does not exist\n", liobn
);
213 ioba
&= ~(SPAPR_VIO_TCE_PAGE_SIZE
- 1);
216 fprintf(stderr
, "spapr_vio_put_tce on %s ioba 0x" TARGET_FMT_lx
217 " TCE 0x" TARGET_FMT_lx
"\n", dev
->qdev
.id
, ioba
, tce
);
220 if (ioba
>= dev
->rtce_window_size
) {
221 hcall_dprintf("Out-of-bounds IOBA 0x" TARGET_FMT_lx
"\n", ioba
);
225 rtce
= dev
->rtce_table
+ (ioba
>> SPAPR_VIO_TCE_PAGE_SHIFT
);
231 int spapr_vio_check_tces(VIOsPAPRDevice
*dev
, target_ulong ioba
,
232 target_ulong len
, enum VIOsPAPR_TCEAccess access
)
236 start
= ioba
>> SPAPR_VIO_TCE_PAGE_SHIFT
;
237 end
= (ioba
+ len
- 1) >> SPAPR_VIO_TCE_PAGE_SHIFT
;
239 for (i
= start
; i
<= end
; i
++) {
240 if ((dev
->rtce_table
[i
].tce
& access
) != access
) {
242 fprintf(stderr
, "FAIL on %d\n", i
);
251 int spapr_tce_dma_write(VIOsPAPRDevice
*dev
, uint64_t taddr
, const void *buf
,
255 fprintf(stderr
, "spapr_tce_dma_write taddr=0x%llx size=0x%x\n",
256 (unsigned long long)taddr
, size
);
259 /* Check for bypass */
260 if (dev
->flags
& VIO_PAPR_FLAG_DMA_BYPASS
) {
261 cpu_physical_memory_write(taddr
, buf
, size
);
270 /* Check if we are in bound */
271 if (taddr
>= dev
->rtce_window_size
) {
273 fprintf(stderr
, "spapr_tce_dma_write out of bounds\n");
277 tce
= dev
->rtce_table
[taddr
>> SPAPR_VIO_TCE_PAGE_SHIFT
].tce
;
279 /* How much til end of page ? */
280 lsize
= MIN(size
, ((~taddr
) & SPAPR_VIO_TCE_PAGE_MASK
) + 1);
288 txaddr
= (tce
& ~SPAPR_VIO_TCE_PAGE_MASK
) |
289 (taddr
& SPAPR_VIO_TCE_PAGE_MASK
);
292 fprintf(stderr
, " -> write to txaddr=0x%llx, size=0x%x\n",
293 (unsigned long long)txaddr
, lsize
);
297 cpu_physical_memory_write(txaddr
, buf
, lsize
);
305 int spapr_tce_dma_zero(VIOsPAPRDevice
*dev
, uint64_t taddr
, uint32_t size
)
307 /* FIXME: allocating a temp buffer is nasty, but just stepping
308 * through writing zeroes is awkward. This will do for now. */
309 uint8_t zeroes
[size
];
312 fprintf(stderr
, "spapr_tce_dma_zero taddr=0x%llx size=0x%x\n",
313 (unsigned long long)taddr
, size
);
316 memset(zeroes
, 0, size
);
317 return spapr_tce_dma_write(dev
, taddr
, zeroes
, size
);
320 void stb_tce(VIOsPAPRDevice
*dev
, uint64_t taddr
, uint8_t val
)
322 spapr_tce_dma_write(dev
, taddr
, &val
, sizeof(val
));
325 void sth_tce(VIOsPAPRDevice
*dev
, uint64_t taddr
, uint16_t val
)
328 spapr_tce_dma_write(dev
, taddr
, &val
, sizeof(val
));
332 void stw_tce(VIOsPAPRDevice
*dev
, uint64_t taddr
, uint32_t val
)
335 spapr_tce_dma_write(dev
, taddr
, &val
, sizeof(val
));
338 void stq_tce(VIOsPAPRDevice
*dev
, uint64_t taddr
, uint64_t val
)
341 spapr_tce_dma_write(dev
, taddr
, &val
, sizeof(val
));
344 int spapr_tce_dma_read(VIOsPAPRDevice
*dev
, uint64_t taddr
, void *buf
,
348 fprintf(stderr
, "spapr_tce_dma_write taddr=0x%llx size=0x%x\n",
349 (unsigned long long)taddr
, size
);
352 /* Check for bypass */
353 if (dev
->flags
& VIO_PAPR_FLAG_DMA_BYPASS
) {
354 cpu_physical_memory_read(taddr
, buf
, size
);
363 /* Check if we are in bound */
364 if (taddr
>= dev
->rtce_window_size
) {
366 fprintf(stderr
, "spapr_tce_dma_read out of bounds\n");
370 tce
= dev
->rtce_table
[taddr
>> SPAPR_VIO_TCE_PAGE_SHIFT
].tce
;
372 /* How much til end of page ? */
373 lsize
= MIN(size
, ((~taddr
) & SPAPR_VIO_TCE_PAGE_MASK
) + 1);
381 txaddr
= (tce
& ~SPAPR_VIO_TCE_PAGE_MASK
) |
382 (taddr
& SPAPR_VIO_TCE_PAGE_MASK
);
385 fprintf(stderr
, " -> write to txaddr=0x%llx, size=0x%x\n",
386 (unsigned long long)txaddr
, lsize
);
389 cpu_physical_memory_read(txaddr
, buf
, lsize
);
397 uint64_t ldq_tce(VIOsPAPRDevice
*dev
, uint64_t taddr
)
401 spapr_tce_dma_read(dev
, taddr
, &val
, sizeof(val
));
408 static target_ulong
h_reg_crq(CPUPPCState
*env
, sPAPREnvironment
*spapr
,
409 target_ulong opcode
, target_ulong
*args
)
411 target_ulong reg
= args
[0];
412 target_ulong queue_addr
= args
[1];
413 target_ulong queue_len
= args
[2];
414 VIOsPAPRDevice
*dev
= spapr_vio_find_by_reg(spapr
->vio_bus
, reg
);
417 hcall_dprintf("Unit 0x" TARGET_FMT_lx
" does not exist\n", reg
);
421 /* We can't grok a queue size bigger than 256M for now */
422 if (queue_len
< 0x1000 || queue_len
> 0x10000000) {
423 hcall_dprintf("Queue size too small or too big (0x" TARGET_FMT_lx
428 /* Check queue alignment */
429 if (queue_addr
& 0xfff) {
430 hcall_dprintf("Queue not aligned (0x" TARGET_FMT_lx
")\n", queue_addr
);
434 /* Check if device supports CRQs */
435 if (!dev
->crq
.SendFunc
) {
436 hcall_dprintf("Device does not support CRQ\n");
440 /* Already a queue ? */
441 if (dev
->crq
.qsize
) {
442 hcall_dprintf("CRQ already registered\n");
445 dev
->crq
.qladdr
= queue_addr
;
446 dev
->crq
.qsize
= queue_len
;
449 dprintf("CRQ for dev 0x" TARGET_FMT_lx
" registered at 0x"
450 TARGET_FMT_lx
"/0x" TARGET_FMT_lx
"\n",
451 reg
, queue_addr
, queue_len
);
455 static target_ulong
free_crq(VIOsPAPRDevice
*dev
)
461 dprintf("CRQ for dev 0x%" PRIx32
" freed\n", dev
->reg
);
466 static target_ulong
h_free_crq(CPUPPCState
*env
, sPAPREnvironment
*spapr
,
467 target_ulong opcode
, target_ulong
*args
)
469 target_ulong reg
= args
[0];
470 VIOsPAPRDevice
*dev
= spapr_vio_find_by_reg(spapr
->vio_bus
, reg
);
473 hcall_dprintf("Unit 0x" TARGET_FMT_lx
" does not exist\n", reg
);
477 return free_crq(dev
);
480 static target_ulong
h_send_crq(CPUPPCState
*env
, sPAPREnvironment
*spapr
,
481 target_ulong opcode
, target_ulong
*args
)
483 target_ulong reg
= args
[0];
484 target_ulong msg_hi
= args
[1];
485 target_ulong msg_lo
= args
[2];
486 VIOsPAPRDevice
*dev
= spapr_vio_find_by_reg(spapr
->vio_bus
, reg
);
487 uint64_t crq_mangle
[2];
490 hcall_dprintf("Unit 0x" TARGET_FMT_lx
" does not exist\n", reg
);
493 crq_mangle
[0] = cpu_to_be64(msg_hi
);
494 crq_mangle
[1] = cpu_to_be64(msg_lo
);
496 if (dev
->crq
.SendFunc
) {
497 return dev
->crq
.SendFunc(dev
, (uint8_t *)crq_mangle
);
503 static target_ulong
h_enable_crq(CPUPPCState
*env
, sPAPREnvironment
*spapr
,
504 target_ulong opcode
, target_ulong
*args
)
506 target_ulong reg
= args
[0];
507 VIOsPAPRDevice
*dev
= spapr_vio_find_by_reg(spapr
->vio_bus
, reg
);
510 hcall_dprintf("Unit 0x" TARGET_FMT_lx
" does not exist\n", reg
);
517 /* Returns negative error, 0 success, or positive: queue full */
518 int spapr_vio_send_crq(VIOsPAPRDevice
*dev
, uint8_t *crq
)
523 if (!dev
->crq
.qsize
) {
524 fprintf(stderr
, "spapr_vio_send_creq on uninitialized queue\n");
528 /* Maybe do a fast path for KVM just writing to the pages */
529 rc
= spapr_tce_dma_read(dev
, dev
->crq
.qladdr
+ dev
->crq
.qnext
, &byte
, 1);
537 rc
= spapr_tce_dma_write(dev
, dev
->crq
.qladdr
+ dev
->crq
.qnext
+ 8,
545 rc
= spapr_tce_dma_write(dev
, dev
->crq
.qladdr
+ dev
->crq
.qnext
, crq
, 8);
550 dev
->crq
.qnext
= (dev
->crq
.qnext
+ 16) % dev
->crq
.qsize
;
552 if (dev
->signal_state
& 1) {
553 qemu_irq_pulse(dev
->qirq
);
559 /* "quiesce" handling */
561 static void spapr_vio_quiesce_one(VIOsPAPRDevice
*dev
)
563 dev
->flags
&= ~VIO_PAPR_FLAG_DMA_BYPASS
;
565 if (dev
->rtce_table
) {
566 size_t size
= (dev
->rtce_window_size
>> SPAPR_VIO_TCE_PAGE_SHIFT
)
567 * sizeof(VIOsPAPR_RTCE
);
568 memset(dev
->rtce_table
, 0, size
);
576 static void rtas_set_tce_bypass(sPAPREnvironment
*spapr
, uint32_t token
,
577 uint32_t nargs
, target_ulong args
,
578 uint32_t nret
, target_ulong rets
)
580 VIOsPAPRBus
*bus
= spapr
->vio_bus
;
582 uint32_t unit
, enable
;
585 rtas_st(rets
, 0, -3);
588 unit
= rtas_ld(args
, 0);
589 enable
= rtas_ld(args
, 1);
590 dev
= spapr_vio_find_by_reg(bus
, unit
);
592 rtas_st(rets
, 0, -3);
596 dev
->flags
|= VIO_PAPR_FLAG_DMA_BYPASS
;
598 dev
->flags
&= ~VIO_PAPR_FLAG_DMA_BYPASS
;
604 static void rtas_quiesce(sPAPREnvironment
*spapr
, uint32_t token
,
605 uint32_t nargs
, target_ulong args
,
606 uint32_t nret
, target_ulong rets
)
608 VIOsPAPRBus
*bus
= spapr
->vio_bus
;
610 VIOsPAPRDevice
*dev
= NULL
;
613 rtas_st(rets
, 0, -3);
617 QTAILQ_FOREACH(kid
, &bus
->bus
.children
, sibling
) {
618 dev
= (VIOsPAPRDevice
*)kid
->child
;
619 spapr_vio_quiesce_one(dev
);
625 static VIOsPAPRDevice
*reg_conflict(VIOsPAPRDevice
*dev
)
627 VIOsPAPRBus
*bus
= DO_UPCAST(VIOsPAPRBus
, bus
, dev
->qdev
.parent_bus
);
629 VIOsPAPRDevice
*other
;
632 * Check for a device other than the given one which is already
633 * using the requested address. We have to open code this because
634 * the given dev might already be in the list.
636 QTAILQ_FOREACH(kid
, &bus
->bus
.children
, sibling
) {
637 other
= DO_UPCAST(VIOsPAPRDevice
, qdev
, kid
->child
);
639 if (other
!= dev
&& other
->reg
== dev
->reg
) {
647 static void spapr_vio_busdev_reset(DeviceState
*qdev
)
649 VIOsPAPRDevice
*dev
= DO_UPCAST(VIOsPAPRDevice
, qdev
, qdev
);
650 VIOsPAPRDeviceClass
*pc
= VIO_SPAPR_DEVICE_GET_CLASS(dev
);
652 if (dev
->crq
.qsize
) {
661 static int spapr_vio_busdev_init(DeviceState
*qdev
)
663 VIOsPAPRDevice
*dev
= (VIOsPAPRDevice
*)qdev
;
664 VIOsPAPRDeviceClass
*pc
= VIO_SPAPR_DEVICE_GET_CLASS(dev
);
667 if (dev
->reg
!= -1) {
669 * Explicitly assigned address, just verify that no-one else
670 * is using it. other mechanism). We have to open code this
671 * rather than using spapr_vio_find_by_reg() because sdev
672 * itself is already in the list.
674 VIOsPAPRDevice
*other
= reg_conflict(dev
);
677 fprintf(stderr
, "vio: %s and %s devices conflict at address %#x\n",
678 object_get_typename(OBJECT(qdev
)),
679 object_get_typename(OBJECT(&other
->qdev
)),
684 /* Need to assign an address */
685 VIOsPAPRBus
*bus
= DO_UPCAST(VIOsPAPRBus
, bus
, dev
->qdev
.parent_bus
);
688 dev
->reg
= bus
->next_reg
++;
689 } while (reg_conflict(dev
));
692 /* Don't overwrite ids assigned on the command line */
694 id
= vio_format_dev_name(dev
);
701 dev
->qirq
= spapr_allocate_msi(dev
->vio_irq_num
, &dev
->vio_irq_num
);
708 return pc
->init(dev
);
711 static target_ulong
h_vio_signal(CPUPPCState
*env
, sPAPREnvironment
*spapr
,
715 target_ulong reg
= args
[0];
716 target_ulong mode
= args
[1];
717 VIOsPAPRDevice
*dev
= spapr_vio_find_by_reg(spapr
->vio_bus
, reg
);
718 VIOsPAPRDeviceClass
*pc
;
724 pc
= VIO_SPAPR_DEVICE_GET_CLASS(dev
);
726 if (mode
& ~pc
->signal_mask
) {
730 dev
->signal_state
= mode
;
735 VIOsPAPRBus
*spapr_vio_bus_init(void)
741 /* Create bridge device */
742 dev
= qdev_create(NULL
, "spapr-vio-bridge");
743 qdev_init_nofail(dev
);
745 /* Create bus on bridge device */
747 qbus
= qbus_create(TYPE_SPAPR_VIO_BUS
, dev
, "spapr-vio");
748 bus
= DO_UPCAST(VIOsPAPRBus
, bus
, qbus
);
749 bus
->next_reg
= 0x1000;
752 spapr_register_hypercall(H_VIO_SIGNAL
, h_vio_signal
);
755 spapr_register_hypercall(H_PUT_TCE
, h_put_tce
);
758 spapr_register_hypercall(H_REG_CRQ
, h_reg_crq
);
759 spapr_register_hypercall(H_FREE_CRQ
, h_free_crq
);
760 spapr_register_hypercall(H_SEND_CRQ
, h_send_crq
);
761 spapr_register_hypercall(H_ENABLE_CRQ
, h_enable_crq
);
764 spapr_rtas_register("ibm,set-tce-bypass", rtas_set_tce_bypass
);
765 spapr_rtas_register("quiesce", rtas_quiesce
);
770 /* Represents sPAPR hcall VIO devices */
772 static int spapr_vio_bridge_init(SysBusDevice
*dev
)
778 static void spapr_vio_bridge_class_init(ObjectClass
*klass
, void *data
)
780 DeviceClass
*dc
= DEVICE_CLASS(klass
);
781 SysBusDeviceClass
*k
= SYS_BUS_DEVICE_CLASS(klass
);
783 k
->init
= spapr_vio_bridge_init
;
787 static TypeInfo spapr_vio_bridge_info
= {
788 .name
= "spapr-vio-bridge",
789 .parent
= TYPE_SYS_BUS_DEVICE
,
790 .instance_size
= sizeof(SysBusDevice
),
791 .class_init
= spapr_vio_bridge_class_init
,
794 static void vio_spapr_device_class_init(ObjectClass
*klass
, void *data
)
796 DeviceClass
*k
= DEVICE_CLASS(klass
);
797 k
->init
= spapr_vio_busdev_init
;
798 k
->reset
= spapr_vio_busdev_reset
;
799 k
->bus_type
= TYPE_SPAPR_VIO_BUS
;
800 k
->props
= spapr_vio_props
;
803 static TypeInfo spapr_vio_type_info
= {
804 .name
= TYPE_VIO_SPAPR_DEVICE
,
805 .parent
= TYPE_DEVICE
,
806 .instance_size
= sizeof(VIOsPAPRDevice
),
808 .class_size
= sizeof(VIOsPAPRDeviceClass
),
809 .class_init
= vio_spapr_device_class_init
,
812 static void spapr_vio_register_types(void)
814 type_register_static(&spapr_vio_bus_info
);
815 type_register_static(&spapr_vio_bridge_info
);
816 type_register_static(&spapr_vio_type_info
);
819 type_init(spapr_vio_register_types
)
822 static int compare_reg(const void *p1
, const void *p2
)
824 VIOsPAPRDevice
const *dev1
, *dev2
;
826 dev1
= (VIOsPAPRDevice
*)*(DeviceState
**)p1
;
827 dev2
= (VIOsPAPRDevice
*)*(DeviceState
**)p2
;
829 if (dev1
->reg
< dev2
->reg
) {
832 if (dev1
->reg
== dev2
->reg
) {
836 /* dev1->reg > dev2->reg */
840 int spapr_populate_vdevice(VIOsPAPRBus
*bus
, void *fdt
)
842 DeviceState
*qdev
, **qdevs
;
846 /* Count qdevs on the bus list */
848 QTAILQ_FOREACH(kid
, &bus
->bus
.children
, sibling
) {
852 /* Copy out into an array of pointers */
853 qdevs
= g_malloc(sizeof(qdev
) * num
);
855 QTAILQ_FOREACH(kid
, &bus
->bus
.children
, sibling
) {
856 qdevs
[num
++] = kid
->child
;
860 qsort(qdevs
, num
, sizeof(qdev
), compare_reg
);
862 /* Hack alert. Give the devices to libfdt in reverse order, we happen
863 * to know that will mean they are in forward order in the tree. */
864 for (i
= num
- 1; i
>= 0; i
--) {
865 VIOsPAPRDevice
*dev
= (VIOsPAPRDevice
*)(qdevs
[i
]);
867 ret
= vio_make_devnode(dev
, fdt
);
881 int spapr_populate_chosen_stdout(void *fdt
, VIOsPAPRBus
*bus
)
887 dev
= spapr_vty_get_default(bus
);
891 offset
= fdt_path_offset(fdt
, "/chosen");
896 name
= vio_format_dev_name(dev
);
901 if (asprintf(&path
, "/vdevice/%s", name
) < 0) {
907 ret
= fdt_setprop_string(fdt
, offset
, "linux,stdout-path", path
);
914 #endif /* CONFIG_FDT */