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"
30 #define TCG_GUEST_DEFAULT_MO 0
32 #define TYPE_RISCV_CPU "riscv-cpu"
34 #define RISCV_CPU_TYPE_SUFFIX "-" TYPE_RISCV_CPU
35 #define RISCV_CPU_TYPE_NAME(name) (name RISCV_CPU_TYPE_SUFFIX)
36 #define CPU_RESOLVING_TYPE TYPE_RISCV_CPU
38 #define TYPE_RISCV_CPU_ANY RISCV_CPU_TYPE_NAME("any")
39 #define TYPE_RISCV_CPU_BASE32 RISCV_CPU_TYPE_NAME("rv32")
40 #define TYPE_RISCV_CPU_BASE64 RISCV_CPU_TYPE_NAME("rv64")
41 #define TYPE_RISCV_CPU_IBEX RISCV_CPU_TYPE_NAME("lowrisc-ibex")
42 #define TYPE_RISCV_CPU_SHAKTI_C RISCV_CPU_TYPE_NAME("shakti-c")
43 #define TYPE_RISCV_CPU_SIFIVE_E31 RISCV_CPU_TYPE_NAME("sifive-e31")
44 #define TYPE_RISCV_CPU_SIFIVE_E34 RISCV_CPU_TYPE_NAME("sifive-e34")
45 #define TYPE_RISCV_CPU_SIFIVE_E51 RISCV_CPU_TYPE_NAME("sifive-e51")
46 #define TYPE_RISCV_CPU_SIFIVE_U34 RISCV_CPU_TYPE_NAME("sifive-u34")
47 #define TYPE_RISCV_CPU_SIFIVE_U54 RISCV_CPU_TYPE_NAME("sifive-u54")
49 #if defined(TARGET_RISCV32)
50 # define TYPE_RISCV_CPU_BASE TYPE_RISCV_CPU_BASE32
51 #elif defined(TARGET_RISCV64)
52 # define TYPE_RISCV_CPU_BASE TYPE_RISCV_CPU_BASE64
55 #define RV(x) ((target_ulong)1 << (x - 'A'))
58 #define RVE RV('E') /* E and I are mutually exclusive */
70 /* S extension denotes that Supervisor mode exists, however it is possible
71 to have a core that support S mode but does not have an MMU and there
72 is currently no bit in misa to indicate whether an MMU exists or not
73 so a cpu features bitfield is required, likewise for optional PMP support */
81 #define PRIV_VERSION_1_10_0 0x00011000
82 #define PRIV_VERSION_1_11_0 0x00011100
84 #define VEXT_VERSION_1_00_0 0x00010000
90 TRANSLATE_G_STAGE_FAIL
93 #define MMU_USER_IDX 3
95 #define MAX_RISCV_PMPS (16)
97 typedef struct CPURISCVState CPURISCVState
;
99 #if !defined(CONFIG_USER_ONLY)
103 #define RV_VLEN_MAX 1024
105 FIELD(VTYPE
, VLMUL
, 0, 3)
106 FIELD(VTYPE
, VSEW
, 3, 3)
107 FIELD(VTYPE
, VTA
, 6, 1)
108 FIELD(VTYPE
, VMA
, 7, 1)
109 FIELD(VTYPE
, VEDIV
, 8, 2)
110 FIELD(VTYPE
, RESERVED
, 10, sizeof(target_ulong
) * 8 - 11)
111 FIELD(VTYPE
, VILL
, sizeof(target_ulong
) * 8 - 1, 1)
113 struct CPURISCVState
{
114 target_ulong gpr
[32];
115 uint64_t fpr
[32]; /* assume both F and D extensions */
117 /* vector coprocessor state. */
118 uint64_t vreg
[32 * RV_VLEN_MAX
/ 64] QEMU_ALIGNED(16);
126 target_ulong load_res
;
127 target_ulong load_val
;
131 target_ulong badaddr
;
132 target_ulong guest_phys_fault_addr
;
134 target_ulong priv_ver
;
135 target_ulong bext_ver
;
136 target_ulong vext_ver
;
138 /* RISCVMXL, but uint32_t for vmstate migration */
139 uint32_t misa_mxl
; /* current mxl */
140 uint32_t misa_mxl_max
; /* max mxl for this cpu */
141 uint32_t misa_ext
; /* current extensions */
142 uint32_t misa_ext_mask
; /* max ext for this cpu */
146 #ifdef CONFIG_USER_ONLY
150 #ifndef CONFIG_USER_ONLY
152 /* This contains QEMU specific information about the virt state. */
154 target_ulong resetvec
;
156 target_ulong mhartid
;
158 * For RV32 this is 32-bit mstatus and 32-bit mstatush.
159 * For RV64 this is a 64-bit mstatus.
168 target_ulong mideleg
;
170 target_ulong satp
; /* since: priv-1.10.0 */
172 target_ulong medeleg
;
181 target_ulong mtval
; /* since: priv-1.10.0 */
183 /* Hypervisor CSRs */
184 target_ulong hstatus
;
185 target_ulong hedeleg
;
186 target_ulong hideleg
;
187 target_ulong hcounteren
;
195 * For RV32 this is 32-bit vsstatus and 32-bit vsstatush.
196 * For RV64 this is a 64-bit vsstatus.
200 target_ulong vsscratch
;
202 target_ulong vscause
;
210 target_ulong stvec_hs
;
211 target_ulong sscratch_hs
;
212 target_ulong sepc_hs
;
213 target_ulong scause_hs
;
214 target_ulong stval_hs
;
215 target_ulong satp_hs
;
218 /* Signals whether the current exception occurred with two-stage address
219 translation active. */
220 bool two_stage_lookup
;
222 target_ulong scounteren
;
223 target_ulong mcounteren
;
225 target_ulong sscratch
;
226 target_ulong mscratch
;
228 /* temporary htif regs */
233 /* physical memory protection */
234 pmp_table_t pmp_state
;
235 target_ulong mseccfg
;
237 /* machine specific rdtime callback */
238 uint64_t (*rdtime_fn
)(uint32_t);
239 uint32_t rdtime_fn_arg
;
241 /* True if in debugger mode. */
245 * CSRs for PointerMasking extension
248 target_ulong mpmmask
;
249 target_ulong mpmbase
;
250 target_ulong spmmask
;
251 target_ulong spmbase
;
252 target_ulong upmmask
;
253 target_ulong upmbase
;
256 float_status fp_status
;
258 /* Fields from here on are preserved across CPU reset. */
259 QEMUTimer
*timer
; /* Internal timer */
262 OBJECT_DECLARE_TYPE(RISCVCPU
, RISCVCPUClass
,
267 * @parent_realize: The parent class' realize handler.
268 * @parent_reset: The parent class' reset handler.
272 struct RISCVCPUClass
{
274 CPUClass parent_class
;
276 DeviceRealize parent_realize
;
277 DeviceReset parent_reset
;
282 * @env: #CPURISCVState
290 CPUNegativeOffsetState neg
;
295 /* Configuration Settings */
333 static inline int riscv_has_ext(CPURISCVState
*env
, target_ulong ext
)
335 return (env
->misa_ext
& ext
) != 0;
338 static inline bool riscv_feature(CPURISCVState
*env
, int feature
)
340 return env
->features
& (1ULL << feature
);
343 #include "cpu_user.h"
345 extern const char * const riscv_int_regnames
[];
346 extern const char * const riscv_fpr_regnames
[];
348 const char *riscv_cpu_get_trap_name(target_ulong cause
, bool async
);
349 void riscv_cpu_do_interrupt(CPUState
*cpu
);
350 int riscv_cpu_write_elf64_note(WriteCoreDumpFunction f
, CPUState
*cs
,
351 int cpuid
, void *opaque
);
352 int riscv_cpu_write_elf32_note(WriteCoreDumpFunction f
, CPUState
*cs
,
353 int cpuid
, void *opaque
);
354 int riscv_cpu_gdb_read_register(CPUState
*cpu
, GByteArray
*buf
, int reg
);
355 int riscv_cpu_gdb_write_register(CPUState
*cpu
, uint8_t *buf
, int reg
);
356 bool riscv_cpu_fp_enabled(CPURISCVState
*env
);
357 bool riscv_cpu_vector_enabled(CPURISCVState
*env
);
358 bool riscv_cpu_virt_enabled(CPURISCVState
*env
);
359 void riscv_cpu_set_virt_enabled(CPURISCVState
*env
, bool enable
);
360 bool riscv_cpu_two_stage_lookup(int mmu_idx
);
361 int riscv_cpu_mmu_index(CPURISCVState
*env
, bool ifetch
);
362 hwaddr
riscv_cpu_get_phys_page_debug(CPUState
*cpu
, vaddr addr
);
363 void riscv_cpu_do_unaligned_access(CPUState
*cs
, vaddr addr
,
364 MMUAccessType access_type
, int mmu_idx
,
365 uintptr_t retaddr
) QEMU_NORETURN
;
366 bool riscv_cpu_tlb_fill(CPUState
*cs
, vaddr address
, int size
,
367 MMUAccessType access_type
, int mmu_idx
,
368 bool probe
, uintptr_t retaddr
);
369 void riscv_cpu_do_transaction_failed(CPUState
*cs
, hwaddr physaddr
,
370 vaddr addr
, unsigned size
,
371 MMUAccessType access_type
,
372 int mmu_idx
, MemTxAttrs attrs
,
373 MemTxResult response
, uintptr_t retaddr
);
374 char *riscv_isa_string(RISCVCPU
*cpu
);
375 void riscv_cpu_list(void);
377 #define cpu_list riscv_cpu_list
378 #define cpu_mmu_index riscv_cpu_mmu_index
380 #ifndef CONFIG_USER_ONLY
381 bool riscv_cpu_exec_interrupt(CPUState
*cs
, int interrupt_request
);
382 void riscv_cpu_swap_hypervisor_regs(CPURISCVState
*env
);
383 int riscv_cpu_claim_interrupts(RISCVCPU
*cpu
, uint32_t interrupts
);
384 uint32_t riscv_cpu_update_mip(RISCVCPU
*cpu
, uint32_t mask
, uint32_t value
);
385 #define BOOL_TO_MASK(x) (-!!(x)) /* helper for riscv_cpu_update_mip value */
386 void riscv_cpu_set_rdtime_fn(CPURISCVState
*env
, uint64_t (*fn
)(uint32_t),
389 void riscv_cpu_set_mode(CPURISCVState
*env
, target_ulong newpriv
);
391 void riscv_translate_init(void);
392 void QEMU_NORETURN
riscv_raise_exception(CPURISCVState
*env
,
393 uint32_t exception
, uintptr_t pc
);
395 target_ulong
riscv_cpu_get_fflags(CPURISCVState
*env
);
396 void riscv_cpu_set_fflags(CPURISCVState
*env
, target_ulong
);
398 #define TB_FLAGS_PRIV_MMU_MASK 3
399 #define TB_FLAGS_PRIV_HYP_ACCESS_MASK (1 << 2)
400 #define TB_FLAGS_MSTATUS_FS MSTATUS_FS
401 #define TB_FLAGS_MSTATUS_VS MSTATUS_VS
403 typedef CPURISCVState CPUArchState
;
404 typedef RISCVCPU ArchCPU
;
405 #include "exec/cpu-all.h"
407 FIELD(TB_FLAGS
, MEM_IDX
, 0, 3)
408 FIELD(TB_FLAGS
, LMUL
, 3, 3)
409 FIELD(TB_FLAGS
, SEW
, 6, 3)
410 /* Skip MSTATUS_VS (0x600) bits */
411 FIELD(TB_FLAGS
, VL_EQ_VLMAX
, 11, 1)
412 FIELD(TB_FLAGS
, VILL
, 12, 1)
413 /* Skip MSTATUS_FS (0x6000) bits */
414 /* Is a Hypervisor instruction load/store allowed? */
415 FIELD(TB_FLAGS
, HLSX
, 15, 1)
416 FIELD(TB_FLAGS
, MSTATUS_HS_FS
, 16, 2)
417 FIELD(TB_FLAGS
, MSTATUS_HS_VS
, 18, 2)
418 /* The combination of MXL/SXL/UXL that applies to the current cpu mode. */
419 FIELD(TB_FLAGS
, XL
, 20, 2)
420 /* If PointerMasking should be applied */
421 FIELD(TB_FLAGS
, PM_ENABLED
, 22, 1)
423 #ifdef TARGET_RISCV32
424 #define riscv_cpu_mxl(env) ((void)(env), MXL_RV32)
426 static inline RISCVMXL
riscv_cpu_mxl(CPURISCVState
*env
)
428 return env
->misa_mxl
;
433 * Encode LMUL to lmul as follows:
444 * then, we can calculate VLMAX = vlen >> (vsew + 3 - lmul)
445 * e.g. vlen = 256 bits, SEW = 16, LMUL = 1/8
446 * => VLMAX = vlen >> (1 + 3 - (-3))
450 static inline uint32_t vext_get_vlmax(RISCVCPU
*cpu
, target_ulong vtype
)
452 uint8_t sew
= FIELD_EX64(vtype
, VTYPE
, VSEW
);
453 int8_t lmul
= sextract32(FIELD_EX64(vtype
, VTYPE
, VLMUL
), 0, 3);
454 return cpu
->cfg
.vlen
>> (sew
+ 3 - lmul
);
457 void cpu_get_tb_cpu_state(CPURISCVState
*env
, target_ulong
*pc
,
458 target_ulong
*cs_base
, uint32_t *pflags
);
460 RISCVException
riscv_csrrw(CPURISCVState
*env
, int csrno
,
461 target_ulong
*ret_value
,
462 target_ulong new_value
, target_ulong write_mask
);
463 RISCVException
riscv_csrrw_debug(CPURISCVState
*env
, int csrno
,
464 target_ulong
*ret_value
,
465 target_ulong new_value
,
466 target_ulong write_mask
);
468 static inline void riscv_csr_write(CPURISCVState
*env
, int csrno
,
471 riscv_csrrw(env
, csrno
, NULL
, val
, MAKE_64BIT_MASK(0, TARGET_LONG_BITS
));
474 static inline target_ulong
riscv_csr_read(CPURISCVState
*env
, int csrno
)
476 target_ulong val
= 0;
477 riscv_csrrw(env
, csrno
, &val
, 0, 0);
481 typedef RISCVException (*riscv_csr_predicate_fn
)(CPURISCVState
*env
,
483 typedef RISCVException (*riscv_csr_read_fn
)(CPURISCVState
*env
, int csrno
,
484 target_ulong
*ret_value
);
485 typedef RISCVException (*riscv_csr_write_fn
)(CPURISCVState
*env
, int csrno
,
486 target_ulong new_value
);
487 typedef RISCVException (*riscv_csr_op_fn
)(CPURISCVState
*env
, int csrno
,
488 target_ulong
*ret_value
,
489 target_ulong new_value
,
490 target_ulong write_mask
);
494 riscv_csr_predicate_fn predicate
;
495 riscv_csr_read_fn read
;
496 riscv_csr_write_fn write
;
498 } riscv_csr_operations
;
500 /* CSR function table constants */
502 CSR_TABLE_SIZE
= 0x1000
505 /* CSR function table */
506 extern riscv_csr_operations csr_ops
[CSR_TABLE_SIZE
];
508 void riscv_get_csr_ops(int csrno
, riscv_csr_operations
*ops
);
509 void riscv_set_csr_ops(int csrno
, riscv_csr_operations
*ops
);
511 void riscv_cpu_register_gdb_regs_for_features(CPUState
*cs
);
513 #endif /* RISCV_CPU_H */