1 /* 2 * QEMU RISC-V CPU 3 * 4 * Copyright (c) 2016-2017 Sagar Karandikar, sagark@eecs.berkeley.edu 5 * Copyright (c) 2017-2018 SiFive, Inc. 6 * 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. 10 * 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 14 * more details. 15 * 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/>. 18 */ 19 20 #ifndef RISCV_CPU_H 21 #define RISCV_CPU_H 22 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" 28 #include "qemu/int128.h" 29 #include "cpu_bits.h" 30 31 #define TCG_GUEST_DEFAULT_MO 0 32 33 #define TYPE_RISCV_CPU "riscv-cpu" 34 35 #define RISCV_CPU_TYPE_SUFFIX "-" TYPE_RISCV_CPU 36 #define RISCV_CPU_TYPE_NAME(name) (name RISCV_CPU_TYPE_SUFFIX) 37 #define CPU_RESOLVING_TYPE TYPE_RISCV_CPU 38 39 #define TYPE_RISCV_CPU_ANY RISCV_CPU_TYPE_NAME("any") 40 #define TYPE_RISCV_CPU_BASE32 RISCV_CPU_TYPE_NAME("rv32") 41 #define TYPE_RISCV_CPU_BASE64 RISCV_CPU_TYPE_NAME("rv64") 42 #define TYPE_RISCV_CPU_BASE128 RISCV_CPU_TYPE_NAME("x-rv128") 43 #define TYPE_RISCV_CPU_IBEX RISCV_CPU_TYPE_NAME("lowrisc-ibex") 44 #define TYPE_RISCV_CPU_SHAKTI_C RISCV_CPU_TYPE_NAME("shakti-c") 45 #define TYPE_RISCV_CPU_SIFIVE_E31 RISCV_CPU_TYPE_NAME("sifive-e31") 46 #define TYPE_RISCV_CPU_SIFIVE_E34 RISCV_CPU_TYPE_NAME("sifive-e34") 47 #define TYPE_RISCV_CPU_SIFIVE_E51 RISCV_CPU_TYPE_NAME("sifive-e51") 48 #define TYPE_RISCV_CPU_SIFIVE_U34 RISCV_CPU_TYPE_NAME("sifive-u34") 49 #define TYPE_RISCV_CPU_SIFIVE_U54 RISCV_CPU_TYPE_NAME("sifive-u54") 50 #define TYPE_RISCV_CPU_HOST RISCV_CPU_TYPE_NAME("host") 51 52 #if defined(TARGET_RISCV32) 53 # define TYPE_RISCV_CPU_BASE TYPE_RISCV_CPU_BASE32 54 #elif defined(TARGET_RISCV64) 55 # define TYPE_RISCV_CPU_BASE TYPE_RISCV_CPU_BASE64 56 #endif 57 58 #define RV(x) ((target_ulong)1 << (x - 'A')) 59 60 #define RVI RV('I') 61 #define RVE RV('E') /* E and I are mutually exclusive */ 62 #define RVM RV('M') 63 #define RVA RV('A') 64 #define RVF RV('F') 65 #define RVD RV('D') 66 #define RVV RV('V') 67 #define RVC RV('C') 68 #define RVS RV('S') 69 #define RVU RV('U') 70 #define RVH RV('H') 71 #define RVJ RV('J') 72 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 */ 77 enum { 78 RISCV_FEATURE_MMU, 79 RISCV_FEATURE_PMP, 80 RISCV_FEATURE_EPMP, 81 RISCV_FEATURE_MISA 82 }; 83 84 #define PRIV_VERSION_1_10_0 0x00011000 85 #define PRIV_VERSION_1_11_0 0x00011100 86 87 #define VEXT_VERSION_1_00_0 0x00010000 88 89 enum { 90 TRANSLATE_SUCCESS, 91 TRANSLATE_FAIL, 92 TRANSLATE_PMP_FAIL, 93 TRANSLATE_G_STAGE_FAIL 94 }; 95 96 #define MMU_USER_IDX 3 97 98 #define MAX_RISCV_PMPS (16) 99 100 typedef struct CPURISCVState CPURISCVState; 101 102 #if !defined(CONFIG_USER_ONLY) 103 #include "pmp.h" 104 #endif 105 106 #define RV_VLEN_MAX 1024 107 108 FIELD(VTYPE, VLMUL, 0, 3) 109 FIELD(VTYPE, VSEW, 3, 3) 110 FIELD(VTYPE, VTA, 6, 1) 111 FIELD(VTYPE, VMA, 7, 1) 112 FIELD(VTYPE, VEDIV, 8, 2) 113 FIELD(VTYPE, RESERVED, 10, sizeof(target_ulong) * 8 - 11) 114 FIELD(VTYPE, VILL, sizeof(target_ulong) * 8 - 1, 1) 115 116 struct CPURISCVState { 117 target_ulong gpr[32]; 118 target_ulong gprh[32]; /* 64 top bits of the 128-bit registers */ 119 uint64_t fpr[32]; /* assume both F and D extensions */ 120 121 /* vector coprocessor state. */ 122 uint64_t vreg[32 * RV_VLEN_MAX / 64] QEMU_ALIGNED(16); 123 target_ulong vxrm; 124 target_ulong vxsat; 125 target_ulong vl; 126 target_ulong vstart; 127 target_ulong vtype; 128 129 target_ulong pc; 130 target_ulong load_res; 131 target_ulong load_val; 132 133 target_ulong frm; 134 135 target_ulong badaddr; 136 uint32_t bins; 137 138 target_ulong guest_phys_fault_addr; 139 140 target_ulong priv_ver; 141 target_ulong bext_ver; 142 target_ulong vext_ver; 143 144 /* RISCVMXL, but uint32_t for vmstate migration */ 145 uint32_t misa_mxl; /* current mxl */ 146 uint32_t misa_mxl_max; /* max mxl for this cpu */ 147 uint32_t misa_ext; /* current extensions */ 148 uint32_t misa_ext_mask; /* max ext for this cpu */ 149 150 /* 128-bit helpers upper part return value */ 151 target_ulong retxh; 152 153 uint32_t features; 154 155 #ifdef CONFIG_USER_ONLY 156 uint32_t elf_flags; 157 #endif 158 159 #ifndef CONFIG_USER_ONLY 160 target_ulong priv; 161 /* This contains QEMU specific information about the virt state. */ 162 target_ulong virt; 163 target_ulong resetvec; 164 165 target_ulong mhartid; 166 /* 167 * For RV32 this is 32-bit mstatus and 32-bit mstatush. 168 * For RV64 this is a 64-bit mstatus. 169 */ 170 uint64_t mstatus; 171 172 target_ulong mip; 173 174 uint32_t miclaim; 175 176 target_ulong mie; 177 target_ulong mideleg; 178 179 target_ulong satp; /* since: priv-1.10.0 */ 180 target_ulong stval; 181 target_ulong medeleg; 182 183 target_ulong stvec; 184 target_ulong sepc; 185 target_ulong scause; 186 187 target_ulong mtvec; 188 target_ulong mepc; 189 target_ulong mcause; 190 target_ulong mtval; /* since: priv-1.10.0 */ 191 192 /* Hypervisor CSRs */ 193 target_ulong hstatus; 194 target_ulong hedeleg; 195 target_ulong hideleg; 196 target_ulong hcounteren; 197 target_ulong htval; 198 target_ulong htinst; 199 target_ulong hgatp; 200 uint64_t htimedelta; 201 202 /* Upper 64-bits of 128-bit CSRs */ 203 uint64_t mscratchh; 204 uint64_t sscratchh; 205 206 /* Virtual CSRs */ 207 /* 208 * For RV32 this is 32-bit vsstatus and 32-bit vsstatush. 209 * For RV64 this is a 64-bit vsstatus. 210 */ 211 uint64_t vsstatus; 212 target_ulong vstvec; 213 target_ulong vsscratch; 214 target_ulong vsepc; 215 target_ulong vscause; 216 target_ulong vstval; 217 target_ulong vsatp; 218 219 target_ulong mtval2; 220 target_ulong mtinst; 221 222 /* HS Backup CSRs */ 223 target_ulong stvec_hs; 224 target_ulong sscratch_hs; 225 target_ulong sepc_hs; 226 target_ulong scause_hs; 227 target_ulong stval_hs; 228 target_ulong satp_hs; 229 uint64_t mstatus_hs; 230 231 /* Signals whether the current exception occurred with two-stage address 232 translation active. */ 233 bool two_stage_lookup; 234 235 target_ulong scounteren; 236 target_ulong mcounteren; 237 238 target_ulong sscratch; 239 target_ulong mscratch; 240 241 /* temporary htif regs */ 242 uint64_t mfromhost; 243 uint64_t mtohost; 244 uint64_t timecmp; 245 246 /* physical memory protection */ 247 pmp_table_t pmp_state; 248 target_ulong mseccfg; 249 250 /* machine specific rdtime callback */ 251 uint64_t (*rdtime_fn)(uint32_t); 252 uint32_t rdtime_fn_arg; 253 254 /* True if in debugger mode. */ 255 bool debugger; 256 257 /* 258 * CSRs for PointerMasking extension 259 */ 260 target_ulong mmte; 261 target_ulong mpmmask; 262 target_ulong mpmbase; 263 target_ulong spmmask; 264 target_ulong spmbase; 265 target_ulong upmmask; 266 target_ulong upmbase; 267 #endif 268 269 float_status fp_status; 270 271 /* Fields from here on are preserved across CPU reset. */ 272 QEMUTimer *timer; /* Internal timer */ 273 274 hwaddr kernel_addr; 275 hwaddr fdt_addr; 276 277 /* kvm timer */ 278 bool kvm_timer_dirty; 279 uint64_t kvm_timer_time; 280 uint64_t kvm_timer_compare; 281 uint64_t kvm_timer_state; 282 uint64_t kvm_timer_frequency; 283 }; 284 285 OBJECT_DECLARE_TYPE(RISCVCPU, RISCVCPUClass, 286 RISCV_CPU) 287 288 /** 289 * RISCVCPUClass: 290 * @parent_realize: The parent class' realize handler. 291 * @parent_reset: The parent class' reset handler. 292 * 293 * A RISCV CPU model. 294 */ 295 struct RISCVCPUClass { 296 /*< private >*/ 297 CPUClass parent_class; 298 /*< public >*/ 299 DeviceRealize parent_realize; 300 DeviceReset parent_reset; 301 }; 302 303 /** 304 * RISCVCPU: 305 * @env: #CPURISCVState 306 * 307 * A RISCV CPU. 308 */ 309 struct RISCVCPU { 310 /*< private >*/ 311 CPUState parent_obj; 312 /*< public >*/ 313 CPUNegativeOffsetState neg; 314 CPURISCVState env; 315 316 char *dyn_csr_xml; 317 char *dyn_vreg_xml; 318 319 /* Configuration Settings */ 320 struct { 321 bool ext_i; 322 bool ext_e; 323 bool ext_g; 324 bool ext_m; 325 bool ext_a; 326 bool ext_f; 327 bool ext_d; 328 bool ext_c; 329 bool ext_s; 330 bool ext_u; 331 bool ext_h; 332 bool ext_j; 333 bool ext_v; 334 bool ext_zba; 335 bool ext_zbb; 336 bool ext_zbc; 337 bool ext_zbs; 338 bool ext_counters; 339 bool ext_ifencei; 340 bool ext_icsr; 341 bool ext_zfh; 342 bool ext_zfhmin; 343 bool ext_zve64f; 344 345 char *priv_spec; 346 char *user_spec; 347 char *bext_spec; 348 char *vext_spec; 349 uint16_t vlen; 350 uint16_t elen; 351 bool mmu; 352 bool pmp; 353 bool epmp; 354 uint64_t resetvec; 355 } cfg; 356 }; 357 358 static inline int riscv_has_ext(CPURISCVState *env, target_ulong ext) 359 { 360 return (env->misa_ext & ext) != 0; 361 } 362 363 static inline bool riscv_feature(CPURISCVState *env, int feature) 364 { 365 return env->features & (1ULL << feature); 366 } 367 368 #include "cpu_user.h" 369 370 extern const char * const riscv_int_regnames[]; 371 extern const char * const riscv_int_regnamesh[]; 372 extern const char * const riscv_fpr_regnames[]; 373 374 const char *riscv_cpu_get_trap_name(target_ulong cause, bool async); 375 void riscv_cpu_do_interrupt(CPUState *cpu); 376 int riscv_cpu_write_elf64_note(WriteCoreDumpFunction f, CPUState *cs, 377 int cpuid, void *opaque); 378 int riscv_cpu_write_elf32_note(WriteCoreDumpFunction f, CPUState *cs, 379 int cpuid, void *opaque); 380 int riscv_cpu_gdb_read_register(CPUState *cpu, GByteArray *buf, int reg); 381 int riscv_cpu_gdb_write_register(CPUState *cpu, uint8_t *buf, int reg); 382 bool riscv_cpu_fp_enabled(CPURISCVState *env); 383 bool riscv_cpu_vector_enabled(CPURISCVState *env); 384 bool riscv_cpu_virt_enabled(CPURISCVState *env); 385 void riscv_cpu_set_virt_enabled(CPURISCVState *env, bool enable); 386 bool riscv_cpu_two_stage_lookup(int mmu_idx); 387 int riscv_cpu_mmu_index(CPURISCVState *env, bool ifetch); 388 hwaddr riscv_cpu_get_phys_page_debug(CPUState *cpu, vaddr addr); 389 void riscv_cpu_do_unaligned_access(CPUState *cs, vaddr addr, 390 MMUAccessType access_type, int mmu_idx, 391 uintptr_t retaddr) QEMU_NORETURN; 392 bool riscv_cpu_tlb_fill(CPUState *cs, vaddr address, int size, 393 MMUAccessType access_type, int mmu_idx, 394 bool probe, uintptr_t retaddr); 395 void riscv_cpu_do_transaction_failed(CPUState *cs, hwaddr physaddr, 396 vaddr addr, unsigned size, 397 MMUAccessType access_type, 398 int mmu_idx, MemTxAttrs attrs, 399 MemTxResult response, uintptr_t retaddr); 400 char *riscv_isa_string(RISCVCPU *cpu); 401 void riscv_cpu_list(void); 402 403 #define cpu_list riscv_cpu_list 404 #define cpu_mmu_index riscv_cpu_mmu_index 405 406 #ifndef CONFIG_USER_ONLY 407 bool riscv_cpu_exec_interrupt(CPUState *cs, int interrupt_request); 408 void riscv_cpu_swap_hypervisor_regs(CPURISCVState *env); 409 int riscv_cpu_claim_interrupts(RISCVCPU *cpu, uint32_t interrupts); 410 uint32_t riscv_cpu_update_mip(RISCVCPU *cpu, uint32_t mask, uint32_t value); 411 #define BOOL_TO_MASK(x) (-!!(x)) /* helper for riscv_cpu_update_mip value */ 412 void riscv_cpu_set_rdtime_fn(CPURISCVState *env, uint64_t (*fn)(uint32_t), 413 uint32_t arg); 414 #endif 415 void riscv_cpu_set_mode(CPURISCVState *env, target_ulong newpriv); 416 417 void riscv_translate_init(void); 418 void QEMU_NORETURN riscv_raise_exception(CPURISCVState *env, 419 uint32_t exception, uintptr_t pc); 420 421 target_ulong riscv_cpu_get_fflags(CPURISCVState *env); 422 void riscv_cpu_set_fflags(CPURISCVState *env, target_ulong); 423 424 #define TB_FLAGS_PRIV_MMU_MASK 3 425 #define TB_FLAGS_PRIV_HYP_ACCESS_MASK (1 << 2) 426 #define TB_FLAGS_MSTATUS_FS MSTATUS_FS 427 #define TB_FLAGS_MSTATUS_VS MSTATUS_VS 428 429 typedef CPURISCVState CPUArchState; 430 typedef RISCVCPU ArchCPU; 431 #include "exec/cpu-all.h" 432 433 FIELD(TB_FLAGS, MEM_IDX, 0, 3) 434 FIELD(TB_FLAGS, LMUL, 3, 3) 435 FIELD(TB_FLAGS, SEW, 6, 3) 436 /* Skip MSTATUS_VS (0x600) bits */ 437 FIELD(TB_FLAGS, VL_EQ_VLMAX, 11, 1) 438 FIELD(TB_FLAGS, VILL, 12, 1) 439 /* Skip MSTATUS_FS (0x6000) bits */ 440 /* Is a Hypervisor instruction load/store allowed? */ 441 FIELD(TB_FLAGS, HLSX, 15, 1) 442 FIELD(TB_FLAGS, MSTATUS_HS_FS, 16, 2) 443 FIELD(TB_FLAGS, MSTATUS_HS_VS, 18, 2) 444 /* The combination of MXL/SXL/UXL that applies to the current cpu mode. */ 445 FIELD(TB_FLAGS, XL, 20, 2) 446 /* If PointerMasking should be applied */ 447 FIELD(TB_FLAGS, PM_ENABLED, 22, 1) 448 449 #ifdef TARGET_RISCV32 450 #define riscv_cpu_mxl(env) ((void)(env), MXL_RV32) 451 #else 452 static inline RISCVMXL riscv_cpu_mxl(CPURISCVState *env) 453 { 454 return env->misa_mxl; 455 } 456 #endif 457 458 /* 459 * Encode LMUL to lmul as follows: 460 * LMUL vlmul lmul 461 * 1 000 0 462 * 2 001 1 463 * 4 010 2 464 * 8 011 3 465 * - 100 - 466 * 1/8 101 -3 467 * 1/4 110 -2 468 * 1/2 111 -1 469 * 470 * then, we can calculate VLMAX = vlen >> (vsew + 3 - lmul) 471 * e.g. vlen = 256 bits, SEW = 16, LMUL = 1/8 472 * => VLMAX = vlen >> (1 + 3 - (-3)) 473 * = 256 >> 7 474 * = 2 475 */ 476 static inline uint32_t vext_get_vlmax(RISCVCPU *cpu, target_ulong vtype) 477 { 478 uint8_t sew = FIELD_EX64(vtype, VTYPE, VSEW); 479 int8_t lmul = sextract32(FIELD_EX64(vtype, VTYPE, VLMUL), 0, 3); 480 return cpu->cfg.vlen >> (sew + 3 - lmul); 481 } 482 483 void cpu_get_tb_cpu_state(CPURISCVState *env, target_ulong *pc, 484 target_ulong *cs_base, uint32_t *pflags); 485 486 RISCVException riscv_csrrw(CPURISCVState *env, int csrno, 487 target_ulong *ret_value, 488 target_ulong new_value, target_ulong write_mask); 489 RISCVException riscv_csrrw_debug(CPURISCVState *env, int csrno, 490 target_ulong *ret_value, 491 target_ulong new_value, 492 target_ulong write_mask); 493 494 static inline void riscv_csr_write(CPURISCVState *env, int csrno, 495 target_ulong val) 496 { 497 riscv_csrrw(env, csrno, NULL, val, MAKE_64BIT_MASK(0, TARGET_LONG_BITS)); 498 } 499 500 static inline target_ulong riscv_csr_read(CPURISCVState *env, int csrno) 501 { 502 target_ulong val = 0; 503 riscv_csrrw(env, csrno, &val, 0, 0); 504 return val; 505 } 506 507 typedef RISCVException (*riscv_csr_predicate_fn)(CPURISCVState *env, 508 int csrno); 509 typedef RISCVException (*riscv_csr_read_fn)(CPURISCVState *env, int csrno, 510 target_ulong *ret_value); 511 typedef RISCVException (*riscv_csr_write_fn)(CPURISCVState *env, int csrno, 512 target_ulong new_value); 513 typedef RISCVException (*riscv_csr_op_fn)(CPURISCVState *env, int csrno, 514 target_ulong *ret_value, 515 target_ulong new_value, 516 target_ulong write_mask); 517 518 RISCVException riscv_csrrw_i128(CPURISCVState *env, int csrno, 519 Int128 *ret_value, 520 Int128 new_value, Int128 write_mask); 521 522 typedef RISCVException (*riscv_csr_read128_fn)(CPURISCVState *env, int csrno, 523 Int128 *ret_value); 524 typedef RISCVException (*riscv_csr_write128_fn)(CPURISCVState *env, int csrno, 525 Int128 new_value); 526 527 typedef struct { 528 const char *name; 529 riscv_csr_predicate_fn predicate; 530 riscv_csr_read_fn read; 531 riscv_csr_write_fn write; 532 riscv_csr_op_fn op; 533 riscv_csr_read128_fn read128; 534 riscv_csr_write128_fn write128; 535 } riscv_csr_operations; 536 537 /* CSR function table constants */ 538 enum { 539 CSR_TABLE_SIZE = 0x1000 540 }; 541 542 /* CSR function table */ 543 extern riscv_csr_operations csr_ops[CSR_TABLE_SIZE]; 544 545 void riscv_get_csr_ops(int csrno, riscv_csr_operations *ops); 546 void riscv_set_csr_ops(int csrno, riscv_csr_operations *ops); 547 548 void riscv_cpu_register_gdb_regs_for_features(CPUState *cs); 549 550 #endif /* RISCV_CPU_H */ 551