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 "exec/cpu-defs.h"
25 #include "fpu/softfloat-types.h"
27 #define TCG_GUEST_DEFAULT_MO 0
29 #define TYPE_RISCV_CPU "riscv-cpu"
31 #define RISCV_CPU_TYPE_SUFFIX "-" TYPE_RISCV_CPU
32 #define RISCV_CPU_TYPE_NAME(name) (name RISCV_CPU_TYPE_SUFFIX)
33 #define CPU_RESOLVING_TYPE TYPE_RISCV_CPU
35 #define TYPE_RISCV_CPU_ANY RISCV_CPU_TYPE_NAME("any")
36 #define TYPE_RISCV_CPU_BASE32 RISCV_CPU_TYPE_NAME("rv32")
37 #define TYPE_RISCV_CPU_BASE64 RISCV_CPU_TYPE_NAME("rv64")
38 #define TYPE_RISCV_CPU_SIFIVE_E31 RISCV_CPU_TYPE_NAME("sifive-e31")
39 #define TYPE_RISCV_CPU_SIFIVE_E34 RISCV_CPU_TYPE_NAME("sifive-e34")
40 #define TYPE_RISCV_CPU_SIFIVE_E51 RISCV_CPU_TYPE_NAME("sifive-e51")
41 #define TYPE_RISCV_CPU_SIFIVE_U34 RISCV_CPU_TYPE_NAME("sifive-u34")
42 #define TYPE_RISCV_CPU_SIFIVE_U54 RISCV_CPU_TYPE_NAME("sifive-u54")
44 #define TYPE_RISCV_CPU_RV32IMACU_NOMMU RISCV_CPU_TYPE_NAME("rv32imacu-nommu")
45 #define TYPE_RISCV_CPU_RV32GCSU_V1_09_1 RISCV_CPU_TYPE_NAME("rv32gcsu-v1.9.1")
46 #define TYPE_RISCV_CPU_RV32GCSU_V1_10_0 RISCV_CPU_TYPE_NAME("rv32gcsu-v1.10.0")
47 #define TYPE_RISCV_CPU_RV64IMACU_NOMMU RISCV_CPU_TYPE_NAME("rv64imacu-nommu")
48 #define TYPE_RISCV_CPU_RV64GCSU_V1_09_1 RISCV_CPU_TYPE_NAME("rv64gcsu-v1.9.1")
49 #define TYPE_RISCV_CPU_RV64GCSU_V1_10_0 RISCV_CPU_TYPE_NAME("rv64gcsu-v1.10.0")
51 #define RV32 ((target_ulong)1 << (TARGET_LONG_BITS - 2))
52 #define RV64 ((target_ulong)2 << (TARGET_LONG_BITS - 2))
54 #if defined(TARGET_RISCV32)
56 #elif defined(TARGET_RISCV64)
60 #define RV(x) ((target_ulong)1 << (x - 'A'))
63 #define RVE RV('E') /* E and I are mutually exclusive */
73 /* S extension denotes that Supervisor mode exists, however it is possible
74 to have a core that support S mode but does not have an MMU and there
75 is currently no bit in misa to indicate whether an MMU exists or not
76 so a cpu features bitfield is required, likewise for optional PMP support */
83 #define PRIV_VERSION_1_09_1 0x00010901
84 #define PRIV_VERSION_1_10_0 0x00011000
85 #define PRIV_VERSION_1_11_0 0x00011100
87 #define TRANSLATE_PMP_FAIL 2
88 #define TRANSLATE_FAIL 1
89 #define TRANSLATE_SUCCESS 0
90 #define MMU_USER_IDX 3
92 #define MAX_RISCV_PMPS (16)
94 typedef struct CPURISCVState CPURISCVState
;
98 struct CPURISCVState
{
100 uint64_t fpr
[32]; /* assume both F and D extensions */
102 target_ulong load_res
;
103 target_ulong load_val
;
107 target_ulong badaddr
;
108 target_ulong guest_phys_fault_addr
;
110 target_ulong priv_ver
;
112 target_ulong misa_mask
;
116 #ifdef CONFIG_USER_ONLY
120 #ifndef CONFIG_USER_ONLY
122 /* This contains QEMU specific information about the virt state. */
124 target_ulong resetvec
;
126 target_ulong mhartid
;
127 target_ulong mstatus
;
131 #ifdef TARGET_RISCV32
132 target_ulong mstatush
;
138 target_ulong mideleg
;
140 target_ulong sptbr
; /* until: priv-1.9.1 */
141 target_ulong satp
; /* since: priv-1.10.0 */
142 target_ulong sbadaddr
;
143 target_ulong mbadaddr
;
144 target_ulong medeleg
;
153 target_ulong mtval
; /* since: priv-1.10.0 */
155 /* Hypervisor CSRs */
156 target_ulong hstatus
;
157 target_ulong hedeleg
;
158 target_ulong hideleg
;
159 target_ulong hcounteren
;
166 target_ulong vsstatus
;
168 target_ulong vsscratch
;
170 target_ulong vscause
;
173 #ifdef TARGET_RISCV32
174 target_ulong vsstatush
;
181 target_ulong stvec_hs
;
182 target_ulong sscratch_hs
;
183 target_ulong sepc_hs
;
184 target_ulong scause_hs
;
185 target_ulong stval_hs
;
186 target_ulong satp_hs
;
187 target_ulong mstatus_hs
;
188 #ifdef TARGET_RISCV32
189 target_ulong mstatush_hs
;
192 target_ulong scounteren
;
193 target_ulong mcounteren
;
195 target_ulong sscratch
;
196 target_ulong mscratch
;
198 /* temporary htif regs */
203 /* physical memory protection */
204 pmp_table_t pmp_state
;
206 /* machine specific rdtime callback */
207 uint64_t (*rdtime_fn
)(void);
209 /* True if in debugger mode. */
213 float_status fp_status
;
215 /* Fields from here on are preserved across CPU reset. */
216 QEMUTimer
*timer
; /* Internal timer */
219 #define RISCV_CPU_CLASS(klass) \
220 OBJECT_CLASS_CHECK(RISCVCPUClass, (klass), TYPE_RISCV_CPU)
221 #define RISCV_CPU(obj) \
222 OBJECT_CHECK(RISCVCPU, (obj), TYPE_RISCV_CPU)
223 #define RISCV_CPU_GET_CLASS(obj) \
224 OBJECT_GET_CLASS(RISCVCPUClass, (obj), TYPE_RISCV_CPU)
228 * @parent_realize: The parent class' realize handler.
229 * @parent_reset: The parent class' reset handler.
233 typedef struct RISCVCPUClass
{
235 CPUClass parent_class
;
237 DeviceRealize parent_realize
;
238 DeviceReset parent_reset
;
243 * @env: #CPURISCVState
247 typedef struct RISCVCPU
{
251 CPUNegativeOffsetState neg
;
254 /* Configuration Settings */
278 static inline int riscv_has_ext(CPURISCVState
*env
, target_ulong ext
)
280 return (env
->misa
& ext
) != 0;
283 static inline bool riscv_feature(CPURISCVState
*env
, int feature
)
285 return env
->features
& (1ULL << feature
);
288 #include "cpu_user.h"
289 #include "cpu_bits.h"
291 extern const char * const riscv_int_regnames
[];
292 extern const char * const riscv_fpr_regnames
[];
293 extern const char * const riscv_excp_names
[];
294 extern const char * const riscv_intr_names
[];
296 void riscv_cpu_do_interrupt(CPUState
*cpu
);
297 int riscv_cpu_gdb_read_register(CPUState
*cpu
, GByteArray
*buf
, int reg
);
298 int riscv_cpu_gdb_write_register(CPUState
*cpu
, uint8_t *buf
, int reg
);
299 bool riscv_cpu_exec_interrupt(CPUState
*cs
, int interrupt_request
);
300 bool riscv_cpu_fp_enabled(CPURISCVState
*env
);
301 bool riscv_cpu_virt_enabled(CPURISCVState
*env
);
302 void riscv_cpu_set_virt_enabled(CPURISCVState
*env
, bool enable
);
303 bool riscv_cpu_force_hs_excep_enabled(CPURISCVState
*env
);
304 void riscv_cpu_set_force_hs_excep(CPURISCVState
*env
, bool enable
);
305 int riscv_cpu_mmu_index(CPURISCVState
*env
, bool ifetch
);
306 hwaddr
riscv_cpu_get_phys_page_debug(CPUState
*cpu
, vaddr addr
);
307 void riscv_cpu_do_unaligned_access(CPUState
*cs
, vaddr addr
,
308 MMUAccessType access_type
, int mmu_idx
,
310 bool riscv_cpu_tlb_fill(CPUState
*cs
, vaddr address
, int size
,
311 MMUAccessType access_type
, int mmu_idx
,
312 bool probe
, uintptr_t retaddr
);
313 void riscv_cpu_do_transaction_failed(CPUState
*cs
, hwaddr physaddr
,
314 vaddr addr
, unsigned size
,
315 MMUAccessType access_type
,
316 int mmu_idx
, MemTxAttrs attrs
,
317 MemTxResult response
, uintptr_t retaddr
);
318 char *riscv_isa_string(RISCVCPU
*cpu
);
319 void riscv_cpu_list(void);
321 #define cpu_signal_handler riscv_cpu_signal_handler
322 #define cpu_list riscv_cpu_list
323 #define cpu_mmu_index riscv_cpu_mmu_index
325 #ifndef CONFIG_USER_ONLY
326 void riscv_cpu_swap_hypervisor_regs(CPURISCVState
*env
);
327 int riscv_cpu_claim_interrupts(RISCVCPU
*cpu
, uint32_t interrupts
);
328 uint32_t riscv_cpu_update_mip(RISCVCPU
*cpu
, uint32_t mask
, uint32_t value
);
329 #define BOOL_TO_MASK(x) (-!!(x)) /* helper for riscv_cpu_update_mip value */
330 void riscv_cpu_set_rdtime_fn(CPURISCVState
*env
, uint64_t (*fn
)(void));
332 void riscv_cpu_set_mode(CPURISCVState
*env
, target_ulong newpriv
);
334 void riscv_translate_init(void);
335 int riscv_cpu_signal_handler(int host_signum
, void *pinfo
, void *puc
);
336 void QEMU_NORETURN
riscv_raise_exception(CPURISCVState
*env
,
337 uint32_t exception
, uintptr_t pc
);
339 target_ulong
riscv_cpu_get_fflags(CPURISCVState
*env
);
340 void riscv_cpu_set_fflags(CPURISCVState
*env
, target_ulong
);
342 #define TB_FLAGS_MMU_MASK 3
343 #define TB_FLAGS_MSTATUS_FS MSTATUS_FS
345 static inline void cpu_get_tb_cpu_state(CPURISCVState
*env
, target_ulong
*pc
,
346 target_ulong
*cs_base
, uint32_t *flags
)
350 #ifdef CONFIG_USER_ONLY
351 *flags
= TB_FLAGS_MSTATUS_FS
;
353 *flags
= cpu_mmu_index(env
, 0);
354 if (riscv_cpu_fp_enabled(env
)) {
355 *flags
|= env
->mstatus
& MSTATUS_FS
;
360 int riscv_csrrw(CPURISCVState
*env
, int csrno
, target_ulong
*ret_value
,
361 target_ulong new_value
, target_ulong write_mask
);
362 int riscv_csrrw_debug(CPURISCVState
*env
, int csrno
, target_ulong
*ret_value
,
363 target_ulong new_value
, target_ulong write_mask
);
365 static inline void riscv_csr_write(CPURISCVState
*env
, int csrno
,
368 riscv_csrrw(env
, csrno
, NULL
, val
, MAKE_64BIT_MASK(0, TARGET_LONG_BITS
));
371 static inline target_ulong
riscv_csr_read(CPURISCVState
*env
, int csrno
)
373 target_ulong val
= 0;
374 riscv_csrrw(env
, csrno
, &val
, 0, 0);
378 typedef int (*riscv_csr_predicate_fn
)(CPURISCVState
*env
, int csrno
);
379 typedef int (*riscv_csr_read_fn
)(CPURISCVState
*env
, int csrno
,
380 target_ulong
*ret_value
);
381 typedef int (*riscv_csr_write_fn
)(CPURISCVState
*env
, int csrno
,
382 target_ulong new_value
);
383 typedef int (*riscv_csr_op_fn
)(CPURISCVState
*env
, int csrno
,
384 target_ulong
*ret_value
, target_ulong new_value
, target_ulong write_mask
);
387 riscv_csr_predicate_fn predicate
;
388 riscv_csr_read_fn read
;
389 riscv_csr_write_fn write
;
391 } riscv_csr_operations
;
393 void riscv_get_csr_ops(int csrno
, riscv_csr_operations
*ops
);
394 void riscv_set_csr_ops(int csrno
, riscv_csr_operations
*ops
);
396 void riscv_cpu_register_gdb_regs_for_features(CPUState
*cs
);
398 typedef CPURISCVState CPUArchState
;
399 typedef RISCVCPU ArchCPU
;
401 #include "exec/cpu-all.h"
403 #endif /* RISCV_CPU_H */