ShuriZma
/
xemu
mirror of https://github.com/xemu-project/xemu.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

target/riscv: select KVM AIA in riscv virt machine 

Select KVM AIA when the host kernel has in-kernel AIA chip support.
Since KVM AIA only has one APLIC instance, we map the QEMU APLIC
devices to KVM APLIC.

Signed-off-by: Yong-Xuan Wang <yongxuan.wang@sifive.com>
Reviewed-by: Jim Shu <jim.shu@sifive.com>
Reviewed-by: Daniel Henrique Barboza <dbarboza@ventanamicro.com>
Reviewed-by: Andrew Jones <ajones@ventanamicro.com>
Message-ID: <20230727102439.22554-6-yongxuan.wang@sifive.com>
Signed-off-by: Alistair Francis <alistair.francis@wdc.com>
This commit is contained in:
Yong-Xuan Wang 2023-07-27 10:24:37 +00:00 committed by Alistair Francis
parent 95a97b3fd2
commit 48c2c33c52
1 changed files with 62 additions and 30 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

92
hw/riscv/virt.c
View File

@ -35,6 +35,7 @@
#include "hw/riscv/virt.h" #include "hw/riscv/virt.h"
#include "hw/riscv/boot.h" #include "hw/riscv/boot.h"
#include "hw/riscv/numa.h" #include "hw/riscv/numa.h"
#include "kvm_riscv.h"
#include "hw/intc/riscv_aclint.h" #include "hw/intc/riscv_aclint.h"
#include "hw/intc/riscv_aplic.h" #include "hw/intc/riscv_aplic.h"
#include "hw/intc/riscv_imsic.h" #include "hw/intc/riscv_imsic.h"
@ -75,6 +76,12 @@
#error "Can't accommodate all IMSIC groups in address space" #error "Can't accommodate all IMSIC groups in address space"
#endif #endif
/* KVM AIA only supports APLIC MSI. APLIC Wired is always emulated by QEMU. */
static bool virt_use_kvm_aia(RISCVVirtState *s)
{
return kvm_irqchip_in_kernel() && s->aia_type == VIRT_AIA_TYPE_APLIC_IMSIC;
}
static const MemMapEntry virt_memmap[] = { static const MemMapEntry virt_memmap[] = {
[VIRT_DEBUG] = { 0x0, 0x100 }, [VIRT_DEBUG] = { 0x0, 0x100 },
[VIRT_MROM] = { 0x1000, 0xf000 }, [VIRT_MROM] = { 0x1000, 0xf000 },
@ -609,16 +616,16 @@ static void create_fdt_one_aplic(RISCVVirtState *s, int socket,
uint32_t *intc_phandles, uint32_t *intc_phandles,
uint32_t aplic_phandle, uint32_t aplic_phandle,
uint32_t aplic_child_phandle, uint32_t aplic_child_phandle,
bool m_mode) bool m_mode, int num_harts)
{ {
int cpu; int cpu;
char *aplic_name; char *aplic_name;
uint32_t *aplic_cells; uint32_t *aplic_cells;
MachineState *ms = MACHINE(s); MachineState *ms = MACHINE(s);
aplic_cells = g_new0(uint32_t, s->soc[socket].num_harts * 2); aplic_cells = g_new0(uint32_t, num_harts * 2);
for (cpu = 0; cpu < s->soc[socket].num_harts; cpu++) { for (cpu = 0; cpu < num_harts; cpu++) {
aplic_cells[cpu * 2 + 0] = cpu_to_be32(intc_phandles[cpu]); aplic_cells[cpu * 2 + 0] = cpu_to_be32(intc_phandles[cpu]);
aplic_cells[cpu * 2 + 1] = cpu_to_be32(m_mode ? IRQ_M_EXT : IRQ_S_EXT); aplic_cells[cpu * 2 + 1] = cpu_to_be32(m_mode ? IRQ_M_EXT : IRQ_S_EXT);
} }
@ -632,8 +639,7 @@ static void create_fdt_one_aplic(RISCVVirtState *s, int socket,
if (s->aia_type == VIRT_AIA_TYPE_APLIC) { if (s->aia_type == VIRT_AIA_TYPE_APLIC) {
qemu_fdt_setprop(ms->fdt, aplic_name, "interrupts-extended", qemu_fdt_setprop(ms->fdt, aplic_name, "interrupts-extended",
aplic_cells, aplic_cells, num_harts * sizeof(uint32_t) * 2);
s->soc[socket].num_harts * sizeof(uint32_t) * 2);
} else { } else {
qemu_fdt_setprop_cell(ms->fdt, aplic_name, "msi-parent", msi_phandle); qemu_fdt_setprop_cell(ms->fdt, aplic_name, "msi-parent", msi_phandle);
} }
@ -664,7 +670,8 @@ static void create_fdt_socket_aplic(RISCVVirtState *s,
uint32_t msi_s_phandle, uint32_t msi_s_phandle,
uint32_t *phandle, uint32_t *phandle,
uint32_t *intc_phandles, uint32_t *intc_phandles,
uint32_t *aplic_phandles) uint32_t *aplic_phandles,
int num_harts)
{ {
char *aplic_name; char *aplic_name;
unsigned long aplic_addr; unsigned long aplic_addr;
@ -681,7 +688,7 @@ static void create_fdt_socket_aplic(RISCVVirtState *s,
create_fdt_one_aplic(s, socket, aplic_addr, memmap[VIRT_APLIC_M].size, create_fdt_one_aplic(s, socket, aplic_addr, memmap[VIRT_APLIC_M].size,
msi_m_phandle, intc_phandles, msi_m_phandle, intc_phandles,
aplic_m_phandle, aplic_s_phandle, aplic_m_phandle, aplic_s_phandle,
true); true, num_harts);
} }
/* S-level APLIC node */ /* S-level APLIC node */
@ -690,7 +697,7 @@ static void create_fdt_socket_aplic(RISCVVirtState *s,
create_fdt_one_aplic(s, socket, aplic_addr, memmap[VIRT_APLIC_S].size, create_fdt_one_aplic(s, socket, aplic_addr, memmap[VIRT_APLIC_S].size,
msi_s_phandle, intc_phandles, msi_s_phandle, intc_phandles,
aplic_s_phandle, 0, aplic_s_phandle, 0,
false); false, num_harts);
aplic_name = g_strdup_printf("/soc/aplic@%lx", aplic_addr); aplic_name = g_strdup_printf("/soc/aplic@%lx", aplic_addr);
@ -774,34 +781,51 @@ static void create_fdt_sockets(RISCVVirtState *s, const MemMapEntry *memmap,
*msi_pcie_phandle = msi_s_phandle; *msi_pcie_phandle = msi_s_phandle;
} }
phandle_pos = ms->smp.cpus; /* KVM AIA only has one APLIC instance */
for (socket = (socket_count - 1); socket >= 0; socket--) { if (virt_use_kvm_aia(s)) {
phandle_pos -= s->soc[socket].num_harts; create_fdt_socket_aplic(s, memmap, 0,
msi_m_phandle, msi_s_phandle, phandle,
&intc_phandles[0], xplic_phandles,
ms->smp.cpus);
} else {
phandle_pos = ms->smp.cpus;
for (socket = (socket_count - 1); socket >= 0; socket--) {
phandle_pos -= s->soc[socket].num_harts;
if (s->aia_type == VIRT_AIA_TYPE_NONE) { if (s->aia_type == VIRT_AIA_TYPE_NONE) {
create_fdt_socket_plic(s, memmap, socket, phandle, create_fdt_socket_plic(s, memmap, socket, phandle,
&intc_phandles[phandle_pos], xplic_phandles); &intc_phandles[phandle_pos],
} else { xplic_phandles);
create_fdt_socket_aplic(s, memmap, socket, } else {
msi_m_phandle, msi_s_phandle, phandle, create_fdt_socket_aplic(s, memmap, socket,
&intc_phandles[phandle_pos], xplic_phandles); msi_m_phandle, msi_s_phandle, phandle,
&intc_phandles[phandle_pos],
xplic_phandles,
s->soc[socket].num_harts);
}
} }
} }
g_free(intc_phandles); g_free(intc_phandles);
for (socket = 0; socket < socket_count; socket++) { if (virt_use_kvm_aia(s)) {
if (socket == 0) { *irq_mmio_phandle = xplic_phandles[0];
*irq_mmio_phandle = xplic_phandles[socket]; *irq_virtio_phandle = xplic_phandles[0];
*irq_virtio_phandle = xplic_phandles[socket]; *irq_pcie_phandle = xplic_phandles[0];
*irq_pcie_phandle = xplic_phandles[socket]; } else {
} for (socket = 0; socket < socket_count; socket++) {
if (socket == 1) { if (socket == 0) {
*irq_virtio_phandle = xplic_phandles[socket]; *irq_mmio_phandle = xplic_phandles[socket];
*irq_pcie_phandle = xplic_phandles[socket]; *irq_virtio_phandle = xplic_phandles[socket];
} *irq_pcie_phandle = xplic_phandles[socket];
if (socket == 2) { }
*irq_pcie_phandle = xplic_phandles[socket]; if (socket == 1) {
*irq_virtio_phandle = xplic_phandles[socket];
*irq_pcie_phandle = xplic_phandles[socket];
}
if (socket == 2) {
*irq_pcie_phandle = xplic_phandles[socket];
}
} }
} }
@ -1437,6 +1461,14 @@ static void virt_machine_init(MachineState *machine)
} }
} }
if (virt_use_kvm_aia(s)) {
kvm_riscv_aia_create(machine, IMSIC_MMIO_GROUP_MIN_SHIFT,
VIRT_IRQCHIP_NUM_SOURCES, VIRT_IRQCHIP_NUM_MSIS,
memmap[VIRT_APLIC_S].base,
memmap[VIRT_IMSIC_S].base,
s->aia_guests);
}
if (riscv_is_32bit(&s->soc[0])) { if (riscv_is_32bit(&s->soc[0])) {
#if HOST_LONG_BITS == 64 #if HOST_LONG_BITS == 64
/* limit RAM size in a 32-bit system */ /* limit RAM size in a 32-bit system */