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_zve32f; 344 bool ext_zve64f; 345 346 char *priv_spec; 347 char *user_spec; 348 char *bext_spec; 349 char *vext_spec; 350 uint16_t vlen; 351 uint16_t elen; 352 bool mmu; 353 bool pmp; 354 bool epmp; 355 uint64_t resetvec; 356 } cfg; 357 }; 358 359 static inline int riscv_has_ext(CPURISCVState *env, target_ulong ext) 360 { 361 return (env->misa_ext & ext) != 0; 362 } 363 364 static inline bool riscv_feature(CPURISCVState *env, int feature) 365 { 366 return env->features & (1ULL << feature); 367 } 368 369 #include "cpu_user.h" 370 371 extern const char * const riscv_int_regnames[]; 372 extern const char * const riscv_int_regnamesh[]; 373 extern const char * const riscv_fpr_regnames[]; 374 375 const char *riscv_cpu_get_trap_name(target_ulong cause, bool async); 376 void riscv_cpu_do_interrupt(CPUState *cpu); 377 int riscv_cpu_write_elf64_note(WriteCoreDumpFunction f, CPUState *cs, 378 int cpuid, void *opaque); 379 int riscv_cpu_write_elf32_note(WriteCoreDumpFunction f, CPUState *cs, 380 int cpuid, void *opaque); 381 int riscv_cpu_gdb_read_register(CPUState *cpu, GByteArray *buf, int reg); 382 int riscv_cpu_gdb_write_register(CPUState *cpu, uint8_t *buf, int reg); 383 bool riscv_cpu_fp_enabled(CPURISCVState *env); 384 bool riscv_cpu_vector_enabled(CPURISCVState *env); 385 bool riscv_cpu_virt_enabled(CPURISCVState *env); 386 void riscv_cpu_set_virt_enabled(CPURISCVState *env, bool enable); 387 bool riscv_cpu_two_stage_lookup(int mmu_idx); 388 int riscv_cpu_mmu_index(CPURISCVState *env, bool ifetch); 389 hwaddr riscv_cpu_get_phys_page_debug(CPUState *cpu, vaddr addr); 390 void riscv_cpu_do_unaligned_access(CPUState *cs, vaddr addr, 391 MMUAccessType access_type, int mmu_idx, 392 uintptr_t retaddr) QEMU_NORETURN; 393 bool riscv_cpu_tlb_fill(CPUState *cs, vaddr address, int size, 394 MMUAccessType access_type, int mmu_idx, 395 bool probe, uintptr_t retaddr); 396 void riscv_cpu_do_transaction_failed(CPUState *cs, hwaddr physaddr, 397 vaddr addr, unsigned size, 398 MMUAccessType access_type, 399 int mmu_idx, MemTxAttrs attrs, 400 MemTxResult response, uintptr_t retaddr); 401 char *riscv_isa_string(RISCVCPU *cpu); 402 void riscv_cpu_list(void); 403 404 #define cpu_list riscv_cpu_list 405 #define cpu_mmu_index riscv_cpu_mmu_index 406 407 #ifndef CONFIG_USER_ONLY 408 bool riscv_cpu_exec_interrupt(CPUState *cs, int interrupt_request); 409 void riscv_cpu_swap_hypervisor_regs(CPURISCVState *env); 410 int riscv_cpu_claim_interrupts(RISCVCPU *cpu, uint32_t interrupts); 411 uint32_t riscv_cpu_update_mip(RISCVCPU *cpu, uint32_t mask, uint32_t value); 412 #define BOOL_TO_MASK(x) (-!!(x)) /* helper for riscv_cpu_update_mip value */ 413 void riscv_cpu_set_rdtime_fn(CPURISCVState *env, uint64_t (*fn)(uint32_t), 414 uint32_t arg); 415 #endif 416 void riscv_cpu_set_mode(CPURISCVState *env, target_ulong newpriv); 417 418 void riscv_translate_init(void); 419 void QEMU_NORETURN riscv_raise_exception(CPURISCVState *env, 420 uint32_t exception, uintptr_t pc); 421 422 target_ulong riscv_cpu_get_fflags(CPURISCVState *env); 423 void riscv_cpu_set_fflags(CPURISCVState *env, target_ulong); 424 425 #define TB_FLAGS_PRIV_MMU_MASK 3 426 #define TB_FLAGS_PRIV_HYP_ACCESS_MASK (1 << 2) 427 #define TB_FLAGS_MSTATUS_FS MSTATUS_FS 428 #define TB_FLAGS_MSTATUS_VS MSTATUS_VS 429 430 typedef CPURISCVState CPUArchState; 431 typedef RISCVCPU ArchCPU; 432 #include "exec/cpu-all.h" 433 434 FIELD(TB_FLAGS, MEM_IDX, 0, 3) 435 FIELD(TB_FLAGS, LMUL, 3, 3) 436 FIELD(TB_FLAGS, SEW, 6, 3) 437 /* Skip MSTATUS_VS (0x600) bits */ 438 FIELD(TB_FLAGS, VL_EQ_VLMAX, 11, 1) 439 FIELD(TB_FLAGS, VILL, 12, 1) 440 /* Skip MSTATUS_FS (0x6000) bits */ 441 /* Is a Hypervisor instruction load/store allowed? */ 442 FIELD(TB_FLAGS, HLSX, 15, 1) 443 FIELD(TB_FLAGS, MSTATUS_HS_FS, 16, 2) 444 FIELD(TB_FLAGS, MSTATUS_HS_VS, 18, 2) 445 /* The combination of MXL/SXL/UXL that applies to the current cpu mode. */ 446 FIELD(TB_FLAGS, XL, 20, 2) 447 /* If PointerMasking should be applied */ 448 FIELD(TB_FLAGS, PM_ENABLED, 22, 1) 449 450 #ifdef TARGET_RISCV32 451 #define riscv_cpu_mxl(env) ((void)(env), MXL_RV32) 452 #else 453 static inline RISCVMXL riscv_cpu_mxl(CPURISCVState *env) 454 { 455 return env->misa_mxl; 456 } 457 #endif 458 459 /* 460 * Encode LMUL to lmul as follows: 461 * LMUL vlmul lmul 462 * 1 000 0 463 * 2 001 1 464 * 4 010 2 465 * 8 011 3 466 * - 100 - 467 * 1/8 101 -3 468 * 1/4 110 -2 469 * 1/2 111 -1 470 * 471 * then, we can calculate VLMAX = vlen >> (vsew + 3 - lmul) 472 * e.g. vlen = 256 bits, SEW = 16, LMUL = 1/8 473 * => VLMAX = vlen >> (1 + 3 - (-3)) 474 * = 256 >> 7 475 * = 2 476 */ 477 static inline uint32_t vext_get_vlmax(RISCVCPU *cpu, target_ulong vtype) 478 { 479 uint8_t sew = FIELD_EX64(vtype, VTYPE, VSEW); 480 int8_t lmul = sextract32(FIELD_EX64(vtype, VTYPE, VLMUL), 0, 3); 481 return cpu->cfg.vlen >> (sew + 3 - lmul); 482 } 483 484 void cpu_get_tb_cpu_state(CPURISCVState *env, target_ulong *pc, 485 target_ulong *cs_base, uint32_t *pflags); 486 487 RISCVException riscv_csrrw(CPURISCVState *env, int csrno, 488 target_ulong *ret_value, 489 target_ulong new_value, target_ulong write_mask); 490 RISCVException riscv_csrrw_debug(CPURISCVState *env, int csrno, 491 target_ulong *ret_value, 492 target_ulong new_value, 493 target_ulong write_mask); 494 495 static inline void riscv_csr_write(CPURISCVState *env, int csrno, 496 target_ulong val) 497 { 498 riscv_csrrw(env, csrno, NULL, val, MAKE_64BIT_MASK(0, TARGET_LONG_BITS)); 499 } 500 501 static inline target_ulong riscv_csr_read(CPURISCVState *env, int csrno) 502 { 503 target_ulong val = 0; 504 riscv_csrrw(env, csrno, &val, 0, 0); 505 return val; 506 } 507 508 typedef RISCVException (*riscv_csr_predicate_fn)(CPURISCVState *env, 509 int csrno); 510 typedef RISCVException (*riscv_csr_read_fn)(CPURISCVState *env, int csrno, 511 target_ulong *ret_value); 512 typedef RISCVException (*riscv_csr_write_fn)(CPURISCVState *env, int csrno, 513 target_ulong new_value); 514 typedef RISCVException (*riscv_csr_op_fn)(CPURISCVState *env, int csrno, 515 target_ulong *ret_value, 516 target_ulong new_value, 517 target_ulong write_mask); 518 519 RISCVException riscv_csrrw_i128(CPURISCVState *env, int csrno, 520 Int128 *ret_value, 521 Int128 new_value, Int128 write_mask); 522 523 typedef RISCVException (*riscv_csr_read128_fn)(CPURISCVState *env, int csrno, 524 Int128 *ret_value); 525 typedef RISCVException (*riscv_csr_write128_fn)(CPURISCVState *env, int csrno, 526 Int128 new_value); 527 528 typedef struct { 529 const char *name; 530 riscv_csr_predicate_fn predicate; 531 riscv_csr_read_fn read; 532 riscv_csr_write_fn write; 533 riscv_csr_op_fn op; 534 riscv_csr_read128_fn read128; 535 riscv_csr_write128_fn write128; 536 } riscv_csr_operations; 537 538 /* CSR function table constants */ 539 enum { 540 CSR_TABLE_SIZE = 0x1000 541 }; 542 543 /* CSR function table */ 544 extern riscv_csr_operations csr_ops[CSR_TABLE_SIZE]; 545 546 void riscv_get_csr_ops(int csrno, riscv_csr_operations *ops); 547 void riscv_set_csr_ops(int csrno, riscv_csr_operations *ops); 548 549 void riscv_cpu_register_gdb_regs_for_features(CPUState *cs); 550 551 #endif /* RISCV_CPU_H */ 552