?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
tests/qapi-schema: Cover duplicate 'Features:' line
[qemu/kevin.git] / target / riscv / cpu.c
blob1b8d001d237f80b4a3524c74dc3865fbd1375b03
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 #include "qemu/osdep.h"
21 #include "qemu/qemu-print.h"
22 #include "qemu/ctype.h"
23 #include "qemu/log.h"
24 #include "cpu.h"
25 #include "cpu_vendorid.h"
26 #include "internals.h"
27 #include "exec/exec-all.h"
28 #include "qapi/error.h"
29 #include "qapi/visitor.h"
30 #include "qemu/error-report.h"
31 #include "hw/qdev-properties.h"
32 #include "hw/core/qdev-prop-internal.h"
33 #include "migration/vmstate.h"
34 #include "fpu/softfloat-helpers.h"
35 #include "sysemu/device_tree.h"
36 #include "sysemu/kvm.h"
37 #include "sysemu/tcg.h"
38 #include "kvm/kvm_riscv.h"
39 #include "tcg/tcg-cpu.h"
40 #include "tcg/tcg.h"
41
42 /* RISC-V CPU definitions */
43 static const char riscv_single_letter_exts[] = "IEMAFDQCBPVH";
44 const uint32_t misa_bits[] = {RVI, RVE, RVM, RVA, RVF, RVD, RVV,
45 RVC, RVS, RVU, RVH, RVJ, RVG, RVB, 0};
46
47 /*
48 * From vector_helper.c
49 * Note that vector data is stored in host-endian 64-bit chunks,
50 * so addressing bytes needs a host-endian fixup.
51 */
52 #if HOST_BIG_ENDIAN
53 #define BYTE(x) ((x) ^ 7)
54 #else
55 #define BYTE(x) (x)
56 #endif
57
58 bool riscv_cpu_is_32bit(RISCVCPU *cpu)
59 {
60 return riscv_cpu_mxl(&cpu->env) == MXL_RV32;
61 }
62
63 /* Hash that stores general user set numeric options */
64 static GHashTable *general_user_opts;
65
66 static void cpu_option_add_user_setting(const char *optname, uint32_t value)
67 {
68 g_hash_table_insert(general_user_opts, (gpointer)optname,
69 GUINT_TO_POINTER(value));
70 }
71
72 bool riscv_cpu_option_set(const char *optname)
73 {
74 return g_hash_table_contains(general_user_opts, optname);
75 }
76
77 #define ISA_EXT_DATA_ENTRY(_name, _min_ver, _prop) \
78 {#_name, _min_ver, CPU_CFG_OFFSET(_prop)}
79
80 /*
81 * Here are the ordering rules of extension naming defined by RISC-V
82 * specification :
83 * 1. All extensions should be separated from other multi-letter extensions
84 * by an underscore.
85 * 2. The first letter following the 'Z' conventionally indicates the most
86 * closely related alphabetical extension category, IMAFDQLCBKJTPVH.
87 * If multiple 'Z' extensions are named, they should be ordered first
88 * by category, then alphabetically within a category.
89 * 3. Standard supervisor-level extensions (starts with 'S') should be
90 * listed after standard unprivileged extensions. If multiple
91 * supervisor-level extensions are listed, they should be ordered
92 * alphabetically.
93 * 4. Non-standard extensions (starts with 'X') must be listed after all
94 * standard extensions. They must be separated from other multi-letter
95 * extensions by an underscore.
96 *
97 * Single letter extensions are checked in riscv_cpu_validate_misa_priv()
98 * instead.
99 */
100 const RISCVIsaExtData isa_edata_arr[] = {
101 ISA_EXT_DATA_ENTRY(zicbom, PRIV_VERSION_1_12_0, ext_zicbom),
102 ISA_EXT_DATA_ENTRY(zicbop, PRIV_VERSION_1_12_0, ext_zicbop),
103 ISA_EXT_DATA_ENTRY(zicboz, PRIV_VERSION_1_12_0, ext_zicboz),
104 ISA_EXT_DATA_ENTRY(zicond, PRIV_VERSION_1_12_0, ext_zicond),
105 ISA_EXT_DATA_ENTRY(zicntr, PRIV_VERSION_1_12_0, ext_zicntr),
106 ISA_EXT_DATA_ENTRY(zicsr, PRIV_VERSION_1_10_0, ext_zicsr),
107 ISA_EXT_DATA_ENTRY(zifencei, PRIV_VERSION_1_10_0, ext_zifencei),
108 ISA_EXT_DATA_ENTRY(zihintntl, PRIV_VERSION_1_10_0, ext_zihintntl),
109 ISA_EXT_DATA_ENTRY(zihintpause, PRIV_VERSION_1_10_0, ext_zihintpause),
110 ISA_EXT_DATA_ENTRY(zihpm, PRIV_VERSION_1_12_0, ext_zihpm),
111 ISA_EXT_DATA_ENTRY(zmmul, PRIV_VERSION_1_12_0, ext_zmmul),
112 ISA_EXT_DATA_ENTRY(zaamo, PRIV_VERSION_1_12_0, ext_zaamo),
113 ISA_EXT_DATA_ENTRY(zacas, PRIV_VERSION_1_12_0, ext_zacas),
114 ISA_EXT_DATA_ENTRY(zalrsc, PRIV_VERSION_1_12_0, ext_zalrsc),
115 ISA_EXT_DATA_ENTRY(zawrs, PRIV_VERSION_1_12_0, ext_zawrs),
116 ISA_EXT_DATA_ENTRY(zfa, PRIV_VERSION_1_12_0, ext_zfa),
117 ISA_EXT_DATA_ENTRY(zfbfmin, PRIV_VERSION_1_12_0, ext_zfbfmin),
118 ISA_EXT_DATA_ENTRY(zfh, PRIV_VERSION_1_11_0, ext_zfh),
119 ISA_EXT_DATA_ENTRY(zfhmin, PRIV_VERSION_1_11_0, ext_zfhmin),
120 ISA_EXT_DATA_ENTRY(zfinx, PRIV_VERSION_1_12_0, ext_zfinx),
121 ISA_EXT_DATA_ENTRY(zdinx, PRIV_VERSION_1_12_0, ext_zdinx),
122 ISA_EXT_DATA_ENTRY(zca, PRIV_VERSION_1_12_0, ext_zca),
123 ISA_EXT_DATA_ENTRY(zcb, PRIV_VERSION_1_12_0, ext_zcb),
124 ISA_EXT_DATA_ENTRY(zcf, PRIV_VERSION_1_12_0, ext_zcf),
125 ISA_EXT_DATA_ENTRY(zcd, PRIV_VERSION_1_12_0, ext_zcd),
126 ISA_EXT_DATA_ENTRY(zce, PRIV_VERSION_1_12_0, ext_zce),
127 ISA_EXT_DATA_ENTRY(zcmp, PRIV_VERSION_1_12_0, ext_zcmp),
128 ISA_EXT_DATA_ENTRY(zcmt, PRIV_VERSION_1_12_0, ext_zcmt),
129 ISA_EXT_DATA_ENTRY(zba, PRIV_VERSION_1_12_0, ext_zba),
130 ISA_EXT_DATA_ENTRY(zbb, PRIV_VERSION_1_12_0, ext_zbb),
131 ISA_EXT_DATA_ENTRY(zbc, PRIV_VERSION_1_12_0, ext_zbc),
132 ISA_EXT_DATA_ENTRY(zbkb, PRIV_VERSION_1_12_0, ext_zbkb),
133 ISA_EXT_DATA_ENTRY(zbkc, PRIV_VERSION_1_12_0, ext_zbkc),
134 ISA_EXT_DATA_ENTRY(zbkx, PRIV_VERSION_1_12_0, ext_zbkx),
135 ISA_EXT_DATA_ENTRY(zbs, PRIV_VERSION_1_12_0, ext_zbs),
136 ISA_EXT_DATA_ENTRY(zk, PRIV_VERSION_1_12_0, ext_zk),
137 ISA_EXT_DATA_ENTRY(zkn, PRIV_VERSION_1_12_0, ext_zkn),
138 ISA_EXT_DATA_ENTRY(zknd, PRIV_VERSION_1_12_0, ext_zknd),
139 ISA_EXT_DATA_ENTRY(zkne, PRIV_VERSION_1_12_0, ext_zkne),
140 ISA_EXT_DATA_ENTRY(zknh, PRIV_VERSION_1_12_0, ext_zknh),
141 ISA_EXT_DATA_ENTRY(zkr, PRIV_VERSION_1_12_0, ext_zkr),
142 ISA_EXT_DATA_ENTRY(zks, PRIV_VERSION_1_12_0, ext_zks),
143 ISA_EXT_DATA_ENTRY(zksed, PRIV_VERSION_1_12_0, ext_zksed),
144 ISA_EXT_DATA_ENTRY(zksh, PRIV_VERSION_1_12_0, ext_zksh),
145 ISA_EXT_DATA_ENTRY(zkt, PRIV_VERSION_1_12_0, ext_zkt),
146 ISA_EXT_DATA_ENTRY(zvbb, PRIV_VERSION_1_12_0, ext_zvbb),
147 ISA_EXT_DATA_ENTRY(zvbc, PRIV_VERSION_1_12_0, ext_zvbc),
148 ISA_EXT_DATA_ENTRY(zve32f, PRIV_VERSION_1_10_0, ext_zve32f),
149 ISA_EXT_DATA_ENTRY(zve64f, PRIV_VERSION_1_10_0, ext_zve64f),
150 ISA_EXT_DATA_ENTRY(zve64d, PRIV_VERSION_1_10_0, ext_zve64d),
151 ISA_EXT_DATA_ENTRY(zvfbfmin, PRIV_VERSION_1_12_0, ext_zvfbfmin),
152 ISA_EXT_DATA_ENTRY(zvfbfwma, PRIV_VERSION_1_12_0, ext_zvfbfwma),
153 ISA_EXT_DATA_ENTRY(zvfh, PRIV_VERSION_1_12_0, ext_zvfh),
154 ISA_EXT_DATA_ENTRY(zvfhmin, PRIV_VERSION_1_12_0, ext_zvfhmin),
155 ISA_EXT_DATA_ENTRY(zvkb, PRIV_VERSION_1_12_0, ext_zvkb),
156 ISA_EXT_DATA_ENTRY(zvkg, PRIV_VERSION_1_12_0, ext_zvkg),
157 ISA_EXT_DATA_ENTRY(zvkn, PRIV_VERSION_1_12_0, ext_zvkn),
158 ISA_EXT_DATA_ENTRY(zvknc, PRIV_VERSION_1_12_0, ext_zvknc),
159 ISA_EXT_DATA_ENTRY(zvkned, PRIV_VERSION_1_12_0, ext_zvkned),
160 ISA_EXT_DATA_ENTRY(zvkng, PRIV_VERSION_1_12_0, ext_zvkng),
161 ISA_EXT_DATA_ENTRY(zvknha, PRIV_VERSION_1_12_0, ext_zvknha),
162 ISA_EXT_DATA_ENTRY(zvknhb, PRIV_VERSION_1_12_0, ext_zvknhb),
163 ISA_EXT_DATA_ENTRY(zvks, PRIV_VERSION_1_12_0, ext_zvks),
164 ISA_EXT_DATA_ENTRY(zvksc, PRIV_VERSION_1_12_0, ext_zvksc),
165 ISA_EXT_DATA_ENTRY(zvksed, PRIV_VERSION_1_12_0, ext_zvksed),
166 ISA_EXT_DATA_ENTRY(zvksg, PRIV_VERSION_1_12_0, ext_zvksg),
167 ISA_EXT_DATA_ENTRY(zvksh, PRIV_VERSION_1_12_0, ext_zvksh),
168 ISA_EXT_DATA_ENTRY(zvkt, PRIV_VERSION_1_12_0, ext_zvkt),
169 ISA_EXT_DATA_ENTRY(zhinx, PRIV_VERSION_1_12_0, ext_zhinx),
170 ISA_EXT_DATA_ENTRY(zhinxmin, PRIV_VERSION_1_12_0, ext_zhinxmin),
171 ISA_EXT_DATA_ENTRY(smaia, PRIV_VERSION_1_12_0, ext_smaia),
172 ISA_EXT_DATA_ENTRY(smepmp, PRIV_VERSION_1_12_0, ext_smepmp),
173 ISA_EXT_DATA_ENTRY(smstateen, PRIV_VERSION_1_12_0, ext_smstateen),
174 ISA_EXT_DATA_ENTRY(ssaia, PRIV_VERSION_1_12_0, ext_ssaia),
175 ISA_EXT_DATA_ENTRY(sscofpmf, PRIV_VERSION_1_12_0, ext_sscofpmf),
176 ISA_EXT_DATA_ENTRY(sstc, PRIV_VERSION_1_12_0, ext_sstc),
177 ISA_EXT_DATA_ENTRY(svadu, PRIV_VERSION_1_12_0, ext_svadu),
178 ISA_EXT_DATA_ENTRY(svinval, PRIV_VERSION_1_12_0, ext_svinval),
179 ISA_EXT_DATA_ENTRY(svnapot, PRIV_VERSION_1_12_0, ext_svnapot),
180 ISA_EXT_DATA_ENTRY(svpbmt, PRIV_VERSION_1_12_0, ext_svpbmt),
181 ISA_EXT_DATA_ENTRY(xtheadba, PRIV_VERSION_1_11_0, ext_xtheadba),
182 ISA_EXT_DATA_ENTRY(xtheadbb, PRIV_VERSION_1_11_0, ext_xtheadbb),
183 ISA_EXT_DATA_ENTRY(xtheadbs, PRIV_VERSION_1_11_0, ext_xtheadbs),
184 ISA_EXT_DATA_ENTRY(xtheadcmo, PRIV_VERSION_1_11_0, ext_xtheadcmo),
185 ISA_EXT_DATA_ENTRY(xtheadcondmov, PRIV_VERSION_1_11_0, ext_xtheadcondmov),
186 ISA_EXT_DATA_ENTRY(xtheadfmemidx, PRIV_VERSION_1_11_0, ext_xtheadfmemidx),
187 ISA_EXT_DATA_ENTRY(xtheadfmv, PRIV_VERSION_1_11_0, ext_xtheadfmv),
188 ISA_EXT_DATA_ENTRY(xtheadmac, PRIV_VERSION_1_11_0, ext_xtheadmac),
189 ISA_EXT_DATA_ENTRY(xtheadmemidx, PRIV_VERSION_1_11_0, ext_xtheadmemidx),
190 ISA_EXT_DATA_ENTRY(xtheadmempair, PRIV_VERSION_1_11_0, ext_xtheadmempair),
191 ISA_EXT_DATA_ENTRY(xtheadsync, PRIV_VERSION_1_11_0, ext_xtheadsync),
192 ISA_EXT_DATA_ENTRY(xventanacondops, PRIV_VERSION_1_12_0, ext_XVentanaCondOps),
193
194 DEFINE_PROP_END_OF_LIST(),
195 };
196
197 bool isa_ext_is_enabled(RISCVCPU *cpu, uint32_t ext_offset)
198 {
199 bool *ext_enabled = (void *)&cpu->cfg + ext_offset;
200
201 return *ext_enabled;
202 }
203
204 void isa_ext_update_enabled(RISCVCPU *cpu, uint32_t ext_offset, bool en)
205 {
206 bool *ext_enabled = (void *)&cpu->cfg + ext_offset;
207
208 *ext_enabled = en;
209 }
210
211 bool riscv_cpu_is_vendor(Object *cpu_obj)
212 {
213 return object_dynamic_cast(cpu_obj, TYPE_RISCV_VENDOR_CPU) != NULL;
214 }
215
216 const char * const riscv_int_regnames[] = {
217 "x0/zero", "x1/ra", "x2/sp", "x3/gp", "x4/tp", "x5/t0", "x6/t1",
218 "x7/t2", "x8/s0", "x9/s1", "x10/a0", "x11/a1", "x12/a2", "x13/a3",
219 "x14/a4", "x15/a5", "x16/a6", "x17/a7", "x18/s2", "x19/s3", "x20/s4",
220 "x21/s5", "x22/s6", "x23/s7", "x24/s8", "x25/s9", "x26/s10", "x27/s11",
221 "x28/t3", "x29/t4", "x30/t5", "x31/t6"
222 };
223
224 const char * const riscv_int_regnamesh[] = {
225 "x0h/zeroh", "x1h/rah", "x2h/sph", "x3h/gph", "x4h/tph", "x5h/t0h",
226 "x6h/t1h", "x7h/t2h", "x8h/s0h", "x9h/s1h", "x10h/a0h", "x11h/a1h",
227 "x12h/a2h", "x13h/a3h", "x14h/a4h", "x15h/a5h", "x16h/a6h", "x17h/a7h",
228 "x18h/s2h", "x19h/s3h", "x20h/s4h", "x21h/s5h", "x22h/s6h", "x23h/s7h",
229 "x24h/s8h", "x25h/s9h", "x26h/s10h", "x27h/s11h", "x28h/t3h", "x29h/t4h",
230 "x30h/t5h", "x31h/t6h"
231 };
232
233 const char * const riscv_fpr_regnames[] = {
234 "f0/ft0", "f1/ft1", "f2/ft2", "f3/ft3", "f4/ft4", "f5/ft5",
235 "f6/ft6", "f7/ft7", "f8/fs0", "f9/fs1", "f10/fa0", "f11/fa1",
236 "f12/fa2", "f13/fa3", "f14/fa4", "f15/fa5", "f16/fa6", "f17/fa7",
237 "f18/fs2", "f19/fs3", "f20/fs4", "f21/fs5", "f22/fs6", "f23/fs7",
238 "f24/fs8", "f25/fs9", "f26/fs10", "f27/fs11", "f28/ft8", "f29/ft9",
239 "f30/ft10", "f31/ft11"
240 };
241
242 const char * const riscv_rvv_regnames[] = {
243 "v0", "v1", "v2", "v3", "v4", "v5", "v6",
244 "v7", "v8", "v9", "v10", "v11", "v12", "v13",
245 "v14", "v15", "v16", "v17", "v18", "v19", "v20",
246 "v21", "v22", "v23", "v24", "v25", "v26", "v27",
247 "v28", "v29", "v30", "v31"
248 };
249
250 static const char * const riscv_excp_names[] = {
251 "misaligned_fetch",
252 "fault_fetch",
253 "illegal_instruction",
254 "breakpoint",
255 "misaligned_load",
256 "fault_load",
257 "misaligned_store",
258 "fault_store",
259 "user_ecall",
260 "supervisor_ecall",
261 "hypervisor_ecall",
262 "machine_ecall",
263 "exec_page_fault",
264 "load_page_fault",
265 "reserved",
266 "store_page_fault",
267 "reserved",
268 "reserved",
269 "reserved",
270 "reserved",
271 "guest_exec_page_fault",
272 "guest_load_page_fault",
273 "reserved",
274 "guest_store_page_fault",
275 };
276
277 static const char * const riscv_intr_names[] = {
278 "u_software",
279 "s_software",
280 "vs_software",
281 "m_software",
282 "u_timer",
283 "s_timer",
284 "vs_timer",
285 "m_timer",
286 "u_external",
287 "s_external",
288 "vs_external",
289 "m_external",
290 "reserved",
291 "reserved",
292 "reserved",
293 "reserved"
294 };
295
296 const char *riscv_cpu_get_trap_name(target_ulong cause, bool async)
297 {
298 if (async) {
299 return (cause < ARRAY_SIZE(riscv_intr_names)) ?
300 riscv_intr_names[cause] : "(unknown)";
301 } else {
302 return (cause < ARRAY_SIZE(riscv_excp_names)) ?
303 riscv_excp_names[cause] : "(unknown)";
304 }
305 }
306
307 void riscv_cpu_set_misa_ext(CPURISCVState *env, uint32_t ext)
308 {
309 env->misa_ext_mask = env->misa_ext = ext;
310 }
311
312 int riscv_cpu_max_xlen(RISCVCPUClass *mcc)
313 {
314 return 16 << mcc->misa_mxl_max;
315 }
316
317 #ifndef CONFIG_USER_ONLY
318 static uint8_t satp_mode_from_str(const char *satp_mode_str)
319 {
320 if (!strncmp(satp_mode_str, "mbare", 5)) {
321 return VM_1_10_MBARE;
322 }
323
324 if (!strncmp(satp_mode_str, "sv32", 4)) {
325 return VM_1_10_SV32;
326 }
327
328 if (!strncmp(satp_mode_str, "sv39", 4)) {
329 return VM_1_10_SV39;
330 }
331
332 if (!strncmp(satp_mode_str, "sv48", 4)) {
333 return VM_1_10_SV48;
334 }
335
336 if (!strncmp(satp_mode_str, "sv57", 4)) {
337 return VM_1_10_SV57;
338 }
339
340 if (!strncmp(satp_mode_str, "sv64", 4)) {
341 return VM_1_10_SV64;
342 }
343
344 g_assert_not_reached();
345 }
346
347 uint8_t satp_mode_max_from_map(uint32_t map)
348 {
349 /*
350 * 'map = 0' will make us return (31 - 32), which C will
351 * happily overflow to UINT_MAX. There's no good result to
352 * return if 'map = 0' (e.g. returning 0 will be ambiguous
353 * with the result for 'map = 1').
354 *
355 * Assert out if map = 0. Callers will have to deal with
356 * it outside of this function.
357 */
358 g_assert(map > 0);
359
360 /* map here has at least one bit set, so no problem with clz */
361 return 31 - __builtin_clz(map);
362 }
363
364 const char *satp_mode_str(uint8_t satp_mode, bool is_32_bit)
365 {
366 if (is_32_bit) {
367 switch (satp_mode) {
368 case VM_1_10_SV32:
369 return "sv32";
370 case VM_1_10_MBARE:
371 return "none";
372 }
373 } else {
374 switch (satp_mode) {
375 case VM_1_10_SV64:
376 return "sv64";
377 case VM_1_10_SV57:
378 return "sv57";
379 case VM_1_10_SV48:
380 return "sv48";
381 case VM_1_10_SV39:
382 return "sv39";
383 case VM_1_10_MBARE:
384 return "none";
385 }
386 }
387
388 g_assert_not_reached();
389 }
390
391 static void set_satp_mode_max_supported(RISCVCPU *cpu,
392 uint8_t satp_mode)
393 {
394 bool rv32 = riscv_cpu_mxl(&cpu->env) == MXL_RV32;
395 const bool *valid_vm = rv32 ? valid_vm_1_10_32 : valid_vm_1_10_64;
396
397 for (int i = 0; i <= satp_mode; ++i) {
398 if (valid_vm[i]) {
399 cpu->cfg.satp_mode.supported |= (1 << i);
400 }
401 }
402 }
403
404 /* Set the satp mode to the max supported */
405 static void set_satp_mode_default_map(RISCVCPU *cpu)
406 {
407 /*
408 * Bare CPUs do not default to the max available.
409 * Users must set a valid satp_mode in the command
410 * line.
411 */
412 if (object_dynamic_cast(OBJECT(cpu), TYPE_RISCV_BARE_CPU) != NULL) {
413 warn_report("No satp mode set. Defaulting to 'bare'");
414 cpu->cfg.satp_mode.map = (1 << VM_1_10_MBARE);
415 return;
416 }
417
418 cpu->cfg.satp_mode.map = cpu->cfg.satp_mode.supported;
419 }
420 #endif
421
422 static void riscv_any_cpu_init(Object *obj)
423 {
424 RISCVCPU *cpu = RISCV_CPU(obj);
425 CPURISCVState *env = &cpu->env;
426 riscv_cpu_set_misa_ext(env, RVI | RVM | RVA | RVF | RVD | RVC | RVU);
427
428 #ifndef CONFIG_USER_ONLY
429 set_satp_mode_max_supported(RISCV_CPU(obj),
430 riscv_cpu_mxl(&RISCV_CPU(obj)->env) == MXL_RV32 ?
431 VM_1_10_SV32 : VM_1_10_SV57);
432 #endif
433
434 env->priv_ver = PRIV_VERSION_LATEST;
435
436 /* inherited from parent obj via riscv_cpu_init() */
437 cpu->cfg.ext_zifencei = true;
438 cpu->cfg.ext_zicsr = true;
439 cpu->cfg.mmu = true;
440 cpu->cfg.pmp = true;
441 }
442
443 static void riscv_max_cpu_init(Object *obj)
444 {
445 RISCVCPU *cpu = RISCV_CPU(obj);
446 CPURISCVState *env = &cpu->env;
447
448 cpu->cfg.mmu = true;
449 cpu->cfg.pmp = true;
450
451 env->priv_ver = PRIV_VERSION_LATEST;
452 #ifndef CONFIG_USER_ONLY
453 #ifdef TARGET_RISCV32
454 set_satp_mode_max_supported(cpu, VM_1_10_SV32);
455 #else
456 set_satp_mode_max_supported(cpu, VM_1_10_SV57);
457 #endif
458 #endif
459 }
460
461 #if defined(TARGET_RISCV64)
462 static void rv64_base_cpu_init(Object *obj)
463 {
464 RISCVCPU *cpu = RISCV_CPU(obj);
465 CPURISCVState *env = &cpu->env;
466
467 cpu->cfg.mmu = true;
468 cpu->cfg.pmp = true;
469
470 /* Set latest version of privileged specification */
471 env->priv_ver = PRIV_VERSION_LATEST;
472 #ifndef CONFIG_USER_ONLY
473 set_satp_mode_max_supported(RISCV_CPU(obj), VM_1_10_SV57);
474 #endif
475 }
476
477 static void rv64_sifive_u_cpu_init(Object *obj)
478 {
479 RISCVCPU *cpu = RISCV_CPU(obj);
480 CPURISCVState *env = &cpu->env;
481 riscv_cpu_set_misa_ext(env, RVI | RVM | RVA | RVF | RVD | RVC | RVS | RVU);
482 env->priv_ver = PRIV_VERSION_1_10_0;
483 #ifndef CONFIG_USER_ONLY
484 set_satp_mode_max_supported(RISCV_CPU(obj), VM_1_10_SV39);
485 #endif
486
487 /* inherited from parent obj via riscv_cpu_init() */
488 cpu->cfg.ext_zifencei = true;
489 cpu->cfg.ext_zicsr = true;
490 cpu->cfg.mmu = true;
491 cpu->cfg.pmp = true;
492 }
493
494 static void rv64_sifive_e_cpu_init(Object *obj)
495 {
496 CPURISCVState *env = &RISCV_CPU(obj)->env;
497 RISCVCPU *cpu = RISCV_CPU(obj);
498
499 riscv_cpu_set_misa_ext(env, RVI | RVM | RVA | RVC | RVU);
500 env->priv_ver = PRIV_VERSION_1_10_0;
501 #ifndef CONFIG_USER_ONLY
502 set_satp_mode_max_supported(cpu, VM_1_10_MBARE);
503 #endif
504
505 /* inherited from parent obj via riscv_cpu_init() */
506 cpu->cfg.ext_zifencei = true;
507 cpu->cfg.ext_zicsr = true;
508 cpu->cfg.pmp = true;
509 }
510
511 static void rv64_thead_c906_cpu_init(Object *obj)
512 {
513 CPURISCVState *env = &RISCV_CPU(obj)->env;
514 RISCVCPU *cpu = RISCV_CPU(obj);
515
516 riscv_cpu_set_misa_ext(env, RVG | RVC | RVS | RVU);
517 env->priv_ver = PRIV_VERSION_1_11_0;
518
519 cpu->cfg.ext_zfa = true;
520 cpu->cfg.ext_zfh = true;
521 cpu->cfg.mmu = true;
522 cpu->cfg.ext_xtheadba = true;
523 cpu->cfg.ext_xtheadbb = true;
524 cpu->cfg.ext_xtheadbs = true;
525 cpu->cfg.ext_xtheadcmo = true;
526 cpu->cfg.ext_xtheadcondmov = true;
527 cpu->cfg.ext_xtheadfmemidx = true;
528 cpu->cfg.ext_xtheadmac = true;
529 cpu->cfg.ext_xtheadmemidx = true;
530 cpu->cfg.ext_xtheadmempair = true;
531 cpu->cfg.ext_xtheadsync = true;
532
533 cpu->cfg.mvendorid = THEAD_VENDOR_ID;
534 #ifndef CONFIG_USER_ONLY
535 set_satp_mode_max_supported(cpu, VM_1_10_SV39);
536 #endif
537
538 /* inherited from parent obj via riscv_cpu_init() */
539 cpu->cfg.pmp = true;
540 }
541
542 static void rv64_veyron_v1_cpu_init(Object *obj)
543 {
544 CPURISCVState *env = &RISCV_CPU(obj)->env;
545 RISCVCPU *cpu = RISCV_CPU(obj);
546
547 riscv_cpu_set_misa_ext(env, RVG | RVC | RVS | RVU | RVH);
548 env->priv_ver = PRIV_VERSION_1_12_0;
549
550 /* Enable ISA extensions */
551 cpu->cfg.mmu = true;
552 cpu->cfg.ext_zifencei = true;
553 cpu->cfg.ext_zicsr = true;
554 cpu->cfg.pmp = true;
555 cpu->cfg.ext_zicbom = true;
556 cpu->cfg.cbom_blocksize = 64;
557 cpu->cfg.cboz_blocksize = 64;
558 cpu->cfg.ext_zicboz = true;
559 cpu->cfg.ext_smaia = true;
560 cpu->cfg.ext_ssaia = true;
561 cpu->cfg.ext_sscofpmf = true;
562 cpu->cfg.ext_sstc = true;
563 cpu->cfg.ext_svinval = true;
564 cpu->cfg.ext_svnapot = true;
565 cpu->cfg.ext_svpbmt = true;
566 cpu->cfg.ext_smstateen = true;
567 cpu->cfg.ext_zba = true;
568 cpu->cfg.ext_zbb = true;
569 cpu->cfg.ext_zbc = true;
570 cpu->cfg.ext_zbs = true;
571 cpu->cfg.ext_XVentanaCondOps = true;
572
573 cpu->cfg.mvendorid = VEYRON_V1_MVENDORID;
574 cpu->cfg.marchid = VEYRON_V1_MARCHID;
575 cpu->cfg.mimpid = VEYRON_V1_MIMPID;
576
577 #ifndef CONFIG_USER_ONLY
578 set_satp_mode_max_supported(cpu, VM_1_10_SV48);
579 #endif
580 }
581
582 static void rv128_base_cpu_init(Object *obj)
583 {
584 RISCVCPU *cpu = RISCV_CPU(obj);
585 CPURISCVState *env = &cpu->env;
586
587 if (qemu_tcg_mttcg_enabled()) {
588 /* Missing 128-bit aligned atomics */
589 error_report("128-bit RISC-V currently does not work with Multi "
590 "Threaded TCG. Please use: -accel tcg,thread=single");
591 exit(EXIT_FAILURE);
592 }
593
594 cpu->cfg.mmu = true;
595 cpu->cfg.pmp = true;
596
597 /* Set latest version of privileged specification */
598 env->priv_ver = PRIV_VERSION_LATEST;
599 #ifndef CONFIG_USER_ONLY
600 set_satp_mode_max_supported(RISCV_CPU(obj), VM_1_10_SV57);
601 #endif
602 }
603
604 static void rv64i_bare_cpu_init(Object *obj)
605 {
606 CPURISCVState *env = &RISCV_CPU(obj)->env;
607 riscv_cpu_set_misa_ext(env, RVI);
608 }
609
610 static void rv64e_bare_cpu_init(Object *obj)
611 {
612 CPURISCVState *env = &RISCV_CPU(obj)->env;
613 riscv_cpu_set_misa_ext(env, RVE);
614 }
615 #else
616 static void rv32_base_cpu_init(Object *obj)
617 {
618 RISCVCPU *cpu = RISCV_CPU(obj);
619 CPURISCVState *env = &cpu->env;
620
621 cpu->cfg.mmu = true;
622 cpu->cfg.pmp = true;
623
624 /* Set latest version of privileged specification */
625 env->priv_ver = PRIV_VERSION_LATEST;
626 #ifndef CONFIG_USER_ONLY
627 set_satp_mode_max_supported(RISCV_CPU(obj), VM_1_10_SV32);
628 #endif
629 }
630
631 static void rv32_sifive_u_cpu_init(Object *obj)
632 {
633 RISCVCPU *cpu = RISCV_CPU(obj);
634 CPURISCVState *env = &cpu->env;
635 riscv_cpu_set_misa_ext(env, RVI | RVM | RVA | RVF | RVD | RVC | RVS | RVU);
636 env->priv_ver = PRIV_VERSION_1_10_0;
637 #ifndef CONFIG_USER_ONLY
638 set_satp_mode_max_supported(RISCV_CPU(obj), VM_1_10_SV32);
639 #endif
640
641 /* inherited from parent obj via riscv_cpu_init() */
642 cpu->cfg.ext_zifencei = true;
643 cpu->cfg.ext_zicsr = true;
644 cpu->cfg.mmu = true;
645 cpu->cfg.pmp = true;
646 }
647
648 static void rv32_sifive_e_cpu_init(Object *obj)
649 {
650 CPURISCVState *env = &RISCV_CPU(obj)->env;
651 RISCVCPU *cpu = RISCV_CPU(obj);
652
653 riscv_cpu_set_misa_ext(env, RVI | RVM | RVA | RVC | RVU);
654 env->priv_ver = PRIV_VERSION_1_10_0;
655 #ifndef CONFIG_USER_ONLY
656 set_satp_mode_max_supported(cpu, VM_1_10_MBARE);
657 #endif
658
659 /* inherited from parent obj via riscv_cpu_init() */
660 cpu->cfg.ext_zifencei = true;
661 cpu->cfg.ext_zicsr = true;
662 cpu->cfg.pmp = true;
663 }
664
665 static void rv32_ibex_cpu_init(Object *obj)
666 {
667 CPURISCVState *env = &RISCV_CPU(obj)->env;
668 RISCVCPU *cpu = RISCV_CPU(obj);
669
670 riscv_cpu_set_misa_ext(env, RVI | RVM | RVC | RVU);
671 env->priv_ver = PRIV_VERSION_1_12_0;
672 #ifndef CONFIG_USER_ONLY
673 set_satp_mode_max_supported(cpu, VM_1_10_MBARE);
674 #endif
675 /* inherited from parent obj via riscv_cpu_init() */
676 cpu->cfg.ext_zifencei = true;
677 cpu->cfg.ext_zicsr = true;
678 cpu->cfg.pmp = true;
679 cpu->cfg.ext_smepmp = true;
680 }
681
682 static void rv32_imafcu_nommu_cpu_init(Object *obj)
683 {
684 CPURISCVState *env = &RISCV_CPU(obj)->env;
685 RISCVCPU *cpu = RISCV_CPU(obj);
686
687 riscv_cpu_set_misa_ext(env, RVI | RVM | RVA | RVF | RVC | RVU);
688 env->priv_ver = PRIV_VERSION_1_10_0;
689 #ifndef CONFIG_USER_ONLY
690 set_satp_mode_max_supported(cpu, VM_1_10_MBARE);
691 #endif
692
693 /* inherited from parent obj via riscv_cpu_init() */
694 cpu->cfg.ext_zifencei = true;
695 cpu->cfg.ext_zicsr = true;
696 cpu->cfg.pmp = true;
697 }
698
699 static void rv32i_bare_cpu_init(Object *obj)
700 {
701 CPURISCVState *env = &RISCV_CPU(obj)->env;
702 riscv_cpu_set_misa_ext(env, RVI);
703 }
704
705 static void rv32e_bare_cpu_init(Object *obj)
706 {
707 CPURISCVState *env = &RISCV_CPU(obj)->env;
708 riscv_cpu_set_misa_ext(env, RVE);
709 }
710 #endif
711
712 static ObjectClass *riscv_cpu_class_by_name(const char *cpu_model)
713 {
714 ObjectClass *oc;
715 char *typename;
716 char **cpuname;
717
718 cpuname = g_strsplit(cpu_model, ",", 1);
719 typename = g_strdup_printf(RISCV_CPU_TYPE_NAME("%s"), cpuname[0]);
720 oc = object_class_by_name(typename);
721 g_strfreev(cpuname);
722 g_free(typename);
723
724 return oc;
725 }
726
727 char *riscv_cpu_get_name(RISCVCPU *cpu)
728 {
729 RISCVCPUClass *rcc = RISCV_CPU_GET_CLASS(cpu);
730 const char *typename = object_class_get_name(OBJECT_CLASS(rcc));
731
732 g_assert(g_str_has_suffix(typename, RISCV_CPU_TYPE_SUFFIX));
733
734 return cpu_model_from_type(typename);
735 }
736
737 static void riscv_cpu_dump_state(CPUState *cs, FILE *f, int flags)
738 {
739 RISCVCPU *cpu = RISCV_CPU(cs);
740 CPURISCVState *env = &cpu->env;
741 int i, j;
742 uint8_t *p;
743
744 #if !defined(CONFIG_USER_ONLY)
745 if (riscv_has_ext(env, RVH)) {
746 qemu_fprintf(f, " %s %d\n", "V = ", env->virt_enabled);
747 }
748 #endif
749 qemu_fprintf(f, " %s " TARGET_FMT_lx "\n", "pc ", env->pc);
750 #ifndef CONFIG_USER_ONLY
751 {
752 static const int dump_csrs[] = {
753 CSR_MHARTID,
754 CSR_MSTATUS,
755 CSR_MSTATUSH,
756 /*
757 * CSR_SSTATUS is intentionally omitted here as its value
758 * can be figured out by looking at CSR_MSTATUS
759 */
760 CSR_HSTATUS,
761 CSR_VSSTATUS,
762 CSR_MIP,
763 CSR_MIE,
764 CSR_MIDELEG,
765 CSR_HIDELEG,
766 CSR_MEDELEG,
767 CSR_HEDELEG,
768 CSR_MTVEC,
769 CSR_STVEC,
770 CSR_VSTVEC,
771 CSR_MEPC,
772 CSR_SEPC,
773 CSR_VSEPC,
774 CSR_MCAUSE,
775 CSR_SCAUSE,
776 CSR_VSCAUSE,
777 CSR_MTVAL,
778 CSR_STVAL,
779 CSR_HTVAL,
780 CSR_MTVAL2,
781 CSR_MSCRATCH,
782 CSR_SSCRATCH,
783 CSR_SATP,
784 CSR_MMTE,
785 CSR_UPMBASE,
786 CSR_UPMMASK,
787 CSR_SPMBASE,
788 CSR_SPMMASK,
789 CSR_MPMBASE,
790 CSR_MPMMASK,
791 };
792
793 for (i = 0; i < ARRAY_SIZE(dump_csrs); ++i) {
794 int csrno = dump_csrs[i];
795 target_ulong val = 0;
796 RISCVException res = riscv_csrrw_debug(env, csrno, &val, 0, 0);
797
798 /*
799 * Rely on the smode, hmode, etc, predicates within csr.c
800 * to do the filtering of the registers that are present.
801 */
802 if (res == RISCV_EXCP_NONE) {
803 qemu_fprintf(f, " %-8s " TARGET_FMT_lx "\n",
804 csr_ops[csrno].name, val);
805 }
806 }
807 }
808 #endif
809
810 for (i = 0; i < 32; i++) {
811 qemu_fprintf(f, " %-8s " TARGET_FMT_lx,
812 riscv_int_regnames[i], env->gpr[i]);
813 if ((i & 3) == 3) {
814 qemu_fprintf(f, "\n");
815 }
816 }
817 if (flags & CPU_DUMP_FPU) {
818 for (i = 0; i < 32; i++) {
819 qemu_fprintf(f, " %-8s %016" PRIx64,
820 riscv_fpr_regnames[i], env->fpr[i]);
821 if ((i & 3) == 3) {
822 qemu_fprintf(f, "\n");
823 }
824 }
825 }
826 if (riscv_has_ext(env, RVV) && (flags & CPU_DUMP_VPU)) {
827 static const int dump_rvv_csrs[] = {
828 CSR_VSTART,
829 CSR_VXSAT,
830 CSR_VXRM,
831 CSR_VCSR,
832 CSR_VL,
833 CSR_VTYPE,
834 CSR_VLENB,
835 };
836 for (i = 0; i < ARRAY_SIZE(dump_rvv_csrs); ++i) {
837 int csrno = dump_rvv_csrs[i];
838 target_ulong val = 0;
839 RISCVException res = riscv_csrrw_debug(env, csrno, &val, 0, 0);
840
841 /*
842 * Rely on the smode, hmode, etc, predicates within csr.c
843 * to do the filtering of the registers that are present.
844 */
845 if (res == RISCV_EXCP_NONE) {
846 qemu_fprintf(f, " %-8s " TARGET_FMT_lx "\n",
847 csr_ops[csrno].name, val);
848 }
849 }
850 uint16_t vlenb = cpu->cfg.vlenb;
851
852 for (i = 0; i < 32; i++) {
853 qemu_fprintf(f, " %-8s ", riscv_rvv_regnames[i]);
854 p = (uint8_t *)env->vreg;
855 for (j = vlenb - 1 ; j >= 0; j--) {
856 qemu_fprintf(f, "%02x", *(p + i * vlenb + BYTE(j)));
857 }
858 qemu_fprintf(f, "\n");
859 }
860 }
861 }
862
863 static void riscv_cpu_set_pc(CPUState *cs, vaddr value)
864 {
865 RISCVCPU *cpu = RISCV_CPU(cs);
866 CPURISCVState *env = &cpu->env;
867
868 if (env->xl == MXL_RV32) {
869 env->pc = (int32_t)value;
870 } else {
871 env->pc = value;
872 }
873 }
874
875 static vaddr riscv_cpu_get_pc(CPUState *cs)
876 {
877 RISCVCPU *cpu = RISCV_CPU(cs);
878 CPURISCVState *env = &cpu->env;
879
880 /* Match cpu_get_tb_cpu_state. */
881 if (env->xl == MXL_RV32) {
882 return env->pc & UINT32_MAX;
883 }
884 return env->pc;
885 }
886
887 static bool riscv_cpu_has_work(CPUState *cs)
888 {
889 #ifndef CONFIG_USER_ONLY
890 RISCVCPU *cpu = RISCV_CPU(cs);
891 CPURISCVState *env = &cpu->env;
892 /*
893 * Definition of the WFI instruction requires it to ignore the privilege
894 * mode and delegation registers, but respect individual enables
895 */
896 return riscv_cpu_all_pending(env) != 0 ||
897 riscv_cpu_sirq_pending(env) != RISCV_EXCP_NONE ||
898 riscv_cpu_vsirq_pending(env) != RISCV_EXCP_NONE;
899 #else
900 return true;
901 #endif
902 }
903
904 static int riscv_cpu_mmu_index(CPUState *cs, bool ifetch)
905 {
906 return riscv_env_mmu_index(cpu_env(cs), ifetch);
907 }
908
909 static void riscv_cpu_reset_hold(Object *obj)
910 {
911 #ifndef CONFIG_USER_ONLY
912 uint8_t iprio;
913 int i, irq, rdzero;
914 #endif
915 CPUState *cs = CPU(obj);
916 RISCVCPU *cpu = RISCV_CPU(cs);
917 RISCVCPUClass *mcc = RISCV_CPU_GET_CLASS(cpu);
918 CPURISCVState *env = &cpu->env;
919
920 if (mcc->parent_phases.hold) {
921 mcc->parent_phases.hold(obj);
922 }
923 #ifndef CONFIG_USER_ONLY
924 env->misa_mxl = mcc->misa_mxl_max;
925 env->priv = PRV_M;
926 env->mstatus &= ~(MSTATUS_MIE | MSTATUS_MPRV);
927 if (env->misa_mxl > MXL_RV32) {
928 /*
929 * The reset status of SXL/UXL is undefined, but mstatus is WARL
930 * and we must ensure that the value after init is valid for read.
931 */
932 env->mstatus = set_field(env->mstatus, MSTATUS64_SXL, env->misa_mxl);
933 env->mstatus = set_field(env->mstatus, MSTATUS64_UXL, env->misa_mxl);
934 if (riscv_has_ext(env, RVH)) {
935 env->vsstatus = set_field(env->vsstatus,
936 MSTATUS64_SXL, env->misa_mxl);
937 env->vsstatus = set_field(env->vsstatus,
938 MSTATUS64_UXL, env->misa_mxl);
939 env->mstatus_hs = set_field(env->mstatus_hs,
940 MSTATUS64_SXL, env->misa_mxl);
941 env->mstatus_hs = set_field(env->mstatus_hs,
942 MSTATUS64_UXL, env->misa_mxl);
943 }
944 }
945 env->mcause = 0;
946 env->miclaim = MIP_SGEIP;
947 env->pc = env->resetvec;
948 env->bins = 0;
949 env->two_stage_lookup = false;
950
951 env->menvcfg = (cpu->cfg.ext_svpbmt ? MENVCFG_PBMTE : 0) |
952 (cpu->cfg.ext_svadu ? MENVCFG_ADUE : 0);
953 env->henvcfg = (cpu->cfg.ext_svpbmt ? HENVCFG_PBMTE : 0) |
954 (cpu->cfg.ext_svadu ? HENVCFG_ADUE : 0);
955
956 /* Initialized default priorities of local interrupts. */
957 for (i = 0; i < ARRAY_SIZE(env->miprio); i++) {
958 iprio = riscv_cpu_default_priority(i);
959 env->miprio[i] = (i == IRQ_M_EXT) ? 0 : iprio;
960 env->siprio[i] = (i == IRQ_S_EXT) ? 0 : iprio;
961 env->hviprio[i] = 0;
962 }
963 i = 0;
964 while (!riscv_cpu_hviprio_index2irq(i, &irq, &rdzero)) {
965 if (!rdzero) {
966 env->hviprio[irq] = env->miprio[irq];
967 }
968 i++;
969 }
970 /* mmte is supposed to have pm.current hardwired to 1 */
971 env->mmte |= (EXT_STATUS_INITIAL | MMTE_M_PM_CURRENT);
972
973 /*
974 * Bits 10, 6, 2 and 12 of mideleg are read only 1 when the Hypervisor
975 * extension is enabled.
976 */
977 if (riscv_has_ext(env, RVH)) {
978 env->mideleg |= HS_MODE_INTERRUPTS;
979 }
980
981 /*
982 * Clear mseccfg and unlock all the PMP entries upon reset.
983 * This is allowed as per the priv and smepmp specifications
984 * and is needed to clear stale entries across reboots.
985 */
986 if (riscv_cpu_cfg(env)->ext_smepmp) {
987 env->mseccfg = 0;
988 }
989
990 pmp_unlock_entries(env);
991 #endif
992 env->xl = riscv_cpu_mxl(env);
993 riscv_cpu_update_mask(env);
994 cs->exception_index = RISCV_EXCP_NONE;
995 env->load_res = -1;
996 set_default_nan_mode(1, &env->fp_status);
997
998 #ifndef CONFIG_USER_ONLY
999 if (cpu->cfg.debug) {
1000 riscv_trigger_reset_hold(env);
1001 }
1002
1003 if (kvm_enabled()) {
1004 kvm_riscv_reset_vcpu(cpu);
1005 }
1006 #endif
1007 }
1008
1009 static void riscv_cpu_disas_set_info(CPUState *s, disassemble_info *info)
1010 {
1011 RISCVCPU *cpu = RISCV_CPU(s);
1012 CPURISCVState *env = &cpu->env;
1013 info->target_info = &cpu->cfg;
1014
1015 switch (env->xl) {
1016 case MXL_RV32:
1017 info->print_insn = print_insn_riscv32;
1018 break;
1019 case MXL_RV64:
1020 info->print_insn = print_insn_riscv64;
1021 break;
1022 case MXL_RV128:
1023 info->print_insn = print_insn_riscv128;
1024 break;
1025 default:
1026 g_assert_not_reached();
1027 }
1028 }
1029
1030 #ifndef CONFIG_USER_ONLY
1031 static void riscv_cpu_satp_mode_finalize(RISCVCPU *cpu, Error **errp)
1032 {
1033 bool rv32 = riscv_cpu_is_32bit(cpu);
1034 uint8_t satp_mode_map_max, satp_mode_supported_max;
1035
1036 /* The CPU wants the OS to decide which satp mode to use */
1037 if (cpu->cfg.satp_mode.supported == 0) {
1038 return;
1039 }
1040
1041 satp_mode_supported_max =
1042 satp_mode_max_from_map(cpu->cfg.satp_mode.supported);
1043
1044 if (cpu->cfg.satp_mode.map == 0) {
1045 if (cpu->cfg.satp_mode.init == 0) {
1046 /* If unset by the user, we fallback to the default satp mode. */
1047 set_satp_mode_default_map(cpu);
1048 } else {
1049 /*
1050 * Find the lowest level that was disabled and then enable the
1051 * first valid level below which can be found in
1052 * valid_vm_1_10_32/64.
1053 */
1054 for (int i = 1; i < 16; ++i) {
1055 if ((cpu->cfg.satp_mode.init & (1 << i)) &&
1056 (cpu->cfg.satp_mode.supported & (1 << i))) {
1057 for (int j = i - 1; j >= 0; --j) {
1058 if (cpu->cfg.satp_mode.supported & (1 << j)) {
1059 cpu->cfg.satp_mode.map |= (1 << j);
1060 break;
1061 }
1062 }
1063 break;
1064 }
1065 }
1066 }
1067 }
1068
1069 satp_mode_map_max = satp_mode_max_from_map(cpu->cfg.satp_mode.map);
1070
1071 /* Make sure the user asked for a supported configuration (HW and qemu) */
1072 if (satp_mode_map_max > satp_mode_supported_max) {
1073 error_setg(errp, "satp_mode %s is higher than hw max capability %s",
1074 satp_mode_str(satp_mode_map_max, rv32),
1075 satp_mode_str(satp_mode_supported_max, rv32));
1076 return;
1077 }
1078
1079 /*
1080 * Make sure the user did not ask for an invalid configuration as per
1081 * the specification.
1082 */
1083 if (!rv32) {
1084 for (int i = satp_mode_map_max - 1; i >= 0; --i) {
1085 if (!(cpu->cfg.satp_mode.map & (1 << i)) &&
1086 (cpu->cfg.satp_mode.init & (1 << i)) &&
1087 (cpu->cfg.satp_mode.supported & (1 << i))) {
1088 error_setg(errp, "cannot disable %s satp mode if %s "
1089 "is enabled", satp_mode_str(i, false),
1090 satp_mode_str(satp_mode_map_max, false));
1091 return;
1092 }
1093 }
1094 }
1095
1096 /* Finally expand the map so that all valid modes are set */
1097 for (int i = satp_mode_map_max - 1; i >= 0; --i) {
1098 if (cpu->cfg.satp_mode.supported & (1 << i)) {
1099 cpu->cfg.satp_mode.map |= (1 << i);
1100 }
1101 }
1102 }
1103 #endif
1104
1105 void riscv_cpu_finalize_features(RISCVCPU *cpu, Error **errp)
1106 {
1107 Error *local_err = NULL;
1108
1109 #ifndef CONFIG_USER_ONLY
1110 riscv_cpu_satp_mode_finalize(cpu, &local_err);
1111 if (local_err != NULL) {
1112 error_propagate(errp, local_err);
1113 return;
1114 }
1115 #endif
1116
1117 if (tcg_enabled()) {
1118 riscv_tcg_cpu_finalize_features(cpu, &local_err);
1119 if (local_err != NULL) {
1120 error_propagate(errp, local_err);
1121 return;
1122 }
1123 } else if (kvm_enabled()) {
1124 riscv_kvm_cpu_finalize_features(cpu, &local_err);
1125 if (local_err != NULL) {
1126 error_propagate(errp, local_err);
1127 return;
1128 }
1129 }
1130 }
1131
1132 static void riscv_cpu_realize(DeviceState *dev, Error **errp)
1133 {
1134 CPUState *cs = CPU(dev);
1135 RISCVCPU *cpu = RISCV_CPU(dev);
1136 RISCVCPUClass *mcc = RISCV_CPU_GET_CLASS(dev);
1137 Error *local_err = NULL;
1138
1139 if (object_dynamic_cast(OBJECT(dev), TYPE_RISCV_CPU_ANY) != NULL) {
1140 warn_report("The 'any' CPU is deprecated and will be "
1141 "removed in the future.");
1142 }
1143
1144 cpu_exec_realizefn(cs, &local_err);
1145 if (local_err != NULL) {
1146 error_propagate(errp, local_err);
1147 return;
1148 }
1149
1150 riscv_cpu_finalize_features(cpu, &local_err);
1151 if (local_err != NULL) {
1152 error_propagate(errp, local_err);
1153 return;
1154 }
1155
1156 riscv_cpu_register_gdb_regs_for_features(cs);
1157
1158 #ifndef CONFIG_USER_ONLY
1159 if (cpu->cfg.debug) {
1160 riscv_trigger_realize(&cpu->env);
1161 }
1162 #endif
1163
1164 qemu_init_vcpu(cs);
1165 cpu_reset(cs);
1166
1167 mcc->parent_realize(dev, errp);
1168 }
1169
1170 bool riscv_cpu_accelerator_compatible(RISCVCPU *cpu)
1171 {
1172 if (tcg_enabled()) {
1173 return riscv_cpu_tcg_compatible(cpu);
1174 }
1175
1176 return true;
1177 }
1178
1179 #ifndef CONFIG_USER_ONLY
1180 static void cpu_riscv_get_satp(Object *obj, Visitor *v, const char *name,
1181 void *opaque, Error **errp)
1182 {
1183 RISCVSATPMap *satp_map = opaque;
1184 uint8_t satp = satp_mode_from_str(name);
1185 bool value;
1186
1187 value = satp_map->map & (1 << satp);
1188
1189 visit_type_bool(v, name, &value, errp);
1190 }
1191
1192 static void cpu_riscv_set_satp(Object *obj, Visitor *v, const char *name,
1193 void *opaque, Error **errp)
1194 {
1195 RISCVSATPMap *satp_map = opaque;
1196 uint8_t satp = satp_mode_from_str(name);
1197 bool value;
1198
1199 if (!visit_type_bool(v, name, &value, errp)) {
1200 return;
1201 }
1202
1203 satp_map->map = deposit32(satp_map->map, satp, 1, value);
1204 satp_map->init |= 1 << satp;
1205 }
1206
1207 void riscv_add_satp_mode_properties(Object *obj)
1208 {
1209 RISCVCPU *cpu = RISCV_CPU(obj);
1210
1211 if (cpu->env.misa_mxl == MXL_RV32) {
1212 object_property_add(obj, "sv32", "bool", cpu_riscv_get_satp,
1213 cpu_riscv_set_satp, NULL, &cpu->cfg.satp_mode);
1214 } else {
1215 object_property_add(obj, "sv39", "bool", cpu_riscv_get_satp,
1216 cpu_riscv_set_satp, NULL, &cpu->cfg.satp_mode);
1217 object_property_add(obj, "sv48", "bool", cpu_riscv_get_satp,
1218 cpu_riscv_set_satp, NULL, &cpu->cfg.satp_mode);
1219 object_property_add(obj, "sv57", "bool", cpu_riscv_get_satp,
1220 cpu_riscv_set_satp, NULL, &cpu->cfg.satp_mode);
1221 object_property_add(obj, "sv64", "bool", cpu_riscv_get_satp,
1222 cpu_riscv_set_satp, NULL, &cpu->cfg.satp_mode);
1223 }
1224 }
1225
1226 static void riscv_cpu_set_irq(void *opaque, int irq, int level)
1227 {
1228 RISCVCPU *cpu = RISCV_CPU(opaque);
1229 CPURISCVState *env = &cpu->env;
1230
1231 if (irq < IRQ_LOCAL_MAX) {
1232 switch (irq) {
1233 case IRQ_U_SOFT:
1234 case IRQ_S_SOFT:
1235 case IRQ_VS_SOFT:
1236 case IRQ_M_SOFT:
1237 case IRQ_U_TIMER:
1238 case IRQ_S_TIMER:
1239 case IRQ_VS_TIMER:
1240 case IRQ_M_TIMER:
1241 case IRQ_U_EXT:
1242 case IRQ_VS_EXT:
1243 case IRQ_M_EXT:
1244 if (kvm_enabled()) {
1245 kvm_riscv_set_irq(cpu, irq, level);
1246 } else {
1247 riscv_cpu_update_mip(env, 1 << irq, BOOL_TO_MASK(level));
1248 }
1249 break;
1250 case IRQ_S_EXT:
1251 if (kvm_enabled()) {
1252 kvm_riscv_set_irq(cpu, irq, level);
1253 } else {
1254 env->external_seip = level;
1255 riscv_cpu_update_mip(env, 1 << irq,
1256 BOOL_TO_MASK(level | env->software_seip));
1257 }
1258 break;
1259 default:
1260 g_assert_not_reached();
1261 }
1262 } else if (irq < (IRQ_LOCAL_MAX + IRQ_LOCAL_GUEST_MAX)) {
1263 /* Require H-extension for handling guest local interrupts */
1264 if (!riscv_has_ext(env, RVH)) {
1265 g_assert_not_reached();
1266 }
1267
1268 /* Compute bit position in HGEIP CSR */
1269 irq = irq - IRQ_LOCAL_MAX + 1;
1270 if (env->geilen < irq) {
1271 g_assert_not_reached();
1272 }
1273
1274 /* Update HGEIP CSR */
1275 env->hgeip &= ~((target_ulong)1 << irq);
1276 if (level) {
1277 env->hgeip |= (target_ulong)1 << irq;
1278 }
1279
1280 /* Update mip.SGEIP bit */
1281 riscv_cpu_update_mip(env, MIP_SGEIP,
1282 BOOL_TO_MASK(!!(env->hgeie & env->hgeip)));
1283 } else {
1284 g_assert_not_reached();
1285 }
1286 }
1287 #endif /* CONFIG_USER_ONLY */
1288
1289 static bool riscv_cpu_is_dynamic(Object *cpu_obj)
1290 {
1291 return object_dynamic_cast(cpu_obj, TYPE_RISCV_DYNAMIC_CPU) != NULL;
1292 }
1293
1294 static void riscv_cpu_post_init(Object *obj)
1295 {
1296 accel_cpu_instance_init(CPU(obj));
1297 }
1298
1299 static void riscv_cpu_init(Object *obj)
1300 {
1301 RISCVCPUClass *mcc = RISCV_CPU_GET_CLASS(obj);
1302 RISCVCPU *cpu = RISCV_CPU(obj);
1303 CPURISCVState *env = &cpu->env;
1304
1305 env->misa_mxl = mcc->misa_mxl_max;
1306
1307 #ifndef CONFIG_USER_ONLY
1308 qdev_init_gpio_in(DEVICE(obj), riscv_cpu_set_irq,
1309 IRQ_LOCAL_MAX + IRQ_LOCAL_GUEST_MAX);
1310 #endif /* CONFIG_USER_ONLY */
1311
1312 general_user_opts = g_hash_table_new(g_str_hash, g_str_equal);
1313
1314 /*
1315 * The timer and performance counters extensions were supported
1316 * in QEMU before they were added as discrete extensions in the
1317 * ISA. To keep compatibility we'll always default them to 'true'
1318 * for all CPUs. Each accelerator will decide what to do when
1319 * users disable them.
1320 */
1321 RISCV_CPU(obj)->cfg.ext_zicntr = true;
1322 RISCV_CPU(obj)->cfg.ext_zihpm = true;
1323
1324 /* Default values for non-bool cpu properties */
1325 cpu->cfg.pmu_mask = MAKE_64BIT_MASK(3, 16);
1326 cpu->cfg.vlenb = 128 >> 3;
1327 cpu->cfg.elen = 64;
1328 cpu->cfg.cbom_blocksize = 64;
1329 cpu->cfg.cbop_blocksize = 64;
1330 cpu->cfg.cboz_blocksize = 64;
1331 cpu->env.vext_ver = VEXT_VERSION_1_00_0;
1332 }
1333
1334 static void riscv_bare_cpu_init(Object *obj)
1335 {
1336 RISCVCPU *cpu = RISCV_CPU(obj);
1337
1338 /*
1339 * Bare CPUs do not inherit the timer and performance
1340 * counters from the parent class (see riscv_cpu_init()
1341 * for info on why the parent enables them).
1342 *
1343 * Users have to explicitly enable these counters for
1344 * bare CPUs.
1345 */
1346 cpu->cfg.ext_zicntr = false;
1347 cpu->cfg.ext_zihpm = false;
1348
1349 /* Set to QEMU's first supported priv version */
1350 cpu->env.priv_ver = PRIV_VERSION_1_10_0;
1351
1352 /*
1353 * Support all available satp_mode settings. The default
1354 * value will be set to MBARE if the user doesn't set
1355 * satp_mode manually (see set_satp_mode_default()).
1356 */
1357 #ifndef CONFIG_USER_ONLY
1358 set_satp_mode_max_supported(cpu, VM_1_10_SV64);
1359 #endif
1360 }
1361
1362 typedef struct misa_ext_info {
1363 const char *name;
1364 const char *description;
1365 } MISAExtInfo;
1366
1367 #define MISA_INFO_IDX(_bit) \
1368 __builtin_ctz(_bit)
1369
1370 #define MISA_EXT_INFO(_bit, _propname, _descr) \
1371 [MISA_INFO_IDX(_bit)] = {.name = _propname, .description = _descr}
1372
1373 static const MISAExtInfo misa_ext_info_arr[] = {
1374 MISA_EXT_INFO(RVA, "a", "Atomic instructions"),
1375 MISA_EXT_INFO(RVC, "c", "Compressed instructions"),
1376 MISA_EXT_INFO(RVD, "d", "Double-precision float point"),
1377 MISA_EXT_INFO(RVF, "f", "Single-precision float point"),
1378 MISA_EXT_INFO(RVI, "i", "Base integer instruction set"),
1379 MISA_EXT_INFO(RVE, "e", "Base integer instruction set (embedded)"),
1380 MISA_EXT_INFO(RVM, "m", "Integer multiplication and division"),
1381 MISA_EXT_INFO(RVS, "s", "Supervisor-level instructions"),
1382 MISA_EXT_INFO(RVU, "u", "User-level instructions"),
1383 MISA_EXT_INFO(RVH, "h", "Hypervisor"),
1384 MISA_EXT_INFO(RVJ, "x-j", "Dynamic translated languages"),
1385 MISA_EXT_INFO(RVV, "v", "Vector operations"),
1386 MISA_EXT_INFO(RVG, "g", "General purpose (IMAFD_Zicsr_Zifencei)"),
1387 MISA_EXT_INFO(RVB, "x-b", "Bit manipulation (Zba_Zbb_Zbs)")
1388 };
1389
1390 static void riscv_cpu_validate_misa_mxl(RISCVCPUClass *mcc)
1391 {
1392 CPUClass *cc = CPU_CLASS(mcc);
1393
1394 /* Validate that MISA_MXL is set properly. */
1395 switch (mcc->misa_mxl_max) {
1396 #ifdef TARGET_RISCV64
1397 case MXL_RV64:
1398 case MXL_RV128:
1399 cc->gdb_core_xml_file = "riscv-64bit-cpu.xml";
1400 break;
1401 #endif
1402 case MXL_RV32:
1403 cc->gdb_core_xml_file = "riscv-32bit-cpu.xml";
1404 break;
1405 default:
1406 g_assert_not_reached();
1407 }
1408 }
1409
1410 static int riscv_validate_misa_info_idx(uint32_t bit)
1411 {
1412 int idx;
1413
1414 /*
1415 * Our lowest valid input (RVA) is 1 and
1416 * __builtin_ctz() is UB with zero.
1417 */
1418 g_assert(bit != 0);
1419 idx = MISA_INFO_IDX(bit);
1420
1421 g_assert(idx < ARRAY_SIZE(misa_ext_info_arr));
1422 return idx;
1423 }
1424
1425 const char *riscv_get_misa_ext_name(uint32_t bit)
1426 {
1427 int idx = riscv_validate_misa_info_idx(bit);
1428 const char *val = misa_ext_info_arr[idx].name;
1429
1430 g_assert(val != NULL);
1431 return val;
1432 }
1433
1434 const char *riscv_get_misa_ext_description(uint32_t bit)
1435 {
1436 int idx = riscv_validate_misa_info_idx(bit);
1437 const char *val = misa_ext_info_arr[idx].description;
1438
1439 g_assert(val != NULL);
1440 return val;
1441 }
1442
1443 #define MULTI_EXT_CFG_BOOL(_name, _prop, _defval) \
1444 {.name = _name, .offset = CPU_CFG_OFFSET(_prop), \
1445 .enabled = _defval}
1446
1447 const RISCVCPUMultiExtConfig riscv_cpu_extensions[] = {
1448 /* Defaults for standard extensions */
1449 MULTI_EXT_CFG_BOOL("sscofpmf", ext_sscofpmf, false),
1450 MULTI_EXT_CFG_BOOL("zifencei", ext_zifencei, true),
1451 MULTI_EXT_CFG_BOOL("zicsr", ext_zicsr, true),
1452 MULTI_EXT_CFG_BOOL("zihintntl", ext_zihintntl, true),
1453 MULTI_EXT_CFG_BOOL("zihintpause", ext_zihintpause, true),
1454 MULTI_EXT_CFG_BOOL("zacas", ext_zacas, false),
1455 MULTI_EXT_CFG_BOOL("zawrs", ext_zawrs, true),
1456 MULTI_EXT_CFG_BOOL("zfa", ext_zfa, true),
1457 MULTI_EXT_CFG_BOOL("zfh", ext_zfh, false),
1458 MULTI_EXT_CFG_BOOL("zfhmin", ext_zfhmin, false),
1459 MULTI_EXT_CFG_BOOL("zve32f", ext_zve32f, false),
1460 MULTI_EXT_CFG_BOOL("zve64f", ext_zve64f, false),
1461 MULTI_EXT_CFG_BOOL("zve64d", ext_zve64d, false),
1462 MULTI_EXT_CFG_BOOL("sstc", ext_sstc, true),
1463
1464 MULTI_EXT_CFG_BOOL("smepmp", ext_smepmp, false),
1465 MULTI_EXT_CFG_BOOL("smstateen", ext_smstateen, false),
1466 MULTI_EXT_CFG_BOOL("svadu", ext_svadu, true),
1467 MULTI_EXT_CFG_BOOL("svinval", ext_svinval, false),
1468 MULTI_EXT_CFG_BOOL("svnapot", ext_svnapot, false),
1469 MULTI_EXT_CFG_BOOL("svpbmt", ext_svpbmt, false),
1470
1471 MULTI_EXT_CFG_BOOL("zicntr", ext_zicntr, true),
1472 MULTI_EXT_CFG_BOOL("zihpm", ext_zihpm, true),
1473
1474 MULTI_EXT_CFG_BOOL("zba", ext_zba, true),
1475 MULTI_EXT_CFG_BOOL("zbb", ext_zbb, true),
1476 MULTI_EXT_CFG_BOOL("zbc", ext_zbc, true),
1477 MULTI_EXT_CFG_BOOL("zbkb", ext_zbkb, false),
1478 MULTI_EXT_CFG_BOOL("zbkc", ext_zbkc, false),
1479 MULTI_EXT_CFG_BOOL("zbkx", ext_zbkx, false),
1480 MULTI_EXT_CFG_BOOL("zbs", ext_zbs, true),
1481 MULTI_EXT_CFG_BOOL("zk", ext_zk, false),
1482 MULTI_EXT_CFG_BOOL("zkn", ext_zkn, false),
1483 MULTI_EXT_CFG_BOOL("zknd", ext_zknd, false),
1484 MULTI_EXT_CFG_BOOL("zkne", ext_zkne, false),
1485 MULTI_EXT_CFG_BOOL("zknh", ext_zknh, false),
1486 MULTI_EXT_CFG_BOOL("zkr", ext_zkr, false),
1487 MULTI_EXT_CFG_BOOL("zks", ext_zks, false),
1488 MULTI_EXT_CFG_BOOL("zksed", ext_zksed, false),
1489 MULTI_EXT_CFG_BOOL("zksh", ext_zksh, false),
1490 MULTI_EXT_CFG_BOOL("zkt", ext_zkt, false),
1491
1492 MULTI_EXT_CFG_BOOL("zdinx", ext_zdinx, false),
1493 MULTI_EXT_CFG_BOOL("zfinx", ext_zfinx, false),
1494 MULTI_EXT_CFG_BOOL("zhinx", ext_zhinx, false),
1495 MULTI_EXT_CFG_BOOL("zhinxmin", ext_zhinxmin, false),
1496
1497 MULTI_EXT_CFG_BOOL("zicbom", ext_zicbom, true),
1498 MULTI_EXT_CFG_BOOL("zicbop", ext_zicbop, true),
1499 MULTI_EXT_CFG_BOOL("zicboz", ext_zicboz, true),
1500
1501 MULTI_EXT_CFG_BOOL("zmmul", ext_zmmul, false),
1502
1503 MULTI_EXT_CFG_BOOL("zca", ext_zca, false),
1504 MULTI_EXT_CFG_BOOL("zcb", ext_zcb, false),
1505 MULTI_EXT_CFG_BOOL("zcd", ext_zcd, false),
1506 MULTI_EXT_CFG_BOOL("zce", ext_zce, false),
1507 MULTI_EXT_CFG_BOOL("zcf", ext_zcf, false),
1508 MULTI_EXT_CFG_BOOL("zcmp", ext_zcmp, false),
1509 MULTI_EXT_CFG_BOOL("zcmt", ext_zcmt, false),
1510 MULTI_EXT_CFG_BOOL("zicond", ext_zicond, false),
1511
1512 /* Vector cryptography extensions */
1513 MULTI_EXT_CFG_BOOL("zvbb", ext_zvbb, false),
1514 MULTI_EXT_CFG_BOOL("zvbc", ext_zvbc, false),
1515 MULTI_EXT_CFG_BOOL("zvkb", ext_zvkg, false),
1516 MULTI_EXT_CFG_BOOL("zvkg", ext_zvkg, false),
1517 MULTI_EXT_CFG_BOOL("zvkned", ext_zvkned, false),
1518 MULTI_EXT_CFG_BOOL("zvknha", ext_zvknha, false),
1519 MULTI_EXT_CFG_BOOL("zvknhb", ext_zvknhb, false),
1520 MULTI_EXT_CFG_BOOL("zvksed", ext_zvksed, false),
1521 MULTI_EXT_CFG_BOOL("zvksh", ext_zvksh, false),
1522 MULTI_EXT_CFG_BOOL("zvkt", ext_zvkt, false),
1523 MULTI_EXT_CFG_BOOL("zvkn", ext_zvkn, false),
1524 MULTI_EXT_CFG_BOOL("zvknc", ext_zvknc, false),
1525 MULTI_EXT_CFG_BOOL("zvkng", ext_zvkng, false),
1526 MULTI_EXT_CFG_BOOL("zvks", ext_zvks, false),
1527 MULTI_EXT_CFG_BOOL("zvksc", ext_zvksc, false),
1528 MULTI_EXT_CFG_BOOL("zvksg", ext_zvksg, false),
1529
1530 DEFINE_PROP_END_OF_LIST(),
1531 };
1532
1533 const RISCVCPUMultiExtConfig riscv_cpu_vendor_exts[] = {
1534 MULTI_EXT_CFG_BOOL("xtheadba", ext_xtheadba, false),
1535 MULTI_EXT_CFG_BOOL("xtheadbb", ext_xtheadbb, false),
1536 MULTI_EXT_CFG_BOOL("xtheadbs", ext_xtheadbs, false),
1537 MULTI_EXT_CFG_BOOL("xtheadcmo", ext_xtheadcmo, false),
1538 MULTI_EXT_CFG_BOOL("xtheadcondmov", ext_xtheadcondmov, false),
1539 MULTI_EXT_CFG_BOOL("xtheadfmemidx", ext_xtheadfmemidx, false),
1540 MULTI_EXT_CFG_BOOL("xtheadfmv", ext_xtheadfmv, false),
1541 MULTI_EXT_CFG_BOOL("xtheadmac", ext_xtheadmac, false),
1542 MULTI_EXT_CFG_BOOL("xtheadmemidx", ext_xtheadmemidx, false),
1543 MULTI_EXT_CFG_BOOL("xtheadmempair", ext_xtheadmempair, false),
1544 MULTI_EXT_CFG_BOOL("xtheadsync", ext_xtheadsync, false),
1545 MULTI_EXT_CFG_BOOL("xventanacondops", ext_XVentanaCondOps, false),
1546
1547 DEFINE_PROP_END_OF_LIST(),
1548 };
1549
1550 /* These are experimental so mark with 'x-' */
1551 const RISCVCPUMultiExtConfig riscv_cpu_experimental_exts[] = {
1552 MULTI_EXT_CFG_BOOL("x-smaia", ext_smaia, false),
1553 MULTI_EXT_CFG_BOOL("x-ssaia", ext_ssaia, false),
1554
1555 MULTI_EXT_CFG_BOOL("x-zaamo", ext_zaamo, false),
1556 MULTI_EXT_CFG_BOOL("x-zalrsc", ext_zalrsc, false),
1557
1558 MULTI_EXT_CFG_BOOL("x-zvfh", ext_zvfh, false),
1559 MULTI_EXT_CFG_BOOL("x-zvfhmin", ext_zvfhmin, false),
1560
1561 MULTI_EXT_CFG_BOOL("x-zfbfmin", ext_zfbfmin, false),
1562 MULTI_EXT_CFG_BOOL("x-zvfbfmin", ext_zvfbfmin, false),
1563 MULTI_EXT_CFG_BOOL("x-zvfbfwma", ext_zvfbfwma, false),
1564
1565 DEFINE_PROP_END_OF_LIST(),
1566 };
1567
1568 const RISCVCPUMultiExtConfig riscv_cpu_named_features[] = {
1569 MULTI_EXT_CFG_BOOL("svade", svade, true),
1570 MULTI_EXT_CFG_BOOL("zic64b", zic64b, true),
1571
1572 DEFINE_PROP_END_OF_LIST(),
1573 };
1574
1575 /* Deprecated entries marked for future removal */
1576 const RISCVCPUMultiExtConfig riscv_cpu_deprecated_exts[] = {
1577 MULTI_EXT_CFG_BOOL("Zifencei", ext_zifencei, true),
1578 MULTI_EXT_CFG_BOOL("Zicsr", ext_zicsr, true),
1579 MULTI_EXT_CFG_BOOL("Zihintntl", ext_zihintntl, true),
1580 MULTI_EXT_CFG_BOOL("Zihintpause", ext_zihintpause, true),
1581 MULTI_EXT_CFG_BOOL("Zawrs", ext_zawrs, true),
1582 MULTI_EXT_CFG_BOOL("Zfa", ext_zfa, true),
1583 MULTI_EXT_CFG_BOOL("Zfh", ext_zfh, false),
1584 MULTI_EXT_CFG_BOOL("Zfhmin", ext_zfhmin, false),
1585 MULTI_EXT_CFG_BOOL("Zve32f", ext_zve32f, false),
1586 MULTI_EXT_CFG_BOOL("Zve64f", ext_zve64f, false),
1587 MULTI_EXT_CFG_BOOL("Zve64d", ext_zve64d, false),
1588
1589 DEFINE_PROP_END_OF_LIST(),
1590 };
1591
1592 static void cpu_set_prop_err(RISCVCPU *cpu, const char *propname,
1593 Error **errp)
1594 {
1595 g_autofree char *cpuname = riscv_cpu_get_name(cpu);
1596 error_setg(errp, "CPU '%s' does not allow changing the value of '%s'",
1597 cpuname, propname);
1598 }
1599
1600 static void prop_pmu_num_set(Object *obj, Visitor *v, const char *name,
1601 void *opaque, Error **errp)
1602 {
1603 RISCVCPU *cpu = RISCV_CPU(obj);
1604 uint8_t pmu_num, curr_pmu_num;
1605 uint32_t pmu_mask;
1606
1607 visit_type_uint8(v, name, &pmu_num, errp);
1608
1609 curr_pmu_num = ctpop32(cpu->cfg.pmu_mask);
1610
1611 if (pmu_num != curr_pmu_num && riscv_cpu_is_vendor(obj)) {
1612 cpu_set_prop_err(cpu, name, errp);
1613 error_append_hint(errp, "Current '%s' val: %u\n",
1614 name, curr_pmu_num);
1615 return;
1616 }
1617
1618 if (pmu_num > (RV_MAX_MHPMCOUNTERS - 3)) {
1619 error_setg(errp, "Number of counters exceeds maximum available");
1620 return;
1621 }
1622
1623 if (pmu_num == 0) {
1624 pmu_mask = 0;
1625 } else {
1626 pmu_mask = MAKE_64BIT_MASK(3, pmu_num);
1627 }
1628
1629 warn_report("\"pmu-num\" property is deprecated; use \"pmu-mask\"");
1630 cpu->cfg.pmu_mask = pmu_mask;
1631 cpu_option_add_user_setting("pmu-mask", pmu_mask);
1632 }
1633
1634 static void prop_pmu_num_get(Object *obj, Visitor *v, const char *name,
1635 void *opaque, Error **errp)
1636 {
1637 RISCVCPU *cpu = RISCV_CPU(obj);
1638 uint8_t pmu_num = ctpop32(cpu->cfg.pmu_mask);
1639
1640 visit_type_uint8(v, name, &pmu_num, errp);
1641 }
1642
1643 static const PropertyInfo prop_pmu_num = {
1644 .name = "pmu-num",
1645 .get = prop_pmu_num_get,
1646 .set = prop_pmu_num_set,
1647 };
1648
1649 static void prop_pmu_mask_set(Object *obj, Visitor *v, const char *name,
1650 void *opaque, Error **errp)
1651 {
1652 RISCVCPU *cpu = RISCV_CPU(obj);
1653 uint32_t value;
1654 uint8_t pmu_num;
1655
1656 visit_type_uint32(v, name, &value, errp);
1657
1658 if (value != cpu->cfg.pmu_mask && riscv_cpu_is_vendor(obj)) {
1659 cpu_set_prop_err(cpu, name, errp);
1660 error_append_hint(errp, "Current '%s' val: %x\n",
1661 name, cpu->cfg.pmu_mask);
1662 return;
1663 }
1664
1665 pmu_num = ctpop32(value);
1666
1667 if (pmu_num > (RV_MAX_MHPMCOUNTERS - 3)) {
1668 error_setg(errp, "Number of counters exceeds maximum available");
1669 return;
1670 }
1671
1672 cpu_option_add_user_setting(name, value);
1673 cpu->cfg.pmu_mask = value;
1674 }
1675
1676 static void prop_pmu_mask_get(Object *obj, Visitor *v, const char *name,
1677 void *opaque, Error **errp)
1678 {
1679 uint8_t pmu_mask = RISCV_CPU(obj)->cfg.pmu_mask;
1680
1681 visit_type_uint8(v, name, &pmu_mask, errp);
1682 }
1683
1684 static const PropertyInfo prop_pmu_mask = {
1685 .name = "pmu-mask",
1686 .get = prop_pmu_mask_get,
1687 .set = prop_pmu_mask_set,
1688 };
1689
1690 static void prop_mmu_set(Object *obj, Visitor *v, const char *name,
1691 void *opaque, Error **errp)
1692 {
1693 RISCVCPU *cpu = RISCV_CPU(obj);
1694 bool value;
1695
1696 visit_type_bool(v, name, &value, errp);
1697
1698 if (cpu->cfg.mmu != value && riscv_cpu_is_vendor(obj)) {
1699 cpu_set_prop_err(cpu, "mmu", errp);
1700 return;
1701 }
1702
1703 cpu_option_add_user_setting(name, value);
1704 cpu->cfg.mmu = value;
1705 }
1706
1707 static void prop_mmu_get(Object *obj, Visitor *v, const char *name,
1708 void *opaque, Error **errp)
1709 {
1710 bool value = RISCV_CPU(obj)->cfg.mmu;
1711
1712 visit_type_bool(v, name, &value, errp);
1713 }
1714
1715 static const PropertyInfo prop_mmu = {
1716 .name = "mmu",
1717 .get = prop_mmu_get,
1718 .set = prop_mmu_set,
1719 };
1720
1721 static void prop_pmp_set(Object *obj, Visitor *v, const char *name,
1722 void *opaque, Error **errp)
1723 {
1724 RISCVCPU *cpu = RISCV_CPU(obj);
1725 bool value;
1726
1727 visit_type_bool(v, name, &value, errp);
1728
1729 if (cpu->cfg.pmp != value && riscv_cpu_is_vendor(obj)) {
1730 cpu_set_prop_err(cpu, name, errp);
1731 return;
1732 }
1733
1734 cpu_option_add_user_setting(name, value);
1735 cpu->cfg.pmp = value;
1736 }
1737
1738 static void prop_pmp_get(Object *obj, Visitor *v, const char *name,
1739 void *opaque, Error **errp)
1740 {
1741 bool value = RISCV_CPU(obj)->cfg.pmp;
1742
1743 visit_type_bool(v, name, &value, errp);
1744 }
1745
1746 static const PropertyInfo prop_pmp = {
1747 .name = "pmp",
1748 .get = prop_pmp_get,
1749 .set = prop_pmp_set,
1750 };
1751
1752 static int priv_spec_from_str(const char *priv_spec_str)
1753 {
1754 int priv_version = -1;
1755
1756 if (!g_strcmp0(priv_spec_str, PRIV_VER_1_12_0_STR)) {
1757 priv_version = PRIV_VERSION_1_12_0;
1758 } else if (!g_strcmp0(priv_spec_str, PRIV_VER_1_11_0_STR)) {
1759 priv_version = PRIV_VERSION_1_11_0;
1760 } else if (!g_strcmp0(priv_spec_str, PRIV_VER_1_10_0_STR)) {
1761 priv_version = PRIV_VERSION_1_10_0;
1762 }
1763
1764 return priv_version;
1765 }
1766
1767 static const char *priv_spec_to_str(int priv_version)
1768 {
1769 switch (priv_version) {
1770 case PRIV_VERSION_1_10_0:
1771 return PRIV_VER_1_10_0_STR;
1772 case PRIV_VERSION_1_11_0:
1773 return PRIV_VER_1_11_0_STR;
1774 case PRIV_VERSION_1_12_0:
1775 return PRIV_VER_1_12_0_STR;
1776 default:
1777 return NULL;
1778 }
1779 }
1780
1781 static void prop_priv_spec_set(Object *obj, Visitor *v, const char *name,
1782 void *opaque, Error **errp)
1783 {
1784 RISCVCPU *cpu = RISCV_CPU(obj);
1785 g_autofree char *value = NULL;
1786 int priv_version = -1;
1787
1788 visit_type_str(v, name, &value, errp);
1789
1790 priv_version = priv_spec_from_str(value);
1791 if (priv_version < 0) {
1792 error_setg(errp, "Unsupported privilege spec version '%s'", value);
1793 return;
1794 }
1795
1796 if (priv_version != cpu->env.priv_ver && riscv_cpu_is_vendor(obj)) {
1797 cpu_set_prop_err(cpu, name, errp);
1798 error_append_hint(errp, "Current '%s' val: %s\n", name,
1799 object_property_get_str(obj, name, NULL));
1800 return;
1801 }
1802
1803 cpu_option_add_user_setting(name, priv_version);
1804 cpu->env.priv_ver = priv_version;
1805 }
1806
1807 static void prop_priv_spec_get(Object *obj, Visitor *v, const char *name,
1808 void *opaque, Error **errp)
1809 {
1810 RISCVCPU *cpu = RISCV_CPU(obj);
1811 const char *value = priv_spec_to_str(cpu->env.priv_ver);
1812
1813 visit_type_str(v, name, (char **)&value, errp);
1814 }
1815
1816 static const PropertyInfo prop_priv_spec = {
1817 .name = "priv_spec",
1818 .get = prop_priv_spec_get,
1819 .set = prop_priv_spec_set,
1820 };
1821
1822 static void prop_vext_spec_set(Object *obj, Visitor *v, const char *name,
1823 void *opaque, Error **errp)
1824 {
1825 RISCVCPU *cpu = RISCV_CPU(obj);
1826 g_autofree char *value = NULL;
1827
1828 visit_type_str(v, name, &value, errp);
1829
1830 if (g_strcmp0(value, VEXT_VER_1_00_0_STR) != 0) {
1831 error_setg(errp, "Unsupported vector spec version '%s'", value);
1832 return;
1833 }
1834
1835 cpu_option_add_user_setting(name, VEXT_VERSION_1_00_0);
1836 cpu->env.vext_ver = VEXT_VERSION_1_00_0;
1837 }
1838
1839 static void prop_vext_spec_get(Object *obj, Visitor *v, const char *name,
1840 void *opaque, Error **errp)
1841 {
1842 const char *value = VEXT_VER_1_00_0_STR;
1843
1844 visit_type_str(v, name, (char **)&value, errp);
1845 }
1846
1847 static const PropertyInfo prop_vext_spec = {
1848 .name = "vext_spec",
1849 .get = prop_vext_spec_get,
1850 .set = prop_vext_spec_set,
1851 };
1852
1853 static void prop_vlen_set(Object *obj, Visitor *v, const char *name,
1854 void *opaque, Error **errp)
1855 {
1856 RISCVCPU *cpu = RISCV_CPU(obj);
1857 uint16_t value;
1858
1859 if (!visit_type_uint16(v, name, &value, errp)) {
1860 return;
1861 }
1862
1863 if (!is_power_of_2(value)) {
1864 error_setg(errp, "Vector extension VLEN must be power of 2");
1865 return;
1866 }
1867
1868 if (value != cpu->cfg.vlenb && riscv_cpu_is_vendor(obj)) {
1869 cpu_set_prop_err(cpu, name, errp);
1870 error_append_hint(errp, "Current '%s' val: %u\n",
1871 name, cpu->cfg.vlenb << 3);
1872 return;
1873 }
1874
1875 cpu_option_add_user_setting(name, value);
1876 cpu->cfg.vlenb = value >> 3;
1877 }
1878
1879 static void prop_vlen_get(Object *obj, Visitor *v, const char *name,
1880 void *opaque, Error **errp)
1881 {
1882 uint16_t value = RISCV_CPU(obj)->cfg.vlenb << 3;
1883
1884 visit_type_uint16(v, name, &value, errp);
1885 }
1886
1887 static const PropertyInfo prop_vlen = {
1888 .name = "vlen",
1889 .get = prop_vlen_get,
1890 .set = prop_vlen_set,
1891 };
1892
1893 static void prop_elen_set(Object *obj, Visitor *v, const char *name,
1894 void *opaque, Error **errp)
1895 {
1896 RISCVCPU *cpu = RISCV_CPU(obj);
1897 uint16_t value;
1898
1899 if (!visit_type_uint16(v, name, &value, errp)) {
1900 return;
1901 }
1902
1903 if (!is_power_of_2(value)) {
1904 error_setg(errp, "Vector extension ELEN must be power of 2");
1905 return;
1906 }
1907
1908 if (value != cpu->cfg.elen && riscv_cpu_is_vendor(obj)) {
1909 cpu_set_prop_err(cpu, name, errp);
1910 error_append_hint(errp, "Current '%s' val: %u\n",
1911 name, cpu->cfg.elen);
1912 return;
1913 }
1914
1915 cpu_option_add_user_setting(name, value);
1916 cpu->cfg.elen = value;
1917 }
1918
1919 static void prop_elen_get(Object *obj, Visitor *v, const char *name,
1920 void *opaque, Error **errp)
1921 {
1922 uint16_t value = RISCV_CPU(obj)->cfg.elen;
1923
1924 visit_type_uint16(v, name, &value, errp);
1925 }
1926
1927 static const PropertyInfo prop_elen = {
1928 .name = "elen",
1929 .get = prop_elen_get,
1930 .set = prop_elen_set,
1931 };
1932
1933 static void prop_cbom_blksize_set(Object *obj, Visitor *v, const char *name,
1934 void *opaque, Error **errp)
1935 {
1936 RISCVCPU *cpu = RISCV_CPU(obj);
1937 uint16_t value;
1938
1939 if (!visit_type_uint16(v, name, &value, errp)) {
1940 return;
1941 }
1942
1943 if (value != cpu->cfg.cbom_blocksize && riscv_cpu_is_vendor(obj)) {
1944 cpu_set_prop_err(cpu, name, errp);
1945 error_append_hint(errp, "Current '%s' val: %u\n",
1946 name, cpu->cfg.cbom_blocksize);
1947 return;
1948 }
1949
1950 cpu_option_add_user_setting(name, value);
1951 cpu->cfg.cbom_blocksize = value;
1952 }
1953
1954 static void prop_cbom_blksize_get(Object *obj, Visitor *v, const char *name,
1955 void *opaque, Error **errp)
1956 {
1957 uint16_t value = RISCV_CPU(obj)->cfg.cbom_blocksize;
1958
1959 visit_type_uint16(v, name, &value, errp);
1960 }
1961
1962 static const PropertyInfo prop_cbom_blksize = {
1963 .name = "cbom_blocksize",
1964 .get = prop_cbom_blksize_get,
1965 .set = prop_cbom_blksize_set,
1966 };
1967
1968 static void prop_cbop_blksize_set(Object *obj, Visitor *v, const char *name,
1969 void *opaque, Error **errp)
1970 {
1971 RISCVCPU *cpu = RISCV_CPU(obj);
1972 uint16_t value;
1973
1974 if (!visit_type_uint16(v, name, &value, errp)) {
1975 return;
1976 }
1977
1978 if (value != cpu->cfg.cbop_blocksize && riscv_cpu_is_vendor(obj)) {
1979 cpu_set_prop_err(cpu, name, errp);
1980 error_append_hint(errp, "Current '%s' val: %u\n",
1981 name, cpu->cfg.cbop_blocksize);
1982 return;
1983 }
1984
1985 cpu_option_add_user_setting(name, value);
1986 cpu->cfg.cbop_blocksize = value;
1987 }
1988
1989 static void prop_cbop_blksize_get(Object *obj, Visitor *v, const char *name,
1990 void *opaque, Error **errp)
1991 {
1992 uint16_t value = RISCV_CPU(obj)->cfg.cbop_blocksize;
1993
1994 visit_type_uint16(v, name, &value, errp);
1995 }
1996
1997 static const PropertyInfo prop_cbop_blksize = {
1998 .name = "cbop_blocksize",
1999 .get = prop_cbop_blksize_get,
2000 .set = prop_cbop_blksize_set,
2001 };
2002
2003 static void prop_cboz_blksize_set(Object *obj, Visitor *v, const char *name,
2004 void *opaque, Error **errp)
2005 {
2006 RISCVCPU *cpu = RISCV_CPU(obj);
2007 uint16_t value;
2008
2009 if (!visit_type_uint16(v, name, &value, errp)) {
2010 return;
2011 }
2012
2013 if (value != cpu->cfg.cboz_blocksize && riscv_cpu_is_vendor(obj)) {
2014 cpu_set_prop_err(cpu, name, errp);
2015 error_append_hint(errp, "Current '%s' val: %u\n",
2016 name, cpu->cfg.cboz_blocksize);
2017 return;
2018 }
2019
2020 cpu_option_add_user_setting(name, value);
2021 cpu->cfg.cboz_blocksize = value;
2022 }
2023
2024 static void prop_cboz_blksize_get(Object *obj, Visitor *v, const char *name,
2025 void *opaque, Error **errp)
2026 {
2027 uint16_t value = RISCV_CPU(obj)->cfg.cboz_blocksize;
2028
2029 visit_type_uint16(v, name, &value, errp);
2030 }
2031
2032 static const PropertyInfo prop_cboz_blksize = {
2033 .name = "cboz_blocksize",
2034 .get = prop_cboz_blksize_get,
2035 .set = prop_cboz_blksize_set,
2036 };
2037
2038 static void prop_mvendorid_set(Object *obj, Visitor *v, const char *name,
2039 void *opaque, Error **errp)
2040 {
2041 bool dynamic_cpu = riscv_cpu_is_dynamic(obj);
2042 RISCVCPU *cpu = RISCV_CPU(obj);
2043 uint32_t prev_val = cpu->cfg.mvendorid;
2044 uint32_t value;
2045
2046 if (!visit_type_uint32(v, name, &value, errp)) {
2047 return;
2048 }
2049
2050 if (!dynamic_cpu && prev_val != value) {
2051 error_setg(errp, "Unable to change %s mvendorid (0x%x)",
2052 object_get_typename(obj), prev_val);
2053 return;
2054 }
2055
2056 cpu->cfg.mvendorid = value;
2057 }
2058
2059 static void prop_mvendorid_get(Object *obj, Visitor *v, const char *name,
2060 void *opaque, Error **errp)
2061 {
2062 uint32_t value = RISCV_CPU(obj)->cfg.mvendorid;
2063
2064 visit_type_uint32(v, name, &value, errp);
2065 }
2066
2067 static const PropertyInfo prop_mvendorid = {
2068 .name = "mvendorid",
2069 .get = prop_mvendorid_get,
2070 .set = prop_mvendorid_set,
2071 };
2072
2073 static void prop_mimpid_set(Object *obj, Visitor *v, const char *name,
2074 void *opaque, Error **errp)
2075 {
2076 bool dynamic_cpu = riscv_cpu_is_dynamic(obj);
2077 RISCVCPU *cpu = RISCV_CPU(obj);
2078 uint64_t prev_val = cpu->cfg.mimpid;
2079 uint64_t value;
2080
2081 if (!visit_type_uint64(v, name, &value, errp)) {
2082 return;
2083 }
2084
2085 if (!dynamic_cpu && prev_val != value) {
2086 error_setg(errp, "Unable to change %s mimpid (0x%" PRIu64 ")",
2087 object_get_typename(obj), prev_val);
2088 return;
2089 }
2090
2091 cpu->cfg.mimpid = value;
2092 }
2093
2094 static void prop_mimpid_get(Object *obj, Visitor *v, const char *name,
2095 void *opaque, Error **errp)
2096 {
2097 uint64_t value = RISCV_CPU(obj)->cfg.mimpid;
2098
2099 visit_type_uint64(v, name, &value, errp);
2100 }
2101
2102 static const PropertyInfo prop_mimpid = {
2103 .name = "mimpid",
2104 .get = prop_mimpid_get,
2105 .set = prop_mimpid_set,
2106 };
2107
2108 static void prop_marchid_set(Object *obj, Visitor *v, const char *name,
2109 void *opaque, Error **errp)
2110 {
2111 bool dynamic_cpu = riscv_cpu_is_dynamic(obj);
2112 RISCVCPU *cpu = RISCV_CPU(obj);
2113 uint64_t prev_val = cpu->cfg.marchid;
2114 uint64_t value, invalid_val;
2115 uint32_t mxlen = 0;
2116
2117 if (!visit_type_uint64(v, name, &value, errp)) {
2118 return;
2119 }
2120
2121 if (!dynamic_cpu && prev_val != value) {
2122 error_setg(errp, "Unable to change %s marchid (0x%" PRIu64 ")",
2123 object_get_typename(obj), prev_val);
2124 return;
2125 }
2126
2127 switch (riscv_cpu_mxl(&cpu->env)) {
2128 case MXL_RV32:
2129 mxlen = 32;
2130 break;
2131 case MXL_RV64:
2132 case MXL_RV128:
2133 mxlen = 64;
2134 break;
2135 default:
2136 g_assert_not_reached();
2137 }
2138
2139 invalid_val = 1LL << (mxlen - 1);
2140
2141 if (value == invalid_val) {
2142 error_setg(errp, "Unable to set marchid with MSB (%u) bit set "
2143 "and the remaining bits zero", mxlen);
2144 return;
2145 }
2146
2147 cpu->cfg.marchid = value;
2148 }
2149
2150 static void prop_marchid_get(Object *obj, Visitor *v, const char *name,
2151 void *opaque, Error **errp)
2152 {
2153 uint64_t value = RISCV_CPU(obj)->cfg.marchid;
2154
2155 visit_type_uint64(v, name, &value, errp);
2156 }
2157
2158 static const PropertyInfo prop_marchid = {
2159 .name = "marchid",
2160 .get = prop_marchid_get,
2161 .set = prop_marchid_set,
2162 };
2163
2164 /*
2165 * RVA22U64 defines some 'named features' or 'synthetic extensions'
2166 * that are cache related: Za64rs, Zic64b, Ziccif, Ziccrse, Ziccamoa
2167 * and Zicclsm. We do not implement caching in QEMU so we'll consider
2168 * all these named features as always enabled.
2169 *
2170 * There's no riscv,isa update for them (nor for zic64b, despite it
2171 * having a cfg offset) at this moment.
2172 */
2173 static RISCVCPUProfile RVA22U64 = {
2174 .parent = NULL,
2175 .name = "rva22u64",
2176 .misa_ext = RVI | RVM | RVA | RVF | RVD | RVC | RVU,
2177 .priv_spec = RISCV_PROFILE_ATTR_UNUSED,
2178 .satp_mode = RISCV_PROFILE_ATTR_UNUSED,
2179 .ext_offsets = {
2180 CPU_CFG_OFFSET(ext_zicsr), CPU_CFG_OFFSET(ext_zihintpause),
2181 CPU_CFG_OFFSET(ext_zba), CPU_CFG_OFFSET(ext_zbb),
2182 CPU_CFG_OFFSET(ext_zbs), CPU_CFG_OFFSET(ext_zfhmin),
2183 CPU_CFG_OFFSET(ext_zkt), CPU_CFG_OFFSET(ext_zicntr),
2184 CPU_CFG_OFFSET(ext_zihpm), CPU_CFG_OFFSET(ext_zicbom),
2185 CPU_CFG_OFFSET(ext_zicbop), CPU_CFG_OFFSET(ext_zicboz),
2186
2187 /* mandatory named features for this profile */
2188 CPU_CFG_OFFSET(zic64b),
2189
2190 RISCV_PROFILE_EXT_LIST_END
2191 }
2192 };
2193
2194 /*
2195 * As with RVA22U64, RVA22S64 also defines 'named features'.
2196 *
2197 * Cache related features that we consider enabled since we don't
2198 * implement cache: Ssccptr
2199 *
2200 * Other named features that we already implement: Sstvecd, Sstvala,
2201 * Sscounterenw
2202 *
2203 * Named features that we need to enable: svade
2204 *
2205 * The remaining features/extensions comes from RVA22U64.
2206 */
2207 static RISCVCPUProfile RVA22S64 = {
2208 .parent = &RVA22U64,
2209 .name = "rva22s64",
2210 .misa_ext = RVS,
2211 .priv_spec = PRIV_VERSION_1_12_0,
2212 .satp_mode = VM_1_10_SV39,
2213 .ext_offsets = {
2214 /* rva22s64 exts */
2215 CPU_CFG_OFFSET(ext_zifencei), CPU_CFG_OFFSET(ext_svpbmt),
2216 CPU_CFG_OFFSET(ext_svinval),
2217
2218 /* rva22s64 named features */
2219 CPU_CFG_OFFSET(svade),
2220
2221 RISCV_PROFILE_EXT_LIST_END
2222 }
2223 };
2224
2225 RISCVCPUProfile *riscv_profiles[] = {
2226 &RVA22U64,
2227 &RVA22S64,
2228 NULL,
2229 };
2230
2231 static Property riscv_cpu_properties[] = {
2232 DEFINE_PROP_BOOL("debug", RISCVCPU, cfg.debug, true),
2233
2234 {.name = "pmu-mask", .info = &prop_pmu_mask},
2235 {.name = "pmu-num", .info = &prop_pmu_num}, /* Deprecated */
2236
2237 {.name = "mmu", .info = &prop_mmu},
2238 {.name = "pmp", .info = &prop_pmp},
2239
2240 {.name = "priv_spec", .info = &prop_priv_spec},
2241 {.name = "vext_spec", .info = &prop_vext_spec},
2242
2243 {.name = "vlen", .info = &prop_vlen},
2244 {.name = "elen", .info = &prop_elen},
2245
2246 {.name = "cbom_blocksize", .info = &prop_cbom_blksize},
2247 {.name = "cbop_blocksize", .info = &prop_cbop_blksize},
2248 {.name = "cboz_blocksize", .info = &prop_cboz_blksize},
2249
2250 {.name = "mvendorid", .info = &prop_mvendorid},
2251 {.name = "mimpid", .info = &prop_mimpid},
2252 {.name = "marchid", .info = &prop_marchid},
2253
2254 #ifndef CONFIG_USER_ONLY
2255 DEFINE_PROP_UINT64("resetvec", RISCVCPU, env.resetvec, DEFAULT_RSTVEC),
2256 #endif
2257
2258 DEFINE_PROP_BOOL("short-isa-string", RISCVCPU, cfg.short_isa_string, false),
2259
2260 DEFINE_PROP_BOOL("rvv_ta_all_1s", RISCVCPU, cfg.rvv_ta_all_1s, false),
2261 DEFINE_PROP_BOOL("rvv_ma_all_1s", RISCVCPU, cfg.rvv_ma_all_1s, false),
2262
2263 /*
2264 * write_misa() is marked as experimental for now so mark
2265 * it with -x and default to 'false'.
2266 */
2267 DEFINE_PROP_BOOL("x-misa-w", RISCVCPU, cfg.misa_w, false),
2268 DEFINE_PROP_END_OF_LIST(),
2269 };
2270
2271 #if defined(TARGET_RISCV64)
2272 static void rva22u64_profile_cpu_init(Object *obj)
2273 {
2274 rv64i_bare_cpu_init(obj);
2275
2276 RVA22U64.enabled = true;
2277 }
2278
2279 static void rva22s64_profile_cpu_init(Object *obj)
2280 {
2281 rv64i_bare_cpu_init(obj);
2282
2283 RVA22S64.enabled = true;
2284 }
2285 #endif
2286
2287 static const gchar *riscv_gdb_arch_name(CPUState *cs)
2288 {
2289 RISCVCPU *cpu = RISCV_CPU(cs);
2290 CPURISCVState *env = &cpu->env;
2291
2292 switch (riscv_cpu_mxl(env)) {
2293 case MXL_RV32:
2294 return "riscv:rv32";
2295 case MXL_RV64:
2296 case MXL_RV128:
2297 return "riscv:rv64";
2298 default:
2299 g_assert_not_reached();
2300 }
2301 }
2302
2303 static const char *riscv_gdb_get_dynamic_xml(CPUState *cs, const char *xmlname)
2304 {
2305 RISCVCPU *cpu = RISCV_CPU(cs);
2306
2307 if (strcmp(xmlname, "riscv-csr.xml") == 0) {
2308 return cpu->dyn_csr_xml;
2309 } else if (strcmp(xmlname, "riscv-vector.xml") == 0) {
2310 return cpu->dyn_vreg_xml;
2311 }
2312
2313 return NULL;
2314 }
2315
2316 #ifndef CONFIG_USER_ONLY
2317 static int64_t riscv_get_arch_id(CPUState *cs)
2318 {
2319 RISCVCPU *cpu = RISCV_CPU(cs);
2320
2321 return cpu->env.mhartid;
2322 }
2323
2324 #include "hw/core/sysemu-cpu-ops.h"
2325
2326 static const struct SysemuCPUOps riscv_sysemu_ops = {
2327 .get_phys_page_debug = riscv_cpu_get_phys_page_debug,
2328 .write_elf64_note = riscv_cpu_write_elf64_note,
2329 .write_elf32_note = riscv_cpu_write_elf32_note,
2330 .legacy_vmsd = &vmstate_riscv_cpu,
2331 };
2332 #endif
2333
2334 static void riscv_cpu_common_class_init(ObjectClass *c, void *data)
2335 {
2336 RISCVCPUClass *mcc = RISCV_CPU_CLASS(c);
2337 CPUClass *cc = CPU_CLASS(c);
2338 DeviceClass *dc = DEVICE_CLASS(c);
2339 ResettableClass *rc = RESETTABLE_CLASS(c);
2340
2341 device_class_set_parent_realize(dc, riscv_cpu_realize,
2342 &mcc->parent_realize);
2343
2344 resettable_class_set_parent_phases(rc, NULL, riscv_cpu_reset_hold, NULL,
2345 &mcc->parent_phases);
2346
2347 cc->class_by_name = riscv_cpu_class_by_name;
2348 cc->has_work = riscv_cpu_has_work;
2349 cc->mmu_index = riscv_cpu_mmu_index;
2350 cc->dump_state = riscv_cpu_dump_state;
2351 cc->set_pc = riscv_cpu_set_pc;
2352 cc->get_pc = riscv_cpu_get_pc;
2353 cc->gdb_read_register = riscv_cpu_gdb_read_register;
2354 cc->gdb_write_register = riscv_cpu_gdb_write_register;
2355 cc->gdb_num_core_regs = 33;
2356 cc->gdb_stop_before_watchpoint = true;
2357 cc->disas_set_info = riscv_cpu_disas_set_info;
2358 #ifndef CONFIG_USER_ONLY
2359 cc->sysemu_ops = &riscv_sysemu_ops;
2360 cc->get_arch_id = riscv_get_arch_id;
2361 #endif
2362 cc->gdb_arch_name = riscv_gdb_arch_name;
2363 cc->gdb_get_dynamic_xml = riscv_gdb_get_dynamic_xml;
2364
2365 device_class_set_props(dc, riscv_cpu_properties);
2366 }
2367
2368 static void riscv_cpu_class_init(ObjectClass *c, void *data)
2369 {
2370 RISCVCPUClass *mcc = RISCV_CPU_CLASS(c);
2371
2372 mcc->misa_mxl_max = (uint32_t)(uintptr_t)data;
2373 riscv_cpu_validate_misa_mxl(mcc);
2374 }
2375
2376 static void riscv_isa_string_ext(RISCVCPU *cpu, char **isa_str,
2377 int max_str_len)
2378 {
2379 const RISCVIsaExtData *edata;
2380 char *old = *isa_str;
2381 char *new = *isa_str;
2382
2383 for (edata = isa_edata_arr; edata && edata->name; edata++) {
2384 if (isa_ext_is_enabled(cpu, edata->ext_enable_offset)) {
2385 new = g_strconcat(old, "_", edata->name, NULL);
2386 g_free(old);
2387 old = new;
2388 }
2389 }
2390
2391 *isa_str = new;
2392 }
2393
2394 char *riscv_isa_string(RISCVCPU *cpu)
2395 {
2396 RISCVCPUClass *mcc = RISCV_CPU_GET_CLASS(cpu);
2397 int i;
2398 const size_t maxlen = sizeof("rv128") + sizeof(riscv_single_letter_exts);
2399 char *isa_str = g_new(char, maxlen);
2400 int xlen = riscv_cpu_max_xlen(mcc);
2401 char *p = isa_str + snprintf(isa_str, maxlen, "rv%d", xlen);
2402
2403 for (i = 0; i < sizeof(riscv_single_letter_exts) - 1; i++) {
2404 if (cpu->env.misa_ext & RV(riscv_single_letter_exts[i])) {
2405 *p++ = qemu_tolower(riscv_single_letter_exts[i]);
2406 }
2407 }
2408 *p = '\0';
2409 if (!cpu->cfg.short_isa_string) {
2410 riscv_isa_string_ext(cpu, &isa_str, maxlen);
2411 }
2412 return isa_str;
2413 }
2414
2415 #ifndef CONFIG_USER_ONLY
2416 static char **riscv_isa_extensions_list(RISCVCPU *cpu, int *count)
2417 {
2418 int maxlen = ARRAY_SIZE(riscv_single_letter_exts) + ARRAY_SIZE(isa_edata_arr);
2419 char **extensions = g_new(char *, maxlen);
2420
2421 for (int i = 0; i < sizeof(riscv_single_letter_exts) - 1; i++) {
2422 if (cpu->env.misa_ext & RV(riscv_single_letter_exts[i])) {
2423 extensions[*count] = g_new(char, 2);
2424 snprintf(extensions[*count], 2, "%c",
2425 qemu_tolower(riscv_single_letter_exts[i]));
2426 (*count)++;
2427 }
2428 }
2429
2430 for (const RISCVIsaExtData *edata = isa_edata_arr; edata->name; edata++) {
2431 if (isa_ext_is_enabled(cpu, edata->ext_enable_offset)) {
2432 extensions[*count] = g_strdup(edata->name);
2433 (*count)++;
2434 }
2435 }
2436
2437 return extensions;
2438 }
2439
2440 void riscv_isa_write_fdt(RISCVCPU *cpu, void *fdt, char *nodename)
2441 {
2442 RISCVCPUClass *mcc = RISCV_CPU_GET_CLASS(cpu);
2443 const size_t maxlen = sizeof("rv128i");
2444 g_autofree char *isa_base = g_new(char, maxlen);
2445 g_autofree char *riscv_isa;
2446 char **isa_extensions;
2447 int count = 0;
2448 int xlen = riscv_cpu_max_xlen(mcc);
2449
2450 riscv_isa = riscv_isa_string(cpu);
2451 qemu_fdt_setprop_string(fdt, nodename, "riscv,isa", riscv_isa);
2452
2453 snprintf(isa_base, maxlen, "rv%di", xlen);
2454 qemu_fdt_setprop_string(fdt, nodename, "riscv,isa-base", isa_base);
2455
2456 isa_extensions = riscv_isa_extensions_list(cpu, &count);
2457 qemu_fdt_setprop_string_array(fdt, nodename, "riscv,isa-extensions",
2458 isa_extensions, count);
2459
2460 for (int i = 0; i < count; i++) {
2461 g_free(isa_extensions[i]);
2462 }
2463
2464 g_free(isa_extensions);
2465 }
2466 #endif
2467
2468 #define DEFINE_CPU(type_name, misa_mxl_max, initfn) \
2469 { \
2470 .name = (type_name), \
2471 .parent = TYPE_RISCV_CPU, \
2472 .instance_init = (initfn), \
2473 .class_init = riscv_cpu_class_init, \
2474 .class_data = (void *)(misa_mxl_max) \
2475 }
2476
2477 #define DEFINE_DYNAMIC_CPU(type_name, misa_mxl_max, initfn) \
2478 { \
2479 .name = (type_name), \
2480 .parent = TYPE_RISCV_DYNAMIC_CPU, \
2481 .instance_init = (initfn), \
2482 .class_init = riscv_cpu_class_init, \
2483 .class_data = (void *)(misa_mxl_max) \
2484 }
2485
2486 #define DEFINE_VENDOR_CPU(type_name, misa_mxl_max, initfn) \
2487 { \
2488 .name = (type_name), \
2489 .parent = TYPE_RISCV_VENDOR_CPU, \
2490 .instance_init = (initfn), \
2491 .class_init = riscv_cpu_class_init, \
2492 .class_data = (void *)(misa_mxl_max) \
2493 }
2494
2495 #define DEFINE_BARE_CPU(type_name, misa_mxl_max, initfn) \
2496 { \
2497 .name = (type_name), \
2498 .parent = TYPE_RISCV_BARE_CPU, \
2499 .instance_init = (initfn), \
2500 .class_init = riscv_cpu_class_init, \
2501 .class_data = (void *)(misa_mxl_max) \
2502 }
2503
2504 #define DEFINE_PROFILE_CPU(type_name, misa_mxl_max, initfn) \
2505 { \
2506 .name = (type_name), \
2507 .parent = TYPE_RISCV_BARE_CPU, \
2508 .instance_init = (initfn), \
2509 .class_init = riscv_cpu_class_init, \
2510 .class_data = (void *)(misa_mxl_max) \
2511 }
2512
2513 static const TypeInfo riscv_cpu_type_infos[] = {
2514 {
2515 .name = TYPE_RISCV_CPU,
2516 .parent = TYPE_CPU,
2517 .instance_size = sizeof(RISCVCPU),
2518 .instance_align = __alignof(RISCVCPU),
2519 .instance_init = riscv_cpu_init,
2520 .instance_post_init = riscv_cpu_post_init,
2521 .abstract = true,
2522 .class_size = sizeof(RISCVCPUClass),
2523 .class_init = riscv_cpu_common_class_init,
2524 },
2525 {
2526 .name = TYPE_RISCV_DYNAMIC_CPU,
2527 .parent = TYPE_RISCV_CPU,
2528 .abstract = true,
2529 },
2530 {
2531 .name = TYPE_RISCV_VENDOR_CPU,
2532 .parent = TYPE_RISCV_CPU,
2533 .abstract = true,
2534 },
2535 {
2536 .name = TYPE_RISCV_BARE_CPU,
2537 .parent = TYPE_RISCV_CPU,
2538 .instance_init = riscv_bare_cpu_init,
2539 .abstract = true,
2540 },
2541 #if defined(TARGET_RISCV32)
2542 DEFINE_DYNAMIC_CPU(TYPE_RISCV_CPU_ANY, MXL_RV32, riscv_any_cpu_init),
2543 DEFINE_DYNAMIC_CPU(TYPE_RISCV_CPU_MAX, MXL_RV32, riscv_max_cpu_init),
2544 DEFINE_DYNAMIC_CPU(TYPE_RISCV_CPU_BASE32, MXL_RV32, rv32_base_cpu_init),
2545 DEFINE_VENDOR_CPU(TYPE_RISCV_CPU_IBEX, MXL_RV32, rv32_ibex_cpu_init),
2546 DEFINE_VENDOR_CPU(TYPE_RISCV_CPU_SIFIVE_E31, MXL_RV32, rv32_sifive_e_cpu_init),
2547 DEFINE_VENDOR_CPU(TYPE_RISCV_CPU_SIFIVE_E34, MXL_RV32, rv32_imafcu_nommu_cpu_init),
2548 DEFINE_VENDOR_CPU(TYPE_RISCV_CPU_SIFIVE_U34, MXL_RV32, rv32_sifive_u_cpu_init),
2549 DEFINE_BARE_CPU(TYPE_RISCV_CPU_RV32I, MXL_RV32, rv32i_bare_cpu_init),
2550 DEFINE_BARE_CPU(TYPE_RISCV_CPU_RV32E, MXL_RV32, rv32e_bare_cpu_init),
2551 #elif defined(TARGET_RISCV64)
2552 DEFINE_DYNAMIC_CPU(TYPE_RISCV_CPU_ANY, MXL_RV64, riscv_any_cpu_init),
2553 DEFINE_DYNAMIC_CPU(TYPE_RISCV_CPU_MAX, MXL_RV64, riscv_max_cpu_init),
2554 DEFINE_DYNAMIC_CPU(TYPE_RISCV_CPU_BASE64, MXL_RV64, rv64_base_cpu_init),
2555 DEFINE_VENDOR_CPU(TYPE_RISCV_CPU_SIFIVE_E51, MXL_RV64, rv64_sifive_e_cpu_init),
2556 DEFINE_VENDOR_CPU(TYPE_RISCV_CPU_SIFIVE_U54, MXL_RV64, rv64_sifive_u_cpu_init),
2557 DEFINE_VENDOR_CPU(TYPE_RISCV_CPU_SHAKTI_C, MXL_RV64, rv64_sifive_u_cpu_init),
2558 DEFINE_VENDOR_CPU(TYPE_RISCV_CPU_THEAD_C906, MXL_RV64, rv64_thead_c906_cpu_init),
2559 DEFINE_VENDOR_CPU(TYPE_RISCV_CPU_VEYRON_V1, MXL_RV64, rv64_veyron_v1_cpu_init),
2560 DEFINE_DYNAMIC_CPU(TYPE_RISCV_CPU_BASE128, MXL_RV128, rv128_base_cpu_init),
2561 DEFINE_BARE_CPU(TYPE_RISCV_CPU_RV64I, MXL_RV64, rv64i_bare_cpu_init),
2562 DEFINE_BARE_CPU(TYPE_RISCV_CPU_RV64E, MXL_RV64, rv64e_bare_cpu_init),
2563 DEFINE_PROFILE_CPU(TYPE_RISCV_CPU_RVA22U64, MXL_RV64, rva22u64_profile_cpu_init),
2564 DEFINE_PROFILE_CPU(TYPE_RISCV_CPU_RVA22S64, MXL_RV64, rva22s64_profile_cpu_init),
2565 #endif
2566 };
2567
2568 DEFINE_TYPES(riscv_cpu_type_infos)
Random patches