4 * Copyright (c) 2016-2017 Sagar Karandikar, sagark@eecs.berkeley.edu
5 * Copyright (c) 2017-2018 SiFive, Inc.
7 * This program is free software; you can redistribute it and/or modify it
8 * under the terms and conditions of the GNU General Public License,
9 * version 2 or later, as published by the Free Software Foundation.
11 * This program is distributed in the hope it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
16 * You should have received a copy of the GNU General Public License along with
17 * this program. If not, see <http://www.gnu.org/licenses/>.
23 #include "hw/core/cpu.h"
24 #include "hw/registerfields.h"
25 #include "exec/cpu-defs.h"
26 #include "fpu/softfloat-types.h"
27 #include "qom/object.h"
29 #define TCG_GUEST_DEFAULT_MO 0
31 #define TYPE_RISCV_CPU "riscv-cpu"
33 #define RISCV_CPU_TYPE_SUFFIX "-" TYPE_RISCV_CPU
34 #define RISCV_CPU_TYPE_NAME(name) (name RISCV_CPU_TYPE_SUFFIX)
35 #define CPU_RESOLVING_TYPE TYPE_RISCV_CPU
37 #define TYPE_RISCV_CPU_ANY RISCV_CPU_TYPE_NAME("any")
38 #define TYPE_RISCV_CPU_BASE32 RISCV_CPU_TYPE_NAME("rv32")
39 #define TYPE_RISCV_CPU_BASE64 RISCV_CPU_TYPE_NAME("rv64")
40 #define TYPE_RISCV_CPU_IBEX RISCV_CPU_TYPE_NAME("lowrisc-ibex")
41 #define TYPE_RISCV_CPU_SHAKTI_C RISCV_CPU_TYPE_NAME("shakti-c")
42 #define TYPE_RISCV_CPU_SIFIVE_E31 RISCV_CPU_TYPE_NAME("sifive-e31")
43 #define TYPE_RISCV_CPU_SIFIVE_E34 RISCV_CPU_TYPE_NAME("sifive-e34")
44 #define TYPE_RISCV_CPU_SIFIVE_E51 RISCV_CPU_TYPE_NAME("sifive-e51")
45 #define TYPE_RISCV_CPU_SIFIVE_U34 RISCV_CPU_TYPE_NAME("sifive-u34")
46 #define TYPE_RISCV_CPU_SIFIVE_U54 RISCV_CPU_TYPE_NAME("sifive-u54")
48 #if defined(TARGET_RISCV32)
49 # define TYPE_RISCV_CPU_BASE TYPE_RISCV_CPU_BASE32
50 #elif defined(TARGET_RISCV64)
51 # define TYPE_RISCV_CPU_BASE TYPE_RISCV_CPU_BASE64
54 #define RV32 ((target_ulong)1 << (TARGET_LONG_BITS - 2))
55 #define RV64 ((target_ulong)2 << (TARGET_LONG_BITS - 2))
57 #if defined(TARGET_RISCV32)
59 #elif defined(TARGET_RISCV64)
63 #define RV(x) ((target_ulong)1 << (x - 'A'))
66 #define RVE RV('E') /* E and I are mutually exclusive */
77 /* S extension denotes that Supervisor mode exists, however it is possible
78 to have a core that support S mode but does not have an MMU and there
79 is currently no bit in misa to indicate whether an MMU exists or not
80 so a cpu features bitfield is required, likewise for optional PMP support */
87 #define PRIV_VERSION_1_10_0 0x00011000
88 #define PRIV_VERSION_1_11_0 0x00011100
90 #define VEXT_VERSION_0_07_1 0x00000701
96 TRANSLATE_G_STAGE_FAIL
99 #define MMU_USER_IDX 3
101 #define MAX_RISCV_PMPS (16)
103 typedef struct CPURISCVState CPURISCVState
;
107 #define RV_VLEN_MAX 256
109 FIELD(VTYPE
, VLMUL
, 0, 2)
110 FIELD(VTYPE
, VSEW
, 2, 3)
111 FIELD(VTYPE
, VEDIV
, 5, 2)
112 FIELD(VTYPE
, RESERVED
, 7, sizeof(target_ulong
) * 8 - 9)
113 FIELD(VTYPE
, VILL
, sizeof(target_ulong
) * 8 - 1, 1)
115 struct CPURISCVState
{
116 target_ulong gpr
[32];
117 uint64_t fpr
[32]; /* assume both F and D extensions */
119 /* vector coprocessor state. */
120 uint64_t vreg
[32 * RV_VLEN_MAX
/ 64] QEMU_ALIGNED(16);
128 target_ulong load_res
;
129 target_ulong load_val
;
133 target_ulong badaddr
;
134 target_ulong guest_phys_fault_addr
;
136 target_ulong priv_ver
;
137 target_ulong vext_ver
;
139 target_ulong misa_mask
;
143 #ifdef CONFIG_USER_ONLY
147 #ifndef CONFIG_USER_ONLY
149 /* This contains QEMU specific information about the virt state. */
151 target_ulong resetvec
;
153 target_ulong mhartid
;
155 * For RV32 this is 32-bit mstatus and 32-bit mstatush.
156 * For RV64 this is a 64-bit mstatus.
165 target_ulong mideleg
;
167 target_ulong satp
; /* since: priv-1.10.0 */
169 target_ulong medeleg
;
178 target_ulong mtval
; /* since: priv-1.10.0 */
180 /* Hypervisor CSRs */
181 target_ulong hstatus
;
182 target_ulong hedeleg
;
183 target_ulong hideleg
;
184 target_ulong hcounteren
;
192 * For RV32 this is 32-bit vsstatus and 32-bit vsstatush.
193 * For RV64 this is a 64-bit vsstatus.
197 target_ulong vsscratch
;
199 target_ulong vscause
;
207 target_ulong stvec_hs
;
208 target_ulong sscratch_hs
;
209 target_ulong sepc_hs
;
210 target_ulong scause_hs
;
211 target_ulong stval_hs
;
212 target_ulong satp_hs
;
215 /* Signals whether the current exception occurred with two-stage address
216 translation active. */
217 bool two_stage_lookup
;
219 target_ulong scounteren
;
220 target_ulong mcounteren
;
222 target_ulong sscratch
;
223 target_ulong mscratch
;
225 /* temporary htif regs */
230 /* physical memory protection */
231 pmp_table_t pmp_state
;
233 /* machine specific rdtime callback */
234 uint64_t (*rdtime_fn
)(uint32_t);
235 uint32_t rdtime_fn_arg
;
237 /* True if in debugger mode. */
241 float_status fp_status
;
243 /* Fields from here on are preserved across CPU reset. */
244 QEMUTimer
*timer
; /* Internal timer */
247 OBJECT_DECLARE_TYPE(RISCVCPU
, RISCVCPUClass
,
252 * @parent_realize: The parent class' realize handler.
253 * @parent_reset: The parent class' reset handler.
257 struct RISCVCPUClass
{
259 CPUClass parent_class
;
261 DeviceRealize parent_realize
;
262 DeviceReset parent_reset
;
267 * @env: #CPURISCVState
275 CPUNegativeOffsetState neg
;
280 /* Configuration Settings */
309 static inline int riscv_has_ext(CPURISCVState
*env
, target_ulong ext
)
311 return (env
->misa
& ext
) != 0;
314 static inline bool riscv_feature(CPURISCVState
*env
, int feature
)
316 return env
->features
& (1ULL << feature
);
319 #include "cpu_user.h"
320 #include "cpu_bits.h"
322 extern const char * const riscv_int_regnames
[];
323 extern const char * const riscv_fpr_regnames
[];
324 extern const char * const riscv_excp_names
[];
325 extern const char * const riscv_intr_names
[];
327 const char *riscv_cpu_get_trap_name(target_ulong cause
, bool async
);
328 void riscv_cpu_do_interrupt(CPUState
*cpu
);
329 int riscv_cpu_write_elf64_note(WriteCoreDumpFunction f
, CPUState
*cs
,
330 int cpuid
, void *opaque
);
331 int riscv_cpu_write_elf32_note(WriteCoreDumpFunction f
, CPUState
*cs
,
332 int cpuid
, void *opaque
);
333 int riscv_cpu_gdb_read_register(CPUState
*cpu
, GByteArray
*buf
, int reg
);
334 int riscv_cpu_gdb_write_register(CPUState
*cpu
, uint8_t *buf
, int reg
);
335 bool riscv_cpu_exec_interrupt(CPUState
*cs
, int interrupt_request
);
336 bool riscv_cpu_fp_enabled(CPURISCVState
*env
);
337 bool riscv_cpu_virt_enabled(CPURISCVState
*env
);
338 void riscv_cpu_set_virt_enabled(CPURISCVState
*env
, bool enable
);
339 bool riscv_cpu_force_hs_excep_enabled(CPURISCVState
*env
);
340 void riscv_cpu_set_force_hs_excep(CPURISCVState
*env
, bool enable
);
341 bool riscv_cpu_two_stage_lookup(int mmu_idx
);
342 int riscv_cpu_mmu_index(CPURISCVState
*env
, bool ifetch
);
343 hwaddr
riscv_cpu_get_phys_page_debug(CPUState
*cpu
, vaddr addr
);
344 void riscv_cpu_do_unaligned_access(CPUState
*cs
, vaddr addr
,
345 MMUAccessType access_type
, int mmu_idx
,
347 bool riscv_cpu_tlb_fill(CPUState
*cs
, vaddr address
, int size
,
348 MMUAccessType access_type
, int mmu_idx
,
349 bool probe
, uintptr_t retaddr
);
350 void riscv_cpu_do_transaction_failed(CPUState
*cs
, hwaddr physaddr
,
351 vaddr addr
, unsigned size
,
352 MMUAccessType access_type
,
353 int mmu_idx
, MemTxAttrs attrs
,
354 MemTxResult response
, uintptr_t retaddr
);
355 char *riscv_isa_string(RISCVCPU
*cpu
);
356 void riscv_cpu_list(void);
358 #define cpu_signal_handler riscv_cpu_signal_handler
359 #define cpu_list riscv_cpu_list
360 #define cpu_mmu_index riscv_cpu_mmu_index
362 #ifndef CONFIG_USER_ONLY
363 void riscv_cpu_swap_hypervisor_regs(CPURISCVState
*env
);
364 int riscv_cpu_claim_interrupts(RISCVCPU
*cpu
, uint32_t interrupts
);
365 uint32_t riscv_cpu_update_mip(RISCVCPU
*cpu
, uint32_t mask
, uint32_t value
);
366 #define BOOL_TO_MASK(x) (-!!(x)) /* helper for riscv_cpu_update_mip value */
367 void riscv_cpu_set_rdtime_fn(CPURISCVState
*env
, uint64_t (*fn
)(uint32_t),
370 void riscv_cpu_set_mode(CPURISCVState
*env
, target_ulong newpriv
);
372 void riscv_translate_init(void);
373 int riscv_cpu_signal_handler(int host_signum
, void *pinfo
, void *puc
);
374 void QEMU_NORETURN
riscv_raise_exception(CPURISCVState
*env
,
375 uint32_t exception
, uintptr_t pc
);
377 target_ulong
riscv_cpu_get_fflags(CPURISCVState
*env
);
378 void riscv_cpu_set_fflags(CPURISCVState
*env
, target_ulong
);
380 #define TB_FLAGS_MMU_MASK 7
381 #define TB_FLAGS_PRIV_MMU_MASK 3
382 #define TB_FLAGS_PRIV_HYP_ACCESS_MASK (1 << 2)
383 #define TB_FLAGS_MSTATUS_FS MSTATUS_FS
385 typedef CPURISCVState CPUArchState
;
386 typedef RISCVCPU ArchCPU
;
387 #include "exec/cpu-all.h"
389 FIELD(TB_FLAGS
, VL_EQ_VLMAX
, 2, 1)
390 FIELD(TB_FLAGS
, LMUL
, 3, 2)
391 FIELD(TB_FLAGS
, SEW
, 5, 3)
392 FIELD(TB_FLAGS
, VILL
, 8, 1)
393 /* Is a Hypervisor instruction load/store allowed? */
394 FIELD(TB_FLAGS
, HLSX
, 9, 1)
396 bool riscv_cpu_is_32bit(CPURISCVState
*env
);
399 * A simplification for VLMAX
400 * = (1 << LMUL) * VLEN / (8 * (1 << SEW))
401 * = (VLEN << LMUL) / (8 << SEW)
402 * = (VLEN << LMUL) >> (SEW + 3)
403 * = VLEN >> (SEW + 3 - LMUL)
405 static inline uint32_t vext_get_vlmax(RISCVCPU
*cpu
, target_ulong vtype
)
409 sew
= FIELD_EX64(vtype
, VTYPE
, VSEW
);
410 lmul
= FIELD_EX64(vtype
, VTYPE
, VLMUL
);
411 return cpu
->cfg
.vlen
>> (sew
+ 3 - lmul
);
414 static inline void cpu_get_tb_cpu_state(CPURISCVState
*env
, target_ulong
*pc
,
415 target_ulong
*cs_base
, uint32_t *pflags
)
422 if (riscv_has_ext(env
, RVV
)) {
423 uint32_t vlmax
= vext_get_vlmax(env_archcpu(env
), env
->vtype
);
424 bool vl_eq_vlmax
= (env
->vstart
== 0) && (vlmax
== env
->vl
);
425 flags
= FIELD_DP32(flags
, TB_FLAGS
, VILL
,
426 FIELD_EX64(env
->vtype
, VTYPE
, VILL
));
427 flags
= FIELD_DP32(flags
, TB_FLAGS
, SEW
,
428 FIELD_EX64(env
->vtype
, VTYPE
, VSEW
));
429 flags
= FIELD_DP32(flags
, TB_FLAGS
, LMUL
,
430 FIELD_EX64(env
->vtype
, VTYPE
, VLMUL
));
431 flags
= FIELD_DP32(flags
, TB_FLAGS
, VL_EQ_VLMAX
, vl_eq_vlmax
);
433 flags
= FIELD_DP32(flags
, TB_FLAGS
, VILL
, 1);
436 #ifdef CONFIG_USER_ONLY
437 flags
|= TB_FLAGS_MSTATUS_FS
;
439 flags
|= cpu_mmu_index(env
, 0);
440 if (riscv_cpu_fp_enabled(env
)) {
441 flags
|= env
->mstatus
& MSTATUS_FS
;
444 if (riscv_has_ext(env
, RVH
)) {
445 if (env
->priv
== PRV_M
||
446 (env
->priv
== PRV_S
&& !riscv_cpu_virt_enabled(env
)) ||
447 (env
->priv
== PRV_U
&& !riscv_cpu_virt_enabled(env
) &&
448 get_field(env
->hstatus
, HSTATUS_HU
))) {
449 flags
= FIELD_DP32(flags
, TB_FLAGS
, HLSX
, 1);
457 int riscv_csrrw(CPURISCVState
*env
, int csrno
, target_ulong
*ret_value
,
458 target_ulong new_value
, target_ulong write_mask
);
459 int riscv_csrrw_debug(CPURISCVState
*env
, int csrno
, target_ulong
*ret_value
,
460 target_ulong new_value
, target_ulong write_mask
);
462 static inline void riscv_csr_write(CPURISCVState
*env
, int csrno
,
465 riscv_csrrw(env
, csrno
, NULL
, val
, MAKE_64BIT_MASK(0, TARGET_LONG_BITS
));
468 static inline target_ulong
riscv_csr_read(CPURISCVState
*env
, int csrno
)
470 target_ulong val
= 0;
471 riscv_csrrw(env
, csrno
, &val
, 0, 0);
475 typedef RISCVException (*riscv_csr_predicate_fn
)(CPURISCVState
*env
,
477 typedef int (*riscv_csr_read_fn
)(CPURISCVState
*env
, int csrno
,
478 target_ulong
*ret_value
);
479 typedef int (*riscv_csr_write_fn
)(CPURISCVState
*env
, int csrno
,
480 target_ulong new_value
);
481 typedef int (*riscv_csr_op_fn
)(CPURISCVState
*env
, int csrno
,
482 target_ulong
*ret_value
, target_ulong new_value
, target_ulong write_mask
);
486 riscv_csr_predicate_fn predicate
;
487 riscv_csr_read_fn read
;
488 riscv_csr_write_fn write
;
490 } riscv_csr_operations
;
492 /* CSR function table constants */
494 CSR_TABLE_SIZE
= 0x1000
497 /* CSR function table */
498 extern riscv_csr_operations csr_ops
[CSR_TABLE_SIZE
];
500 void riscv_get_csr_ops(int csrno
, riscv_csr_operations
*ops
);
501 void riscv_set_csr_ops(int csrno
, riscv_csr_operations
*ops
);
503 void riscv_cpu_register_gdb_regs_for_features(CPUState
*cs
);
505 #endif /* RISCV_CPU_H */