2018-03-02 13:31:10 +01:00
|
|
|
/*
|
|
|
|
* QEMU RISC-V CPU
|
|
|
|
*
|
|
|
|
* Copyright (c) 2016-2017 Sagar Karandikar, sagark@eecs.berkeley.edu
|
|
|
|
* Copyright (c) 2017-2018 SiFive, Inc.
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or modify it
|
|
|
|
* under the terms and conditions of the GNU General Public License,
|
|
|
|
* version 2 or later, as published by the Free Software Foundation.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope it will be useful, but WITHOUT
|
|
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
|
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
|
|
|
|
* more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License along with
|
|
|
|
* this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "qemu/osdep.h"
|
2019-04-17 21:17:57 +02:00
|
|
|
#include "qemu/qemu-print.h"
|
2019-05-23 16:35:06 +02:00
|
|
|
#include "qemu/ctype.h"
|
2018-03-02 13:31:10 +01:00
|
|
|
#include "qemu/log.h"
|
|
|
|
#include "cpu.h"
|
2020-10-26 12:55:26 +01:00
|
|
|
#include "internals.h"
|
2018-03-02 13:31:10 +01:00
|
|
|
#include "exec/exec-all.h"
|
|
|
|
#include "qapi/error.h"
|
2019-05-07 00:49:53 +02:00
|
|
|
#include "qemu/error-report.h"
|
2019-04-20 04:24:01 +02:00
|
|
|
#include "hw/qdev-properties.h"
|
2018-03-02 13:31:10 +01:00
|
|
|
#include "migration/vmstate.h"
|
2019-08-08 18:29:41 +02:00
|
|
|
#include "fpu/softfloat-helpers.h"
|
2022-01-12 09:13:22 +01:00
|
|
|
#include "sysemu/kvm.h"
|
|
|
|
#include "kvm_riscv.h"
|
2018-03-02 13:31:10 +01:00
|
|
|
|
|
|
|
/* RISC-V CPU definitions */
|
|
|
|
|
2022-04-22 06:04:34 +02:00
|
|
|
#define RISCV_CPU_MARCHID ((QEMU_VERSION_MAJOR << 16) | \
|
|
|
|
(QEMU_VERSION_MINOR << 8) | \
|
|
|
|
(QEMU_VERSION_MICRO))
|
2022-05-23 17:31:46 +02:00
|
|
|
#define RISCV_CPU_MIMPID RISCV_CPU_MARCHID
|
2022-04-22 06:04:34 +02:00
|
|
|
|
2022-03-28 15:11:23 +02:00
|
|
|
static const char riscv_single_letter_exts[] = "IEMAFDQCPVH";
|
2018-03-02 13:31:10 +01:00
|
|
|
|
2022-03-29 21:56:57 +02:00
|
|
|
struct isa_ext_data {
|
|
|
|
const char *name;
|
|
|
|
bool enabled;
|
|
|
|
};
|
|
|
|
|
2018-03-02 13:31:10 +01:00
|
|
|
const char * const riscv_int_regnames[] = {
|
2019-08-23 17:21:19 +02:00
|
|
|
"x0/zero", "x1/ra", "x2/sp", "x3/gp", "x4/tp", "x5/t0", "x6/t1",
|
|
|
|
"x7/t2", "x8/s0", "x9/s1", "x10/a0", "x11/a1", "x12/a2", "x13/a3",
|
|
|
|
"x14/a4", "x15/a5", "x16/a6", "x17/a7", "x18/s2", "x19/s3", "x20/s4",
|
|
|
|
"x21/s5", "x22/s6", "x23/s7", "x24/s8", "x25/s9", "x26/s10", "x27/s11",
|
|
|
|
"x28/t3", "x29/t4", "x30/t5", "x31/t6"
|
2018-03-02 13:31:10 +01:00
|
|
|
};
|
|
|
|
|
2022-01-06 22:00:56 +01:00
|
|
|
const char * const riscv_int_regnamesh[] = {
|
|
|
|
"x0h/zeroh", "x1h/rah", "x2h/sph", "x3h/gph", "x4h/tph", "x5h/t0h",
|
|
|
|
"x6h/t1h", "x7h/t2h", "x8h/s0h", "x9h/s1h", "x10h/a0h", "x11h/a1h",
|
|
|
|
"x12h/a2h", "x13h/a3h", "x14h/a4h", "x15h/a5h", "x16h/a6h", "x17h/a7h",
|
|
|
|
"x18h/s2h", "x19h/s3h", "x20h/s4h", "x21h/s5h", "x22h/s6h", "x23h/s7h",
|
|
|
|
"x24h/s8h", "x25h/s9h", "x26h/s10h", "x27h/s11h", "x28h/t3h", "x29h/t4h",
|
|
|
|
"x30h/t5h", "x31h/t6h"
|
|
|
|
};
|
|
|
|
|
2018-03-02 13:31:10 +01:00
|
|
|
const char * const riscv_fpr_regnames[] = {
|
2019-08-23 17:21:19 +02:00
|
|
|
"f0/ft0", "f1/ft1", "f2/ft2", "f3/ft3", "f4/ft4", "f5/ft5",
|
|
|
|
"f6/ft6", "f7/ft7", "f8/fs0", "f9/fs1", "f10/fa0", "f11/fa1",
|
|
|
|
"f12/fa2", "f13/fa3", "f14/fa4", "f15/fa5", "f16/fa6", "f17/fa7",
|
|
|
|
"f18/fs2", "f19/fs3", "f20/fs4", "f21/fs5", "f22/fs6", "f23/fs7",
|
|
|
|
"f24/fs8", "f25/fs9", "f26/fs10", "f27/fs11", "f28/ft8", "f29/ft9",
|
|
|
|
"f30/ft10", "f31/ft11"
|
2018-03-02 13:31:10 +01:00
|
|
|
};
|
|
|
|
|
2021-05-14 07:24:35 +02:00
|
|
|
static const char * const riscv_excp_names[] = {
|
2018-03-02 13:31:10 +01:00
|
|
|
"misaligned_fetch",
|
|
|
|
"fault_fetch",
|
|
|
|
"illegal_instruction",
|
|
|
|
"breakpoint",
|
|
|
|
"misaligned_load",
|
|
|
|
"fault_load",
|
|
|
|
"misaligned_store",
|
|
|
|
"fault_store",
|
|
|
|
"user_ecall",
|
|
|
|
"supervisor_ecall",
|
|
|
|
"hypervisor_ecall",
|
|
|
|
"machine_ecall",
|
|
|
|
"exec_page_fault",
|
|
|
|
"load_page_fault",
|
|
|
|
"reserved",
|
2020-03-05 17:46:20 +01:00
|
|
|
"store_page_fault",
|
2020-02-01 02:01:46 +01:00
|
|
|
"reserved",
|
|
|
|
"reserved",
|
|
|
|
"reserved",
|
|
|
|
"reserved",
|
|
|
|
"guest_exec_page_fault",
|
|
|
|
"guest_load_page_fault",
|
|
|
|
"reserved",
|
2020-03-05 17:46:20 +01:00
|
|
|
"guest_store_page_fault",
|
2018-03-02 13:31:10 +01:00
|
|
|
};
|
|
|
|
|
2021-05-14 07:24:35 +02:00
|
|
|
static const char * const riscv_intr_names[] = {
|
2018-03-02 13:31:10 +01:00
|
|
|
"u_software",
|
|
|
|
"s_software",
|
2020-02-01 02:01:49 +01:00
|
|
|
"vs_software",
|
2018-03-02 13:31:10 +01:00
|
|
|
"m_software",
|
|
|
|
"u_timer",
|
|
|
|
"s_timer",
|
2020-02-01 02:01:49 +01:00
|
|
|
"vs_timer",
|
2018-03-02 13:31:10 +01:00
|
|
|
"m_timer",
|
|
|
|
"u_external",
|
2021-04-21 15:32:36 +02:00
|
|
|
"s_external",
|
2020-02-01 02:01:49 +01:00
|
|
|
"vs_external",
|
2018-03-02 13:31:10 +01:00
|
|
|
"m_external",
|
2018-03-05 22:51:53 +01:00
|
|
|
"reserved",
|
|
|
|
"reserved",
|
|
|
|
"reserved",
|
|
|
|
"reserved"
|
2018-03-02 13:31:10 +01:00
|
|
|
};
|
|
|
|
|
2022-06-08 08:14:37 +02:00
|
|
|
static void register_cpu_props(DeviceState *dev);
|
|
|
|
|
2020-08-14 05:58:19 +02:00
|
|
|
const char *riscv_cpu_get_trap_name(target_ulong cause, bool async)
|
|
|
|
{
|
|
|
|
if (async) {
|
|
|
|
return (cause < ARRAY_SIZE(riscv_intr_names)) ?
|
|
|
|
riscv_intr_names[cause] : "(unknown)";
|
|
|
|
} else {
|
|
|
|
return (cause < ARRAY_SIZE(riscv_excp_names)) ?
|
|
|
|
riscv_excp_names[cause] : "(unknown)";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-10-20 05:16:57 +02:00
|
|
|
static void set_misa(CPURISCVState *env, RISCVMXL mxl, uint32_t ext)
|
2018-03-02 13:31:10 +01:00
|
|
|
{
|
2021-10-20 05:16:57 +02:00
|
|
|
env->misa_mxl_max = env->misa_mxl = mxl;
|
|
|
|
env->misa_ext_mask = env->misa_ext = ext;
|
2018-03-02 13:31:10 +01:00
|
|
|
}
|
|
|
|
|
2019-06-18 03:31:19 +02:00
|
|
|
static void set_priv_version(CPURISCVState *env, int priv_ver)
|
2018-03-02 13:31:10 +01:00
|
|
|
{
|
|
|
|
env->priv_ver = priv_ver;
|
|
|
|
}
|
|
|
|
|
2020-07-01 17:24:50 +02:00
|
|
|
static void set_vext_version(CPURISCVState *env, int vext_ver)
|
|
|
|
{
|
|
|
|
env->vext_ver = vext_ver;
|
|
|
|
}
|
|
|
|
|
2021-03-29 05:48:01 +02:00
|
|
|
static void set_resetvec(CPURISCVState *env, target_ulong resetvec)
|
2018-03-02 13:31:10 +01:00
|
|
|
{
|
|
|
|
#ifndef CONFIG_USER_ONLY
|
|
|
|
env->resetvec = resetvec;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
static void riscv_any_cpu_init(Object *obj)
|
|
|
|
{
|
|
|
|
CPURISCVState *env = &RISCV_CPU(obj)->env;
|
2021-04-24 05:28:33 +02:00
|
|
|
#if defined(TARGET_RISCV32)
|
2021-10-20 05:16:57 +02:00
|
|
|
set_misa(env, MXL_RV32, RVI | RVM | RVA | RVF | RVD | RVC | RVU);
|
2021-04-24 05:28:33 +02:00
|
|
|
#elif defined(TARGET_RISCV64)
|
2021-10-20 05:16:57 +02:00
|
|
|
set_misa(env, MXL_RV64, RVI | RVM | RVA | RVF | RVD | RVC | RVU);
|
2021-04-24 05:28:33 +02:00
|
|
|
#endif
|
2022-03-03 19:54:40 +01:00
|
|
|
set_priv_version(env, PRIV_VERSION_1_12_0);
|
2022-06-08 08:14:37 +02:00
|
|
|
register_cpu_props(DEVICE(obj));
|
2018-03-02 13:31:10 +01:00
|
|
|
}
|
|
|
|
|
2020-12-16 19:23:05 +01:00
|
|
|
#if defined(TARGET_RISCV64)
|
|
|
|
static void rv64_base_cpu_init(Object *obj)
|
2019-04-20 04:24:09 +02:00
|
|
|
{
|
|
|
|
CPURISCVState *env = &RISCV_CPU(obj)->env;
|
2019-05-07 00:49:53 +02:00
|
|
|
/* We set this in the realise function */
|
2021-10-20 05:16:57 +02:00
|
|
|
set_misa(env, MXL_RV64, 0);
|
2022-06-08 08:14:37 +02:00
|
|
|
register_cpu_props(DEVICE(obj));
|
2022-06-11 10:01:04 +02:00
|
|
|
/* Set latest version of privileged specification */
|
|
|
|
set_priv_version(env, PRIV_VERSION_1_12_0);
|
2019-04-20 04:24:09 +02:00
|
|
|
}
|
|
|
|
|
2020-12-16 19:22:54 +01:00
|
|
|
static void rv64_sifive_u_cpu_init(Object *obj)
|
2018-03-02 13:31:10 +01:00
|
|
|
{
|
|
|
|
CPURISCVState *env = &RISCV_CPU(obj)->env;
|
2021-10-20 05:16:57 +02:00
|
|
|
set_misa(env, MXL_RV64, RVI | RVM | RVA | RVF | RVD | RVC | RVS | RVU);
|
2019-06-18 03:31:19 +02:00
|
|
|
set_priv_version(env, PRIV_VERSION_1_10_0);
|
2018-03-02 13:31:10 +01:00
|
|
|
}
|
|
|
|
|
2020-12-16 19:22:54 +01:00
|
|
|
static void rv64_sifive_e_cpu_init(Object *obj)
|
2020-04-23 19:50:09 +02:00
|
|
|
{
|
|
|
|
CPURISCVState *env = &RISCV_CPU(obj)->env;
|
2022-06-08 08:14:37 +02:00
|
|
|
RISCVCPU *cpu = RISCV_CPU(obj);
|
|
|
|
|
2021-10-20 05:16:57 +02:00
|
|
|
set_misa(env, MXL_RV64, RVI | RVM | RVA | RVC | RVU);
|
2020-04-23 19:50:09 +02:00
|
|
|
set_priv_version(env, PRIV_VERSION_1_10_0);
|
2022-06-08 08:14:37 +02:00
|
|
|
cpu->cfg.mmu = false;
|
2020-04-23 19:50:09 +02:00
|
|
|
}
|
2022-01-06 22:00:57 +01:00
|
|
|
|
|
|
|
static void rv128_base_cpu_init(Object *obj)
|
|
|
|
{
|
|
|
|
if (qemu_tcg_mttcg_enabled()) {
|
|
|
|
/* Missing 128-bit aligned atomics */
|
|
|
|
error_report("128-bit RISC-V currently does not work with Multi "
|
|
|
|
"Threaded TCG. Please use: -accel tcg,thread=single");
|
|
|
|
exit(EXIT_FAILURE);
|
|
|
|
}
|
|
|
|
CPURISCVState *env = &RISCV_CPU(obj)->env;
|
|
|
|
/* We set this in the realise function */
|
|
|
|
set_misa(env, MXL_RV128, 0);
|
2022-06-08 08:14:37 +02:00
|
|
|
register_cpu_props(DEVICE(obj));
|
2022-06-11 10:01:04 +02:00
|
|
|
/* Set latest version of privileged specification */
|
|
|
|
set_priv_version(env, PRIV_VERSION_1_12_0);
|
2022-01-06 22:00:57 +01:00
|
|
|
}
|
2020-12-16 19:22:54 +01:00
|
|
|
#else
|
2020-12-16 19:23:05 +01:00
|
|
|
static void rv32_base_cpu_init(Object *obj)
|
|
|
|
{
|
|
|
|
CPURISCVState *env = &RISCV_CPU(obj)->env;
|
|
|
|
/* We set this in the realise function */
|
2021-10-20 05:16:57 +02:00
|
|
|
set_misa(env, MXL_RV32, 0);
|
2022-06-08 08:14:37 +02:00
|
|
|
register_cpu_props(DEVICE(obj));
|
2022-06-11 10:01:04 +02:00
|
|
|
/* Set latest version of privileged specification */
|
|
|
|
set_priv_version(env, PRIV_VERSION_1_12_0);
|
2020-12-16 19:23:05 +01:00
|
|
|
}
|
|
|
|
|
2020-12-16 19:22:54 +01:00
|
|
|
static void rv32_sifive_u_cpu_init(Object *obj)
|
|
|
|
{
|
|
|
|
CPURISCVState *env = &RISCV_CPU(obj)->env;
|
2021-10-20 05:16:57 +02:00
|
|
|
set_misa(env, MXL_RV32, RVI | RVM | RVA | RVF | RVD | RVC | RVS | RVU);
|
2020-12-16 19:22:54 +01:00
|
|
|
set_priv_version(env, PRIV_VERSION_1_10_0);
|
|
|
|
}
|
2020-04-23 19:50:09 +02:00
|
|
|
|
2020-12-16 19:22:54 +01:00
|
|
|
static void rv32_sifive_e_cpu_init(Object *obj)
|
|
|
|
{
|
|
|
|
CPURISCVState *env = &RISCV_CPU(obj)->env;
|
2022-06-08 08:14:37 +02:00
|
|
|
RISCVCPU *cpu = RISCV_CPU(obj);
|
|
|
|
|
2021-10-20 05:16:57 +02:00
|
|
|
set_misa(env, MXL_RV32, RVI | RVM | RVA | RVC | RVU);
|
2020-12-16 19:22:54 +01:00
|
|
|
set_priv_version(env, PRIV_VERSION_1_10_0);
|
2022-06-08 08:14:37 +02:00
|
|
|
cpu->cfg.mmu = false;
|
2020-12-16 19:22:54 +01:00
|
|
|
}
|
2020-06-11 03:08:48 +02:00
|
|
|
|
2020-06-16 02:50:37 +02:00
|
|
|
static void rv32_ibex_cpu_init(Object *obj)
|
2018-03-02 13:31:10 +01:00
|
|
|
{
|
|
|
|
CPURISCVState *env = &RISCV_CPU(obj)->env;
|
2022-06-08 08:14:37 +02:00
|
|
|
RISCVCPU *cpu = RISCV_CPU(obj);
|
|
|
|
|
2021-10-20 05:16:57 +02:00
|
|
|
set_misa(env, MXL_RV32, RVI | RVM | RVC | RVU);
|
2022-06-30 01:31:02 +02:00
|
|
|
set_priv_version(env, PRIV_VERSION_1_11_0);
|
2022-06-08 08:14:37 +02:00
|
|
|
cpu->cfg.mmu = false;
|
|
|
|
cpu->cfg.epmp = true;
|
2018-03-02 13:31:10 +01:00
|
|
|
}
|
|
|
|
|
2020-06-11 03:08:49 +02:00
|
|
|
static void rv32_imafcu_nommu_cpu_init(Object *obj)
|
2020-03-13 20:34:29 +01:00
|
|
|
{
|
|
|
|
CPURISCVState *env = &RISCV_CPU(obj)->env;
|
2022-06-08 08:14:37 +02:00
|
|
|
RISCVCPU *cpu = RISCV_CPU(obj);
|
|
|
|
|
2021-10-20 05:16:57 +02:00
|
|
|
set_misa(env, MXL_RV32, RVI | RVM | RVA | RVF | RVC | RVU);
|
2020-03-13 20:34:29 +01:00
|
|
|
set_priv_version(env, PRIV_VERSION_1_10_0);
|
|
|
|
set_resetvec(env, DEFAULT_RSTVEC);
|
2022-06-08 08:14:37 +02:00
|
|
|
cpu->cfg.mmu = false;
|
2020-03-13 20:34:29 +01:00
|
|
|
}
|
2018-03-08 23:12:31 +01:00
|
|
|
#endif
|
2018-03-02 13:31:10 +01:00
|
|
|
|
2022-01-12 09:13:25 +01:00
|
|
|
#if defined(CONFIG_KVM)
|
|
|
|
static void riscv_host_cpu_init(Object *obj)
|
|
|
|
{
|
|
|
|
CPURISCVState *env = &RISCV_CPU(obj)->env;
|
|
|
|
#if defined(TARGET_RISCV32)
|
|
|
|
set_misa(env, MXL_RV32, 0);
|
|
|
|
#elif defined(TARGET_RISCV64)
|
|
|
|
set_misa(env, MXL_RV64, 0);
|
|
|
|
#endif
|
2022-06-08 08:14:37 +02:00
|
|
|
register_cpu_props(DEVICE(obj));
|
2022-01-12 09:13:25 +01:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2018-03-02 13:31:10 +01:00
|
|
|
static ObjectClass *riscv_cpu_class_by_name(const char *cpu_model)
|
|
|
|
{
|
|
|
|
ObjectClass *oc;
|
|
|
|
char *typename;
|
|
|
|
char **cpuname;
|
|
|
|
|
|
|
|
cpuname = g_strsplit(cpu_model, ",", 1);
|
|
|
|
typename = g_strdup_printf(RISCV_CPU_TYPE_NAME("%s"), cpuname[0]);
|
|
|
|
oc = object_class_by_name(typename);
|
|
|
|
g_strfreev(cpuname);
|
|
|
|
g_free(typename);
|
|
|
|
if (!oc || !object_class_dynamic_cast(oc, TYPE_RISCV_CPU) ||
|
|
|
|
object_class_is_abstract(oc)) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
return oc;
|
|
|
|
}
|
|
|
|
|
2019-04-17 21:18:02 +02:00
|
|
|
static void riscv_cpu_dump_state(CPUState *cs, FILE *f, int flags)
|
2018-03-02 13:31:10 +01:00
|
|
|
{
|
|
|
|
RISCVCPU *cpu = RISCV_CPU(cs);
|
|
|
|
CPURISCVState *env = &cpu->env;
|
|
|
|
int i;
|
|
|
|
|
2020-02-01 02:02:02 +01:00
|
|
|
#if !defined(CONFIG_USER_ONLY)
|
|
|
|
if (riscv_has_ext(env, RVH)) {
|
|
|
|
qemu_fprintf(f, " %s %d\n", "V = ", riscv_cpu_virt_enabled(env));
|
|
|
|
}
|
|
|
|
#endif
|
2019-04-17 21:18:02 +02:00
|
|
|
qemu_fprintf(f, " %s " TARGET_FMT_lx "\n", "pc ", env->pc);
|
2018-03-02 13:31:10 +01:00
|
|
|
#ifndef CONFIG_USER_ONLY
|
2021-10-20 05:17:08 +02:00
|
|
|
{
|
|
|
|
static const int dump_csrs[] = {
|
|
|
|
CSR_MHARTID,
|
|
|
|
CSR_MSTATUS,
|
|
|
|
CSR_MSTATUSH,
|
|
|
|
CSR_HSTATUS,
|
|
|
|
CSR_VSSTATUS,
|
|
|
|
CSR_MIP,
|
|
|
|
CSR_MIE,
|
|
|
|
CSR_MIDELEG,
|
|
|
|
CSR_HIDELEG,
|
|
|
|
CSR_MEDELEG,
|
|
|
|
CSR_HEDELEG,
|
|
|
|
CSR_MTVEC,
|
|
|
|
CSR_STVEC,
|
|
|
|
CSR_VSTVEC,
|
|
|
|
CSR_MEPC,
|
|
|
|
CSR_SEPC,
|
|
|
|
CSR_VSEPC,
|
|
|
|
CSR_MCAUSE,
|
|
|
|
CSR_SCAUSE,
|
|
|
|
CSR_VSCAUSE,
|
|
|
|
CSR_MTVAL,
|
|
|
|
CSR_STVAL,
|
|
|
|
CSR_HTVAL,
|
|
|
|
CSR_MTVAL2,
|
|
|
|
CSR_MSCRATCH,
|
|
|
|
CSR_SSCRATCH,
|
|
|
|
CSR_SATP,
|
2021-10-25 19:36:06 +02:00
|
|
|
CSR_MMTE,
|
|
|
|
CSR_UPMBASE,
|
|
|
|
CSR_UPMMASK,
|
|
|
|
CSR_SPMBASE,
|
|
|
|
CSR_SPMMASK,
|
|
|
|
CSR_MPMBASE,
|
|
|
|
CSR_MPMMASK,
|
2021-10-20 05:17:08 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
for (int i = 0; i < ARRAY_SIZE(dump_csrs); ++i) {
|
|
|
|
int csrno = dump_csrs[i];
|
|
|
|
target_ulong val = 0;
|
|
|
|
RISCVException res = riscv_csrrw_debug(env, csrno, &val, 0, 0);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Rely on the smode, hmode, etc, predicates within csr.c
|
|
|
|
* to do the filtering of the registers that are present.
|
|
|
|
*/
|
|
|
|
if (res == RISCV_EXCP_NONE) {
|
|
|
|
qemu_fprintf(f, " %-8s " TARGET_FMT_lx "\n",
|
|
|
|
csr_ops[csrno].name, val);
|
|
|
|
}
|
|
|
|
}
|
2020-02-01 02:02:02 +01:00
|
|
|
}
|
2018-03-02 13:31:10 +01:00
|
|
|
#endif
|
|
|
|
|
|
|
|
for (i = 0; i < 32; i++) {
|
2021-10-09 07:50:19 +02:00
|
|
|
qemu_fprintf(f, " %-8s " TARGET_FMT_lx,
|
2019-04-17 21:18:02 +02:00
|
|
|
riscv_int_regnames[i], env->gpr[i]);
|
2018-03-02 13:31:10 +01:00
|
|
|
if ((i & 3) == 3) {
|
2019-04-17 21:18:02 +02:00
|
|
|
qemu_fprintf(f, "\n");
|
2018-03-02 13:31:10 +01:00
|
|
|
}
|
|
|
|
}
|
2018-05-11 05:31:33 +02:00
|
|
|
if (flags & CPU_DUMP_FPU) {
|
|
|
|
for (i = 0; i < 32; i++) {
|
2021-10-09 07:50:19 +02:00
|
|
|
qemu_fprintf(f, " %-8s %016" PRIx64,
|
2019-04-17 21:18:02 +02:00
|
|
|
riscv_fpr_regnames[i], env->fpr[i]);
|
2018-05-11 05:31:33 +02:00
|
|
|
if ((i & 3) == 3) {
|
2019-04-17 21:18:02 +02:00
|
|
|
qemu_fprintf(f, "\n");
|
2018-05-11 05:31:33 +02:00
|
|
|
}
|
2018-03-02 13:31:10 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void riscv_cpu_set_pc(CPUState *cs, vaddr value)
|
|
|
|
{
|
|
|
|
RISCVCPU *cpu = RISCV_CPU(cs);
|
|
|
|
CPURISCVState *env = &cpu->env;
|
2022-01-20 13:20:34 +01:00
|
|
|
|
|
|
|
if (env->xl == MXL_RV32) {
|
|
|
|
env->pc = (int32_t)value;
|
|
|
|
} else {
|
|
|
|
env->pc = value;
|
|
|
|
}
|
2018-03-02 13:31:10 +01:00
|
|
|
}
|
|
|
|
|
2020-10-29 20:30:01 +01:00
|
|
|
static void riscv_cpu_synchronize_from_tb(CPUState *cs,
|
|
|
|
const TranslationBlock *tb)
|
2018-03-02 13:31:10 +01:00
|
|
|
{
|
|
|
|
RISCVCPU *cpu = RISCV_CPU(cs);
|
|
|
|
CPURISCVState *env = &cpu->env;
|
2022-01-20 13:20:34 +01:00
|
|
|
RISCVMXL xl = FIELD_EX32(tb->flags, TB_FLAGS, XL);
|
|
|
|
|
|
|
|
if (xl == MXL_RV32) {
|
|
|
|
env->pc = (int32_t)tb->pc;
|
|
|
|
} else {
|
|
|
|
env->pc = tb->pc;
|
|
|
|
}
|
2018-03-02 13:31:10 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static bool riscv_cpu_has_work(CPUState *cs)
|
|
|
|
{
|
|
|
|
#ifndef CONFIG_USER_ONLY
|
|
|
|
RISCVCPU *cpu = RISCV_CPU(cs);
|
|
|
|
CPURISCVState *env = &cpu->env;
|
|
|
|
/*
|
|
|
|
* Definition of the WFI instruction requires it to ignore the privilege
|
|
|
|
* mode and delegation registers, but respect individual enables
|
|
|
|
*/
|
2022-05-31 23:05:44 +02:00
|
|
|
return riscv_cpu_all_pending(env) != 0;
|
2018-03-02 13:31:10 +01:00
|
|
|
#else
|
|
|
|
return true;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
void restore_state_to_opc(CPURISCVState *env, TranslationBlock *tb,
|
|
|
|
target_ulong *data)
|
|
|
|
{
|
2022-01-20 13:20:34 +01:00
|
|
|
RISCVMXL xl = FIELD_EX32(tb->flags, TB_FLAGS, XL);
|
|
|
|
if (xl == MXL_RV32) {
|
|
|
|
env->pc = (int32_t)data[0];
|
|
|
|
} else {
|
|
|
|
env->pc = data[0];
|
|
|
|
}
|
2022-05-11 16:45:23 +02:00
|
|
|
env->bins = data[1];
|
2018-03-02 13:31:10 +01:00
|
|
|
}
|
|
|
|
|
cpu: Use DeviceClass reset instead of a special CPUClass reset
The CPUClass has a 'reset' method. This is a legacy from when
TYPE_CPU used not to inherit from TYPE_DEVICE. We don't need it any
more, as we can simply use the TYPE_DEVICE reset. The 'cpu_reset()'
function is kept as the API which most places use to reset a CPU; it
is now a wrapper which calls device_cold_reset() and then the
tracepoint function.
This change should not cause CPU objects to be reset more often
than they are at the moment, because:
* nobody is directly calling device_cold_reset() or
qdev_reset_all() on CPU objects
* no CPU object is on a qbus, so they will not be reset either
by somebody calling qbus_reset_all()/bus_cold_reset(), or
by the main "reset sysbus and everything in the qbus tree"
reset that most devices are reset by
Note that this does not change the need for each machine or whatever
to use qemu_register_reset() to arrange to call cpu_reset() -- that
is necessary because CPU objects are not on any qbus, so they don't
get reset when the qbus tree rooted at the sysbus bus is reset, and
this isn't being changed here.
All the changes to the files under target/ were made using the
included Coccinelle script, except:
(1) the deletion of the now-inaccurate and not terribly useful
"CPUClass::reset" comments was done with a perl one-liner afterwards:
perl -n -i -e '/ CPUClass::reset/ or print' target/*/*.c
(2) this bit of the s390 change was done by hand, because the
Coccinelle script is not sophisticated enough to handle the
parent_reset call being inside another function:
| @@ -96,8 +96,9 @@ static void s390_cpu_reset(CPUState *s, cpu_reset_type type)
| S390CPU *cpu = S390_CPU(s);
| S390CPUClass *scc = S390_CPU_GET_CLASS(cpu);
| CPUS390XState *env = &cpu->env;
|+ DeviceState *dev = DEVICE(s);
|
|- scc->parent_reset(s);
|+ scc->parent_reset(dev);
| cpu->env.sigp_order = 0;
| s390_cpu_set_state(S390_CPU_STATE_STOPPED, cpu);
Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
Message-Id: <20200303100511.5498-1-peter.maydell@linaro.org>
Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Reviewed-by: Richard Henderson <richard.henderson@linaro.org>
Tested-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Signed-off-by: Eduardo Habkost <ehabkost@redhat.com>
2020-03-03 11:05:11 +01:00
|
|
|
static void riscv_cpu_reset(DeviceState *dev)
|
2018-03-02 13:31:10 +01:00
|
|
|
{
|
2022-02-04 18:46:45 +01:00
|
|
|
#ifndef CONFIG_USER_ONLY
|
|
|
|
uint8_t iprio;
|
|
|
|
int i, irq, rdzero;
|
|
|
|
#endif
|
cpu: Use DeviceClass reset instead of a special CPUClass reset
The CPUClass has a 'reset' method. This is a legacy from when
TYPE_CPU used not to inherit from TYPE_DEVICE. We don't need it any
more, as we can simply use the TYPE_DEVICE reset. The 'cpu_reset()'
function is kept as the API which most places use to reset a CPU; it
is now a wrapper which calls device_cold_reset() and then the
tracepoint function.
This change should not cause CPU objects to be reset more often
than they are at the moment, because:
* nobody is directly calling device_cold_reset() or
qdev_reset_all() on CPU objects
* no CPU object is on a qbus, so they will not be reset either
by somebody calling qbus_reset_all()/bus_cold_reset(), or
by the main "reset sysbus and everything in the qbus tree"
reset that most devices are reset by
Note that this does not change the need for each machine or whatever
to use qemu_register_reset() to arrange to call cpu_reset() -- that
is necessary because CPU objects are not on any qbus, so they don't
get reset when the qbus tree rooted at the sysbus bus is reset, and
this isn't being changed here.
All the changes to the files under target/ were made using the
included Coccinelle script, except:
(1) the deletion of the now-inaccurate and not terribly useful
"CPUClass::reset" comments was done with a perl one-liner afterwards:
perl -n -i -e '/ CPUClass::reset/ or print' target/*/*.c
(2) this bit of the s390 change was done by hand, because the
Coccinelle script is not sophisticated enough to handle the
parent_reset call being inside another function:
| @@ -96,8 +96,9 @@ static void s390_cpu_reset(CPUState *s, cpu_reset_type type)
| S390CPU *cpu = S390_CPU(s);
| S390CPUClass *scc = S390_CPU_GET_CLASS(cpu);
| CPUS390XState *env = &cpu->env;
|+ DeviceState *dev = DEVICE(s);
|
|- scc->parent_reset(s);
|+ scc->parent_reset(dev);
| cpu->env.sigp_order = 0;
| s390_cpu_set_state(S390_CPU_STATE_STOPPED, cpu);
Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
Message-Id: <20200303100511.5498-1-peter.maydell@linaro.org>
Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Reviewed-by: Richard Henderson <richard.henderson@linaro.org>
Tested-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Signed-off-by: Eduardo Habkost <ehabkost@redhat.com>
2020-03-03 11:05:11 +01:00
|
|
|
CPUState *cs = CPU(dev);
|
2018-03-02 13:31:10 +01:00
|
|
|
RISCVCPU *cpu = RISCV_CPU(cs);
|
|
|
|
RISCVCPUClass *mcc = RISCV_CPU_GET_CLASS(cpu);
|
|
|
|
CPURISCVState *env = &cpu->env;
|
|
|
|
|
cpu: Use DeviceClass reset instead of a special CPUClass reset
The CPUClass has a 'reset' method. This is a legacy from when
TYPE_CPU used not to inherit from TYPE_DEVICE. We don't need it any
more, as we can simply use the TYPE_DEVICE reset. The 'cpu_reset()'
function is kept as the API which most places use to reset a CPU; it
is now a wrapper which calls device_cold_reset() and then the
tracepoint function.
This change should not cause CPU objects to be reset more often
than they are at the moment, because:
* nobody is directly calling device_cold_reset() or
qdev_reset_all() on CPU objects
* no CPU object is on a qbus, so they will not be reset either
by somebody calling qbus_reset_all()/bus_cold_reset(), or
by the main "reset sysbus and everything in the qbus tree"
reset that most devices are reset by
Note that this does not change the need for each machine or whatever
to use qemu_register_reset() to arrange to call cpu_reset() -- that
is necessary because CPU objects are not on any qbus, so they don't
get reset when the qbus tree rooted at the sysbus bus is reset, and
this isn't being changed here.
All the changes to the files under target/ were made using the
included Coccinelle script, except:
(1) the deletion of the now-inaccurate and not terribly useful
"CPUClass::reset" comments was done with a perl one-liner afterwards:
perl -n -i -e '/ CPUClass::reset/ or print' target/*/*.c
(2) this bit of the s390 change was done by hand, because the
Coccinelle script is not sophisticated enough to handle the
parent_reset call being inside another function:
| @@ -96,8 +96,9 @@ static void s390_cpu_reset(CPUState *s, cpu_reset_type type)
| S390CPU *cpu = S390_CPU(s);
| S390CPUClass *scc = S390_CPU_GET_CLASS(cpu);
| CPUS390XState *env = &cpu->env;
|+ DeviceState *dev = DEVICE(s);
|
|- scc->parent_reset(s);
|+ scc->parent_reset(dev);
| cpu->env.sigp_order = 0;
| s390_cpu_set_state(S390_CPU_STATE_STOPPED, cpu);
Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
Message-Id: <20200303100511.5498-1-peter.maydell@linaro.org>
Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Reviewed-by: Richard Henderson <richard.henderson@linaro.org>
Tested-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Signed-off-by: Eduardo Habkost <ehabkost@redhat.com>
2020-03-03 11:05:11 +01:00
|
|
|
mcc->parent_reset(dev);
|
2018-03-02 13:31:10 +01:00
|
|
|
#ifndef CONFIG_USER_ONLY
|
2021-10-20 05:16:57 +02:00
|
|
|
env->misa_mxl = env->misa_mxl_max;
|
2018-03-02 13:31:10 +01:00
|
|
|
env->priv = PRV_M;
|
|
|
|
env->mstatus &= ~(MSTATUS_MIE | MSTATUS_MPRV);
|
2021-10-20 05:16:59 +02:00
|
|
|
if (env->misa_mxl > MXL_RV32) {
|
|
|
|
/*
|
|
|
|
* The reset status of SXL/UXL is undefined, but mstatus is WARL
|
|
|
|
* and we must ensure that the value after init is valid for read.
|
|
|
|
*/
|
|
|
|
env->mstatus = set_field(env->mstatus, MSTATUS64_SXL, env->misa_mxl);
|
|
|
|
env->mstatus = set_field(env->mstatus, MSTATUS64_UXL, env->misa_mxl);
|
2022-01-20 13:20:48 +01:00
|
|
|
if (riscv_has_ext(env, RVH)) {
|
|
|
|
env->vsstatus = set_field(env->vsstatus,
|
|
|
|
MSTATUS64_SXL, env->misa_mxl);
|
|
|
|
env->vsstatus = set_field(env->vsstatus,
|
|
|
|
MSTATUS64_UXL, env->misa_mxl);
|
|
|
|
env->mstatus_hs = set_field(env->mstatus_hs,
|
|
|
|
MSTATUS64_SXL, env->misa_mxl);
|
|
|
|
env->mstatus_hs = set_field(env->mstatus_hs,
|
|
|
|
MSTATUS64_UXL, env->misa_mxl);
|
|
|
|
}
|
2021-10-20 05:16:59 +02:00
|
|
|
}
|
2018-03-02 13:31:10 +01:00
|
|
|
env->mcause = 0;
|
2022-02-04 18:46:38 +01:00
|
|
|
env->miclaim = MIP_SGEIP;
|
2018-03-02 13:31:10 +01:00
|
|
|
env->pc = env->resetvec;
|
2022-05-11 16:45:23 +02:00
|
|
|
env->bins = 0;
|
2021-03-19 15:14:59 +01:00
|
|
|
env->two_stage_lookup = false;
|
2022-02-04 18:46:45 +01:00
|
|
|
|
|
|
|
/* Initialized default priorities of local interrupts. */
|
|
|
|
for (i = 0; i < ARRAY_SIZE(env->miprio); i++) {
|
|
|
|
iprio = riscv_cpu_default_priority(i);
|
|
|
|
env->miprio[i] = (i == IRQ_M_EXT) ? 0 : iprio;
|
|
|
|
env->siprio[i] = (i == IRQ_S_EXT) ? 0 : iprio;
|
|
|
|
env->hviprio[i] = 0;
|
|
|
|
}
|
|
|
|
i = 0;
|
|
|
|
while (!riscv_cpu_hviprio_index2irq(i, &irq, &rdzero)) {
|
|
|
|
if (!rdzero) {
|
|
|
|
env->hviprio[irq] = env->miprio[irq];
|
|
|
|
}
|
|
|
|
i++;
|
|
|
|
}
|
2021-10-25 19:36:04 +02:00
|
|
|
/* mmte is supposed to have pm.current hardwired to 1 */
|
|
|
|
env->mmte |= (PM_EXT_INITIAL | MMTE_M_PM_CURRENT);
|
2018-03-02 13:31:10 +01:00
|
|
|
#endif
|
2022-01-20 13:20:32 +01:00
|
|
|
env->xl = riscv_cpu_mxl(env);
|
2022-01-20 13:20:38 +01:00
|
|
|
riscv_cpu_update_mask(env);
|
2021-04-01 17:17:29 +02:00
|
|
|
cs->exception_index = RISCV_EXCP_NONE;
|
2019-06-24 20:08:38 +02:00
|
|
|
env->load_res = -1;
|
2018-03-02 13:31:10 +01:00
|
|
|
set_default_nan_mode(1, &env->fp_status);
|
2022-01-12 09:13:22 +01:00
|
|
|
|
|
|
|
#ifndef CONFIG_USER_ONLY
|
2022-04-21 02:33:21 +02:00
|
|
|
if (riscv_feature(env, RISCV_FEATURE_DEBUG)) {
|
|
|
|
riscv_trigger_init(env);
|
|
|
|
}
|
|
|
|
|
2022-01-12 09:13:22 +01:00
|
|
|
if (kvm_enabled()) {
|
|
|
|
kvm_riscv_reset_vcpu(cpu);
|
|
|
|
}
|
|
|
|
#endif
|
2018-03-02 13:31:10 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static void riscv_cpu_disas_set_info(CPUState *s, disassemble_info *info)
|
|
|
|
{
|
2020-12-16 19:22:56 +01:00
|
|
|
RISCVCPU *cpu = RISCV_CPU(s);
|
2021-10-20 05:16:58 +02:00
|
|
|
|
|
|
|
switch (riscv_cpu_mxl(&cpu->env)) {
|
|
|
|
case MXL_RV32:
|
2020-12-16 19:22:56 +01:00
|
|
|
info->print_insn = print_insn_riscv32;
|
2021-10-20 05:16:58 +02:00
|
|
|
break;
|
|
|
|
case MXL_RV64:
|
2020-12-16 19:22:56 +01:00
|
|
|
info->print_insn = print_insn_riscv64;
|
2021-10-20 05:16:58 +02:00
|
|
|
break;
|
2022-01-06 22:00:57 +01:00
|
|
|
case MXL_RV128:
|
|
|
|
info->print_insn = print_insn_riscv128;
|
|
|
|
break;
|
2021-10-20 05:16:58 +02:00
|
|
|
default:
|
|
|
|
g_assert_not_reached();
|
2020-12-16 19:22:56 +01:00
|
|
|
}
|
2018-03-02 13:31:10 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static void riscv_cpu_realize(DeviceState *dev, Error **errp)
|
|
|
|
{
|
|
|
|
CPUState *cs = CPU(dev);
|
2019-04-20 04:24:01 +02:00
|
|
|
RISCVCPU *cpu = RISCV_CPU(dev);
|
|
|
|
CPURISCVState *env = &cpu->env;
|
2018-03-02 13:31:10 +01:00
|
|
|
RISCVCPUClass *mcc = RISCV_CPU_GET_CLASS(dev);
|
2022-01-20 13:20:35 +01:00
|
|
|
CPUClass *cc = CPU_CLASS(mcc);
|
2022-06-11 10:01:04 +02:00
|
|
|
int priv_version = -1;
|
2018-03-02 13:31:10 +01:00
|
|
|
Error *local_err = NULL;
|
|
|
|
|
|
|
|
cpu_exec_realizefn(cs, &local_err);
|
|
|
|
if (local_err != NULL) {
|
|
|
|
error_propagate(errp, local_err);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2019-04-20 04:24:01 +02:00
|
|
|
if (cpu->cfg.priv_spec) {
|
2022-03-03 19:54:40 +01:00
|
|
|
if (!g_strcmp0(cpu->cfg.priv_spec, "v1.12.0")) {
|
|
|
|
priv_version = PRIV_VERSION_1_12_0;
|
|
|
|
} else if (!g_strcmp0(cpu->cfg.priv_spec, "v1.11.0")) {
|
2019-06-18 03:31:11 +02:00
|
|
|
priv_version = PRIV_VERSION_1_11_0;
|
|
|
|
} else if (!g_strcmp0(cpu->cfg.priv_spec, "v1.10.0")) {
|
2019-04-20 04:24:01 +02:00
|
|
|
priv_version = PRIV_VERSION_1_10_0;
|
|
|
|
} else {
|
|
|
|
error_setg(errp,
|
|
|
|
"Unsupported privilege spec version '%s'",
|
|
|
|
cpu->cfg.priv_spec);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-06-11 10:01:04 +02:00
|
|
|
if (priv_version >= PRIV_VERSION_1_10_0) {
|
2021-08-11 16:46:12 +02:00
|
|
|
set_priv_version(env, priv_version);
|
|
|
|
}
|
2019-04-20 04:24:01 +02:00
|
|
|
|
|
|
|
if (cpu->cfg.mmu) {
|
2022-02-04 18:46:41 +01:00
|
|
|
riscv_set_feature(env, RISCV_FEATURE_MMU);
|
2019-04-20 04:24:01 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
if (cpu->cfg.pmp) {
|
2022-02-04 18:46:41 +01:00
|
|
|
riscv_set_feature(env, RISCV_FEATURE_PMP);
|
2021-04-19 08:17:25 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Enhanced PMP should only be available
|
|
|
|
* on harts with PMP support
|
|
|
|
*/
|
|
|
|
if (cpu->cfg.epmp) {
|
2022-02-04 18:46:41 +01:00
|
|
|
riscv_set_feature(env, RISCV_FEATURE_EPMP);
|
2021-04-19 08:17:25 +02:00
|
|
|
}
|
2019-04-20 04:24:01 +02:00
|
|
|
}
|
|
|
|
|
2022-02-04 18:46:53 +01:00
|
|
|
if (cpu->cfg.aia) {
|
|
|
|
riscv_set_feature(env, RISCV_FEATURE_AIA);
|
|
|
|
}
|
|
|
|
|
2022-04-21 02:33:20 +02:00
|
|
|
if (cpu->cfg.debug) {
|
|
|
|
riscv_set_feature(env, RISCV_FEATURE_DEBUG);
|
|
|
|
}
|
|
|
|
|
2020-09-01 03:38:58 +02:00
|
|
|
set_resetvec(env, cpu->cfg.resetvec);
|
|
|
|
|
2021-10-20 05:16:57 +02:00
|
|
|
/* Validate that MISA_MXL is set properly. */
|
|
|
|
switch (env->misa_mxl_max) {
|
|
|
|
#ifdef TARGET_RISCV64
|
|
|
|
case MXL_RV64:
|
2022-01-06 22:00:57 +01:00
|
|
|
case MXL_RV128:
|
2022-01-24 21:24:56 +01:00
|
|
|
cc->gdb_core_xml_file = "riscv-64bit-cpu.xml";
|
2022-01-06 22:00:57 +01:00
|
|
|
break;
|
2021-10-20 05:16:57 +02:00
|
|
|
#endif
|
|
|
|
case MXL_RV32:
|
2022-01-20 13:20:35 +01:00
|
|
|
cc->gdb_core_xml_file = "riscv-32bit-cpu.xml";
|
2021-10-20 05:16:57 +02:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
g_assert_not_reached();
|
|
|
|
}
|
|
|
|
assert(env->misa_mxl_max == env->misa_mxl);
|
|
|
|
|
|
|
|
/* If only MISA_EXT is unset for misa, then set it from properties */
|
|
|
|
if (env->misa_ext == 0) {
|
|
|
|
uint32_t ext = 0;
|
|
|
|
|
2019-05-07 00:49:53 +02:00
|
|
|
/* Do some ISA extension error checking */
|
2022-05-15 04:56:07 +02:00
|
|
|
if (cpu->cfg.ext_g && !(cpu->cfg.ext_i && cpu->cfg.ext_m &&
|
|
|
|
cpu->cfg.ext_a && cpu->cfg.ext_f &&
|
2022-05-15 04:56:09 +02:00
|
|
|
cpu->cfg.ext_d &&
|
|
|
|
cpu->cfg.ext_icsr && cpu->cfg.ext_ifencei)) {
|
|
|
|
warn_report("Setting G will also set IMAFD_Zicsr_Zifencei");
|
2019-05-07 00:49:53 +02:00
|
|
|
cpu->cfg.ext_i = true;
|
|
|
|
cpu->cfg.ext_m = true;
|
|
|
|
cpu->cfg.ext_a = true;
|
|
|
|
cpu->cfg.ext_f = true;
|
|
|
|
cpu->cfg.ext_d = true;
|
2022-05-15 04:56:09 +02:00
|
|
|
cpu->cfg.ext_icsr = true;
|
|
|
|
cpu->cfg.ext_ifencei = true;
|
2019-05-07 00:49:53 +02:00
|
|
|
}
|
|
|
|
|
2022-05-31 05:07:32 +02:00
|
|
|
if (cpu->cfg.ext_m && cpu->cfg.ext_zmmul) {
|
|
|
|
warn_report("Zmmul will override M");
|
|
|
|
cpu->cfg.ext_m = false;
|
|
|
|
}
|
|
|
|
|
2022-05-18 03:26:11 +02:00
|
|
|
if (cpu->cfg.ext_i && cpu->cfg.ext_e) {
|
|
|
|
error_setg(errp,
|
|
|
|
"I and E extensions are incompatible");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!cpu->cfg.ext_i && !cpu->cfg.ext_e) {
|
|
|
|
error_setg(errp,
|
|
|
|
"Either I or E extension must be set");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2022-05-15 04:56:10 +02:00
|
|
|
if (cpu->cfg.ext_f && !cpu->cfg.ext_icsr) {
|
|
|
|
error_setg(errp, "F extension requires Zicsr");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((cpu->cfg.ext_zfh || cpu->cfg.ext_zfhmin) && !cpu->cfg.ext_f) {
|
|
|
|
error_setg(errp, "Zfh/Zfhmin extensions require F extension");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (cpu->cfg.ext_d && !cpu->cfg.ext_f) {
|
|
|
|
error_setg(errp, "D extension requires F extension");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (cpu->cfg.ext_v && !cpu->cfg.ext_d) {
|
|
|
|
error_setg(errp, "V extension requires D extension");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2022-05-15 04:56:11 +02:00
|
|
|
if ((cpu->cfg.ext_zve32f || cpu->cfg.ext_zve64f) && !cpu->cfg.ext_f) {
|
|
|
|
error_setg(errp, "Zve32f/Zve64f extensions require F extension");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Set the ISA extensions, checks should have happened above */
|
2022-02-11 05:39:15 +01:00
|
|
|
if (cpu->cfg.ext_zdinx || cpu->cfg.ext_zhinx ||
|
|
|
|
cpu->cfg.ext_zhinxmin) {
|
|
|
|
cpu->cfg.ext_zfinx = true;
|
|
|
|
}
|
|
|
|
|
2022-05-15 04:56:11 +02:00
|
|
|
if (cpu->cfg.ext_zfinx) {
|
|
|
|
if (!cpu->cfg.ext_icsr) {
|
|
|
|
error_setg(errp, "Zfinx extension requires Zicsr");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (cpu->cfg.ext_f) {
|
|
|
|
error_setg(errp,
|
|
|
|
"Zfinx cannot be supported together with F extension");
|
|
|
|
return;
|
|
|
|
}
|
2022-05-15 04:56:10 +02:00
|
|
|
}
|
|
|
|
|
2022-04-23 04:34:57 +02:00
|
|
|
if (cpu->cfg.ext_zk) {
|
|
|
|
cpu->cfg.ext_zkn = true;
|
|
|
|
cpu->cfg.ext_zkr = true;
|
|
|
|
cpu->cfg.ext_zkt = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (cpu->cfg.ext_zkn) {
|
|
|
|
cpu->cfg.ext_zbkb = true;
|
|
|
|
cpu->cfg.ext_zbkc = true;
|
|
|
|
cpu->cfg.ext_zbkx = true;
|
|
|
|
cpu->cfg.ext_zkne = true;
|
|
|
|
cpu->cfg.ext_zknd = true;
|
|
|
|
cpu->cfg.ext_zknh = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (cpu->cfg.ext_zks) {
|
|
|
|
cpu->cfg.ext_zbkb = true;
|
|
|
|
cpu->cfg.ext_zbkc = true;
|
|
|
|
cpu->cfg.ext_zbkx = true;
|
|
|
|
cpu->cfg.ext_zksed = true;
|
|
|
|
cpu->cfg.ext_zksh = true;
|
|
|
|
}
|
|
|
|
|
2019-05-07 00:49:53 +02:00
|
|
|
if (cpu->cfg.ext_i) {
|
2021-10-20 05:16:57 +02:00
|
|
|
ext |= RVI;
|
2019-05-07 00:49:53 +02:00
|
|
|
}
|
|
|
|
if (cpu->cfg.ext_e) {
|
2021-10-20 05:16:57 +02:00
|
|
|
ext |= RVE;
|
2019-05-07 00:49:53 +02:00
|
|
|
}
|
|
|
|
if (cpu->cfg.ext_m) {
|
2021-10-20 05:16:57 +02:00
|
|
|
ext |= RVM;
|
2019-05-07 00:49:53 +02:00
|
|
|
}
|
|
|
|
if (cpu->cfg.ext_a) {
|
2021-10-20 05:16:57 +02:00
|
|
|
ext |= RVA;
|
2019-05-07 00:49:53 +02:00
|
|
|
}
|
|
|
|
if (cpu->cfg.ext_f) {
|
2021-10-20 05:16:57 +02:00
|
|
|
ext |= RVF;
|
2019-05-07 00:49:53 +02:00
|
|
|
}
|
|
|
|
if (cpu->cfg.ext_d) {
|
2021-10-20 05:16:57 +02:00
|
|
|
ext |= RVD;
|
2019-05-07 00:49:53 +02:00
|
|
|
}
|
|
|
|
if (cpu->cfg.ext_c) {
|
2021-10-20 05:16:57 +02:00
|
|
|
ext |= RVC;
|
2019-05-07 00:49:53 +02:00
|
|
|
}
|
|
|
|
if (cpu->cfg.ext_s) {
|
2021-10-20 05:16:57 +02:00
|
|
|
ext |= RVS;
|
2019-05-07 00:49:53 +02:00
|
|
|
}
|
|
|
|
if (cpu->cfg.ext_u) {
|
2021-10-20 05:16:57 +02:00
|
|
|
ext |= RVU;
|
2019-05-07 00:49:53 +02:00
|
|
|
}
|
2020-02-01 02:03:11 +01:00
|
|
|
if (cpu->cfg.ext_h) {
|
2021-10-20 05:16:57 +02:00
|
|
|
ext |= RVH;
|
2020-02-01 02:03:11 +01:00
|
|
|
}
|
2020-07-01 17:25:49 +02:00
|
|
|
if (cpu->cfg.ext_v) {
|
2021-12-10 08:55:47 +01:00
|
|
|
int vext_version = VEXT_VERSION_1_00_0;
|
2021-10-20 05:16:57 +02:00
|
|
|
ext |= RVV;
|
2020-07-01 17:25:49 +02:00
|
|
|
if (!is_power_of_2(cpu->cfg.vlen)) {
|
|
|
|
error_setg(errp,
|
|
|
|
"Vector extension VLEN must be power of 2");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (cpu->cfg.vlen > RV_VLEN_MAX || cpu->cfg.vlen < 128) {
|
|
|
|
error_setg(errp,
|
|
|
|
"Vector extension implementation only supports VLEN "
|
|
|
|
"in the range [128, %d]", RV_VLEN_MAX);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (!is_power_of_2(cpu->cfg.elen)) {
|
|
|
|
error_setg(errp,
|
|
|
|
"Vector extension ELEN must be power of 2");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (cpu->cfg.elen > 64 || cpu->cfg.vlen < 8) {
|
|
|
|
error_setg(errp,
|
|
|
|
"Vector extension implementation only supports ELEN "
|
|
|
|
"in the range [8, 64]");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (cpu->cfg.vext_spec) {
|
2021-12-10 08:55:47 +01:00
|
|
|
if (!g_strcmp0(cpu->cfg.vext_spec, "v1.0")) {
|
|
|
|
vext_version = VEXT_VERSION_1_00_0;
|
2020-07-01 17:25:49 +02:00
|
|
|
} else {
|
|
|
|
error_setg(errp,
|
|
|
|
"Unsupported vector spec version '%s'",
|
|
|
|
cpu->cfg.vext_spec);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
} else {
|
2021-03-09 12:15:10 +01:00
|
|
|
qemu_log("vector version is not specified, "
|
2021-12-10 08:55:47 +01:00
|
|
|
"use the default value v1.0\n");
|
2020-07-01 17:25:49 +02:00
|
|
|
}
|
|
|
|
set_vext_version(env, vext_version);
|
|
|
|
}
|
2021-10-25 19:36:09 +02:00
|
|
|
if (cpu->cfg.ext_j) {
|
|
|
|
ext |= RVJ;
|
|
|
|
}
|
2019-05-07 00:49:53 +02:00
|
|
|
|
2021-10-20 05:16:57 +02:00
|
|
|
set_misa(env, env->misa_mxl, ext);
|
2019-05-07 00:49:53 +02:00
|
|
|
}
|
|
|
|
|
2019-03-15 11:26:59 +01:00
|
|
|
riscv_cpu_register_gdb_regs_for_features(cs);
|
|
|
|
|
2018-03-02 13:31:10 +01:00
|
|
|
qemu_init_vcpu(cs);
|
|
|
|
cpu_reset(cs);
|
|
|
|
|
|
|
|
mcc->parent_realize(dev, errp);
|
|
|
|
}
|
|
|
|
|
2021-08-30 07:34:20 +02:00
|
|
|
#ifndef CONFIG_USER_ONLY
|
|
|
|
static void riscv_cpu_set_irq(void *opaque, int irq, int level)
|
|
|
|
{
|
|
|
|
RISCVCPU *cpu = RISCV_CPU(opaque);
|
2022-02-04 18:46:39 +01:00
|
|
|
CPURISCVState *env = &cpu->env;
|
2021-08-30 07:34:20 +02:00
|
|
|
|
2022-02-04 18:46:39 +01:00
|
|
|
if (irq < IRQ_LOCAL_MAX) {
|
|
|
|
switch (irq) {
|
|
|
|
case IRQ_U_SOFT:
|
|
|
|
case IRQ_S_SOFT:
|
|
|
|
case IRQ_VS_SOFT:
|
|
|
|
case IRQ_M_SOFT:
|
|
|
|
case IRQ_U_TIMER:
|
|
|
|
case IRQ_S_TIMER:
|
|
|
|
case IRQ_VS_TIMER:
|
|
|
|
case IRQ_M_TIMER:
|
|
|
|
case IRQ_U_EXT:
|
|
|
|
case IRQ_VS_EXT:
|
|
|
|
case IRQ_M_EXT:
|
2022-03-17 07:18:16 +01:00
|
|
|
if (kvm_enabled()) {
|
2022-02-04 18:46:39 +01:00
|
|
|
kvm_riscv_set_irq(cpu, irq, level);
|
2022-03-17 07:18:16 +01:00
|
|
|
} else {
|
2022-02-04 18:46:39 +01:00
|
|
|
riscv_cpu_update_mip(cpu, 1 << irq, BOOL_TO_MASK(level));
|
2022-03-17 07:18:16 +01:00
|
|
|
}
|
2022-02-04 18:46:39 +01:00
|
|
|
break;
|
2022-03-17 07:18:17 +01:00
|
|
|
case IRQ_S_EXT:
|
|
|
|
if (kvm_enabled()) {
|
|
|
|
kvm_riscv_set_irq(cpu, irq, level);
|
|
|
|
} else {
|
|
|
|
env->external_seip = level;
|
|
|
|
riscv_cpu_update_mip(cpu, 1 << irq,
|
|
|
|
BOOL_TO_MASK(level | env->software_seip));
|
|
|
|
}
|
|
|
|
break;
|
2022-02-04 18:46:39 +01:00
|
|
|
default:
|
|
|
|
g_assert_not_reached();
|
2022-01-12 09:13:23 +01:00
|
|
|
}
|
2022-02-04 18:46:39 +01:00
|
|
|
} else if (irq < (IRQ_LOCAL_MAX + IRQ_LOCAL_GUEST_MAX)) {
|
|
|
|
/* Require H-extension for handling guest local interrupts */
|
|
|
|
if (!riscv_has_ext(env, RVH)) {
|
|
|
|
g_assert_not_reached();
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Compute bit position in HGEIP CSR */
|
|
|
|
irq = irq - IRQ_LOCAL_MAX + 1;
|
|
|
|
if (env->geilen < irq) {
|
|
|
|
g_assert_not_reached();
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Update HGEIP CSR */
|
|
|
|
env->hgeip &= ~((target_ulong)1 << irq);
|
|
|
|
if (level) {
|
|
|
|
env->hgeip |= (target_ulong)1 << irq;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Update mip.SGEIP bit */
|
|
|
|
riscv_cpu_update_mip(cpu, MIP_SGEIP,
|
|
|
|
BOOL_TO_MASK(!!(env->hgeie & env->hgeip)));
|
|
|
|
} else {
|
2021-08-30 07:34:20 +02:00
|
|
|
g_assert_not_reached();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_USER_ONLY */
|
|
|
|
|
2018-03-02 13:31:10 +01:00
|
|
|
static void riscv_cpu_init(Object *obj)
|
|
|
|
{
|
|
|
|
RISCVCPU *cpu = RISCV_CPU(obj);
|
|
|
|
|
2022-06-08 08:14:37 +02:00
|
|
|
cpu->cfg.ext_ifencei = true;
|
|
|
|
cpu->cfg.ext_icsr = true;
|
|
|
|
cpu->cfg.mmu = true;
|
|
|
|
cpu->cfg.pmp = true;
|
|
|
|
|
2019-03-28 22:26:22 +01:00
|
|
|
cpu_set_cpustate_pointers(cpu);
|
2021-08-30 07:34:20 +02:00
|
|
|
|
|
|
|
#ifndef CONFIG_USER_ONLY
|
2022-02-04 18:46:39 +01:00
|
|
|
qdev_init_gpio_in(DEVICE(cpu), riscv_cpu_set_irq,
|
|
|
|
IRQ_LOCAL_MAX + IRQ_LOCAL_GUEST_MAX);
|
2021-08-30 07:34:20 +02:00
|
|
|
#endif /* CONFIG_USER_ONLY */
|
2018-03-02 13:31:10 +01:00
|
|
|
}
|
|
|
|
|
2022-06-08 08:14:37 +02:00
|
|
|
static Property riscv_cpu_extensions[] = {
|
2021-10-18 06:32:15 +02:00
|
|
|
/* Defaults for standard extensions */
|
2019-05-07 00:49:53 +02:00
|
|
|
DEFINE_PROP_BOOL("i", RISCVCPU, cfg.ext_i, true),
|
|
|
|
DEFINE_PROP_BOOL("e", RISCVCPU, cfg.ext_e, false),
|
2022-05-15 04:56:08 +02:00
|
|
|
DEFINE_PROP_BOOL("g", RISCVCPU, cfg.ext_g, false),
|
2019-05-07 00:49:53 +02:00
|
|
|
DEFINE_PROP_BOOL("m", RISCVCPU, cfg.ext_m, true),
|
|
|
|
DEFINE_PROP_BOOL("a", RISCVCPU, cfg.ext_a, true),
|
|
|
|
DEFINE_PROP_BOOL("f", RISCVCPU, cfg.ext_f, true),
|
|
|
|
DEFINE_PROP_BOOL("d", RISCVCPU, cfg.ext_d, true),
|
|
|
|
DEFINE_PROP_BOOL("c", RISCVCPU, cfg.ext_c, true),
|
|
|
|
DEFINE_PROP_BOOL("s", RISCVCPU, cfg.ext_s, true),
|
|
|
|
DEFINE_PROP_BOOL("u", RISCVCPU, cfg.ext_u, true),
|
2021-12-10 08:55:47 +01:00
|
|
|
DEFINE_PROP_BOOL("v", RISCVCPU, cfg.ext_v, false),
|
2022-01-05 22:39:35 +01:00
|
|
|
DEFINE_PROP_BOOL("h", RISCVCPU, cfg.ext_h, true),
|
2022-06-21 01:15:54 +02:00
|
|
|
DEFINE_PROP_UINT8("pmu-num", RISCVCPU, cfg.pmu_num, 16),
|
2021-10-18 06:32:15 +02:00
|
|
|
DEFINE_PROP_BOOL("Zifencei", RISCVCPU, cfg.ext_ifencei, true),
|
|
|
|
DEFINE_PROP_BOOL("Zicsr", RISCVCPU, cfg.ext_icsr, true),
|
2021-12-10 08:43:25 +01:00
|
|
|
DEFINE_PROP_BOOL("Zfh", RISCVCPU, cfg.ext_zfh, false),
|
2021-12-10 08:43:27 +01:00
|
|
|
DEFINE_PROP_BOOL("Zfhmin", RISCVCPU, cfg.ext_zfhmin, false),
|
2022-01-18 02:45:20 +01:00
|
|
|
DEFINE_PROP_BOOL("Zve32f", RISCVCPU, cfg.ext_zve32f, false),
|
2022-01-18 02:45:13 +01:00
|
|
|
DEFINE_PROP_BOOL("Zve64f", RISCVCPU, cfg.ext_zve64f, false),
|
2021-10-18 06:32:15 +02:00
|
|
|
DEFINE_PROP_BOOL("mmu", RISCVCPU, cfg.mmu, true),
|
|
|
|
DEFINE_PROP_BOOL("pmp", RISCVCPU, cfg.pmp, true),
|
|
|
|
|
|
|
|
DEFINE_PROP_STRING("priv_spec", RISCVCPU, cfg.priv_spec),
|
2021-12-10 08:55:47 +01:00
|
|
|
DEFINE_PROP_STRING("vext_spec", RISCVCPU, cfg.vext_spec),
|
|
|
|
DEFINE_PROP_UINT16("vlen", RISCVCPU, cfg.vlen, 128),
|
|
|
|
DEFINE_PROP_UINT16("elen", RISCVCPU, cfg.elen, 64),
|
2021-10-18 06:32:15 +02:00
|
|
|
|
2022-02-04 03:26:57 +01:00
|
|
|
DEFINE_PROP_BOOL("svinval", RISCVCPU, cfg.ext_svinval, false),
|
2022-02-04 03:26:56 +01:00
|
|
|
DEFINE_PROP_BOOL("svnapot", RISCVCPU, cfg.ext_svnapot, false),
|
2022-02-04 03:26:58 +01:00
|
|
|
DEFINE_PROP_BOOL("svpbmt", RISCVCPU, cfg.ext_svpbmt, false),
|
2022-02-04 03:26:56 +01:00
|
|
|
|
2021-12-16 06:18:44 +01:00
|
|
|
DEFINE_PROP_BOOL("zba", RISCVCPU, cfg.ext_zba, true),
|
|
|
|
DEFINE_PROP_BOOL("zbb", RISCVCPU, cfg.ext_zbb, true),
|
|
|
|
DEFINE_PROP_BOOL("zbc", RISCVCPU, cfg.ext_zbc, true),
|
2022-04-23 04:35:10 +02:00
|
|
|
DEFINE_PROP_BOOL("zbkb", RISCVCPU, cfg.ext_zbkb, false),
|
|
|
|
DEFINE_PROP_BOOL("zbkc", RISCVCPU, cfg.ext_zbkc, false),
|
|
|
|
DEFINE_PROP_BOOL("zbkx", RISCVCPU, cfg.ext_zbkx, false),
|
2021-12-16 06:18:44 +01:00
|
|
|
DEFINE_PROP_BOOL("zbs", RISCVCPU, cfg.ext_zbs, true),
|
2022-04-23 04:35:10 +02:00
|
|
|
DEFINE_PROP_BOOL("zk", RISCVCPU, cfg.ext_zk, false),
|
|
|
|
DEFINE_PROP_BOOL("zkn", RISCVCPU, cfg.ext_zkn, false),
|
|
|
|
DEFINE_PROP_BOOL("zknd", RISCVCPU, cfg.ext_zknd, false),
|
|
|
|
DEFINE_PROP_BOOL("zkne", RISCVCPU, cfg.ext_zkne, false),
|
|
|
|
DEFINE_PROP_BOOL("zknh", RISCVCPU, cfg.ext_zknh, false),
|
|
|
|
DEFINE_PROP_BOOL("zkr", RISCVCPU, cfg.ext_zkr, false),
|
|
|
|
DEFINE_PROP_BOOL("zks", RISCVCPU, cfg.ext_zks, false),
|
|
|
|
DEFINE_PROP_BOOL("zksed", RISCVCPU, cfg.ext_zksed, false),
|
|
|
|
DEFINE_PROP_BOOL("zksh", RISCVCPU, cfg.ext_zksh, false),
|
|
|
|
DEFINE_PROP_BOOL("zkt", RISCVCPU, cfg.ext_zkt, false),
|
2022-01-06 14:40:20 +01:00
|
|
|
|
2022-02-11 05:39:20 +01:00
|
|
|
DEFINE_PROP_BOOL("zdinx", RISCVCPU, cfg.ext_zdinx, false),
|
|
|
|
DEFINE_PROP_BOOL("zfinx", RISCVCPU, cfg.ext_zfinx, false),
|
|
|
|
DEFINE_PROP_BOOL("zhinx", RISCVCPU, cfg.ext_zhinx, false),
|
|
|
|
DEFINE_PROP_BOOL("zhinxmin", RISCVCPU, cfg.ext_zhinxmin, false),
|
|
|
|
|
2022-02-02 01:52:48 +01:00
|
|
|
/* Vendor-specific custom extensions */
|
|
|
|
DEFINE_PROP_BOOL("xventanacondops", RISCVCPU, cfg.ext_XVentanaCondOps, false),
|
|
|
|
|
2022-01-06 14:40:20 +01:00
|
|
|
/* These are experimental so mark with 'x-' */
|
2021-10-25 19:36:09 +02:00
|
|
|
DEFINE_PROP_BOOL("x-j", RISCVCPU, cfg.ext_j, false),
|
2022-05-31 05:07:32 +02:00
|
|
|
DEFINE_PROP_BOOL("x-zmmul", RISCVCPU, cfg.ext_zmmul, false),
|
2021-09-02 02:40:10 +02:00
|
|
|
/* ePMP 0.9.3 */
|
2021-04-19 08:17:25 +02:00
|
|
|
DEFINE_PROP_BOOL("x-epmp", RISCVCPU, cfg.epmp, false),
|
2022-02-04 18:46:53 +01:00
|
|
|
DEFINE_PROP_BOOL("x-aia", RISCVCPU, cfg.aia, false),
|
2021-04-19 08:17:25 +02:00
|
|
|
|
2022-06-08 08:14:37 +02:00
|
|
|
DEFINE_PROP_END_OF_LIST(),
|
|
|
|
};
|
|
|
|
|
|
|
|
static void register_cpu_props(DeviceState *dev)
|
|
|
|
{
|
|
|
|
Property *prop;
|
|
|
|
|
|
|
|
for (prop = riscv_cpu_extensions; prop && prop->name; prop++) {
|
|
|
|
qdev_property_add_static(dev, prop);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static Property riscv_cpu_properties[] = {
|
|
|
|
DEFINE_PROP_BOOL("debug", RISCVCPU, cfg.debug, true),
|
|
|
|
|
|
|
|
DEFINE_PROP_UINT32("mvendorid", RISCVCPU, cfg.mvendorid, 0),
|
|
|
|
DEFINE_PROP_UINT64("marchid", RISCVCPU, cfg.marchid, RISCV_CPU_MARCHID),
|
|
|
|
DEFINE_PROP_UINT64("mimpid", RISCVCPU, cfg.mimpid, RISCV_CPU_MIMPID),
|
|
|
|
|
2020-09-01 03:38:56 +02:00
|
|
|
DEFINE_PROP_UINT64("resetvec", RISCVCPU, cfg.resetvec, DEFAULT_RSTVEC),
|
2022-05-10 13:29:08 +02:00
|
|
|
|
|
|
|
DEFINE_PROP_BOOL("short-isa-string", RISCVCPU, cfg.short_isa_string, false),
|
2022-06-06 08:16:56 +02:00
|
|
|
|
|
|
|
DEFINE_PROP_BOOL("rvv_ta_all_1s", RISCVCPU, cfg.rvv_ta_all_1s, false),
|
2019-04-20 04:24:01 +02:00
|
|
|
DEFINE_PROP_END_OF_LIST(),
|
|
|
|
};
|
|
|
|
|
2021-01-06 21:41:41 +01:00
|
|
|
static gchar *riscv_gdb_arch_name(CPUState *cs)
|
|
|
|
{
|
|
|
|
RISCVCPU *cpu = RISCV_CPU(cs);
|
|
|
|
CPURISCVState *env = &cpu->env;
|
|
|
|
|
2021-10-20 05:16:58 +02:00
|
|
|
switch (riscv_cpu_mxl(env)) {
|
|
|
|
case MXL_RV32:
|
2021-01-06 21:41:41 +01:00
|
|
|
return g_strdup("riscv:rv32");
|
2021-10-20 05:16:58 +02:00
|
|
|
case MXL_RV64:
|
2022-01-06 22:00:57 +01:00
|
|
|
case MXL_RV128:
|
2021-01-06 21:41:41 +01:00
|
|
|
return g_strdup("riscv:rv64");
|
2021-10-20 05:16:58 +02:00
|
|
|
default:
|
|
|
|
g_assert_not_reached();
|
2021-01-06 21:41:41 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-01-16 06:41:22 +01:00
|
|
|
static const char *riscv_gdb_get_dynamic_xml(CPUState *cs, const char *xmlname)
|
|
|
|
{
|
|
|
|
RISCVCPU *cpu = RISCV_CPU(cs);
|
|
|
|
|
|
|
|
if (strcmp(xmlname, "riscv-csr.xml") == 0) {
|
|
|
|
return cpu->dyn_csr_xml;
|
2021-12-10 08:56:54 +01:00
|
|
|
} else if (strcmp(xmlname, "riscv-vector.xml") == 0) {
|
|
|
|
return cpu->dyn_vreg_xml;
|
2021-01-16 06:41:22 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2021-05-17 12:51:31 +02:00
|
|
|
#ifndef CONFIG_USER_ONLY
|
|
|
|
#include "hw/core/sysemu-cpu-ops.h"
|
|
|
|
|
|
|
|
static const struct SysemuCPUOps riscv_sysemu_ops = {
|
2021-05-17 12:51:37 +02:00
|
|
|
.get_phys_page_debug = riscv_cpu_get_phys_page_debug,
|
2021-05-17 12:51:35 +02:00
|
|
|
.write_elf64_note = riscv_cpu_write_elf64_note,
|
|
|
|
.write_elf32_note = riscv_cpu_write_elf32_note,
|
2021-05-17 12:51:32 +02:00
|
|
|
.legacy_vmsd = &vmstate_riscv_cpu,
|
2021-05-17 12:51:31 +02:00
|
|
|
};
|
|
|
|
#endif
|
|
|
|
|
2021-02-04 17:39:23 +01:00
|
|
|
#include "hw/core/tcg-cpu-ops.h"
|
|
|
|
|
2021-02-28 00:21:17 +01:00
|
|
|
static const struct TCGCPUOps riscv_tcg_ops = {
|
2021-02-04 17:39:23 +01:00
|
|
|
.initialize = riscv_translate_init,
|
|
|
|
.synchronize_from_tb = riscv_cpu_synchronize_from_tb,
|
|
|
|
|
|
|
|
#ifndef CONFIG_USER_ONLY
|
2021-09-15 05:46:38 +02:00
|
|
|
.tlb_fill = riscv_cpu_tlb_fill,
|
2021-09-11 18:54:28 +02:00
|
|
|
.cpu_exec_interrupt = riscv_cpu_exec_interrupt,
|
2021-02-04 17:39:23 +01:00
|
|
|
.do_interrupt = riscv_cpu_do_interrupt,
|
|
|
|
.do_transaction_failed = riscv_cpu_do_transaction_failed,
|
|
|
|
.do_unaligned_access = riscv_cpu_do_unaligned_access,
|
2022-04-21 02:33:19 +02:00
|
|
|
.debug_excp_handler = riscv_cpu_debug_excp_handler,
|
|
|
|
.debug_check_breakpoint = riscv_cpu_debug_check_breakpoint,
|
|
|
|
.debug_check_watchpoint = riscv_cpu_debug_check_watchpoint,
|
2021-02-04 17:39:23 +01:00
|
|
|
#endif /* !CONFIG_USER_ONLY */
|
|
|
|
};
|
|
|
|
|
2018-03-02 13:31:10 +01:00
|
|
|
static void riscv_cpu_class_init(ObjectClass *c, void *data)
|
|
|
|
{
|
|
|
|
RISCVCPUClass *mcc = RISCV_CPU_CLASS(c);
|
|
|
|
CPUClass *cc = CPU_CLASS(c);
|
|
|
|
DeviceClass *dc = DEVICE_CLASS(c);
|
|
|
|
|
2018-11-26 04:20:38 +01:00
|
|
|
device_class_set_parent_realize(dc, riscv_cpu_realize,
|
|
|
|
&mcc->parent_realize);
|
2018-03-02 13:31:10 +01:00
|
|
|
|
cpu: Use DeviceClass reset instead of a special CPUClass reset
The CPUClass has a 'reset' method. This is a legacy from when
TYPE_CPU used not to inherit from TYPE_DEVICE. We don't need it any
more, as we can simply use the TYPE_DEVICE reset. The 'cpu_reset()'
function is kept as the API which most places use to reset a CPU; it
is now a wrapper which calls device_cold_reset() and then the
tracepoint function.
This change should not cause CPU objects to be reset more often
than they are at the moment, because:
* nobody is directly calling device_cold_reset() or
qdev_reset_all() on CPU objects
* no CPU object is on a qbus, so they will not be reset either
by somebody calling qbus_reset_all()/bus_cold_reset(), or
by the main "reset sysbus and everything in the qbus tree"
reset that most devices are reset by
Note that this does not change the need for each machine or whatever
to use qemu_register_reset() to arrange to call cpu_reset() -- that
is necessary because CPU objects are not on any qbus, so they don't
get reset when the qbus tree rooted at the sysbus bus is reset, and
this isn't being changed here.
All the changes to the files under target/ were made using the
included Coccinelle script, except:
(1) the deletion of the now-inaccurate and not terribly useful
"CPUClass::reset" comments was done with a perl one-liner afterwards:
perl -n -i -e '/ CPUClass::reset/ or print' target/*/*.c
(2) this bit of the s390 change was done by hand, because the
Coccinelle script is not sophisticated enough to handle the
parent_reset call being inside another function:
| @@ -96,8 +96,9 @@ static void s390_cpu_reset(CPUState *s, cpu_reset_type type)
| S390CPU *cpu = S390_CPU(s);
| S390CPUClass *scc = S390_CPU_GET_CLASS(cpu);
| CPUS390XState *env = &cpu->env;
|+ DeviceState *dev = DEVICE(s);
|
|- scc->parent_reset(s);
|+ scc->parent_reset(dev);
| cpu->env.sigp_order = 0;
| s390_cpu_set_state(S390_CPU_STATE_STOPPED, cpu);
Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
Message-Id: <20200303100511.5498-1-peter.maydell@linaro.org>
Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Reviewed-by: Richard Henderson <richard.henderson@linaro.org>
Tested-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Signed-off-by: Eduardo Habkost <ehabkost@redhat.com>
2020-03-03 11:05:11 +01:00
|
|
|
device_class_set_parent_reset(dc, riscv_cpu_reset, &mcc->parent_reset);
|
2018-03-02 13:31:10 +01:00
|
|
|
|
|
|
|
cc->class_by_name = riscv_cpu_class_by_name;
|
|
|
|
cc->has_work = riscv_cpu_has_work;
|
|
|
|
cc->dump_state = riscv_cpu_dump_state;
|
|
|
|
cc->set_pc = riscv_cpu_set_pc;
|
|
|
|
cc->gdb_read_register = riscv_cpu_gdb_read_register;
|
|
|
|
cc->gdb_write_register = riscv_cpu_gdb_write_register;
|
2019-03-15 11:26:59 +01:00
|
|
|
cc->gdb_num_core_regs = 33;
|
2018-03-02 13:31:10 +01:00
|
|
|
cc->gdb_stop_before_watchpoint = true;
|
|
|
|
cc->disas_set_info = riscv_cpu_disas_set_info;
|
2019-04-02 12:12:38 +02:00
|
|
|
#ifndef CONFIG_USER_ONLY
|
2021-05-17 12:51:31 +02:00
|
|
|
cc->sysemu_ops = &riscv_sysemu_ops;
|
2018-03-02 13:31:10 +01:00
|
|
|
#endif
|
2021-01-06 21:41:41 +01:00
|
|
|
cc->gdb_arch_name = riscv_gdb_arch_name;
|
2021-01-16 06:41:22 +01:00
|
|
|
cc->gdb_get_dynamic_xml = riscv_gdb_get_dynamic_xml;
|
2021-02-04 17:39:23 +01:00
|
|
|
cc->tcg_ops = &riscv_tcg_ops;
|
2021-02-04 17:39:10 +01:00
|
|
|
|
2020-01-10 16:30:32 +01:00
|
|
|
device_class_set_props(dc, riscv_cpu_properties);
|
2018-03-02 13:31:10 +01:00
|
|
|
}
|
|
|
|
|
2022-03-29 21:56:57 +02:00
|
|
|
#define ISA_EDATA_ENTRY(name, prop) {#name, cpu->cfg.prop}
|
|
|
|
|
|
|
|
static void riscv_isa_string_ext(RISCVCPU *cpu, char **isa_str, int max_str_len)
|
|
|
|
{
|
|
|
|
char *old = *isa_str;
|
|
|
|
char *new = *isa_str;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Here are the ordering rules of extension naming defined by RISC-V
|
|
|
|
* specification :
|
|
|
|
* 1. All extensions should be separated from other multi-letter extensions
|
|
|
|
* by an underscore.
|
|
|
|
* 2. The first letter following the 'Z' conventionally indicates the most
|
|
|
|
* closely related alphabetical extension category, IMAFDQLCBKJTPVH.
|
|
|
|
* If multiple 'Z' extensions are named, they should be ordered first
|
|
|
|
* by category, then alphabetically within a category.
|
|
|
|
* 3. Standard supervisor-level extensions (starts with 'S') should be
|
|
|
|
* listed after standard unprivileged extensions. If multiple
|
|
|
|
* supervisor-level extensions are listed, they should be ordered
|
|
|
|
* alphabetically.
|
|
|
|
* 4. Non-standard extensions (starts with 'X') must be listed after all
|
|
|
|
* standard extensions. They must be separated from other multi-letter
|
|
|
|
* extensions by an underscore.
|
|
|
|
*/
|
|
|
|
struct isa_ext_data isa_edata_arr[] = {
|
2022-05-18 14:46:58 +02:00
|
|
|
ISA_EDATA_ENTRY(zicsr, ext_icsr),
|
|
|
|
ISA_EDATA_ENTRY(zifencei, ext_ifencei),
|
2022-05-31 05:07:32 +02:00
|
|
|
ISA_EDATA_ENTRY(zmmul, ext_zmmul),
|
2022-03-29 21:56:57 +02:00
|
|
|
ISA_EDATA_ENTRY(zfh, ext_zfh),
|
|
|
|
ISA_EDATA_ENTRY(zfhmin, ext_zfhmin),
|
|
|
|
ISA_EDATA_ENTRY(zfinx, ext_zfinx),
|
|
|
|
ISA_EDATA_ENTRY(zdinx, ext_zdinx),
|
|
|
|
ISA_EDATA_ENTRY(zba, ext_zba),
|
|
|
|
ISA_EDATA_ENTRY(zbb, ext_zbb),
|
|
|
|
ISA_EDATA_ENTRY(zbc, ext_zbc),
|
2022-04-26 11:52:04 +02:00
|
|
|
ISA_EDATA_ENTRY(zbkb, ext_zbkb),
|
|
|
|
ISA_EDATA_ENTRY(zbkc, ext_zbkc),
|
|
|
|
ISA_EDATA_ENTRY(zbkx, ext_zbkx),
|
2022-03-29 21:56:57 +02:00
|
|
|
ISA_EDATA_ENTRY(zbs, ext_zbs),
|
2022-04-26 11:52:04 +02:00
|
|
|
ISA_EDATA_ENTRY(zk, ext_zk),
|
|
|
|
ISA_EDATA_ENTRY(zkn, ext_zkn),
|
|
|
|
ISA_EDATA_ENTRY(zknd, ext_zknd),
|
|
|
|
ISA_EDATA_ENTRY(zkne, ext_zkne),
|
|
|
|
ISA_EDATA_ENTRY(zknh, ext_zknh),
|
|
|
|
ISA_EDATA_ENTRY(zkr, ext_zkr),
|
|
|
|
ISA_EDATA_ENTRY(zks, ext_zks),
|
|
|
|
ISA_EDATA_ENTRY(zksed, ext_zksed),
|
|
|
|
ISA_EDATA_ENTRY(zksh, ext_zksh),
|
|
|
|
ISA_EDATA_ENTRY(zkt, ext_zkt),
|
2022-03-29 21:56:57 +02:00
|
|
|
ISA_EDATA_ENTRY(zve32f, ext_zve32f),
|
|
|
|
ISA_EDATA_ENTRY(zve64f, ext_zve64f),
|
2022-05-10 13:29:07 +02:00
|
|
|
ISA_EDATA_ENTRY(zhinx, ext_zhinx),
|
|
|
|
ISA_EDATA_ENTRY(zhinxmin, ext_zhinxmin),
|
2022-03-29 21:56:57 +02:00
|
|
|
ISA_EDATA_ENTRY(svinval, ext_svinval),
|
|
|
|
ISA_EDATA_ENTRY(svnapot, ext_svnapot),
|
|
|
|
ISA_EDATA_ENTRY(svpbmt, ext_svpbmt),
|
|
|
|
};
|
|
|
|
|
|
|
|
for (i = 0; i < ARRAY_SIZE(isa_edata_arr); i++) {
|
|
|
|
if (isa_edata_arr[i].enabled) {
|
|
|
|
new = g_strconcat(old, "_", isa_edata_arr[i].name, NULL);
|
|
|
|
g_free(old);
|
|
|
|
old = new;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
*isa_str = new;
|
|
|
|
}
|
|
|
|
|
2018-03-02 13:31:10 +01:00
|
|
|
char *riscv_isa_string(RISCVCPU *cpu)
|
|
|
|
{
|
|
|
|
int i;
|
2022-03-28 15:11:23 +02:00
|
|
|
const size_t maxlen = sizeof("rv128") + sizeof(riscv_single_letter_exts);
|
2018-03-19 22:18:49 +01:00
|
|
|
char *isa_str = g_new(char, maxlen);
|
|
|
|
char *p = isa_str + snprintf(isa_str, maxlen, "rv%d", TARGET_LONG_BITS);
|
2022-03-28 15:11:23 +02:00
|
|
|
for (i = 0; i < sizeof(riscv_single_letter_exts) - 1; i++) {
|
|
|
|
if (cpu->env.misa_ext & RV(riscv_single_letter_exts[i])) {
|
|
|
|
*p++ = qemu_tolower(riscv_single_letter_exts[i]);
|
2018-03-02 13:31:10 +01:00
|
|
|
}
|
|
|
|
}
|
2018-03-19 22:18:49 +01:00
|
|
|
*p = '\0';
|
2022-05-10 13:29:08 +02:00
|
|
|
if (!cpu->cfg.short_isa_string) {
|
|
|
|
riscv_isa_string_ext(cpu, &isa_str, maxlen);
|
|
|
|
}
|
2018-03-19 22:18:49 +01:00
|
|
|
return isa_str;
|
2018-03-02 13:31:10 +01:00
|
|
|
}
|
|
|
|
|
2018-03-08 23:12:31 +01:00
|
|
|
static gint riscv_cpu_list_compare(gconstpointer a, gconstpointer b)
|
2018-03-02 13:31:10 +01:00
|
|
|
{
|
2018-03-08 23:12:31 +01:00
|
|
|
ObjectClass *class_a = (ObjectClass *)a;
|
|
|
|
ObjectClass *class_b = (ObjectClass *)b;
|
|
|
|
const char *name_a, *name_b;
|
2018-03-02 13:31:10 +01:00
|
|
|
|
2018-03-08 23:12:31 +01:00
|
|
|
name_a = object_class_get_name(class_a);
|
|
|
|
name_b = object_class_get_name(class_b);
|
|
|
|
return strcmp(name_a, name_b);
|
2018-03-02 13:31:10 +01:00
|
|
|
}
|
|
|
|
|
2018-03-08 23:12:31 +01:00
|
|
|
static void riscv_cpu_list_entry(gpointer data, gpointer user_data)
|
2018-03-02 13:31:10 +01:00
|
|
|
{
|
2018-03-08 23:12:31 +01:00
|
|
|
const char *typename = object_class_get_name(OBJECT_CLASS(data));
|
|
|
|
int len = strlen(typename) - strlen(RISCV_CPU_TYPE_SUFFIX);
|
2018-03-02 13:31:10 +01:00
|
|
|
|
2019-04-17 21:17:57 +02:00
|
|
|
qemu_printf("%.*s\n", len, typename);
|
2018-03-08 23:12:31 +01:00
|
|
|
}
|
2018-03-02 13:31:10 +01:00
|
|
|
|
2019-04-17 21:17:57 +02:00
|
|
|
void riscv_cpu_list(void)
|
2018-03-08 23:12:31 +01:00
|
|
|
{
|
|
|
|
GSList *list;
|
|
|
|
|
|
|
|
list = object_class_get_list(TYPE_RISCV_CPU, false);
|
|
|
|
list = g_slist_sort(list, riscv_cpu_list_compare);
|
2019-04-17 21:17:57 +02:00
|
|
|
g_slist_foreach(list, riscv_cpu_list_entry, NULL);
|
2018-03-08 23:12:31 +01:00
|
|
|
g_slist_free(list);
|
2018-03-02 13:31:10 +01:00
|
|
|
}
|
|
|
|
|
2018-03-08 23:12:31 +01:00
|
|
|
#define DEFINE_CPU(type_name, initfn) \
|
|
|
|
{ \
|
|
|
|
.name = type_name, \
|
|
|
|
.parent = TYPE_RISCV_CPU, \
|
|
|
|
.instance_init = initfn \
|
|
|
|
}
|
|
|
|
|
|
|
|
static const TypeInfo riscv_cpu_type_infos[] = {
|
|
|
|
{
|
|
|
|
.name = TYPE_RISCV_CPU,
|
|
|
|
.parent = TYPE_CPU,
|
|
|
|
.instance_size = sizeof(RISCVCPU),
|
2020-09-16 02:46:37 +02:00
|
|
|
.instance_align = __alignof__(RISCVCPU),
|
2018-03-08 23:12:31 +01:00
|
|
|
.instance_init = riscv_cpu_init,
|
|
|
|
.abstract = true,
|
|
|
|
.class_size = sizeof(RISCVCPUClass),
|
|
|
|
.class_init = riscv_cpu_class_init,
|
|
|
|
},
|
|
|
|
DEFINE_CPU(TYPE_RISCV_CPU_ANY, riscv_any_cpu_init),
|
2022-01-12 09:13:25 +01:00
|
|
|
#if defined(CONFIG_KVM)
|
|
|
|
DEFINE_CPU(TYPE_RISCV_CPU_HOST, riscv_host_cpu_init),
|
|
|
|
#endif
|
2018-03-08 23:12:31 +01:00
|
|
|
#if defined(TARGET_RISCV32)
|
2020-12-16 19:23:05 +01:00
|
|
|
DEFINE_CPU(TYPE_RISCV_CPU_BASE32, rv32_base_cpu_init),
|
2020-06-16 02:50:37 +02:00
|
|
|
DEFINE_CPU(TYPE_RISCV_CPU_IBEX, rv32_ibex_cpu_init),
|
2020-12-16 19:22:54 +01:00
|
|
|
DEFINE_CPU(TYPE_RISCV_CPU_SIFIVE_E31, rv32_sifive_e_cpu_init),
|
2020-06-11 03:08:49 +02:00
|
|
|
DEFINE_CPU(TYPE_RISCV_CPU_SIFIVE_E34, rv32_imafcu_nommu_cpu_init),
|
2020-12-16 19:22:54 +01:00
|
|
|
DEFINE_CPU(TYPE_RISCV_CPU_SIFIVE_U34, rv32_sifive_u_cpu_init),
|
2018-03-08 23:12:31 +01:00
|
|
|
#elif defined(TARGET_RISCV64)
|
2020-12-16 19:23:05 +01:00
|
|
|
DEFINE_CPU(TYPE_RISCV_CPU_BASE64, rv64_base_cpu_init),
|
2020-12-16 19:22:54 +01:00
|
|
|
DEFINE_CPU(TYPE_RISCV_CPU_SIFIVE_E51, rv64_sifive_e_cpu_init),
|
|
|
|
DEFINE_CPU(TYPE_RISCV_CPU_SIFIVE_U54, rv64_sifive_u_cpu_init),
|
2021-04-01 20:14:54 +02:00
|
|
|
DEFINE_CPU(TYPE_RISCV_CPU_SHAKTI_C, rv64_sifive_u_cpu_init),
|
2022-01-06 22:00:57 +01:00
|
|
|
DEFINE_CPU(TYPE_RISCV_CPU_BASE128, rv128_base_cpu_init),
|
2018-03-08 23:12:31 +01:00
|
|
|
#endif
|
|
|
|
};
|
|
|
|
|
|
|
|
DEFINE_TYPES(riscv_cpu_type_infos)
|