HPM SDK
HPMicro Software Development Kit
hpm_csr_regs.h
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2021-2024 HPMicro
3  *
4  * SPDX-License-Identifier: BSD-3-Clause
5  *
6  */
7 
8 
9 #ifndef HPM_CSR_H
10 #define HPM_CSR_H
11 
12 /* STANDARD CRS address definition */
13 #define CSR_USTATUS (0x0)
14 #define CSR_UIE (0x4)
15 #define CSR_UTVEC (0x5)
16 #define CSR_USCRATCH (0x40)
17 #define CSR_UEPC (0x41)
18 #define CSR_UCAUSE (0x42)
19 #define CSR_UTVAL (0x43)
20 #define CSR_UIP (0x44)
21 #define CSR_MSTATUS (0x300)
22 #define CSR_MISA (0x301)
23 #define CSR_MIE (0x304)
24 #define CSR_MTVEC (0x305)
25 #define CSR_MCOUNTEREN (0x306)
26 #define CSR_MHPMEVENT3 (0x323)
27 #define CSR_MHPMEVENT4 (0x324)
28 #define CSR_MHPMEVENT5 (0x325)
29 #define CSR_MHPMEVENT6 (0x326)
30 #define CSR_MSCRATCH (0x340)
31 #define CSR_MEPC (0x341)
32 #define CSR_MCAUSE (0x342)
33 #define CSR_MTVAL (0x343)
34 #define CSR_MIP (0x344)
35 #define CSR_PMPCFG0 (0x3A0)
36 #define CSR_PMPCFG1 (0x3A1)
37 #define CSR_PMPCFG2 (0x3A2)
38 #define CSR_PMPCFG3 (0x3A3)
39 #define CSR_PMPADDR0 (0x3B0)
40 #define CSR_PMPADDR1 (0x3B1)
41 #define CSR_PMPADDR2 (0x3B2)
42 #define CSR_PMPADDR3 (0x3B3)
43 #define CSR_PMPADDR4 (0x3B4)
44 #define CSR_PMPADDR5 (0x3B5)
45 #define CSR_PMPADDR6 (0x3B6)
46 #define CSR_PMPADDR7 (0x3B7)
47 #define CSR_PMPADDR8 (0x3B8)
48 #define CSR_PMPADDR9 (0x3B9)
49 #define CSR_PMPADDR10 (0x3BA)
50 #define CSR_PMPADDR11 (0x3BB)
51 #define CSR_PMPADDR12 (0x3BC)
52 #define CSR_PMPADDR13 (0x3BD)
53 #define CSR_PMPADDR14 (0x3BE)
54 #define CSR_PMPADDR15 (0x3BF)
55 #define CSR_TSELECT (0x7A0)
56 #define CSR_TDATA1 (0x7A1)
57 #define CSR_MCONTROL (0x7A1)
58 #define CSR_ICOUNT (0x7A1)
59 #define CSR_ITRIGGER (0x7A1)
60 #define CSR_ETRIGGER (0x7A1)
61 #define CSR_TDATA2 (0x7A2)
62 #define CSR_TDATA3 (0x7A3)
63 #define CSR_TEXTRA (0x7A3)
64 #define CSR_TINFO (0x7A4)
65 #define CSR_TCONTROL (0x7A5)
66 #define CSR_MCONTEXT (0x7A8)
67 #define CSR_SCONTEXT (0x7AA)
68 #define CSR_DCSR (0x7B0)
69 #define CSR_DPC (0x7B1)
70 #define CSR_DSCRATCH0 (0x7B2)
71 #define CSR_DSCRATCH1 (0x7B3)
72 #define CSR_MCYCLE (0xB00)
73 #define CSR_MINSTRET (0xB02)
74 #define CSR_MHPMCOUNTER3 (0xB03)
75 #define CSR_MHPMCOUNTER4 (0xB04)
76 #define CSR_MHPMCOUNTER5 (0xB05)
77 #define CSR_MHPMCOUNTER6 (0xB06)
78 #define CSR_MCYCLEH (0xB80)
79 #define CSR_MINSTRETH (0xB82)
80 #define CSR_MHPMCOUNTER3H (0xB83)
81 #define CSR_MHPMCOUNTER4H (0xB84)
82 #define CSR_MHPMCOUNTER5H (0xB85)
83 #define CSR_MHPMCOUNTER6H (0xB86)
84 #define CSR_CYCLE (0xC00)
85 #define CSR_CYCLEH (0xC80)
86 #define CSR_MVENDORID (0xF11)
87 #define CSR_MARCHID (0xF12)
88 #define CSR_MIMPID (0xF13)
89 #define CSR_MHARTID (0xF14)
90 
91 /* NON-STANDARD CRS address definition */
92 #define CSR_MCOUNTINHIBIT (0x320)
93 #define CSR_MILMB (0x7C0)
94 #define CSR_MDLMB (0x7C1)
95 #define CSR_MECC_CODE (0x7C2)
96 #define CSR_MNVEC (0x7C3)
97 #define CSR_MXSTATUS (0x7C4)
98 #define CSR_MPFT_CTL (0x7C5)
99 #define CSR_MHSP_CTL (0x7C6)
100 #define CSR_MSP_BOUND (0x7C7)
101 #define CSR_MSP_BASE (0x7C8)
102 #define CSR_MDCAUSE (0x7C9)
103 #define CSR_MCACHE_CTL (0x7CA)
104 #define CSR_MCCTLBEGINADDR (0x7CB)
105 #define CSR_MCCTLCOMMAND (0x7CC)
106 #define CSR_MCCTLDATA (0x7CD)
107 #define CSR_MCOUNTERWEN (0x7CE)
108 #define CSR_MCOUNTERINTEN (0x7CF)
109 #define CSR_MMISC_CTL (0x7D0)
110 #define CSR_MCOUNTERMASK_M (0x7D1)
111 #define CSR_MCOUNTERMASK_S (0x7D2)
112 #define CSR_MCOUNTERMASK_U (0x7D3)
113 #define CSR_MCOUNTEROVF (0x7D4)
114 #define CSR_DEXC2DBG (0x7E0)
115 #define CSR_DDCAUSE (0x7E1)
116 #define CSR_UITB (0x800)
117 #define CSR_UCODE (0x801)
118 #define CSR_UDCAUSE (0x809)
119 #define CSR_UCCTLBEGINADDR (0x80B)
120 #define CSR_UCCTLCOMMAND (0x80C)
121 #define CSR_MICM_CFG (0xFC0)
122 #define CSR_MDCM_CFG (0xFC1)
123 #define CSR_MMSC_CFG (0xFC2)
124 #define CSR_MMSC_CFG2 (0xFC3)
125 
126 /* STANDARD CRS register bitfiled definitions */
127 
128 /* Bitfield definition for register: USTATUS */
129 /*
130  * UPIE (RW)
131  *
132  * UPIE holds the value of the UIE bit prior to a trap.
133  */
134 #define CSR_USTATUS_UPIE_MASK (0x10U)
135 #define CSR_USTATUS_UPIE_SHIFT (4U)
136 #define CSR_USTATUS_UPIE_SET(x) (((uint32_t)(x) << CSR_USTATUS_UPIE_SHIFT) & CSR_USTATUS_UPIE_MASK)
137 #define CSR_USTATUS_UPIE_GET(x) (((uint32_t)(x) & CSR_USTATUS_UPIE_MASK) >> CSR_USTATUS_UPIE_SHIFT)
138 
139 /*
140  * UIE (RW)
141  *
142  * U mode interrupt enable bit.
143  * 0:Disabled
144  * 1:Enabled
145  */
146 #define CSR_USTATUS_UIE_MASK (0x1U)
147 #define CSR_USTATUS_UIE_SHIFT (0U)
148 #define CSR_USTATUS_UIE_SET(x) (((uint32_t)(x) << CSR_USTATUS_UIE_SHIFT) & CSR_USTATUS_UIE_MASK)
149 #define CSR_USTATUS_UIE_GET(x) (((uint32_t)(x) & CSR_USTATUS_UIE_MASK) >> CSR_USTATUS_UIE_SHIFT)
150 
151 /* Bitfield definition for register: UIE */
152 /*
153  * UEIE (RW)
154  *
155  * U mode external interrupt enable bit
156  * 0:Disabled
157  * 1:Enabled
158  */
159 #define CSR_UIE_UEIE_MASK (0x100U)
160 #define CSR_UIE_UEIE_SHIFT (8U)
161 #define CSR_UIE_UEIE_SET(x) (((uint32_t)(x) << CSR_UIE_UEIE_SHIFT) & CSR_UIE_UEIE_MASK)
162 #define CSR_UIE_UEIE_GET(x) (((uint32_t)(x) & CSR_UIE_UEIE_MASK) >> CSR_UIE_UEIE_SHIFT)
163 
164 /*
165  * UTIE (RW)
166  *
167  * U mode timer interrupt enable bit.
168  * 0:Disabled
169  * 1:Enabled
170  */
171 #define CSR_UIE_UTIE_MASK (0x10U)
172 #define CSR_UIE_UTIE_SHIFT (4U)
173 #define CSR_UIE_UTIE_SET(x) (((uint32_t)(x) << CSR_UIE_UTIE_SHIFT) & CSR_UIE_UTIE_MASK)
174 #define CSR_UIE_UTIE_GET(x) (((uint32_t)(x) & CSR_UIE_UTIE_MASK) >> CSR_UIE_UTIE_SHIFT)
175 
176 /*
177  * USIE (RW)
178  *
179  * U mode software interrupt enable bit.
180  * 0:Disabled
181  * 1:Enabled
182  */
183 #define CSR_UIE_USIE_MASK (0x1U)
184 #define CSR_UIE_USIE_SHIFT (0U)
185 #define CSR_UIE_USIE_SET(x) (((uint32_t)(x) << CSR_UIE_USIE_SHIFT) & CSR_UIE_USIE_MASK)
186 #define CSR_UIE_USIE_GET(x) (((uint32_t)(x) & CSR_UIE_USIE_MASK) >> CSR_UIE_USIE_SHIFT)
187 
188 /* Bitfield definition for register: UTVEC */
189 /*
190  * BASE_31_2 (RW)
191  *
192  * Base address for interrupt and exception handlers. See description above for alignment requirements when PLIC is in the vector mode.
193  */
194 #define CSR_UTVEC_BASE_31_2_MASK (0xFFFFFFFCUL)
195 #define CSR_UTVEC_BASE_31_2_SHIFT (2U)
196 #define CSR_UTVEC_BASE_31_2_SET(x) (((uint32_t)(x) << CSR_UTVEC_BASE_31_2_SHIFT) & CSR_UTVEC_BASE_31_2_MASK)
197 #define CSR_UTVEC_BASE_31_2_GET(x) (((uint32_t)(x) & CSR_UTVEC_BASE_31_2_MASK) >> CSR_UTVEC_BASE_31_2_SHIFT)
198 
199 /* Bitfield definition for register: USCRATCH */
200 /*
201  * USCRATCH (RW)
202  *
203  * Scratch register storage.
204  */
205 #define CSR_USCRATCH_USCRATCH_MASK (0xFFFFFFFFUL)
206 #define CSR_USCRATCH_USCRATCH_SHIFT (0U)
207 #define CSR_USCRATCH_USCRATCH_SET(x) (((uint32_t)(x) << CSR_USCRATCH_USCRATCH_SHIFT) & CSR_USCRATCH_USCRATCH_MASK)
208 #define CSR_USCRATCH_USCRATCH_GET(x) (((uint32_t)(x) & CSR_USCRATCH_USCRATCH_MASK) >> CSR_USCRATCH_USCRATCH_SHIFT)
209 
210 /* Bitfield definition for register: UEPC */
211 /*
212  * EPC (RW)
213  *
214  * Exception program counter.
215  */
216 #define CSR_UEPC_EPC_MASK (0xFFFFFFFEUL)
217 #define CSR_UEPC_EPC_SHIFT (1U)
218 #define CSR_UEPC_EPC_SET(x) (((uint32_t)(x) << CSR_UEPC_EPC_SHIFT) & CSR_UEPC_EPC_MASK)
219 #define CSR_UEPC_EPC_GET(x) (((uint32_t)(x) & CSR_UEPC_EPC_MASK) >> CSR_UEPC_EPC_SHIFT)
220 
221 /* Bitfield definition for register: UCAUSE */
222 /*
223  * INTERRUPT (RW)
224  *
225  * Interrupt.
226  */
227 #define CSR_UCAUSE_INTERRUPT_MASK (0x80000000UL)
228 #define CSR_UCAUSE_INTERRUPT_SHIFT (31U)
229 #define CSR_UCAUSE_INTERRUPT_SET(x) (((uint32_t)(x) << CSR_UCAUSE_INTERRUPT_SHIFT) & CSR_UCAUSE_INTERRUPT_MASK)
230 #define CSR_UCAUSE_INTERRUPT_GET(x) (((uint32_t)(x) & CSR_UCAUSE_INTERRUPT_MASK) >> CSR_UCAUSE_INTERRUPT_SHIFT)
231 
232 /*
233  * EXCEPTION_CODE (RW)
234  *
235  * Exception Code.
236  * When interrupt is 1:
237  * 0:User software interrupt
238  * 4:User timer interrupt
239  * 8:User external interrupt
240  * When interrupt is 0:
241  * 0:Instruction address misaligned
242  * 1:Instruction access fault
243  * 2:Illegal instruction
244  * 3:Breakpoint
245  * 4:Load address misaligned
246  * 5:Load access fault
247  * 6:Store/AMO address misaligned
248  * 7:Store/AMO access fault
249  * 8:Environment call from U-mode
250  * 9-11:Reserved
251  * 12:Instruction page fault
252  * 13:Load page fault
253  * 14:Reserved
254  * 15:Store/AMO page fault
255  * 32:Stack overflow exception
256  * 33:Stack underflow exception
257  * 40-47:Reserved
258  */
259 #define CSR_UCAUSE_EXCEPTION_CODE_MASK (0x3FFU)
260 #define CSR_UCAUSE_EXCEPTION_CODE_SHIFT (0U)
261 #define CSR_UCAUSE_EXCEPTION_CODE_SET(x) (((uint32_t)(x) << CSR_UCAUSE_EXCEPTION_CODE_SHIFT) & CSR_UCAUSE_EXCEPTION_CODE_MASK)
262 #define CSR_UCAUSE_EXCEPTION_CODE_GET(x) (((uint32_t)(x) & CSR_UCAUSE_EXCEPTION_CODE_MASK) >> CSR_UCAUSE_EXCEPTION_CODE_SHIFT)
263 
264 /* Bitfield definition for register: UTVAL */
265 /*
266  * UTVAL (RW)
267  *
268  * Exception-specific information for software trap handling.
269  */
270 #define CSR_UTVAL_UTVAL_MASK (0xFFFFFFFFUL)
271 #define CSR_UTVAL_UTVAL_SHIFT (0U)
272 #define CSR_UTVAL_UTVAL_SET(x) (((uint32_t)(x) << CSR_UTVAL_UTVAL_SHIFT) & CSR_UTVAL_UTVAL_MASK)
273 #define CSR_UTVAL_UTVAL_GET(x) (((uint32_t)(x) & CSR_UTVAL_UTVAL_MASK) >> CSR_UTVAL_UTVAL_SHIFT)
274 
275 /* Bitfield definition for register: UIP */
276 /*
277  * UEIP (RW)
278  *
279  * U mode external interrupt pending bit.
280  * 0:Not pending
281  * 1:Pending
282  */
283 #define CSR_UIP_UEIP_MASK (0x100U)
284 #define CSR_UIP_UEIP_SHIFT (8U)
285 #define CSR_UIP_UEIP_SET(x) (((uint32_t)(x) << CSR_UIP_UEIP_SHIFT) & CSR_UIP_UEIP_MASK)
286 #define CSR_UIP_UEIP_GET(x) (((uint32_t)(x) & CSR_UIP_UEIP_MASK) >> CSR_UIP_UEIP_SHIFT)
287 
288 /*
289  * UTIP (RW)
290  *
291  * U mode timer interrupt pending bit.
292  * 0:Not pending
293  * 1:Pending
294  */
295 #define CSR_UIP_UTIP_MASK (0x10U)
296 #define CSR_UIP_UTIP_SHIFT (4U)
297 #define CSR_UIP_UTIP_SET(x) (((uint32_t)(x) << CSR_UIP_UTIP_SHIFT) & CSR_UIP_UTIP_MASK)
298 #define CSR_UIP_UTIP_GET(x) (((uint32_t)(x) & CSR_UIP_UTIP_MASK) >> CSR_UIP_UTIP_SHIFT)
299 
300 /*
301  * USIP (RW)
302  *
303  * U mode software interrupt pending bit.
304  * 0:Not pending
305  * 1:Pending
306  */
307 #define CSR_UIP_USIP_MASK (0x1U)
308 #define CSR_UIP_USIP_SHIFT (0U)
309 #define CSR_UIP_USIP_SET(x) (((uint32_t)(x) << CSR_UIP_USIP_SHIFT) & CSR_UIP_USIP_MASK)
310 #define CSR_UIP_USIP_GET(x) (((uint32_t)(x) & CSR_UIP_USIP_MASK) >> CSR_UIP_USIP_SHIFT)
311 
312 /* Bitfield definition for register: MSTATUS */
313 /*
314  * SD (RO)
315  *
316  * SD summarizes whether either the FS field or XS field is dirty.
317  */
318 #define CSR_MSTATUS_SD_MASK (0x80000000UL)
319 #define CSR_MSTATUS_SD_SHIFT (31U)
320 #define CSR_MSTATUS_SD_GET(x) (((uint32_t)(x) & CSR_MSTATUS_SD_MASK) >> CSR_MSTATUS_SD_SHIFT)
321 
322 /*
323  * MXR (RW)
324  *
325  * MXR controls whether execute-only pages are readable. It has no effect when page-based virtual memory is not in effect
326  * 0:Execute-only pages are not readable
327  * 1:Execute-only pages are readable
328  */
329 #define CSR_MSTATUS_MXR_MASK (0x80000UL)
330 #define CSR_MSTATUS_MXR_SHIFT (19U)
331 #define CSR_MSTATUS_MXR_SET(x) (((uint32_t)(x) << CSR_MSTATUS_MXR_SHIFT) & CSR_MSTATUS_MXR_MASK)
332 #define CSR_MSTATUS_MXR_GET(x) (((uint32_t)(x) & CSR_MSTATUS_MXR_MASK) >> CSR_MSTATUS_MXR_SHIFT)
333 
334 /*
335  * MPRV (RW)
336  *
337  * When the MPRV bit is set, the memory access privilege for load and store are specified by the MPP field. When U-mode is not available, this field is hardwired to 0.
338  */
339 #define CSR_MSTATUS_MPRV_MASK (0x20000UL)
340 #define CSR_MSTATUS_MPRV_SHIFT (17U)
341 #define CSR_MSTATUS_MPRV_SET(x) (((uint32_t)(x) << CSR_MSTATUS_MPRV_SHIFT) & CSR_MSTATUS_MPRV_MASK)
342 #define CSR_MSTATUS_MPRV_GET(x) (((uint32_t)(x) & CSR_MSTATUS_MPRV_MASK) >> CSR_MSTATUS_MPRV_SHIFT)
343 
344 /*
345  * XS (RO)
346  *
347  * XS holds the status of the architectural states (ACE registers) of ACE instructions. The value of this field is zero if ACE extension is not configured. This field is primarily managed by software. The processor hardware assists the state managements in two regards:
348  * Illegal instruction exceptions are triggered when XS is Off.
349  * XS is updated to the Dirty state with the execution of ACE instructions when XS is not Off. Changing the setting of this field has no effect on the contents of ACE states. In particular, setting XS to Off does not destroy the states, nor does setting XS to Initial clear the contents.
350  * 0:Off
351  * 1:Initial
352  * 2:Clean
353  * 3:Dirty
354  */
355 #define CSR_MSTATUS_XS_MASK (0x18000UL)
356 #define CSR_MSTATUS_XS_SHIFT (15U)
357 #define CSR_MSTATUS_XS_GET(x) (((uint32_t)(x) & CSR_MSTATUS_XS_MASK) >> CSR_MSTATUS_XS_SHIFT)
358 
359 /*
360  * FS (RW)
361  *
362  * FS holds the status of the architectural states of the floating-point unit, including the fcsr CSR and f0 – f31 floating-point data registers. The value of this field is zero and read-only if the processor does not have FPU. This field is primarily managed by software. The processor hardware assists the state
363  * managements in two regards:
364  * Attempts to access fcsr or any f register raise an illegal-instruction exception when FS is Off.
365  * FS is updated to the Dirty state with the execution of any instruction that updates fcsr or any f register when FS is Initial or Clean. Changing the setting of this field has no effect on the contents of the floating-point register states. In particular, setting FS to Off does not destroy the states, nor does setting FS to Initial clear the contents.
366  * 0:Off
367  * 1:Initial
368  * 2:Clean
369  * 3:Dirty
370  */
371 #define CSR_MSTATUS_FS_MASK (0x6000U)
372 #define CSR_MSTATUS_FS_SHIFT (13U)
373 #define CSR_MSTATUS_FS_SET(x) (((uint32_t)(x) << CSR_MSTATUS_FS_SHIFT) & CSR_MSTATUS_FS_MASK)
374 #define CSR_MSTATUS_FS_GET(x) (((uint32_t)(x) & CSR_MSTATUS_FS_MASK) >> CSR_MSTATUS_FS_SHIFT)
375 
376 /*
377  * MPP (RW)
378  *
379  * MPP holds the privilege mode prior to a trap. Encoding for privilege mode is described in Table5. When U-mode is not available, this field is hardwired to 3.
380  */
381 #define CSR_MSTATUS_MPP_MASK (0x1800U)
382 #define CSR_MSTATUS_MPP_SHIFT (11U)
383 #define CSR_MSTATUS_MPP_SET(x) (((uint32_t)(x) << CSR_MSTATUS_MPP_SHIFT) & CSR_MSTATUS_MPP_MASK)
384 #define CSR_MSTATUS_MPP_GET(x) (((uint32_t)(x) & CSR_MSTATUS_MPP_MASK) >> CSR_MSTATUS_MPP_SHIFT)
385 
386 /*
387  * MPIE (RW)
388  *
389  * MPIE holds the value of the MIE bit prior to a trap.
390  */
391 #define CSR_MSTATUS_MPIE_MASK (0x80U)
392 #define CSR_MSTATUS_MPIE_SHIFT (7U)
393 #define CSR_MSTATUS_MPIE_SET(x) (((uint32_t)(x) << CSR_MSTATUS_MPIE_SHIFT) & CSR_MSTATUS_MPIE_MASK)
394 #define CSR_MSTATUS_MPIE_GET(x) (((uint32_t)(x) & CSR_MSTATUS_MPIE_MASK) >> CSR_MSTATUS_MPIE_SHIFT)
395 
396 /*
397  * UPIE (RW)
398  *
399  * UPIE holds the value of the UIE bit prior to a trap.
400  */
401 #define CSR_MSTATUS_UPIE_MASK (0x10U)
402 #define CSR_MSTATUS_UPIE_SHIFT (4U)
403 #define CSR_MSTATUS_UPIE_SET(x) (((uint32_t)(x) << CSR_MSTATUS_UPIE_SHIFT) & CSR_MSTATUS_UPIE_MASK)
404 #define CSR_MSTATUS_UPIE_GET(x) (((uint32_t)(x) & CSR_MSTATUS_UPIE_MASK) >> CSR_MSTATUS_UPIE_SHIFT)
405 
406 /*
407  * MIE (RW)
408  *
409  * M mode interrupt enable bit.
410  * 0: Disabled
411  * 1: Enabled
412  */
413 #define CSR_MSTATUS_MIE_MASK (0x8U)
414 #define CSR_MSTATUS_MIE_SHIFT (3U)
415 #define CSR_MSTATUS_MIE_SET(x) (((uint32_t)(x) << CSR_MSTATUS_MIE_SHIFT) & CSR_MSTATUS_MIE_MASK)
416 #define CSR_MSTATUS_MIE_GET(x) (((uint32_t)(x) & CSR_MSTATUS_MIE_MASK) >> CSR_MSTATUS_MIE_SHIFT)
417 
418 /*
419  * UIE (RW)
420  *
421  * U mode interrupt enable bit.
422  * 0: Disabled
423  * 1: Enabled
424  */
425 #define CSR_MSTATUS_UIE_MASK (0x1U)
426 #define CSR_MSTATUS_UIE_SHIFT (0U)
427 #define CSR_MSTATUS_UIE_SET(x) (((uint32_t)(x) << CSR_MSTATUS_UIE_SHIFT) & CSR_MSTATUS_UIE_MASK)
428 #define CSR_MSTATUS_UIE_GET(x) (((uint32_t)(x) & CSR_MSTATUS_UIE_MASK) >> CSR_MSTATUS_UIE_SHIFT)
429 
430 /* Bitfield definition for register: MISA */
431 /*
432  * BASE (RO)
433  *
434  * The general-purpose register width of the native base integer ISA.
435  * 0:Reserved
436  * 1:32
437  * 2:64
438  * 3:128
439  */
440 #define CSR_MISA_BASE_MASK (0xC0000000UL)
441 #define CSR_MISA_BASE_SHIFT (30U)
442 #define CSR_MISA_BASE_GET(x) (((uint32_t)(x) & CSR_MISA_BASE_MASK) >> CSR_MISA_BASE_SHIFT)
443 
444 /*
445  * Z (RO)
446  *
447  * Reserved
448  */
449 #define CSR_MISA_Z_MASK (0x2000000UL)
450 #define CSR_MISA_Z_SHIFT (25U)
451 #define CSR_MISA_Z_GET(x) (((uint32_t)(x) & CSR_MISA_Z_MASK) >> CSR_MISA_Z_SHIFT)
452 
453 /*
454  * Y (RO)
455  *
456  * Reserved
457  */
458 #define CSR_MISA_Y_MASK (0x1000000UL)
459 #define CSR_MISA_Y_SHIFT (24U)
460 #define CSR_MISA_Y_GET(x) (((uint32_t)(x) & CSR_MISA_Y_MASK) >> CSR_MISA_Y_SHIFT)
461 
462 /*
463  * X (RO)
464  *
465  * Non-standard extensions present
466  */
467 #define CSR_MISA_X_MASK (0x800000UL)
468 #define CSR_MISA_X_SHIFT (23U)
469 #define CSR_MISA_X_GET(x) (((uint32_t)(x) & CSR_MISA_X_MASK) >> CSR_MISA_X_SHIFT)
470 
471 /*
472  * W (RO)
473  *
474  * Reserved
475  */
476 #define CSR_MISA_W_MASK (0x400000UL)
477 #define CSR_MISA_W_SHIFT (22U)
478 #define CSR_MISA_W_GET(x) (((uint32_t)(x) & CSR_MISA_W_MASK) >> CSR_MISA_W_SHIFT)
479 
480 /*
481  * V (RO)
482  *
483  * Tentatively reserved for Vector extension
484  */
485 #define CSR_MISA_V_MASK (0x200000UL)
486 #define CSR_MISA_V_SHIFT (21U)
487 #define CSR_MISA_V_GET(x) (((uint32_t)(x) & CSR_MISA_V_MASK) >> CSR_MISA_V_SHIFT)
488 
489 /*
490  * U (RO)
491  *
492  * User mode implemented
493  * 0:Machine
494  * 1:Machine + User / Machine + Supervisor + User
495  */
496 #define CSR_MISA_U_MASK (0x100000UL)
497 #define CSR_MISA_U_SHIFT (20U)
498 #define CSR_MISA_U_GET(x) (((uint32_t)(x) & CSR_MISA_U_MASK) >> CSR_MISA_U_SHIFT)
499 
500 /*
501  * T (RO)
502  *
503  * Tentatively reserved for Transactional Memory extension
504  */
505 #define CSR_MISA_T_MASK (0x80000UL)
506 #define CSR_MISA_T_SHIFT (19U)
507 #define CSR_MISA_T_GET(x) (((uint32_t)(x) & CSR_MISA_T_MASK) >> CSR_MISA_T_SHIFT)
508 
509 /*
510  * S (RO)
511  *
512  * Supervisor mode implemented
513  * 0:Machine / Machine + User
514  * 1:Machine + Supervisor + User
515  */
516 #define CSR_MISA_S_MASK (0x40000UL)
517 #define CSR_MISA_S_SHIFT (18U)
518 #define CSR_MISA_S_GET(x) (((uint32_t)(x) & CSR_MISA_S_MASK) >> CSR_MISA_S_SHIFT)
519 
520 /*
521  * R (RO)
522  *
523  * Reserved
524  */
525 #define CSR_MISA_R_MASK (0x20000UL)
526 #define CSR_MISA_R_SHIFT (17U)
527 #define CSR_MISA_R_GET(x) (((uint32_t)(x) & CSR_MISA_R_MASK) >> CSR_MISA_R_SHIFT)
528 
529 /*
530  * Q (RO)
531  *
532  * Quad-precision floating-point extension
533  */
534 #define CSR_MISA_Q_MASK (0x10000UL)
535 #define CSR_MISA_Q_SHIFT (16U)
536 #define CSR_MISA_Q_GET(x) (((uint32_t)(x) & CSR_MISA_Q_MASK) >> CSR_MISA_Q_SHIFT)
537 
538 /*
539  * P (RO)
540  *
541  * Tentatively reserved for Packed-SIMD extension
542  */
543 #define CSR_MISA_P_MASK (0x8000U)
544 #define CSR_MISA_P_SHIFT (15U)
545 #define CSR_MISA_P_GET(x) (((uint32_t)(x) & CSR_MISA_P_MASK) >> CSR_MISA_P_SHIFT)
546 
547 /*
548  * O (RO)
549  *
550  * Reserved
551  */
552 #define CSR_MISA_O_MASK (0x4000U)
553 #define CSR_MISA_O_SHIFT (14U)
554 #define CSR_MISA_O_GET(x) (((uint32_t)(x) & CSR_MISA_O_MASK) >> CSR_MISA_O_SHIFT)
555 
556 /*
557  * N (RO)
558  *
559  * User-level interrupts supported
560  * 0:no
561  * 1:yes
562  */
563 #define CSR_MISA_N_MASK (0x2000U)
564 #define CSR_MISA_N_SHIFT (13U)
565 #define CSR_MISA_N_GET(x) (((uint32_t)(x) & CSR_MISA_N_MASK) >> CSR_MISA_N_SHIFT)
566 
567 /*
568  * M (RO)
569  *
570  * Integer Multiply/Divide extension
571  */
572 #define CSR_MISA_M_MASK (0x1000U)
573 #define CSR_MISA_M_SHIFT (12U)
574 #define CSR_MISA_M_GET(x) (((uint32_t)(x) & CSR_MISA_M_MASK) >> CSR_MISA_M_SHIFT)
575 
576 /*
577  * L (RO)
578  *
579  * Tentatively reserved for Decimal Floating-Point extension
580  */
581 #define CSR_MISA_L_MASK (0x800U)
582 #define CSR_MISA_L_SHIFT (11U)
583 #define CSR_MISA_L_GET(x) (((uint32_t)(x) & CSR_MISA_L_MASK) >> CSR_MISA_L_SHIFT)
584 
585 /*
586  * K (RO)
587  *
588  * Reserved
589  */
590 #define CSR_MISA_K_MASK (0x400U)
591 #define CSR_MISA_K_SHIFT (10U)
592 #define CSR_MISA_K_GET(x) (((uint32_t)(x) & CSR_MISA_K_MASK) >> CSR_MISA_K_SHIFT)
593 
594 /*
595  * J (RO)
596  *
597  * Tentatively reserved for Dynamically Translated Languages extension
598  */
599 #define CSR_MISA_J_MASK (0x200U)
600 #define CSR_MISA_J_SHIFT (9U)
601 #define CSR_MISA_J_GET(x) (((uint32_t)(x) & CSR_MISA_J_MASK) >> CSR_MISA_J_SHIFT)
602 
603 /*
604  * I (RO)
605  *
606  * RV32I/64I/128I base ISA
607  */
608 #define CSR_MISA_I_MASK (0x100U)
609 #define CSR_MISA_I_SHIFT (8U)
610 #define CSR_MISA_I_GET(x) (((uint32_t)(x) & CSR_MISA_I_MASK) >> CSR_MISA_I_SHIFT)
611 
612 /*
613  * H (RO)
614  *
615  * Reserved
616  */
617 #define CSR_MISA_H_MASK (0x80U)
618 #define CSR_MISA_H_SHIFT (7U)
619 #define CSR_MISA_H_GET(x) (((uint32_t)(x) & CSR_MISA_H_MASK) >> CSR_MISA_H_SHIFT)
620 
621 /*
622  * G (RO)
623  *
624  * Additional standard extensions present
625  */
626 #define CSR_MISA_G_MASK (0x40U)
627 #define CSR_MISA_G_SHIFT (6U)
628 #define CSR_MISA_G_GET(x) (((uint32_t)(x) & CSR_MISA_G_MASK) >> CSR_MISA_G_SHIFT)
629 
630 /*
631  * F (RO)
632  *
633  * Single-precision floating-point extension
634  * 0:none
635  * 1:double+single precision / single precision
636  */
637 #define CSR_MISA_F_MASK (0x20U)
638 #define CSR_MISA_F_SHIFT (5U)
639 #define CSR_MISA_F_GET(x) (((uint32_t)(x) & CSR_MISA_F_MASK) >> CSR_MISA_F_SHIFT)
640 
641 /*
642  * E (RO)
643  *
644  * RV32E base ISA
645  */
646 #define CSR_MISA_E_MASK (0x10U)
647 #define CSR_MISA_E_SHIFT (4U)
648 #define CSR_MISA_E_GET(x) (((uint32_t)(x) & CSR_MISA_E_MASK) >> CSR_MISA_E_SHIFT)
649 
650 /*
651  * D (RO)
652  *
653  * Double-precision floating-point extension
654  * 0:single precision / none
655  * 1:double+single precision
656  */
657 #define CSR_MISA_D_MASK (0x8U)
658 #define CSR_MISA_D_SHIFT (3U)
659 #define CSR_MISA_D_GET(x) (((uint32_t)(x) & CSR_MISA_D_MASK) >> CSR_MISA_D_SHIFT)
660 
661 /*
662  * C (RO)
663  *
664  * Compressed extension
665  */
666 #define CSR_MISA_C_MASK (0x4U)
667 #define CSR_MISA_C_SHIFT (2U)
668 #define CSR_MISA_C_GET(x) (((uint32_t)(x) & CSR_MISA_C_MASK) >> CSR_MISA_C_SHIFT)
669 
670 /*
671  * B (RO)
672  *
673  * Tentatively reserved for Bit operations extension
674  */
675 #define CSR_MISA_B_MASK (0x2U)
676 #define CSR_MISA_B_SHIFT (1U)
677 #define CSR_MISA_B_GET(x) (((uint32_t)(x) & CSR_MISA_B_MASK) >> CSR_MISA_B_SHIFT)
678 
679 /*
680  * A (RO)
681  *
682  * Atomic extension
683  * 0:no
684  * 1:yes
685  */
686 #define CSR_MISA_A_MASK (0x1U)
687 #define CSR_MISA_A_SHIFT (0U)
688 #define CSR_MISA_A_GET(x) (((uint32_t)(x) & CSR_MISA_A_MASK) >> CSR_MISA_A_SHIFT)
689 
690 /* Bitfield definition for register: MIE */
691 /*
692  * PMOVI (RW)
693  *
694  * Performance monitor overflow local interrupt enable bit
695  * 0:Disabled
696  * 1:Enabled
697  */
698 #define CSR_MIE_PMOVI_MASK (0x40000UL)
699 #define CSR_MIE_PMOVI_SHIFT (18U)
700 #define CSR_MIE_PMOVI_SET(x) (((uint32_t)(x) << CSR_MIE_PMOVI_SHIFT) & CSR_MIE_PMOVI_MASK)
701 #define CSR_MIE_PMOVI_GET(x) (((uint32_t)(x) & CSR_MIE_PMOVI_MASK) >> CSR_MIE_PMOVI_SHIFT)
702 
703 /*
704  * BWEI (RW)
705  *
706  * Bus read/write transaction error local interrupt enable bit. The processor may receive bus errors on load/store instructions or cache writebacks.
707  * 0:Disabled
708  * 1:Enabled
709  */
710 #define CSR_MIE_BWEI_MASK (0x20000UL)
711 #define CSR_MIE_BWEI_SHIFT (17U)
712 #define CSR_MIE_BWEI_SET(x) (((uint32_t)(x) << CSR_MIE_BWEI_SHIFT) & CSR_MIE_BWEI_MASK)
713 #define CSR_MIE_BWEI_GET(x) (((uint32_t)(x) & CSR_MIE_BWEI_MASK) >> CSR_MIE_BWEI_SHIFT)
714 
715 /*
716  * IMECCI (RW)
717  *
718  * Imprecise ECC error local interrupt enable bit. The processor may receive imprecise ECC errors on slave port accesses or cache writebacks.
719  * 0:Disabled
720  * 1:Enabled
721  */
722 #define CSR_MIE_IMECCI_MASK (0x10000UL)
723 #define CSR_MIE_IMECCI_SHIFT (16U)
724 #define CSR_MIE_IMECCI_SET(x) (((uint32_t)(x) << CSR_MIE_IMECCI_SHIFT) & CSR_MIE_IMECCI_MASK)
725 #define CSR_MIE_IMECCI_GET(x) (((uint32_t)(x) & CSR_MIE_IMECCI_MASK) >> CSR_MIE_IMECCI_SHIFT)
726 
727 /*
728  * MEIE (RW)
729  *
730  * M mode external interrupt enable bit
731  * 0:Disabled
732  * 1:Enabled
733  */
734 #define CSR_MIE_MEIE_MASK (0x800U)
735 #define CSR_MIE_MEIE_SHIFT (11U)
736 #define CSR_MIE_MEIE_SET(x) (((uint32_t)(x) << CSR_MIE_MEIE_SHIFT) & CSR_MIE_MEIE_MASK)
737 #define CSR_MIE_MEIE_GET(x) (((uint32_t)(x) & CSR_MIE_MEIE_MASK) >> CSR_MIE_MEIE_SHIFT)
738 
739 /*
740  * UEIE (RW)
741  *
742  * U mode external interrupt enable bit
743  * 0:Disabled
744  * 1:Enabled
745  */
746 #define CSR_MIE_UEIE_MASK (0x100U)
747 #define CSR_MIE_UEIE_SHIFT (8U)
748 #define CSR_MIE_UEIE_SET(x) (((uint32_t)(x) << CSR_MIE_UEIE_SHIFT) & CSR_MIE_UEIE_MASK)
749 #define CSR_MIE_UEIE_GET(x) (((uint32_t)(x) & CSR_MIE_UEIE_MASK) >> CSR_MIE_UEIE_SHIFT)
750 
751 /*
752  * MTIE (RW)
753  *
754  * M mode timer interrupt enable bit.
755  * 0:Disabled
756  * 1:Enabled
757  */
758 #define CSR_MIE_MTIE_MASK (0x80U)
759 #define CSR_MIE_MTIE_SHIFT (7U)
760 #define CSR_MIE_MTIE_SET(x) (((uint32_t)(x) << CSR_MIE_MTIE_SHIFT) & CSR_MIE_MTIE_MASK)
761 #define CSR_MIE_MTIE_GET(x) (((uint32_t)(x) & CSR_MIE_MTIE_MASK) >> CSR_MIE_MTIE_SHIFT)
762 
763 /*
764  * UTIE (RW)
765  *
766  * U mode timer interrupt enable bit.
767  * 0:Disabled
768  * 1:Enabled
769  */
770 #define CSR_MIE_UTIE_MASK (0x10U)
771 #define CSR_MIE_UTIE_SHIFT (4U)
772 #define CSR_MIE_UTIE_SET(x) (((uint32_t)(x) << CSR_MIE_UTIE_SHIFT) & CSR_MIE_UTIE_MASK)
773 #define CSR_MIE_UTIE_GET(x) (((uint32_t)(x) & CSR_MIE_UTIE_MASK) >> CSR_MIE_UTIE_SHIFT)
774 
775 /*
776  * MSIE (RW)
777  *
778  * M mode software interrupt enable bit
779  * 0:Disabled
780  * 1:Enabled
781  */
782 #define CSR_MIE_MSIE_MASK (0x8U)
783 #define CSR_MIE_MSIE_SHIFT (3U)
784 #define CSR_MIE_MSIE_SET(x) (((uint32_t)(x) << CSR_MIE_MSIE_SHIFT) & CSR_MIE_MSIE_MASK)
785 #define CSR_MIE_MSIE_GET(x) (((uint32_t)(x) & CSR_MIE_MSIE_MASK) >> CSR_MIE_MSIE_SHIFT)
786 
787 /*
788  * USIE (RW)
789  *
790  * U mode software interrupt enable bit.
791  * 0:Disabled
792  * 1:Enabled
793  */
794 #define CSR_MIE_USIE_MASK (0x1U)
795 #define CSR_MIE_USIE_SHIFT (0U)
796 #define CSR_MIE_USIE_SET(x) (((uint32_t)(x) << CSR_MIE_USIE_SHIFT) & CSR_MIE_USIE_MASK)
797 #define CSR_MIE_USIE_GET(x) (((uint32_t)(x) & CSR_MIE_USIE_MASK) >> CSR_MIE_USIE_SHIFT)
798 
799 /* Bitfield definition for register: MTVEC */
800 /*
801  * BASE_31_2 (RW)
802  *
803  * Base address for interrupt and exception handlers. See description above for alignment requirements when PLIC is in the vector mode
804  */
805 #define CSR_MTVEC_BASE_31_2_MASK (0xFFFFFFFCUL)
806 #define CSR_MTVEC_BASE_31_2_SHIFT (2U)
807 #define CSR_MTVEC_BASE_31_2_SET(x) (((uint32_t)(x) << CSR_MTVEC_BASE_31_2_SHIFT) & CSR_MTVEC_BASE_31_2_MASK)
808 #define CSR_MTVEC_BASE_31_2_GET(x) (((uint32_t)(x) & CSR_MTVEC_BASE_31_2_MASK) >> CSR_MTVEC_BASE_31_2_SHIFT)
809 
810 /* Bitfield definition for register: MCOUNTEREN */
811 /*
812  * HPM6 (RW)
813  *
814  * See register description
815  */
816 #define CSR_MCOUNTEREN_HPM6_MASK (0x40U)
817 #define CSR_MCOUNTEREN_HPM6_SHIFT (6U)
818 #define CSR_MCOUNTEREN_HPM6_SET(x) (((uint32_t)(x) << CSR_MCOUNTEREN_HPM6_SHIFT) & CSR_MCOUNTEREN_HPM6_MASK)
819 #define CSR_MCOUNTEREN_HPM6_GET(x) (((uint32_t)(x) & CSR_MCOUNTEREN_HPM6_MASK) >> CSR_MCOUNTEREN_HPM6_SHIFT)
820 
821 /*
822  * HPM5 (RW)
823  *
824  * See register description
825  */
826 #define CSR_MCOUNTEREN_HPM5_MASK (0x20U)
827 #define CSR_MCOUNTEREN_HPM5_SHIFT (5U)
828 #define CSR_MCOUNTEREN_HPM5_SET(x) (((uint32_t)(x) << CSR_MCOUNTEREN_HPM5_SHIFT) & CSR_MCOUNTEREN_HPM5_MASK)
829 #define CSR_MCOUNTEREN_HPM5_GET(x) (((uint32_t)(x) & CSR_MCOUNTEREN_HPM5_MASK) >> CSR_MCOUNTEREN_HPM5_SHIFT)
830 
831 /*
832  * HPM4 (RW)
833  *
834  * See register description
835  */
836 #define CSR_MCOUNTEREN_HPM4_MASK (0x10U)
837 #define CSR_MCOUNTEREN_HPM4_SHIFT (4U)
838 #define CSR_MCOUNTEREN_HPM4_SET(x) (((uint32_t)(x) << CSR_MCOUNTEREN_HPM4_SHIFT) & CSR_MCOUNTEREN_HPM4_MASK)
839 #define CSR_MCOUNTEREN_HPM4_GET(x) (((uint32_t)(x) & CSR_MCOUNTEREN_HPM4_MASK) >> CSR_MCOUNTEREN_HPM4_SHIFT)
840 
841 /*
842  * HPM3 (RW)
843  *
844  * See register description
845  */
846 #define CSR_MCOUNTEREN_HPM3_MASK (0x8U)
847 #define CSR_MCOUNTEREN_HPM3_SHIFT (3U)
848 #define CSR_MCOUNTEREN_HPM3_SET(x) (((uint32_t)(x) << CSR_MCOUNTEREN_HPM3_SHIFT) & CSR_MCOUNTEREN_HPM3_MASK)
849 #define CSR_MCOUNTEREN_HPM3_GET(x) (((uint32_t)(x) & CSR_MCOUNTEREN_HPM3_MASK) >> CSR_MCOUNTEREN_HPM3_SHIFT)
850 
851 /*
852  * IR (RW)
853  *
854  * See register description
855  */
856 #define CSR_MCOUNTEREN_IR_MASK (0x4U)
857 #define CSR_MCOUNTEREN_IR_SHIFT (2U)
858 #define CSR_MCOUNTEREN_IR_SET(x) (((uint32_t)(x) << CSR_MCOUNTEREN_IR_SHIFT) & CSR_MCOUNTEREN_IR_MASK)
859 #define CSR_MCOUNTEREN_IR_GET(x) (((uint32_t)(x) & CSR_MCOUNTEREN_IR_MASK) >> CSR_MCOUNTEREN_IR_SHIFT)
860 
861 /*
862  * TM (RW)
863  *
864  * See register description
865  */
866 #define CSR_MCOUNTEREN_TM_MASK (0x2U)
867 #define CSR_MCOUNTEREN_TM_SHIFT (1U)
868 #define CSR_MCOUNTEREN_TM_SET(x) (((uint32_t)(x) << CSR_MCOUNTEREN_TM_SHIFT) & CSR_MCOUNTEREN_TM_MASK)
869 #define CSR_MCOUNTEREN_TM_GET(x) (((uint32_t)(x) & CSR_MCOUNTEREN_TM_MASK) >> CSR_MCOUNTEREN_TM_SHIFT)
870 
871 /*
872  * CY (RW)
873  *
874  * See register description
875  */
876 #define CSR_MCOUNTEREN_CY_MASK (0x1U)
877 #define CSR_MCOUNTEREN_CY_SHIFT (0U)
878 #define CSR_MCOUNTEREN_CY_SET(x) (((uint32_t)(x) << CSR_MCOUNTEREN_CY_SHIFT) & CSR_MCOUNTEREN_CY_MASK)
879 #define CSR_MCOUNTEREN_CY_GET(x) (((uint32_t)(x) & CSR_MCOUNTEREN_CY_MASK) >> CSR_MCOUNTEREN_CY_SHIFT)
880 
881 /* Bitfield definition for register: MHPMEVENT3 */
882 /*
883  * SEL (RW)
884  *
885  * See Event Selectors table
886  */
887 #define CSR_MHPMEVENT3_SEL_MASK (0x1F0U)
888 #define CSR_MHPMEVENT3_SEL_SHIFT (4U)
889 #define CSR_MHPMEVENT3_SEL_SET(x) (((uint32_t)(x) << CSR_MHPMEVENT3_SEL_SHIFT) & CSR_MHPMEVENT3_SEL_MASK)
890 #define CSR_MHPMEVENT3_SEL_GET(x) (((uint32_t)(x) & CSR_MHPMEVENT3_SEL_MASK) >> CSR_MHPMEVENT3_SEL_SHIFT)
891 
892 /*
893  * TYPE (RW)
894  *
895  * See Event Selectors table
896  */
897 #define CSR_MHPMEVENT3_TYPE_MASK (0xFU)
898 #define CSR_MHPMEVENT3_TYPE_SHIFT (0U)
899 #define CSR_MHPMEVENT3_TYPE_SET(x) (((uint32_t)(x) << CSR_MHPMEVENT3_TYPE_SHIFT) & CSR_MHPMEVENT3_TYPE_MASK)
900 #define CSR_MHPMEVENT3_TYPE_GET(x) (((uint32_t)(x) & CSR_MHPMEVENT3_TYPE_MASK) >> CSR_MHPMEVENT3_TYPE_SHIFT)
901 
902 /* Bitfield definition for register: MHPMEVENT4 */
903 /*
904  * SEL (RW)
905  *
906  * See Event Selectors table
907  */
908 #define CSR_MHPMEVENT4_SEL_MASK (0x1F0U)
909 #define CSR_MHPMEVENT4_SEL_SHIFT (4U)
910 #define CSR_MHPMEVENT4_SEL_SET(x) (((uint32_t)(x) << CSR_MHPMEVENT4_SEL_SHIFT) & CSR_MHPMEVENT4_SEL_MASK)
911 #define CSR_MHPMEVENT4_SEL_GET(x) (((uint32_t)(x) & CSR_MHPMEVENT4_SEL_MASK) >> CSR_MHPMEVENT4_SEL_SHIFT)
912 
913 /*
914  * TYPE (RW)
915  *
916  * See Event Selectors table
917  */
918 #define CSR_MHPMEVENT4_TYPE_MASK (0xFU)
919 #define CSR_MHPMEVENT4_TYPE_SHIFT (0U)
920 #define CSR_MHPMEVENT4_TYPE_SET(x) (((uint32_t)(x) << CSR_MHPMEVENT4_TYPE_SHIFT) & CSR_MHPMEVENT4_TYPE_MASK)
921 #define CSR_MHPMEVENT4_TYPE_GET(x) (((uint32_t)(x) & CSR_MHPMEVENT4_TYPE_MASK) >> CSR_MHPMEVENT4_TYPE_SHIFT)
922 
923 /* Bitfield definition for register: MHPMEVENT5 */
924 /*
925  * SEL (RW)
926  *
927  * See Event Selectors table
928  */
929 #define CSR_MHPMEVENT5_SEL_MASK (0x1F0U)
930 #define CSR_MHPMEVENT5_SEL_SHIFT (4U)
931 #define CSR_MHPMEVENT5_SEL_SET(x) (((uint32_t)(x) << CSR_MHPMEVENT5_SEL_SHIFT) & CSR_MHPMEVENT5_SEL_MASK)
932 #define CSR_MHPMEVENT5_SEL_GET(x) (((uint32_t)(x) & CSR_MHPMEVENT5_SEL_MASK) >> CSR_MHPMEVENT5_SEL_SHIFT)
933 
934 /*
935  * TYPE (RW)
936  *
937  * See Event Selectors table
938  */
939 #define CSR_MHPMEVENT5_TYPE_MASK (0xFU)
940 #define CSR_MHPMEVENT5_TYPE_SHIFT (0U)
941 #define CSR_MHPMEVENT5_TYPE_SET(x) (((uint32_t)(x) << CSR_MHPMEVENT5_TYPE_SHIFT) & CSR_MHPMEVENT5_TYPE_MASK)
942 #define CSR_MHPMEVENT5_TYPE_GET(x) (((uint32_t)(x) & CSR_MHPMEVENT5_TYPE_MASK) >> CSR_MHPMEVENT5_TYPE_SHIFT)
943 
944 /* Bitfield definition for register: MHPMEVENT6 */
945 /*
946  * SEL (RW)
947  *
948  * See Event Selectors table
949  */
950 #define CSR_MHPMEVENT6_SEL_MASK (0x1F0U)
951 #define CSR_MHPMEVENT6_SEL_SHIFT (4U)
952 #define CSR_MHPMEVENT6_SEL_SET(x) (((uint32_t)(x) << CSR_MHPMEVENT6_SEL_SHIFT) & CSR_MHPMEVENT6_SEL_MASK)
953 #define CSR_MHPMEVENT6_SEL_GET(x) (((uint32_t)(x) & CSR_MHPMEVENT6_SEL_MASK) >> CSR_MHPMEVENT6_SEL_SHIFT)
954 
955 /*
956  * TYPE (RW)
957  *
958  * See Event Selectors table
959  */
960 #define CSR_MHPMEVENT6_TYPE_MASK (0xFU)
961 #define CSR_MHPMEVENT6_TYPE_SHIFT (0U)
962 #define CSR_MHPMEVENT6_TYPE_SET(x) (((uint32_t)(x) << CSR_MHPMEVENT6_TYPE_SHIFT) & CSR_MHPMEVENT6_TYPE_MASK)
963 #define CSR_MHPMEVENT6_TYPE_GET(x) (((uint32_t)(x) & CSR_MHPMEVENT6_TYPE_MASK) >> CSR_MHPMEVENT6_TYPE_SHIFT)
964 
965 /* Bitfield definition for register: MSCRATCH */
966 /*
967  * MSCRATCH (RW)
968  *
969  * Scratch register storage.
970  */
971 #define CSR_MSCRATCH_MSCRATCH_MASK (0xFFFFFFFFUL)
972 #define CSR_MSCRATCH_MSCRATCH_SHIFT (0U)
973 #define CSR_MSCRATCH_MSCRATCH_SET(x) (((uint32_t)(x) << CSR_MSCRATCH_MSCRATCH_SHIFT) & CSR_MSCRATCH_MSCRATCH_MASK)
974 #define CSR_MSCRATCH_MSCRATCH_GET(x) (((uint32_t)(x) & CSR_MSCRATCH_MSCRATCH_MASK) >> CSR_MSCRATCH_MSCRATCH_SHIFT)
975 
976 /* Bitfield definition for register: MEPC */
977 /*
978  * EPC (RW)
979  *
980  * Exception program counter.
981  */
982 #define CSR_MEPC_EPC_MASK (0xFFFFFFFEUL)
983 #define CSR_MEPC_EPC_SHIFT (1U)
984 #define CSR_MEPC_EPC_SET(x) (((uint32_t)(x) << CSR_MEPC_EPC_SHIFT) & CSR_MEPC_EPC_MASK)
985 #define CSR_MEPC_EPC_GET(x) (((uint32_t)(x) & CSR_MEPC_EPC_MASK) >> CSR_MEPC_EPC_SHIFT)
986 
987 /* Bitfield definition for register: MCAUSE */
988 /*
989  * INTERRUPT (RW)
990  *
991  * Interrupt
992  */
993 #define CSR_MCAUSE_INTERRUPT_MASK (0x80000000UL)
994 #define CSR_MCAUSE_INTERRUPT_SHIFT (31U)
995 #define CSR_MCAUSE_INTERRUPT_SET(x) (((uint32_t)(x) << CSR_MCAUSE_INTERRUPT_SHIFT) & CSR_MCAUSE_INTERRUPT_MASK)
996 #define CSR_MCAUSE_INTERRUPT_GET(x) (((uint32_t)(x) & CSR_MCAUSE_INTERRUPT_MASK) >> CSR_MCAUSE_INTERRUPT_SHIFT)
997 
998 /*
999  * EXCEPTION_CODE (RW)
1000  *
1001  * Exception code
1002  * When interrupt is 1, the value means:
1003  * 0:User software interrupt
1004  * 1:Supervisor software interrupt
1005  * 3:Machine software interrupt
1006  * 4:User timer interrupt
1007  * 5:Supervisor timer interrupt
1008  * 7:Machine timer interrupt
1009  * 8:User external interrupt
1010  * 9:Supervisor external interrupt
1011  * 11:Machine external interrupt
1012  * 16:Imprecise ECC error interrupt (slave port accesses, D-Cache evictions, and nonblocking load/stores) (M-mode)
1013  * 17:Bus read/write transaction error interrupt (M-mode)
1014  * 18:Performance monitor overflow interrupt (M-mode)
1015  * 256+16:Imprecise ECC error interrupt (slave port accesses, D-Cache evictions, and nonblocking load/stores) (S-mode)
1016  * 256+17:Bus write transaction error interrupt (S-mode)
1017  * 256+18:Performance monitor overflow interrupt (S-mode)
1018  * When interrupt bit is 0, the value means:
1019  * 0:Instruction address misaligned
1020  * 1:Instruction access fault
1021  * 2:Illegal instruction
1022  * 3:Breakpoint
1023  * 4:Load address misaligned
1024  * 5:Load access fault
1025  * 6:Store/AMO address misaligned
1026  * 7:Store/AMO access fault
1027  * 8:Environment call from U-mode
1028  * 9:Environment call from S-mode
1029  * 11:Environment call from M-mode
1030  * 32:Stack overflow exception
1031  * 33:Stack underflow exception
1032  * 40-47:Reserved
1033  */
1034 #define CSR_MCAUSE_EXCEPTION_CODE_MASK (0xFFFU)
1035 #define CSR_MCAUSE_EXCEPTION_CODE_SHIFT (0U)
1036 #define CSR_MCAUSE_EXCEPTION_CODE_SET(x) (((uint32_t)(x) << CSR_MCAUSE_EXCEPTION_CODE_SHIFT) & CSR_MCAUSE_EXCEPTION_CODE_MASK)
1037 #define CSR_MCAUSE_EXCEPTION_CODE_GET(x) (((uint32_t)(x) & CSR_MCAUSE_EXCEPTION_CODE_MASK) >> CSR_MCAUSE_EXCEPTION_CODE_SHIFT)
1038 
1039 /* Bitfield definition for register: MTVAL */
1040 /*
1041  * MTVAL (RW)
1042  *
1043  * Exception-specific information for software trap handling.
1044  */
1045 #define CSR_MTVAL_MTVAL_MASK (0xFFFFFFFFUL)
1046 #define CSR_MTVAL_MTVAL_SHIFT (0U)
1047 #define CSR_MTVAL_MTVAL_SET(x) (((uint32_t)(x) << CSR_MTVAL_MTVAL_SHIFT) & CSR_MTVAL_MTVAL_MASK)
1048 #define CSR_MTVAL_MTVAL_GET(x) (((uint32_t)(x) & CSR_MTVAL_MTVAL_MASK) >> CSR_MTVAL_MTVAL_SHIFT)
1049 
1050 /* Bitfield definition for register: MIP */
1051 /*
1052  * PMOVI (RW)
1053  *
1054  * Performance monitor overflow local interrupt pending bit.
1055  * 0:Not pending
1056  * 1:Pending
1057  */
1058 #define CSR_MIP_PMOVI_MASK (0x40000UL)
1059 #define CSR_MIP_PMOVI_SHIFT (18U)
1060 #define CSR_MIP_PMOVI_SET(x) (((uint32_t)(x) << CSR_MIP_PMOVI_SHIFT) & CSR_MIP_PMOVI_MASK)
1061 #define CSR_MIP_PMOVI_GET(x) (((uint32_t)(x) & CSR_MIP_PMOVI_MASK) >> CSR_MIP_PMOVI_SHIFT)
1062 
1063 /*
1064  * BWEI (RW)
1065  *
1066  * Bus read/write transaction error local interrupt pending bit. The processor may receive bus errors on load/store instructions or cache writebacks.
1067  * 0:Not pending
1068  * 1:Pending
1069  */
1070 #define CSR_MIP_BWEI_MASK (0x20000UL)
1071 #define CSR_MIP_BWEI_SHIFT (17U)
1072 #define CSR_MIP_BWEI_SET(x) (((uint32_t)(x) << CSR_MIP_BWEI_SHIFT) & CSR_MIP_BWEI_MASK)
1073 #define CSR_MIP_BWEI_GET(x) (((uint32_t)(x) & CSR_MIP_BWEI_MASK) >> CSR_MIP_BWEI_SHIFT)
1074 
1075 /*
1076  * IMECCI (RW)
1077  *
1078  * Imprecise ECC error local interrupt enable bit. The processor may receive imprecise ECC errors on slave port accesses or cache writebacks.
1079  * 0:Not pending
1080  * 1:Pending
1081  */
1082 #define CSR_MIP_IMECCI_MASK (0x10000UL)
1083 #define CSR_MIP_IMECCI_SHIFT (16U)
1084 #define CSR_MIP_IMECCI_SET(x) (((uint32_t)(x) << CSR_MIP_IMECCI_SHIFT) & CSR_MIP_IMECCI_MASK)
1085 #define CSR_MIP_IMECCI_GET(x) (((uint32_t)(x) & CSR_MIP_IMECCI_MASK) >> CSR_MIP_IMECCI_SHIFT)
1086 
1087 /*
1088  * MEIP (RW)
1089  *
1090  * M mode external interrupt pending bit.
1091  * 0:Not pending
1092  * 1:Pending
1093  */
1094 #define CSR_MIP_MEIP_MASK (0x800U)
1095 #define CSR_MIP_MEIP_SHIFT (11U)
1096 #define CSR_MIP_MEIP_SET(x) (((uint32_t)(x) << CSR_MIP_MEIP_SHIFT) & CSR_MIP_MEIP_MASK)
1097 #define CSR_MIP_MEIP_GET(x) (((uint32_t)(x) & CSR_MIP_MEIP_MASK) >> CSR_MIP_MEIP_SHIFT)
1098 
1099 /*
1100  * SEIP (RW)
1101  *
1102  * S mode external interrupt pending bit.
1103  * 0:Not pending
1104  * 1:Pending
1105  */
1106 #define CSR_MIP_SEIP_MASK (0x200U)
1107 #define CSR_MIP_SEIP_SHIFT (9U)
1108 #define CSR_MIP_SEIP_SET(x) (((uint32_t)(x) << CSR_MIP_SEIP_SHIFT) & CSR_MIP_SEIP_MASK)
1109 #define CSR_MIP_SEIP_GET(x) (((uint32_t)(x) & CSR_MIP_SEIP_MASK) >> CSR_MIP_SEIP_SHIFT)
1110 
1111 /*
1112  * UEIP (RW)
1113  *
1114  * U mode external interrupt pending bit.
1115  * 0:Not pending
1116  * 1:Pending
1117  */
1118 #define CSR_MIP_UEIP_MASK (0x100U)
1119 #define CSR_MIP_UEIP_SHIFT (8U)
1120 #define CSR_MIP_UEIP_SET(x) (((uint32_t)(x) << CSR_MIP_UEIP_SHIFT) & CSR_MIP_UEIP_MASK)
1121 #define CSR_MIP_UEIP_GET(x) (((uint32_t)(x) & CSR_MIP_UEIP_MASK) >> CSR_MIP_UEIP_SHIFT)
1122 
1123 /*
1124  * MTIP (RW)
1125  *
1126  * M mode timer interrupt pending bit.
1127  * 0:Not pending
1128  * 1:Pending
1129  */
1130 #define CSR_MIP_MTIP_MASK (0x80U)
1131 #define CSR_MIP_MTIP_SHIFT (7U)
1132 #define CSR_MIP_MTIP_SET(x) (((uint32_t)(x) << CSR_MIP_MTIP_SHIFT) & CSR_MIP_MTIP_MASK)
1133 #define CSR_MIP_MTIP_GET(x) (((uint32_t)(x) & CSR_MIP_MTIP_MASK) >> CSR_MIP_MTIP_SHIFT)
1134 
1135 /*
1136  * STIP (RW)
1137  *
1138  * S mode timer interrupt pending bit.
1139  * 0:Not pending
1140  * 1:Pending
1141  */
1142 #define CSR_MIP_STIP_MASK (0x20U)
1143 #define CSR_MIP_STIP_SHIFT (5U)
1144 #define CSR_MIP_STIP_SET(x) (((uint32_t)(x) << CSR_MIP_STIP_SHIFT) & CSR_MIP_STIP_MASK)
1145 #define CSR_MIP_STIP_GET(x) (((uint32_t)(x) & CSR_MIP_STIP_MASK) >> CSR_MIP_STIP_SHIFT)
1146 
1147 /*
1148  * UTIP (RW)
1149  *
1150  * U mode timer interrupt pending bit
1151  * 0:Not pending
1152  * 1:Pending
1153  */
1154 #define CSR_MIP_UTIP_MASK (0x10U)
1155 #define CSR_MIP_UTIP_SHIFT (4U)
1156 #define CSR_MIP_UTIP_SET(x) (((uint32_t)(x) << CSR_MIP_UTIP_SHIFT) & CSR_MIP_UTIP_MASK)
1157 #define CSR_MIP_UTIP_GET(x) (((uint32_t)(x) & CSR_MIP_UTIP_MASK) >> CSR_MIP_UTIP_SHIFT)
1158 
1159 /*
1160  * MSIP (RW)
1161  *
1162  * M mode software interrupt pending bit.
1163  * 0:Not pending
1164  * 1:Pending
1165  */
1166 #define CSR_MIP_MSIP_MASK (0x8U)
1167 #define CSR_MIP_MSIP_SHIFT (3U)
1168 #define CSR_MIP_MSIP_SET(x) (((uint32_t)(x) << CSR_MIP_MSIP_SHIFT) & CSR_MIP_MSIP_MASK)
1169 #define CSR_MIP_MSIP_GET(x) (((uint32_t)(x) & CSR_MIP_MSIP_MASK) >> CSR_MIP_MSIP_SHIFT)
1170 
1171 /*
1172  * SSIP (RW)
1173  *
1174  * S mode software interrupt pending bit.
1175  * 0:Not pending
1176  * 1:Pending
1177  */
1178 #define CSR_MIP_SSIP_MASK (0x2U)
1179 #define CSR_MIP_SSIP_SHIFT (1U)
1180 #define CSR_MIP_SSIP_SET(x) (((uint32_t)(x) << CSR_MIP_SSIP_SHIFT) & CSR_MIP_SSIP_MASK)
1181 #define CSR_MIP_SSIP_GET(x) (((uint32_t)(x) & CSR_MIP_SSIP_MASK) >> CSR_MIP_SSIP_SHIFT)
1182 
1183 /*
1184  * USIP (RW)
1185  *
1186  * U mode software interrupt pending bit.
1187  * 0:Not pending
1188  * 1:Pending
1189  */
1190 #define CSR_MIP_USIP_MASK (0x1U)
1191 #define CSR_MIP_USIP_SHIFT (0U)
1192 #define CSR_MIP_USIP_SET(x) (((uint32_t)(x) << CSR_MIP_USIP_SHIFT) & CSR_MIP_USIP_MASK)
1193 #define CSR_MIP_USIP_GET(x) (((uint32_t)(x) & CSR_MIP_USIP_MASK) >> CSR_MIP_USIP_SHIFT)
1194 
1195 /* Bitfield definition for register: PMPCFG0 */
1196 /*
1197  * PMP3CFG (RW)
1198  *
1199  * See PMPCFG Table
1200  */
1201 #define CSR_PMPCFG0_PMP3CFG_MASK (0xFF000000UL)
1202 #define CSR_PMPCFG0_PMP3CFG_SHIFT (24U)
1203 #define CSR_PMPCFG0_PMP3CFG_SET(x) (((uint32_t)(x) << CSR_PMPCFG0_PMP3CFG_SHIFT) & CSR_PMPCFG0_PMP3CFG_MASK)
1204 #define CSR_PMPCFG0_PMP3CFG_GET(x) (((uint32_t)(x) & CSR_PMPCFG0_PMP3CFG_MASK) >> CSR_PMPCFG0_PMP3CFG_SHIFT)
1205 
1206 /*
1207  * PMP2CFG (RW)
1208  *
1209  * See PMPCFG Table
1210  */
1211 #define CSR_PMPCFG0_PMP2CFG_MASK (0xFF0000UL)
1212 #define CSR_PMPCFG0_PMP2CFG_SHIFT (16U)
1213 #define CSR_PMPCFG0_PMP2CFG_SET(x) (((uint32_t)(x) << CSR_PMPCFG0_PMP2CFG_SHIFT) & CSR_PMPCFG0_PMP2CFG_MASK)
1214 #define CSR_PMPCFG0_PMP2CFG_GET(x) (((uint32_t)(x) & CSR_PMPCFG0_PMP2CFG_MASK) >> CSR_PMPCFG0_PMP2CFG_SHIFT)
1215 
1216 /*
1217  * PMP1CFG (RW)
1218  *
1219  * See PMPCFG Table
1220  */
1221 #define CSR_PMPCFG0_PMP1CFG_MASK (0xFF00U)
1222 #define CSR_PMPCFG0_PMP1CFG_SHIFT (8U)
1223 #define CSR_PMPCFG0_PMP1CFG_SET(x) (((uint32_t)(x) << CSR_PMPCFG0_PMP1CFG_SHIFT) & CSR_PMPCFG0_PMP1CFG_MASK)
1224 #define CSR_PMPCFG0_PMP1CFG_GET(x) (((uint32_t)(x) & CSR_PMPCFG0_PMP1CFG_MASK) >> CSR_PMPCFG0_PMP1CFG_SHIFT)
1225 
1226 /*
1227  * PMP0CFG (RW)
1228  *
1229  * See PMPCFG Table
1230  */
1231 #define CSR_PMPCFG0_PMP0CFG_MASK (0xFFU)
1232 #define CSR_PMPCFG0_PMP0CFG_SHIFT (0U)
1233 #define CSR_PMPCFG0_PMP0CFG_SET(x) (((uint32_t)(x) << CSR_PMPCFG0_PMP0CFG_SHIFT) & CSR_PMPCFG0_PMP0CFG_MASK)
1234 #define CSR_PMPCFG0_PMP0CFG_GET(x) (((uint32_t)(x) & CSR_PMPCFG0_PMP0CFG_MASK) >> CSR_PMPCFG0_PMP0CFG_SHIFT)
1235 
1236 /* Bitfield definition for register: PMPCFG1 */
1237 /*
1238  * PMP7CFG (RW)
1239  *
1240  * See PMPCFG Table
1241  */
1242 #define CSR_PMPCFG1_PMP7CFG_MASK (0xFF000000UL)
1243 #define CSR_PMPCFG1_PMP7CFG_SHIFT (24U)
1244 #define CSR_PMPCFG1_PMP7CFG_SET(x) (((uint32_t)(x) << CSR_PMPCFG1_PMP7CFG_SHIFT) & CSR_PMPCFG1_PMP7CFG_MASK)
1245 #define CSR_PMPCFG1_PMP7CFG_GET(x) (((uint32_t)(x) & CSR_PMPCFG1_PMP7CFG_MASK) >> CSR_PMPCFG1_PMP7CFG_SHIFT)
1246 
1247 /*
1248  * PMP6CFG (RW)
1249  *
1250  * See PMPCFG Table
1251  */
1252 #define CSR_PMPCFG1_PMP6CFG_MASK (0xFF0000UL)
1253 #define CSR_PMPCFG1_PMP6CFG_SHIFT (16U)
1254 #define CSR_PMPCFG1_PMP6CFG_SET(x) (((uint32_t)(x) << CSR_PMPCFG1_PMP6CFG_SHIFT) & CSR_PMPCFG1_PMP6CFG_MASK)
1255 #define CSR_PMPCFG1_PMP6CFG_GET(x) (((uint32_t)(x) & CSR_PMPCFG1_PMP6CFG_MASK) >> CSR_PMPCFG1_PMP6CFG_SHIFT)
1256 
1257 /*
1258  * PMP5CFG (RW)
1259  *
1260  * See PMPCFG Table
1261  */
1262 #define CSR_PMPCFG1_PMP5CFG_MASK (0xFF00U)
1263 #define CSR_PMPCFG1_PMP5CFG_SHIFT (8U)
1264 #define CSR_PMPCFG1_PMP5CFG_SET(x) (((uint32_t)(x) << CSR_PMPCFG1_PMP5CFG_SHIFT) & CSR_PMPCFG1_PMP5CFG_MASK)
1265 #define CSR_PMPCFG1_PMP5CFG_GET(x) (((uint32_t)(x) & CSR_PMPCFG1_PMP5CFG_MASK) >> CSR_PMPCFG1_PMP5CFG_SHIFT)
1266 
1267 /*
1268  * PMP4CFG (RW)
1269  *
1270  * See PMPCFG Table
1271  */
1272 #define CSR_PMPCFG1_PMP4CFG_MASK (0xFFU)
1273 #define CSR_PMPCFG1_PMP4CFG_SHIFT (0U)
1274 #define CSR_PMPCFG1_PMP4CFG_SET(x) (((uint32_t)(x) << CSR_PMPCFG1_PMP4CFG_SHIFT) & CSR_PMPCFG1_PMP4CFG_MASK)
1275 #define CSR_PMPCFG1_PMP4CFG_GET(x) (((uint32_t)(x) & CSR_PMPCFG1_PMP4CFG_MASK) >> CSR_PMPCFG1_PMP4CFG_SHIFT)
1276 
1277 /* Bitfield definition for register: PMPCFG2 */
1278 /*
1279  * PMP11CFG (RW)
1280  *
1281  * See PMPCFG Table
1282  */
1283 #define CSR_PMPCFG2_PMP11CFG_MASK (0xFF000000UL)
1284 #define CSR_PMPCFG2_PMP11CFG_SHIFT (24U)
1285 #define CSR_PMPCFG2_PMP11CFG_SET(x) (((uint32_t)(x) << CSR_PMPCFG2_PMP11CFG_SHIFT) & CSR_PMPCFG2_PMP11CFG_MASK)
1286 #define CSR_PMPCFG2_PMP11CFG_GET(x) (((uint32_t)(x) & CSR_PMPCFG2_PMP11CFG_MASK) >> CSR_PMPCFG2_PMP11CFG_SHIFT)
1287 
1288 /*
1289  * PMP10CFG (RW)
1290  *
1291  * See PMPCFG Table
1292  */
1293 #define CSR_PMPCFG2_PMP10CFG_MASK (0xFF0000UL)
1294 #define CSR_PMPCFG2_PMP10CFG_SHIFT (16U)
1295 #define CSR_PMPCFG2_PMP10CFG_SET(x) (((uint32_t)(x) << CSR_PMPCFG2_PMP10CFG_SHIFT) & CSR_PMPCFG2_PMP10CFG_MASK)
1296 #define CSR_PMPCFG2_PMP10CFG_GET(x) (((uint32_t)(x) & CSR_PMPCFG2_PMP10CFG_MASK) >> CSR_PMPCFG2_PMP10CFG_SHIFT)
1297 
1298 /*
1299  * PMP9CFG (RW)
1300  *
1301  * See PMPCFG Table
1302  */
1303 #define CSR_PMPCFG2_PMP9CFG_MASK (0xFF00U)
1304 #define CSR_PMPCFG2_PMP9CFG_SHIFT (8U)
1305 #define CSR_PMPCFG2_PMP9CFG_SET(x) (((uint32_t)(x) << CSR_PMPCFG2_PMP9CFG_SHIFT) & CSR_PMPCFG2_PMP9CFG_MASK)
1306 #define CSR_PMPCFG2_PMP9CFG_GET(x) (((uint32_t)(x) & CSR_PMPCFG2_PMP9CFG_MASK) >> CSR_PMPCFG2_PMP9CFG_SHIFT)
1307 
1308 /*
1309  * PMP8CFG (RW)
1310  *
1311  * See PMPCFG Table
1312  */
1313 #define CSR_PMPCFG2_PMP8CFG_MASK (0xFFU)
1314 #define CSR_PMPCFG2_PMP8CFG_SHIFT (0U)
1315 #define CSR_PMPCFG2_PMP8CFG_SET(x) (((uint32_t)(x) << CSR_PMPCFG2_PMP8CFG_SHIFT) & CSR_PMPCFG2_PMP8CFG_MASK)
1316 #define CSR_PMPCFG2_PMP8CFG_GET(x) (((uint32_t)(x) & CSR_PMPCFG2_PMP8CFG_MASK) >> CSR_PMPCFG2_PMP8CFG_SHIFT)
1317 
1318 /* Bitfield definition for register: PMPCFG3 */
1319 /*
1320  * PMP15CFG (RW)
1321  *
1322  * See PMPCFG Table
1323  */
1324 #define CSR_PMPCFG3_PMP15CFG_MASK (0xFF000000UL)
1325 #define CSR_PMPCFG3_PMP15CFG_SHIFT (24U)
1326 #define CSR_PMPCFG3_PMP15CFG_SET(x) (((uint32_t)(x) << CSR_PMPCFG3_PMP15CFG_SHIFT) & CSR_PMPCFG3_PMP15CFG_MASK)
1327 #define CSR_PMPCFG3_PMP15CFG_GET(x) (((uint32_t)(x) & CSR_PMPCFG3_PMP15CFG_MASK) >> CSR_PMPCFG3_PMP15CFG_SHIFT)
1328 
1329 /*
1330  * PMP14CFG (RW)
1331  *
1332  * See PMPCFG Table
1333  */
1334 #define CSR_PMPCFG3_PMP14CFG_MASK (0xFF0000UL)
1335 #define CSR_PMPCFG3_PMP14CFG_SHIFT (16U)
1336 #define CSR_PMPCFG3_PMP14CFG_SET(x) (((uint32_t)(x) << CSR_PMPCFG3_PMP14CFG_SHIFT) & CSR_PMPCFG3_PMP14CFG_MASK)
1337 #define CSR_PMPCFG3_PMP14CFG_GET(x) (((uint32_t)(x) & CSR_PMPCFG3_PMP14CFG_MASK) >> CSR_PMPCFG3_PMP14CFG_SHIFT)
1338 
1339 /*
1340  * PMP13CFG (RW)
1341  *
1342  * See PMPCFG Table
1343  */
1344 #define CSR_PMPCFG3_PMP13CFG_MASK (0xFF00U)
1345 #define CSR_PMPCFG3_PMP13CFG_SHIFT (8U)
1346 #define CSR_PMPCFG3_PMP13CFG_SET(x) (((uint32_t)(x) << CSR_PMPCFG3_PMP13CFG_SHIFT) & CSR_PMPCFG3_PMP13CFG_MASK)
1347 #define CSR_PMPCFG3_PMP13CFG_GET(x) (((uint32_t)(x) & CSR_PMPCFG3_PMP13CFG_MASK) >> CSR_PMPCFG3_PMP13CFG_SHIFT)
1348 
1349 /*
1350  * PMP12CFG (RW)
1351  *
1352  * See PMPCFG Table
1353  */
1354 #define CSR_PMPCFG3_PMP12CFG_MASK (0xFFU)
1355 #define CSR_PMPCFG3_PMP12CFG_SHIFT (0U)
1356 #define CSR_PMPCFG3_PMP12CFG_SET(x) (((uint32_t)(x) << CSR_PMPCFG3_PMP12CFG_SHIFT) & CSR_PMPCFG3_PMP12CFG_MASK)
1357 #define CSR_PMPCFG3_PMP12CFG_GET(x) (((uint32_t)(x) & CSR_PMPCFG3_PMP12CFG_MASK) >> CSR_PMPCFG3_PMP12CFG_SHIFT)
1358 
1359 /* Bitfield definition for register array: PMPADDR */
1360 /*
1361  * PMPADDR_31_2 (RW)
1362  *
1363  * Register Content : Match Size(Byte)
1364  * aaaa. . . aaa0 8
1365  * aaaa. . . aa01 16
1366  * aaaa. . . a011 32
1367  * . . . . . .
1368  * aa01. . . 1111 2^{XLEN}
1369  * a011. . . 1111 2^{XLEN+1}
1370  * 0111. . . 1111 2^{XLEN+2}
1371  * 1111. . . 1111 2^{XLEN+3*1}
1372  */
1373 #define CSR_PMPADDR0_PMPADDR_31_2_MASK (0xFFFFFFFCUL)
1374 #define CSR_PMPADDR0_PMPADDR_31_2_SHIFT (2U)
1375 #define CSR_PMPADDR0_PMPADDR_31_2_SET(x) (((uint32_t)(x) << CSR_PMPADDR0_PMPADDR_31_2_SHIFT) & CSR_PMPADDR0_PMPADDR_31_2_MASK)
1376 #define CSR_PMPADDR0_PMPADDR_31_2_GET(x) (((uint32_t)(x) & CSR_PMPADDR0_PMPADDR_31_2_MASK) >> CSR_PMPADDR0_PMPADDR_31_2_SHIFT)
1377 
1378 /* Bitfield definition for register array: PMPADDR */
1379 /*
1380  * PMPADDR_31_2 (RW)
1381  *
1382  * same as pmpaddr0
1383  */
1384 #define CSR_PMPADDR1_PMPADDR_31_2_MASK (0xFFFFFFFCUL)
1385 #define CSR_PMPADDR1_PMPADDR_31_2_SHIFT (2U)
1386 #define CSR_PMPADDR1_PMPADDR_31_2_SET(x) (((uint32_t)(x) << CSR_PMPADDR1_PMPADDR_31_2_SHIFT) & CSR_PMPADDR1_PMPADDR_31_2_MASK)
1387 #define CSR_PMPADDR1_PMPADDR_31_2_GET(x) (((uint32_t)(x) & CSR_PMPADDR1_PMPADDR_31_2_MASK) >> CSR_PMPADDR1_PMPADDR_31_2_SHIFT)
1388 
1389 /* Bitfield definition for register array: PMPADDR */
1390 /*
1391  * PMPADDR_31_2 (RW)
1392  *
1393  * same as pmpaddr0
1394  */
1395 #define CSR_PMPADDR2_PMPADDR_31_2_MASK (0xFFFFFFFCUL)
1396 #define CSR_PMPADDR2_PMPADDR_31_2_SHIFT (2U)
1397 #define CSR_PMPADDR2_PMPADDR_31_2_SET(x) (((uint32_t)(x) << CSR_PMPADDR2_PMPADDR_31_2_SHIFT) & CSR_PMPADDR2_PMPADDR_31_2_MASK)
1398 #define CSR_PMPADDR2_PMPADDR_31_2_GET(x) (((uint32_t)(x) & CSR_PMPADDR2_PMPADDR_31_2_MASK) >> CSR_PMPADDR2_PMPADDR_31_2_SHIFT)
1399 
1400 /* Bitfield definition for register array: PMPADDR */
1401 /*
1402  * PMPADDR_31_2 (RW)
1403  *
1404  * same as pmpaddr0
1405  */
1406 #define CSR_PMPADDR3_PMPADDR_31_2_MASK (0xFFFFFFFCUL)
1407 #define CSR_PMPADDR3_PMPADDR_31_2_SHIFT (2U)
1408 #define CSR_PMPADDR3_PMPADDR_31_2_SET(x) (((uint32_t)(x) << CSR_PMPADDR3_PMPADDR_31_2_SHIFT) & CSR_PMPADDR3_PMPADDR_31_2_MASK)
1409 #define CSR_PMPADDR3_PMPADDR_31_2_GET(x) (((uint32_t)(x) & CSR_PMPADDR3_PMPADDR_31_2_MASK) >> CSR_PMPADDR3_PMPADDR_31_2_SHIFT)
1410 
1411 /* Bitfield definition for register array: PMPADDR */
1412 /*
1413  * PMPADDR_31_2 (RW)
1414  *
1415  * same as pmpaddr0
1416  */
1417 #define CSR_PMPADDR4_PMPADDR_31_2_MASK (0xFFFFFFFCUL)
1418 #define CSR_PMPADDR4_PMPADDR_31_2_SHIFT (2U)
1419 #define CSR_PMPADDR4_PMPADDR_31_2_SET(x) (((uint32_t)(x) << CSR_PMPADDR4_PMPADDR_31_2_SHIFT) & CSR_PMPADDR4_PMPADDR_31_2_MASK)
1420 #define CSR_PMPADDR4_PMPADDR_31_2_GET(x) (((uint32_t)(x) & CSR_PMPADDR4_PMPADDR_31_2_MASK) >> CSR_PMPADDR4_PMPADDR_31_2_SHIFT)
1421 
1422 /* Bitfield definition for register array: PMPADDR */
1423 /*
1424  * PMPADDR_31_2 (RW)
1425  *
1426  * same as pmpaddr0
1427  */
1428 #define CSR_PMPADDR5_PMPADDR_31_2_MASK (0xFFFFFFFCUL)
1429 #define CSR_PMPADDR5_PMPADDR_31_2_SHIFT (2U)
1430 #define CSR_PMPADDR5_PMPADDR_31_2_SET(x) (((uint32_t)(x) << CSR_PMPADDR5_PMPADDR_31_2_SHIFT) & CSR_PMPADDR5_PMPADDR_31_2_MASK)
1431 #define CSR_PMPADDR5_PMPADDR_31_2_GET(x) (((uint32_t)(x) & CSR_PMPADDR5_PMPADDR_31_2_MASK) >> CSR_PMPADDR5_PMPADDR_31_2_SHIFT)
1432 
1433 /* Bitfield definition for register array: PMPADDR */
1434 /*
1435  * PMPADDR_31_2 (RW)
1436  *
1437  * same as pmpaddr0
1438  */
1439 #define CSR_PMPADDR6_PMPADDR_31_2_MASK (0xFFFFFFFCUL)
1440 #define CSR_PMPADDR6_PMPADDR_31_2_SHIFT (2U)
1441 #define CSR_PMPADDR6_PMPADDR_31_2_SET(x) (((uint32_t)(x) << CSR_PMPADDR6_PMPADDR_31_2_SHIFT) & CSR_PMPADDR6_PMPADDR_31_2_MASK)
1442 #define CSR_PMPADDR6_PMPADDR_31_2_GET(x) (((uint32_t)(x) & CSR_PMPADDR6_PMPADDR_31_2_MASK) >> CSR_PMPADDR6_PMPADDR_31_2_SHIFT)
1443 
1444 /* Bitfield definition for register array: PMPADDR */
1445 /*
1446  * PMPADDR_31_2 (RW)
1447  *
1448  * same as pmpaddr0
1449  */
1450 #define CSR_PMPADDR7_PMPADDR_31_2_MASK (0xFFFFFFFCUL)
1451 #define CSR_PMPADDR7_PMPADDR_31_2_SHIFT (2U)
1452 #define CSR_PMPADDR7_PMPADDR_31_2_SET(x) (((uint32_t)(x) << CSR_PMPADDR7_PMPADDR_31_2_SHIFT) & CSR_PMPADDR7_PMPADDR_31_2_MASK)
1453 #define CSR_PMPADDR7_PMPADDR_31_2_GET(x) (((uint32_t)(x) & CSR_PMPADDR7_PMPADDR_31_2_MASK) >> CSR_PMPADDR7_PMPADDR_31_2_SHIFT)
1454 
1455 /* Bitfield definition for register array: PMPADDR */
1456 /*
1457  * PMPADDR_31_2 (RW)
1458  *
1459  * same as pmpaddr0
1460  */
1461 #define CSR_PMPADDR8_PMPADDR_31_2_MASK (0xFFFFFFFCUL)
1462 #define CSR_PMPADDR8_PMPADDR_31_2_SHIFT (2U)
1463 #define CSR_PMPADDR8_PMPADDR_31_2_SET(x) (((uint32_t)(x) << CSR_PMPADDR8_PMPADDR_31_2_SHIFT) & CSR_PMPADDR8_PMPADDR_31_2_MASK)
1464 #define CSR_PMPADDR8_PMPADDR_31_2_GET(x) (((uint32_t)(x) & CSR_PMPADDR8_PMPADDR_31_2_MASK) >> CSR_PMPADDR8_PMPADDR_31_2_SHIFT)
1465 
1466 /* Bitfield definition for register array: PMPADDR */
1467 /*
1468  * PMPADDR_31_2 (RW)
1469  *
1470  * same as pmpaddr0
1471  */
1472 #define CSR_PMPADDR9_PMPADDR_31_2_MASK (0xFFFFFFFCUL)
1473 #define CSR_PMPADDR9_PMPADDR_31_2_SHIFT (2U)
1474 #define CSR_PMPADDR9_PMPADDR_31_2_SET(x) (((uint32_t)(x) << CSR_PMPADDR9_PMPADDR_31_2_SHIFT) & CSR_PMPADDR9_PMPADDR_31_2_MASK)
1475 #define CSR_PMPADDR9_PMPADDR_31_2_GET(x) (((uint32_t)(x) & CSR_PMPADDR9_PMPADDR_31_2_MASK) >> CSR_PMPADDR9_PMPADDR_31_2_SHIFT)
1476 
1477 /* Bitfield definition for register array: PMPADDR */
1478 /*
1479  * PMPADDR_31_2 (RW)
1480  *
1481  * same as pmpaddr0
1482  */
1483 #define CSR_PMPADDR10_PMPADDR_31_2_MASK (0xFFFFFFFCUL)
1484 #define CSR_PMPADDR10_PMPADDR_31_2_SHIFT (2U)
1485 #define CSR_PMPADDR10_PMPADDR_31_2_SET(x) (((uint32_t)(x) << CSR_PMPADDR10_PMPADDR_31_2_SHIFT) & CSR_PMPADDR10_PMPADDR_31_2_MASK)
1486 #define CSR_PMPADDR10_PMPADDR_31_2_GET(x) (((uint32_t)(x) & CSR_PMPADDR10_PMPADDR_31_2_MASK) >> CSR_PMPADDR10_PMPADDR_31_2_SHIFT)
1487 
1488 /* Bitfield definition for register array: PMPADDR */
1489 /*
1490  * PMPADDR_31_2 (RW)
1491  *
1492  * same as pmpaddr0
1493  */
1494 #define CSR_PMPADDR11_PMPADDR_31_2_MASK (0xFFFFFFFCUL)
1495 #define CSR_PMPADDR11_PMPADDR_31_2_SHIFT (2U)
1496 #define CSR_PMPADDR11_PMPADDR_31_2_SET(x) (((uint32_t)(x) << CSR_PMPADDR11_PMPADDR_31_2_SHIFT) & CSR_PMPADDR11_PMPADDR_31_2_MASK)
1497 #define CSR_PMPADDR11_PMPADDR_31_2_GET(x) (((uint32_t)(x) & CSR_PMPADDR11_PMPADDR_31_2_MASK) >> CSR_PMPADDR11_PMPADDR_31_2_SHIFT)
1498 
1499 /* Bitfield definition for register array: PMPADDR */
1500 /*
1501  * PMPADDR_31_2 (RW)
1502  *
1503  * same as pmpaddr0
1504  */
1505 #define CSR_PMPADDR12_PMPADDR_31_2_MASK (0xFFFFFFFCUL)
1506 #define CSR_PMPADDR12_PMPADDR_31_2_SHIFT (2U)
1507 #define CSR_PMPADDR12_PMPADDR_31_2_SET(x) (((uint32_t)(x) << CSR_PMPADDR12_PMPADDR_31_2_SHIFT) & CSR_PMPADDR12_PMPADDR_31_2_MASK)
1508 #define CSR_PMPADDR12_PMPADDR_31_2_GET(x) (((uint32_t)(x) & CSR_PMPADDR12_PMPADDR_31_2_MASK) >> CSR_PMPADDR12_PMPADDR_31_2_SHIFT)
1509 
1510 /* Bitfield definition for register array: PMPADDR */
1511 /*
1512  * PMPADDR_31_2 (RW)
1513  *
1514  * same as pmpaddr0
1515  */
1516 #define CSR_PMPADDR13_PMPADDR_31_2_MASK (0xFFFFFFFCUL)
1517 #define CSR_PMPADDR13_PMPADDR_31_2_SHIFT (2U)
1518 #define CSR_PMPADDR13_PMPADDR_31_2_SET(x) (((uint32_t)(x) << CSR_PMPADDR13_PMPADDR_31_2_SHIFT) & CSR_PMPADDR13_PMPADDR_31_2_MASK)
1519 #define CSR_PMPADDR13_PMPADDR_31_2_GET(x) (((uint32_t)(x) & CSR_PMPADDR13_PMPADDR_31_2_MASK) >> CSR_PMPADDR13_PMPADDR_31_2_SHIFT)
1520 
1521 /* Bitfield definition for register array: PMPADDR */
1522 /*
1523  * PMPADDR_31_2 (RW)
1524  *
1525  * same as pmpaddr0
1526  */
1527 #define CSR_PMPADDR14_PMPADDR_31_2_MASK (0xFFFFFFFCUL)
1528 #define CSR_PMPADDR14_PMPADDR_31_2_SHIFT (2U)
1529 #define CSR_PMPADDR14_PMPADDR_31_2_SET(x) (((uint32_t)(x) << CSR_PMPADDR14_PMPADDR_31_2_SHIFT) & CSR_PMPADDR14_PMPADDR_31_2_MASK)
1530 #define CSR_PMPADDR14_PMPADDR_31_2_GET(x) (((uint32_t)(x) & CSR_PMPADDR14_PMPADDR_31_2_MASK) >> CSR_PMPADDR14_PMPADDR_31_2_SHIFT)
1531 
1532 /* Bitfield definition for register array: PMPADDR */
1533 /*
1534  * PMPADDR_31_2 (RW)
1535  *
1536  * same as pmpaddr0
1537  */
1538 #define CSR_PMPADDR15_PMPADDR_31_2_MASK (0xFFFFFFFCUL)
1539 #define CSR_PMPADDR15_PMPADDR_31_2_SHIFT (2U)
1540 #define CSR_PMPADDR15_PMPADDR_31_2_SET(x) (((uint32_t)(x) << CSR_PMPADDR15_PMPADDR_31_2_SHIFT) & CSR_PMPADDR15_PMPADDR_31_2_MASK)
1541 #define CSR_PMPADDR15_PMPADDR_31_2_GET(x) (((uint32_t)(x) & CSR_PMPADDR15_PMPADDR_31_2_MASK) >> CSR_PMPADDR15_PMPADDR_31_2_SHIFT)
1542 
1543 /* Bitfield definition for register: TSELECT */
1544 /*
1545  * TRIGGER_INDEX (RW)
1546  *
1547  * This register determines which trigger is accessible through other trigger registers.
1548  */
1549 #define CSR_TSELECT_TRIGGER_INDEX_MASK (0xFFFFFFFFUL)
1550 #define CSR_TSELECT_TRIGGER_INDEX_SHIFT (0U)
1551 #define CSR_TSELECT_TRIGGER_INDEX_SET(x) (((uint32_t)(x) << CSR_TSELECT_TRIGGER_INDEX_SHIFT) & CSR_TSELECT_TRIGGER_INDEX_MASK)
1552 #define CSR_TSELECT_TRIGGER_INDEX_GET(x) (((uint32_t)(x) & CSR_TSELECT_TRIGGER_INDEX_MASK) >> CSR_TSELECT_TRIGGER_INDEX_SHIFT)
1553 
1554 /* Bitfield definition for register: TDATA1 */
1555 /*
1556  * TYPE (RW)
1557  *
1558  * Indicates the trigger type.
1559  * 0:The selected trigger is invalid.
1560  * 2:The selected trigger is an address/data match trigger.
1561  * 3:The selected trigger is an instruction count trigger
1562  * 4:The selected trigger is an interrupt trigger.
1563  * 5:The selected trigger is an exception trigger.
1564  */
1565 #define CSR_TDATA1_TYPE_MASK (0xF0000000UL)
1566 #define CSR_TDATA1_TYPE_SHIFT (28U)
1567 #define CSR_TDATA1_TYPE_SET(x) (((uint32_t)(x) << CSR_TDATA1_TYPE_SHIFT) & CSR_TDATA1_TYPE_MASK)
1568 #define CSR_TDATA1_TYPE_GET(x) (((uint32_t)(x) & CSR_TDATA1_TYPE_MASK) >> CSR_TDATA1_TYPE_SHIFT)
1569 
1570 /*
1571  * DMODE (RW)
1572  *
1573  * Setting this field to indicate the trigger is used by Debug Mode.
1574  * 0:Both Debug-mode and M-mode can write the currently selected trigger registers.
1575  * 1:Only Debug Mode can write the currently selected trigger registers. Writes from M-mode is ignored.
1576  */
1577 #define CSR_TDATA1_DMODE_MASK (0x8000000UL)
1578 #define CSR_TDATA1_DMODE_SHIFT (27U)
1579 #define CSR_TDATA1_DMODE_SET(x) (((uint32_t)(x) << CSR_TDATA1_DMODE_SHIFT) & CSR_TDATA1_DMODE_MASK)
1580 #define CSR_TDATA1_DMODE_GET(x) (((uint32_t)(x) & CSR_TDATA1_DMODE_MASK) >> CSR_TDATA1_DMODE_SHIFT)
1581 
1582 /*
1583  * DATA (RW)
1584  *
1585  * Trigger-specific data
1586  */
1587 #define CSR_TDATA1_DATA_MASK (0x7FFFFFFUL)
1588 #define CSR_TDATA1_DATA_SHIFT (0U)
1589 #define CSR_TDATA1_DATA_SET(x) (((uint32_t)(x) << CSR_TDATA1_DATA_SHIFT) & CSR_TDATA1_DATA_MASK)
1590 #define CSR_TDATA1_DATA_GET(x) (((uint32_t)(x) & CSR_TDATA1_DATA_MASK) >> CSR_TDATA1_DATA_SHIFT)
1591 
1592 /* Bitfield definition for register: MCONTROL */
1593 /*
1594  * TYPE (RW)
1595  *
1596  * Indicates the trigger type.
1597  * 0:The selected trigger is invalid.
1598  * 2:The selected trigger is an address/data match trigger.
1599  */
1600 #define CSR_MCONTROL_TYPE_MASK (0xF0000000UL)
1601 #define CSR_MCONTROL_TYPE_SHIFT (28U)
1602 #define CSR_MCONTROL_TYPE_SET(x) (((uint32_t)(x) << CSR_MCONTROL_TYPE_SHIFT) & CSR_MCONTROL_TYPE_MASK)
1603 #define CSR_MCONTROL_TYPE_GET(x) (((uint32_t)(x) & CSR_MCONTROL_TYPE_MASK) >> CSR_MCONTROL_TYPE_SHIFT)
1604 
1605 /*
1606  * DMODE (RW)
1607  *
1608  * Setting this field to indicate the trigger is used by Debug Mode.
1609  * 0:Both Debug-mode and M-mode can write the currently selected trigger registers
1610  * 1:Only Debug Mode can write the currently selected trigger registers. Writes from M-mode is ignored.
1611  */
1612 #define CSR_MCONTROL_DMODE_MASK (0x8000000UL)
1613 #define CSR_MCONTROL_DMODE_SHIFT (27U)
1614 #define CSR_MCONTROL_DMODE_SET(x) (((uint32_t)(x) << CSR_MCONTROL_DMODE_SHIFT) & CSR_MCONTROL_DMODE_MASK)
1615 #define CSR_MCONTROL_DMODE_GET(x) (((uint32_t)(x) & CSR_MCONTROL_DMODE_MASK) >> CSR_MCONTROL_DMODE_SHIFT)
1616 
1617 /*
1618  * MASKMAX (RO)
1619  *
1620  * Indicates the largest naturally aligned range supported by the hardware is 2ˆ12 bytes.
1621  */
1622 #define CSR_MCONTROL_MASKMAX_MASK (0x7E00000UL)
1623 #define CSR_MCONTROL_MASKMAX_SHIFT (21U)
1624 #define CSR_MCONTROL_MASKMAX_GET(x) (((uint32_t)(x) & CSR_MCONTROL_MASKMAX_MASK) >> CSR_MCONTROL_MASKMAX_SHIFT)
1625 
1626 /*
1627  * ACTION (RW)
1628  *
1629  * Setting this field to select what happens when this trigger matches.
1630  * 0:Raise a breakpoint exception
1631  * 1:Enter Debug Mode. (Only supported when DMODE is 1.)
1632  */
1633 #define CSR_MCONTROL_ACTION_MASK (0xF000U)
1634 #define CSR_MCONTROL_ACTION_SHIFT (12U)
1635 #define CSR_MCONTROL_ACTION_SET(x) (((uint32_t)(x) << CSR_MCONTROL_ACTION_SHIFT) & CSR_MCONTROL_ACTION_MASK)
1636 #define CSR_MCONTROL_ACTION_GET(x) (((uint32_t)(x) & CSR_MCONTROL_ACTION_MASK) >> CSR_MCONTROL_ACTION_SHIFT)
1637 
1638 /*
1639  * CHAIN (RW)
1640  *
1641  * Setting this field to enable trigger chain.
1642  * 0:When this trigger matches, the configured action is taken.
1643  * 1:While this trigger does not match, it prevents the trigger with the next index from matching.
1644  * If Number of Triggers is 2, this field is hardwired to 0 on trigger 1 (tselect = 1).
1645  * If Number of Triggers is 4, this field is hardwired
1646  * to 0 on trigger 3 (tselect = 3).
1647  * If Number of Triggers is 8, this field is hardwired to 0 on trigger 3 and trigger 7 (tselect = 3 or 7).
1648  */
1649 #define CSR_MCONTROL_CHAIN_MASK (0x800U)
1650 #define CSR_MCONTROL_CHAIN_SHIFT (11U)
1651 #define CSR_MCONTROL_CHAIN_SET(x) (((uint32_t)(x) << CSR_MCONTROL_CHAIN_SHIFT) & CSR_MCONTROL_CHAIN_MASK)
1652 #define CSR_MCONTROL_CHAIN_GET(x) (((uint32_t)(x) & CSR_MCONTROL_CHAIN_MASK) >> CSR_MCONTROL_CHAIN_SHIFT)
1653 
1654 /*
1655  * MATCH (RW)
1656  *
1657  * Setting this field to select the matching scheme. 0:Matches when the value equals tdata2. 1:Matches when the top M bits of the value match the top M bits of tdata2. M is 31 minus the index of the least-significant bit containing 0 in tdata2.
1658  * 2:Matches when the value is greater than (unsigned) or equal to tdata2.
1659  * 3:Matches when the value is less than (unsigned) tdata2
1660  */
1661 #define CSR_MCONTROL_MATCH_MASK (0x780U)
1662 #define CSR_MCONTROL_MATCH_SHIFT (7U)
1663 #define CSR_MCONTROL_MATCH_SET(x) (((uint32_t)(x) << CSR_MCONTROL_MATCH_SHIFT) & CSR_MCONTROL_MATCH_MASK)
1664 #define CSR_MCONTROL_MATCH_GET(x) (((uint32_t)(x) & CSR_MCONTROL_MATCH_MASK) >> CSR_MCONTROL_MATCH_SHIFT)
1665 
1666 /*
1667  * M (RW)
1668  *
1669  * Setting this field to enable this trigger in M-mode.
1670  */
1671 #define CSR_MCONTROL_M_MASK (0x40U)
1672 #define CSR_MCONTROL_M_SHIFT (6U)
1673 #define CSR_MCONTROL_M_SET(x) (((uint32_t)(x) << CSR_MCONTROL_M_SHIFT) & CSR_MCONTROL_M_MASK)
1674 #define CSR_MCONTROL_M_GET(x) (((uint32_t)(x) & CSR_MCONTROL_M_MASK) >> CSR_MCONTROL_M_SHIFT)
1675 
1676 /*
1677  * U (RW)
1678  *
1679  * Setting this field to enable this trigger in U-mode.
1680  */
1681 #define CSR_MCONTROL_U_MASK (0x8U)
1682 #define CSR_MCONTROL_U_SHIFT (3U)
1683 #define CSR_MCONTROL_U_SET(x) (((uint32_t)(x) << CSR_MCONTROL_U_SHIFT) & CSR_MCONTROL_U_MASK)
1684 #define CSR_MCONTROL_U_GET(x) (((uint32_t)(x) & CSR_MCONTROL_U_MASK) >> CSR_MCONTROL_U_SHIFT)
1685 
1686 /*
1687  * EXECUTE (RW)
1688  *
1689  * Setting this field to enable this trigger to compare virtual address of an instruction.
1690  */
1691 #define CSR_MCONTROL_EXECUTE_MASK (0x4U)
1692 #define CSR_MCONTROL_EXECUTE_SHIFT (2U)
1693 #define CSR_MCONTROL_EXECUTE_SET(x) (((uint32_t)(x) << CSR_MCONTROL_EXECUTE_SHIFT) & CSR_MCONTROL_EXECUTE_MASK)
1694 #define CSR_MCONTROL_EXECUTE_GET(x) (((uint32_t)(x) & CSR_MCONTROL_EXECUTE_MASK) >> CSR_MCONTROL_EXECUTE_SHIFT)
1695 
1696 /*
1697  * STORE (RW)
1698  *
1699  * Setting this field to enable this trigger to compare virtual address of a store.
1700  */
1701 #define CSR_MCONTROL_STORE_MASK (0x2U)
1702 #define CSR_MCONTROL_STORE_SHIFT (1U)
1703 #define CSR_MCONTROL_STORE_SET(x) (((uint32_t)(x) << CSR_MCONTROL_STORE_SHIFT) & CSR_MCONTROL_STORE_MASK)
1704 #define CSR_MCONTROL_STORE_GET(x) (((uint32_t)(x) & CSR_MCONTROL_STORE_MASK) >> CSR_MCONTROL_STORE_SHIFT)
1705 
1706 /*
1707  * LOAD (RW)
1708  *
1709  * Setting this field to enable this trigger to compare virtual address of a load.
1710  */
1711 #define CSR_MCONTROL_LOAD_MASK (0x1U)
1712 #define CSR_MCONTROL_LOAD_SHIFT (0U)
1713 #define CSR_MCONTROL_LOAD_SET(x) (((uint32_t)(x) << CSR_MCONTROL_LOAD_SHIFT) & CSR_MCONTROL_LOAD_MASK)
1714 #define CSR_MCONTROL_LOAD_GET(x) (((uint32_t)(x) & CSR_MCONTROL_LOAD_MASK) >> CSR_MCONTROL_LOAD_SHIFT)
1715 
1716 /* Bitfield definition for register: ICOUNT */
1717 /*
1718  * TYPE (RW)
1719  *
1720  * The selected trigger is an instruction count trigger.
1721  */
1722 #define CSR_ICOUNT_TYPE_MASK (0xF0000000UL)
1723 #define CSR_ICOUNT_TYPE_SHIFT (28U)
1724 #define CSR_ICOUNT_TYPE_SET(x) (((uint32_t)(x) << CSR_ICOUNT_TYPE_SHIFT) & CSR_ICOUNT_TYPE_MASK)
1725 #define CSR_ICOUNT_TYPE_GET(x) (((uint32_t)(x) & CSR_ICOUNT_TYPE_MASK) >> CSR_ICOUNT_TYPE_SHIFT)
1726 
1727 /*
1728  * DMODE (RW)
1729  *
1730  * Setting this field to indicate the trigger is used by Debug Mode.
1731  * 0:Both Debug-mode and M-mode can write the currently selected trigger registers.
1732  * 1:Only Debug Mode can write the currently selected trigger registers. Writes from M-mode is ignored.
1733  */
1734 #define CSR_ICOUNT_DMODE_MASK (0x8000000UL)
1735 #define CSR_ICOUNT_DMODE_SHIFT (27U)
1736 #define CSR_ICOUNT_DMODE_SET(x) (((uint32_t)(x) << CSR_ICOUNT_DMODE_SHIFT) & CSR_ICOUNT_DMODE_MASK)
1737 #define CSR_ICOUNT_DMODE_GET(x) (((uint32_t)(x) & CSR_ICOUNT_DMODE_MASK) >> CSR_ICOUNT_DMODE_SHIFT)
1738 
1739 /*
1740  * COUNT (RO)
1741  *
1742  * This field is hardwired to 1 for single-stepping support
1743  */
1744 #define CSR_ICOUNT_COUNT_MASK (0x400U)
1745 #define CSR_ICOUNT_COUNT_SHIFT (10U)
1746 #define CSR_ICOUNT_COUNT_GET(x) (((uint32_t)(x) & CSR_ICOUNT_COUNT_MASK) >> CSR_ICOUNT_COUNT_SHIFT)
1747 
1748 /*
1749  * M (RW)
1750  *
1751  * Setting this field to enable this trigger in M-mode.
1752  */
1753 #define CSR_ICOUNT_M_MASK (0x200U)
1754 #define CSR_ICOUNT_M_SHIFT (9U)
1755 #define CSR_ICOUNT_M_SET(x) (((uint32_t)(x) << CSR_ICOUNT_M_SHIFT) & CSR_ICOUNT_M_MASK)
1756 #define CSR_ICOUNT_M_GET(x) (((uint32_t)(x) & CSR_ICOUNT_M_MASK) >> CSR_ICOUNT_M_SHIFT)
1757 
1758 /*
1759  * U (RW)
1760  *
1761  * Setting this field to enable this trigger in U-mode.
1762  */
1763 #define CSR_ICOUNT_U_MASK (0x40U)
1764 #define CSR_ICOUNT_U_SHIFT (6U)
1765 #define CSR_ICOUNT_U_SET(x) (((uint32_t)(x) << CSR_ICOUNT_U_SHIFT) & CSR_ICOUNT_U_MASK)
1766 #define CSR_ICOUNT_U_GET(x) (((uint32_t)(x) & CSR_ICOUNT_U_MASK) >> CSR_ICOUNT_U_SHIFT)
1767 
1768 /*
1769  * ACTION (RW)
1770  *
1771  * Setting this field to select what happens when this trigger matches.
1772  * 0:Raise a breakpoint exception
1773  * 1:Enter Debug Mode. (Only supported when DMODE is 1.)
1774  */
1775 #define CSR_ICOUNT_ACTION_MASK (0x3FU)
1776 #define CSR_ICOUNT_ACTION_SHIFT (0U)
1777 #define CSR_ICOUNT_ACTION_SET(x) (((uint32_t)(x) << CSR_ICOUNT_ACTION_SHIFT) & CSR_ICOUNT_ACTION_MASK)
1778 #define CSR_ICOUNT_ACTION_GET(x) (((uint32_t)(x) & CSR_ICOUNT_ACTION_MASK) >> CSR_ICOUNT_ACTION_SHIFT)
1779 
1780 /* Bitfield definition for register: ITRIGGER */
1781 /*
1782  * TYPE (RW)
1783  *
1784  * The selected trigger is an interrupt trigger.
1785  */
1786 #define CSR_ITRIGGER_TYPE_MASK (0xF0000000UL)
1787 #define CSR_ITRIGGER_TYPE_SHIFT (28U)
1788 #define CSR_ITRIGGER_TYPE_SET(x) (((uint32_t)(x) << CSR_ITRIGGER_TYPE_SHIFT) & CSR_ITRIGGER_TYPE_MASK)
1789 #define CSR_ITRIGGER_TYPE_GET(x) (((uint32_t)(x) & CSR_ITRIGGER_TYPE_MASK) >> CSR_ITRIGGER_TYPE_SHIFT)
1790 
1791 /*
1792  * DMODE (RW)
1793  *
1794  * Setting this field to indicate the trigger is used by Debug Mode.
1795  * 0:Both Debug-mode and M-mode can write the currently selected trigger registers.
1796  * 1:Only Debug Mode can write the currently selected trigger registers. Writes from M-mode is ignored.
1797  */
1798 #define CSR_ITRIGGER_DMODE_MASK (0x8000000UL)
1799 #define CSR_ITRIGGER_DMODE_SHIFT (27U)
1800 #define CSR_ITRIGGER_DMODE_SET(x) (((uint32_t)(x) << CSR_ITRIGGER_DMODE_SHIFT) & CSR_ITRIGGER_DMODE_MASK)
1801 #define CSR_ITRIGGER_DMODE_GET(x) (((uint32_t)(x) & CSR_ITRIGGER_DMODE_MASK) >> CSR_ITRIGGER_DMODE_SHIFT)
1802 
1803 /*
1804  * M (RW)
1805  *
1806  * Setting this field to enable this trigger in M-mode.
1807  */
1808 #define CSR_ITRIGGER_M_MASK (0x200U)
1809 #define CSR_ITRIGGER_M_SHIFT (9U)
1810 #define CSR_ITRIGGER_M_SET(x) (((uint32_t)(x) << CSR_ITRIGGER_M_SHIFT) & CSR_ITRIGGER_M_MASK)
1811 #define CSR_ITRIGGER_M_GET(x) (((uint32_t)(x) & CSR_ITRIGGER_M_MASK) >> CSR_ITRIGGER_M_SHIFT)
1812 
1813 /*
1814  * U (RW)
1815  *
1816  * Setting this field to enable this trigger in U-mode.
1817  */
1818 #define CSR_ITRIGGER_U_MASK (0x40U)
1819 #define CSR_ITRIGGER_U_SHIFT (6U)
1820 #define CSR_ITRIGGER_U_SET(x) (((uint32_t)(x) << CSR_ITRIGGER_U_SHIFT) & CSR_ITRIGGER_U_MASK)
1821 #define CSR_ITRIGGER_U_GET(x) (((uint32_t)(x) & CSR_ITRIGGER_U_MASK) >> CSR_ITRIGGER_U_SHIFT)
1822 
1823 /*
1824  * ACTION (RW)
1825  *
1826  * Setting this field to select what happens when this trigger matches.
1827  * 0:Raise a breakpoint exception.
1828  * 1:Enter Debug Mode. (Only supported when DMODE is 1.)
1829  */
1830 #define CSR_ITRIGGER_ACTION_MASK (0x3FU)
1831 #define CSR_ITRIGGER_ACTION_SHIFT (0U)
1832 #define CSR_ITRIGGER_ACTION_SET(x) (((uint32_t)(x) << CSR_ITRIGGER_ACTION_SHIFT) & CSR_ITRIGGER_ACTION_MASK)
1833 #define CSR_ITRIGGER_ACTION_GET(x) (((uint32_t)(x) & CSR_ITRIGGER_ACTION_MASK) >> CSR_ITRIGGER_ACTION_SHIFT)
1834 
1835 /* Bitfield definition for register: ETRIGGER */
1836 /*
1837  * TYPE (RW)
1838  *
1839  * The selected trigger is an exception trigger.
1840  */
1841 #define CSR_ETRIGGER_TYPE_MASK (0xF0000000UL)
1842 #define CSR_ETRIGGER_TYPE_SHIFT (28U)
1843 #define CSR_ETRIGGER_TYPE_SET(x) (((uint32_t)(x) << CSR_ETRIGGER_TYPE_SHIFT) & CSR_ETRIGGER_TYPE_MASK)
1844 #define CSR_ETRIGGER_TYPE_GET(x) (((uint32_t)(x) & CSR_ETRIGGER_TYPE_MASK) >> CSR_ETRIGGER_TYPE_SHIFT)
1845 
1846 /*
1847  * DMODE (RW)
1848  *
1849  * Setting this field to indicate the trigger is used by Debug Mode.
1850  * 0:Both Debug-mode and M-mode can write the currently selected trigger registers.
1851  * 1:Only Debug Mode can write the currently selected trigger registers. Writes from M-mode is ignored.
1852  */
1853 #define CSR_ETRIGGER_DMODE_MASK (0x8000000UL)
1854 #define CSR_ETRIGGER_DMODE_SHIFT (27U)
1855 #define CSR_ETRIGGER_DMODE_SET(x) (((uint32_t)(x) << CSR_ETRIGGER_DMODE_SHIFT) & CSR_ETRIGGER_DMODE_MASK)
1856 #define CSR_ETRIGGER_DMODE_GET(x) (((uint32_t)(x) & CSR_ETRIGGER_DMODE_MASK) >> CSR_ETRIGGER_DMODE_SHIFT)
1857 
1858 /*
1859  * NMI (RW)
1860  *
1861  * Setting this field to enable this trigger in non-maskable interrupts, regardless of the values of s, u, and m.
1862  */
1863 #define CSR_ETRIGGER_NMI_MASK (0x400U)
1864 #define CSR_ETRIGGER_NMI_SHIFT (10U)
1865 #define CSR_ETRIGGER_NMI_SET(x) (((uint32_t)(x) << CSR_ETRIGGER_NMI_SHIFT) & CSR_ETRIGGER_NMI_MASK)
1866 #define CSR_ETRIGGER_NMI_GET(x) (((uint32_t)(x) & CSR_ETRIGGER_NMI_MASK) >> CSR_ETRIGGER_NMI_SHIFT)
1867 
1868 /*
1869  * M (RW)
1870  *
1871  * Setting this field to enable this trigger in M-mode.
1872  */
1873 #define CSR_ETRIGGER_M_MASK (0x200U)
1874 #define CSR_ETRIGGER_M_SHIFT (9U)
1875 #define CSR_ETRIGGER_M_SET(x) (((uint32_t)(x) << CSR_ETRIGGER_M_SHIFT) & CSR_ETRIGGER_M_MASK)
1876 #define CSR_ETRIGGER_M_GET(x) (((uint32_t)(x) & CSR_ETRIGGER_M_MASK) >> CSR_ETRIGGER_M_SHIFT)
1877 
1878 /*
1879  * U (RW)
1880  *
1881  * Setting this field to enable this trigger in U-mode.
1882  */
1883 #define CSR_ETRIGGER_U_MASK (0x40U)
1884 #define CSR_ETRIGGER_U_SHIFT (6U)
1885 #define CSR_ETRIGGER_U_SET(x) (((uint32_t)(x) << CSR_ETRIGGER_U_SHIFT) & CSR_ETRIGGER_U_MASK)
1886 #define CSR_ETRIGGER_U_GET(x) (((uint32_t)(x) & CSR_ETRIGGER_U_MASK) >> CSR_ETRIGGER_U_SHIFT)
1887 
1888 /*
1889  * ACTION (RW)
1890  *
1891  * Setting this field to select what happens when this trigger matches.
1892  * 0:Raise a breakpoint exception
1893  * 1:Enter Debug Mode. (Only supported when DMODE is 1.)
1894  */
1895 #define CSR_ETRIGGER_ACTION_MASK (0x3FU)
1896 #define CSR_ETRIGGER_ACTION_SHIFT (0U)
1897 #define CSR_ETRIGGER_ACTION_SET(x) (((uint32_t)(x) << CSR_ETRIGGER_ACTION_SHIFT) & CSR_ETRIGGER_ACTION_MASK)
1898 #define CSR_ETRIGGER_ACTION_GET(x) (((uint32_t)(x) & CSR_ETRIGGER_ACTION_MASK) >> CSR_ETRIGGER_ACTION_SHIFT)
1899 
1900 /* Bitfield definition for register: TDATA2 */
1901 /*
1902  * DATA (RW)
1903  *
1904  * This register provides accesses to the tdata2 register of the currently selected trigger registers selected by the tselect register, and it holds trigger-specific data..
1905  */
1906 #define CSR_TDATA2_DATA_MASK (0xFFFFFFFFUL)
1907 #define CSR_TDATA2_DATA_SHIFT (0U)
1908 #define CSR_TDATA2_DATA_SET(x) (((uint32_t)(x) << CSR_TDATA2_DATA_SHIFT) & CSR_TDATA2_DATA_MASK)
1909 #define CSR_TDATA2_DATA_GET(x) (((uint32_t)(x) & CSR_TDATA2_DATA_MASK) >> CSR_TDATA2_DATA_SHIFT)
1910 
1911 /* Bitfield definition for register: TDATA3 */
1912 /*
1913  * DATA (RW)
1914  *
1915  * This register provides accesses to the tdata3 register of the currently selected trigger registers selected by the tselect register, and it holds trigger-specific data..
1916  */
1917 #define CSR_TDATA3_DATA_MASK (0xFFFFFFFFUL)
1918 #define CSR_TDATA3_DATA_SHIFT (0U)
1919 #define CSR_TDATA3_DATA_SET(x) (((uint32_t)(x) << CSR_TDATA3_DATA_SHIFT) & CSR_TDATA3_DATA_MASK)
1920 #define CSR_TDATA3_DATA_GET(x) (((uint32_t)(x) & CSR_TDATA3_DATA_MASK) >> CSR_TDATA3_DATA_SHIFT)
1921 
1922 /* Bitfield definition for register: TEXTRA */
1923 /*
1924  * MVALUE (RW)
1925  *
1926  * Data used together with MSELECT.
1927  */
1928 #define CSR_TEXTRA_MVALUE_MASK (0xFC000000UL)
1929 #define CSR_TEXTRA_MVALUE_SHIFT (26U)
1930 #define CSR_TEXTRA_MVALUE_SET(x) (((uint32_t)(x) << CSR_TEXTRA_MVALUE_SHIFT) & CSR_TEXTRA_MVALUE_MASK)
1931 #define CSR_TEXTRA_MVALUE_GET(x) (((uint32_t)(x) & CSR_TEXTRA_MVALUE_MASK) >> CSR_TEXTRA_MVALUE_SHIFT)
1932 
1933 /*
1934  * MSELECT (RW)
1935  *
1936  * 0:Ignore MVALUE.
1937  * 1:This trigger will only match if the lower bits of mcontext equal MVALUE.
1938  */
1939 #define CSR_TEXTRA_MSELECT_MASK (0x2000000UL)
1940 #define CSR_TEXTRA_MSELECT_SHIFT (25U)
1941 #define CSR_TEXTRA_MSELECT_SET(x) (((uint32_t)(x) << CSR_TEXTRA_MSELECT_SHIFT) & CSR_TEXTRA_MSELECT_MASK)
1942 #define CSR_TEXTRA_MSELECT_GET(x) (((uint32_t)(x) & CSR_TEXTRA_MSELECT_MASK) >> CSR_TEXTRA_MSELECT_SHIFT)
1943 
1944 /*
1945  * SVALUE (RW)
1946  *
1947  * Data used together with SSELECT.
1948  */
1949 #define CSR_TEXTRA_SVALUE_MASK (0x7FCU)
1950 #define CSR_TEXTRA_SVALUE_SHIFT (2U)
1951 #define CSR_TEXTRA_SVALUE_SET(x) (((uint32_t)(x) << CSR_TEXTRA_SVALUE_SHIFT) & CSR_TEXTRA_SVALUE_MASK)
1952 #define CSR_TEXTRA_SVALUE_GET(x) (((uint32_t)(x) & CSR_TEXTRA_SVALUE_MASK) >> CSR_TEXTRA_SVALUE_SHIFT)
1953 
1954 /*
1955  * SSELECT (RW)
1956  *
1957  * 0:Ignore MVALUE
1958  * 1:This trigger will only match if the lower bits of scontext equal SVALUE
1959  * 2This trigger will only match if satp.ASID equals SVALUE.
1960  */
1961 #define CSR_TEXTRA_SSELECT_MASK (0x3U)
1962 #define CSR_TEXTRA_SSELECT_SHIFT (0U)
1963 #define CSR_TEXTRA_SSELECT_SET(x) (((uint32_t)(x) << CSR_TEXTRA_SSELECT_SHIFT) & CSR_TEXTRA_SSELECT_MASK)
1964 #define CSR_TEXTRA_SSELECT_GET(x) (((uint32_t)(x) & CSR_TEXTRA_SSELECT_MASK) >> CSR_TEXTRA_SSELECT_SHIFT)
1965 
1966 /* Bitfield definition for register: TINFO */
1967 /*
1968  * INFO (RO)
1969  *
1970  * One bit for each possible type in tdata1. Bit N corresponds to type N. If the bit is set, then that
1971  * type is supported by the currently selected trigger. If the currently selected trigger does not exist, this field contains 1.
1972  * 0:When this bit is set, there is no trigger at this tselect
1973  * 1:Reserved and hardwired to 0.
1974  * 2:When this bit is set, the selected trigger supports type of address/data match trigger
1975  * 3:When this bit is set, the selected trigger supports type of instruction count trigger.
1976  * 4:When this bit is set, the selected trigger supports type of interrupt trigger
1977  * 5:When this bit is set, the selected trigger supports type of exception trigger
1978  * 15:When this bit is set, the selected trigger exists (so enumeration shouldn’t terminate), but is not currently available.
1979  * Others:Reserved for future use.
1980  */
1981 #define CSR_TINFO_INFO_MASK (0xFFFFU)
1982 #define CSR_TINFO_INFO_SHIFT (0U)
1983 #define CSR_TINFO_INFO_GET(x) (((uint32_t)(x) & CSR_TINFO_INFO_MASK) >> CSR_TINFO_INFO_SHIFT)
1984 
1985 /* Bitfield definition for register: TCONTROL */
1986 /*
1987  * MPTE (RW)
1988  *
1989  * M-mode previous trigger enable field. When a trap into M-mode is taken, MPTE is set to the value of MTE.
1990  */
1991 #define CSR_TCONTROL_MPTE_MASK (0x80U)
1992 #define CSR_TCONTROL_MPTE_SHIFT (7U)
1993 #define CSR_TCONTROL_MPTE_SET(x) (((uint32_t)(x) << CSR_TCONTROL_MPTE_SHIFT) & CSR_TCONTROL_MPTE_MASK)
1994 #define CSR_TCONTROL_MPTE_GET(x) (((uint32_t)(x) & CSR_TCONTROL_MPTE_MASK) >> CSR_TCONTROL_MPTE_SHIFT)
1995 
1996 /*
1997  * MTE (RW)
1998  *
1999  * M-mode trigger enable field. When a trap into M-mode is taken, MTE is set to 0. When the MRET instruction is executed, MTE is set to the value of MPTE.
2000  * 0:Triggers do not match/fire while the hart is in M-mode.
2001  * 1:Triggers do match/fire while the hart is in M-mode.
2002  */
2003 #define CSR_TCONTROL_MTE_MASK (0x8U)
2004 #define CSR_TCONTROL_MTE_SHIFT (3U)
2005 #define CSR_TCONTROL_MTE_SET(x) (((uint32_t)(x) << CSR_TCONTROL_MTE_SHIFT) & CSR_TCONTROL_MTE_MASK)
2006 #define CSR_TCONTROL_MTE_GET(x) (((uint32_t)(x) & CSR_TCONTROL_MTE_MASK) >> CSR_TCONTROL_MTE_SHIFT)
2007 
2008 /* Bitfield definition for register: MCONTEXT */
2009 /*
2010  * MCONTEXT (RW)
2011  *
2012  * Machine mode software can write a context number to this register, which can be used to set triggers that only fire in that specific context.
2013  */
2014 #define CSR_MCONTEXT_MCONTEXT_MASK (0x3FU)
2015 #define CSR_MCONTEXT_MCONTEXT_SHIFT (0U)
2016 #define CSR_MCONTEXT_MCONTEXT_SET(x) (((uint32_t)(x) << CSR_MCONTEXT_MCONTEXT_SHIFT) & CSR_MCONTEXT_MCONTEXT_MASK)
2017 #define CSR_MCONTEXT_MCONTEXT_GET(x) (((uint32_t)(x) & CSR_MCONTEXT_MCONTEXT_MASK) >> CSR_MCONTEXT_MCONTEXT_SHIFT)
2018 
2019 /* Bitfield definition for register: SCONTEXT */
2020 /*
2021  * SCONTEXT (RW)
2022  *
2023  * Machine mode software can write a context number to this register, which can be used to set triggers that only fire in that specific context.
2024  */
2025 #define CSR_SCONTEXT_SCONTEXT_MASK (0x1FFU)
2026 #define CSR_SCONTEXT_SCONTEXT_SHIFT (0U)
2027 #define CSR_SCONTEXT_SCONTEXT_SET(x) (((uint32_t)(x) << CSR_SCONTEXT_SCONTEXT_SHIFT) & CSR_SCONTEXT_SCONTEXT_MASK)
2028 #define CSR_SCONTEXT_SCONTEXT_GET(x) (((uint32_t)(x) & CSR_SCONTEXT_SCONTEXT_MASK) >> CSR_SCONTEXT_SCONTEXT_SHIFT)
2029 
2030 /* Bitfield definition for register: DCSR */
2031 /*
2032  * XDEBUGVER (RO)
2033  *
2034  * Version of the external debugger. 0 indicates that no external debugger exists and 4 indicates that the external debugger conforms to the RISC-V External Debug Support (TD003) V0.13
2035  */
2036 #define CSR_DCSR_XDEBUGVER_MASK (0xF0000000UL)
2037 #define CSR_DCSR_XDEBUGVER_SHIFT (28U)
2038 #define CSR_DCSR_XDEBUGVER_GET(x) (((uint32_t)(x) & CSR_DCSR_XDEBUGVER_MASK) >> CSR_DCSR_XDEBUGVER_SHIFT)
2039 
2040 /*
2041  * EBREAKM (RW)
2042  *
2043  * This bit controls the behavior of EBREAK instructions in Machine Mode
2044  * 0:Generate a regular breakpoint exception
2045  * 1:Enter Debug Mode
2046  */
2047 #define CSR_DCSR_EBREAKM_MASK (0x8000U)
2048 #define CSR_DCSR_EBREAKM_SHIFT (15U)
2049 #define CSR_DCSR_EBREAKM_SET(x) (((uint32_t)(x) << CSR_DCSR_EBREAKM_SHIFT) & CSR_DCSR_EBREAKM_MASK)
2050 #define CSR_DCSR_EBREAKM_GET(x) (((uint32_t)(x) & CSR_DCSR_EBREAKM_MASK) >> CSR_DCSR_EBREAKM_SHIFT)
2051 
2052 /*
2053  * EBREAKU (RW)
2054  *
2055  * This bit controls the behavior of EBREAK instructions in User/Application Mode
2056  * 0:Generate a regular breakpoint exception
2057  * 1:Enter Debug Mode
2058  */
2059 #define CSR_DCSR_EBREAKU_MASK (0x1000U)
2060 #define CSR_DCSR_EBREAKU_SHIFT (12U)
2061 #define CSR_DCSR_EBREAKU_SET(x) (((uint32_t)(x) << CSR_DCSR_EBREAKU_SHIFT) & CSR_DCSR_EBREAKU_MASK)
2062 #define CSR_DCSR_EBREAKU_GET(x) (((uint32_t)(x) & CSR_DCSR_EBREAKU_MASK) >> CSR_DCSR_EBREAKU_SHIFT)
2063 
2064 /*
2065  * STEPIE (RW)
2066  *
2067  * This bit controls whether interrupts are enabled during single stepping
2068  * 0:Disable interrupts during single stepping
2069  * 1:Allow interrupts in single stepping
2070  */
2071 #define CSR_DCSR_STEPIE_MASK (0x800U)
2072 #define CSR_DCSR_STEPIE_SHIFT (11U)
2073 #define CSR_DCSR_STEPIE_SET(x) (((uint32_t)(x) << CSR_DCSR_STEPIE_SHIFT) & CSR_DCSR_STEPIE_MASK)
2074 #define CSR_DCSR_STEPIE_GET(x) (((uint32_t)(x) & CSR_DCSR_STEPIE_MASK) >> CSR_DCSR_STEPIE_SHIFT)
2075 
2076 /*
2077  * STOPCOUNT (RW)
2078  *
2079  * This bit controls whether performance counters are stopped in Debug Mode.
2080  * 0:Do not stop counters in Debug Mode
2081  * 1:Stop counters in Debug Mode
2082  */
2083 #define CSR_DCSR_STOPCOUNT_MASK (0x400U)
2084 #define CSR_DCSR_STOPCOUNT_SHIFT (10U)
2085 #define CSR_DCSR_STOPCOUNT_SET(x) (((uint32_t)(x) << CSR_DCSR_STOPCOUNT_SHIFT) & CSR_DCSR_STOPCOUNT_MASK)
2086 #define CSR_DCSR_STOPCOUNT_GET(x) (((uint32_t)(x) & CSR_DCSR_STOPCOUNT_MASK) >> CSR_DCSR_STOPCOUNT_SHIFT)
2087 
2088 /*
2089  * STOPTIME (RW)
2090  *
2091  * This bit controls whether timers are stopped in Debug Mode. The processor only drives its stoptime output pin to 1 if it is in Debug Mode and this bit is set. Integration effort is required to make timers in the platform observe this pin to really stop them.
2092  * 0:Do not stop timers in Debug Mode
2093  * 1:Stop timers in Debug Mode
2094  */
2095 #define CSR_DCSR_STOPTIME_MASK (0x200U)
2096 #define CSR_DCSR_STOPTIME_SHIFT (9U)
2097 #define CSR_DCSR_STOPTIME_SET(x) (((uint32_t)(x) << CSR_DCSR_STOPTIME_SHIFT) & CSR_DCSR_STOPTIME_MASK)
2098 #define CSR_DCSR_STOPTIME_GET(x) (((uint32_t)(x) & CSR_DCSR_STOPTIME_MASK) >> CSR_DCSR_STOPTIME_SHIFT)
2099 
2100 /*
2101  * CAUSE (RO)
2102  *
2103  * Reason why Debug Mode was entered. When there are multiple reasons to enter Debug Mode, the priority to determine the CAUSE value will be: trigger module > EBREAK > halt-on-reset > halt request > single step. Halt requests are requests issued by the external debugger
2104  * 0:Reserved
2105  * 1:EBREAK
2106  * 2:Trigger module
2107  * 3:Halt request
2108  * 4:Single step
2109  * 5:Halt-on-reset
2110  * 6-7:Reserved
2111  */
2112 #define CSR_DCSR_CAUSE_MASK (0x1C0U)
2113 #define CSR_DCSR_CAUSE_SHIFT (6U)
2114 #define CSR_DCSR_CAUSE_GET(x) (((uint32_t)(x) & CSR_DCSR_CAUSE_MASK) >> CSR_DCSR_CAUSE_SHIFT)
2115 
2116 /*
2117  * MPRVEN (RW)
2118  *
2119  * This bit controls whether mstatus.MPRV takes effect in Debug Mode.
2120  * 0:MPRV in mstatus is ignored in Debug Mode.
2121  * 1:MPRV in mstatus takes effect in Debug Mode.
2122  */
2123 #define CSR_DCSR_MPRVEN_MASK (0x10U)
2124 #define CSR_DCSR_MPRVEN_SHIFT (4U)
2125 #define CSR_DCSR_MPRVEN_SET(x) (((uint32_t)(x) << CSR_DCSR_MPRVEN_SHIFT) & CSR_DCSR_MPRVEN_MASK)
2126 #define CSR_DCSR_MPRVEN_GET(x) (((uint32_t)(x) & CSR_DCSR_MPRVEN_MASK) >> CSR_DCSR_MPRVEN_SHIFT)
2127 
2128 /*
2129  * NMIP (RO)
2130  *
2131  * When this bit is set, there is a Non-Maskable-Interrupt (NMI) pending for the hart. Since an NMI can indicate a hardware error condition, reliable debugging may no longer be possible once this bit becomes set.
2132  */
2133 #define CSR_DCSR_NMIP_MASK (0x8U)
2134 #define CSR_DCSR_NMIP_SHIFT (3U)
2135 #define CSR_DCSR_NMIP_GET(x) (((uint32_t)(x) & CSR_DCSR_NMIP_MASK) >> CSR_DCSR_NMIP_SHIFT)
2136 
2137 /*
2138  * STEP (RW)
2139  *
2140  * This bit controls whether non-Debug Mode instruction execution is in the single step mode. When set, the hart returns to Debug Mode after a single instruction execution. If the instruction does not complete due to an exception, the hart will immediately enter Debug Mode before executing the trap handler, with appropriate exception registers set.
2141  * 0:Single Step Mode is off
2142  * 1:Single Step Mode is on
2143  */
2144 #define CSR_DCSR_STEP_MASK (0x4U)
2145 #define CSR_DCSR_STEP_SHIFT (2U)
2146 #define CSR_DCSR_STEP_SET(x) (((uint32_t)(x) << CSR_DCSR_STEP_SHIFT) & CSR_DCSR_STEP_MASK)
2147 #define CSR_DCSR_STEP_GET(x) (((uint32_t)(x) & CSR_DCSR_STEP_MASK) >> CSR_DCSR_STEP_SHIFT)
2148 
2149 /*
2150  * PRV (RW)
2151  *
2152  * The privilege level that the hart was operating in when Debug Mode was entered. The external debugger can modify this value to change the hart’s privilege level when exiting Debug Mode.
2153  * 0:User/Application
2154  * 1:Supervisor
2155  * 2:Reserved
2156  * 3:Machine
2157  */
2158 #define CSR_DCSR_PRV_MASK (0x3U)
2159 #define CSR_DCSR_PRV_SHIFT (0U)
2160 #define CSR_DCSR_PRV_SET(x) (((uint32_t)(x) << CSR_DCSR_PRV_SHIFT) & CSR_DCSR_PRV_MASK)
2161 #define CSR_DCSR_PRV_GET(x) (((uint32_t)(x) & CSR_DCSR_PRV_MASK) >> CSR_DCSR_PRV_SHIFT)
2162 
2163 /* Bitfield definition for register: DPC */
2164 /*
2165  * DPC (RW)
2166  *
2167  * Debug Program Counter. Bit 0 is hardwired to 0.
2168  */
2169 #define CSR_DPC_DPC_MASK (0xFFFFFFFFUL)
2170 #define CSR_DPC_DPC_SHIFT (0U)
2171 #define CSR_DPC_DPC_SET(x) (((uint32_t)(x) << CSR_DPC_DPC_SHIFT) & CSR_DPC_DPC_MASK)
2172 #define CSR_DPC_DPC_GET(x) (((uint32_t)(x) & CSR_DPC_DPC_MASK) >> CSR_DPC_DPC_SHIFT)
2173 
2174 /* Bitfield definition for register: DSCRATCH0 */
2175 /*
2176  * DSCRATCH (RO)
2177  *
2178  * A scratch register that is reserved for use by Debug Module.
2179  */
2180 #define CSR_DSCRATCH0_DSCRATCH_MASK (0xFFFFFFFFUL)
2181 #define CSR_DSCRATCH0_DSCRATCH_SHIFT (0U)
2182 #define CSR_DSCRATCH0_DSCRATCH_GET(x) (((uint32_t)(x) & CSR_DSCRATCH0_DSCRATCH_MASK) >> CSR_DSCRATCH0_DSCRATCH_SHIFT)
2183 
2184 /* Bitfield definition for register: DSCRATCH1 */
2185 /*
2186  * DSCRATCH (RO)
2187  *
2188  * A scratch register that is reserved for use by Debug Module.
2189  */
2190 #define CSR_DSCRATCH1_DSCRATCH_MASK (0xFFFFFFFFUL)
2191 #define CSR_DSCRATCH1_DSCRATCH_SHIFT (0U)
2192 #define CSR_DSCRATCH1_DSCRATCH_GET(x) (((uint32_t)(x) & CSR_DSCRATCH1_DSCRATCH_MASK) >> CSR_DSCRATCH1_DSCRATCH_SHIFT)
2193 
2194 /* Bitfield definition for register: MCYCLE */
2195 /*
2196  * COUNTER (RW)
2197  *
2198  * the lower 32 bits of Machine Cycle Counter
2199  */
2200 #define CSR_MCYCLE_COUNTER_MASK (0xFFFFFFFFUL)
2201 #define CSR_MCYCLE_COUNTER_SHIFT (0U)
2202 #define CSR_MCYCLE_COUNTER_SET(x) (((uint32_t)(x) << CSR_MCYCLE_COUNTER_SHIFT) & CSR_MCYCLE_COUNTER_MASK)
2203 #define CSR_MCYCLE_COUNTER_GET(x) (((uint32_t)(x) & CSR_MCYCLE_COUNTER_MASK) >> CSR_MCYCLE_COUNTER_SHIFT)
2204 
2205 /* Bitfield definition for register: MINSTRET */
2206 /*
2207  * COUNTER (RW)
2208  *
2209  * the lower 32 bits of Machine Instruction-Retired Counter
2210  */
2211 #define CSR_MINSTRET_COUNTER_MASK (0xFFFFFFFFUL)
2212 #define CSR_MINSTRET_COUNTER_SHIFT (0U)
2213 #define CSR_MINSTRET_COUNTER_SET(x) (((uint32_t)(x) << CSR_MINSTRET_COUNTER_SHIFT) & CSR_MINSTRET_COUNTER_MASK)
2214 #define CSR_MINSTRET_COUNTER_GET(x) (((uint32_t)(x) & CSR_MINSTRET_COUNTER_MASK) >> CSR_MINSTRET_COUNTER_SHIFT)
2215 
2216 /* Bitfield definition for register: MHPMCOUNTER3 */
2217 /*
2218  * COUNTER (RW)
2219  *
2220  * count the num- ber of events selected by mhpmevent3
2221  */
2222 #define CSR_MHPMCOUNTER3_COUNTER_MASK (0xFFFFFFFFUL)
2223 #define CSR_MHPMCOUNTER3_COUNTER_SHIFT (0U)
2224 #define CSR_MHPMCOUNTER3_COUNTER_SET(x) (((uint32_t)(x) << CSR_MHPMCOUNTER3_COUNTER_SHIFT) & CSR_MHPMCOUNTER3_COUNTER_MASK)
2225 #define CSR_MHPMCOUNTER3_COUNTER_GET(x) (((uint32_t)(x) & CSR_MHPMCOUNTER3_COUNTER_MASK) >> CSR_MHPMCOUNTER3_COUNTER_SHIFT)
2226 
2227 /* Bitfield definition for register: MHPMCOUNTER4 */
2228 /*
2229  * COUNTER (RW)
2230  *
2231  * count the num- ber of events selected by mhpmevent4
2232  */
2233 #define CSR_MHPMCOUNTER4_COUNTER_MASK (0xFFFFFFFFUL)
2234 #define CSR_MHPMCOUNTER4_COUNTER_SHIFT (0U)
2235 #define CSR_MHPMCOUNTER4_COUNTER_SET(x) (((uint32_t)(x) << CSR_MHPMCOUNTER4_COUNTER_SHIFT) & CSR_MHPMCOUNTER4_COUNTER_MASK)
2236 #define CSR_MHPMCOUNTER4_COUNTER_GET(x) (((uint32_t)(x) & CSR_MHPMCOUNTER4_COUNTER_MASK) >> CSR_MHPMCOUNTER4_COUNTER_SHIFT)
2237 
2238 /* Bitfield definition for register: MHPMCOUNTER5 */
2239 /*
2240  * COUNTER (RW)
2241  *
2242  * count the num- ber of events selected by mhpmevent5
2243  */
2244 #define CSR_MHPMCOUNTER5_COUNTER_MASK (0xFFFFFFFFUL)
2245 #define CSR_MHPMCOUNTER5_COUNTER_SHIFT (0U)
2246 #define CSR_MHPMCOUNTER5_COUNTER_SET(x) (((uint32_t)(x) << CSR_MHPMCOUNTER5_COUNTER_SHIFT) & CSR_MHPMCOUNTER5_COUNTER_MASK)
2247 #define CSR_MHPMCOUNTER5_COUNTER_GET(x) (((uint32_t)(x) & CSR_MHPMCOUNTER5_COUNTER_MASK) >> CSR_MHPMCOUNTER5_COUNTER_SHIFT)
2248 
2249 /* Bitfield definition for register: MHPMCOUNTER6 */
2250 /*
2251  * COUNTER (RW)
2252  *
2253  * count the num- ber of events selected by mhpmevent6
2254  */
2255 #define CSR_MHPMCOUNTER6_COUNTER_MASK (0xFFFFFFFFUL)
2256 #define CSR_MHPMCOUNTER6_COUNTER_SHIFT (0U)
2257 #define CSR_MHPMCOUNTER6_COUNTER_SET(x) (((uint32_t)(x) << CSR_MHPMCOUNTER6_COUNTER_SHIFT) & CSR_MHPMCOUNTER6_COUNTER_MASK)
2258 #define CSR_MHPMCOUNTER6_COUNTER_GET(x) (((uint32_t)(x) & CSR_MHPMCOUNTER6_COUNTER_MASK) >> CSR_MHPMCOUNTER6_COUNTER_SHIFT)
2259 
2260 /* Bitfield definition for register: MCYCLEH */
2261 /*
2262  * COUNTER (RW)
2263  *
2264  * the higher 32 bits of Machine Cycle Counter
2265  */
2266 #define CSR_MCYCLEH_COUNTER_MASK (0xFFFFFFFFUL)
2267 #define CSR_MCYCLEH_COUNTER_SHIFT (0U)
2268 #define CSR_MCYCLEH_COUNTER_SET(x) (((uint32_t)(x) << CSR_MCYCLEH_COUNTER_SHIFT) & CSR_MCYCLEH_COUNTER_MASK)
2269 #define CSR_MCYCLEH_COUNTER_GET(x) (((uint32_t)(x) & CSR_MCYCLEH_COUNTER_MASK) >> CSR_MCYCLEH_COUNTER_SHIFT)
2270 
2271 /* Bitfield definition for register: MINSTRETH */
2272 /*
2273  * COUNTER (RW)
2274  *
2275  * the higher 32 bits of Machine Instruction-Retired Counter
2276  */
2277 #define CSR_MINSTRETH_COUNTER_MASK (0xFFFFFFFFUL)
2278 #define CSR_MINSTRETH_COUNTER_SHIFT (0U)
2279 #define CSR_MINSTRETH_COUNTER_SET(x) (((uint32_t)(x) << CSR_MINSTRETH_COUNTER_SHIFT) & CSR_MINSTRETH_COUNTER_MASK)
2280 #define CSR_MINSTRETH_COUNTER_GET(x) (((uint32_t)(x) & CSR_MINSTRETH_COUNTER_MASK) >> CSR_MINSTRETH_COUNTER_SHIFT)
2281 
2282 /* Bitfield definition for register: MHPMCOUNTER3H */
2283 /*
2284  * COUNTER (RW)
2285  *
2286  * count the num- ber of events selected by mhpmevent3
2287  */
2288 #define CSR_MHPMCOUNTER3H_COUNTER_MASK (0xFFFFFFFFUL)
2289 #define CSR_MHPMCOUNTER3H_COUNTER_SHIFT (0U)
2290 #define CSR_MHPMCOUNTER3H_COUNTER_SET(x) (((uint32_t)(x) << CSR_MHPMCOUNTER3H_COUNTER_SHIFT) & CSR_MHPMCOUNTER3H_COUNTER_MASK)
2291 #define CSR_MHPMCOUNTER3H_COUNTER_GET(x) (((uint32_t)(x) & CSR_MHPMCOUNTER3H_COUNTER_MASK) >> CSR_MHPMCOUNTER3H_COUNTER_SHIFT)
2292 
2293 /* Bitfield definition for register: MHPMCOUNTER4H */
2294 /*
2295  * COUNTER (RW)
2296  *
2297  * count the num- ber of events selected by mhpmevent4
2298  */
2299 #define CSR_MHPMCOUNTER4H_COUNTER_MASK (0xFFFFFFFFUL)
2300 #define CSR_MHPMCOUNTER4H_COUNTER_SHIFT (0U)
2301 #define CSR_MHPMCOUNTER4H_COUNTER_SET(x) (((uint32_t)(x) << CSR_MHPMCOUNTER4H_COUNTER_SHIFT) & CSR_MHPMCOUNTER4H_COUNTER_MASK)
2302 #define CSR_MHPMCOUNTER4H_COUNTER_GET(x) (((uint32_t)(x) & CSR_MHPMCOUNTER4H_COUNTER_MASK) >> CSR_MHPMCOUNTER4H_COUNTER_SHIFT)
2303 
2304 /* Bitfield definition for register: MHPMCOUNTER5H */
2305 /*
2306  * COUNTER (RW)
2307  *
2308  * count the num- ber of events selected by mhpmevent5
2309  */
2310 #define CSR_MHPMCOUNTER5H_COUNTER_MASK (0xFFFFFFFFUL)
2311 #define CSR_MHPMCOUNTER5H_COUNTER_SHIFT (0U)
2312 #define CSR_MHPMCOUNTER5H_COUNTER_SET(x) (((uint32_t)(x) << CSR_MHPMCOUNTER5H_COUNTER_SHIFT) & CSR_MHPMCOUNTER5H_COUNTER_MASK)
2313 #define CSR_MHPMCOUNTER5H_COUNTER_GET(x) (((uint32_t)(x) & CSR_MHPMCOUNTER5H_COUNTER_MASK) >> CSR_MHPMCOUNTER5H_COUNTER_SHIFT)
2314 
2315 /* Bitfield definition for register: MHPMCOUNTER6H */
2316 /*
2317  * COUNTER (RW)
2318  *
2319  * count the num- ber of events selected by mhpmevent6
2320  */
2321 #define CSR_MHPMCOUNTER6H_COUNTER_MASK (0xFFFFFFFFUL)
2322 #define CSR_MHPMCOUNTER6H_COUNTER_SHIFT (0U)
2323 #define CSR_MHPMCOUNTER6H_COUNTER_SET(x) (((uint32_t)(x) << CSR_MHPMCOUNTER6H_COUNTER_SHIFT) & CSR_MHPMCOUNTER6H_COUNTER_MASK)
2324 #define CSR_MHPMCOUNTER6H_COUNTER_GET(x) (((uint32_t)(x) & CSR_MHPMCOUNTER6H_COUNTER_MASK) >> CSR_MHPMCOUNTER6H_COUNTER_SHIFT)
2325 
2326 /* Bitfield definition for register: CYCLE */
2327 /*
2328  * CYCLE (RW)
2329  *
2330  * Cycle Counter
2331  */
2332 #define CSR_CYCLE_CYCLE_MASK (0xFFFFFFFFUL)
2333 #define CSR_CYCLE_CYCLE_SHIFT (0U)
2334 #define CSR_CYCLE_CYCLE_SET(x) (((uint32_t)(x) << CSR_CYCLE_CYCLE_SHIFT) & CSR_CYCLE_CYCLE_MASK)
2335 #define CSR_CYCLE_CYCLE_GET(x) (((uint32_t)(x) & CSR_CYCLE_CYCLE_MASK) >> CSR_CYCLE_CYCLE_SHIFT)
2336 
2337 /* Bitfield definition for register: CYCLEH */
2338 /*
2339  * CYCLEH (RW)
2340  *
2341  * Cycle Counter Higher 32-bit
2342  */
2343 #define CSR_CYCLEH_CYCLEH_MASK (0xFFFFFFFFUL)
2344 #define CSR_CYCLEH_CYCLEH_SHIFT (0U)
2345 #define CSR_CYCLEH_CYCLEH_SET(x) (((uint32_t)(x) << CSR_CYCLEH_CYCLEH_SHIFT) & CSR_CYCLEH_CYCLEH_MASK)
2346 #define CSR_CYCLEH_CYCLEH_GET(x) (((uint32_t)(x) & CSR_CYCLEH_CYCLEH_MASK) >> CSR_CYCLEH_CYCLEH_SHIFT)
2347 
2348 /* Bitfield definition for register: MVENDORID */
2349 /*
2350  * MVENDORID (RO)
2351  *
2352  * The manufacturer ID
2353  */
2354 #define CSR_MVENDORID_MVENDORID_MASK (0xFFFFFFFFUL)
2355 #define CSR_MVENDORID_MVENDORID_SHIFT (0U)
2356 #define CSR_MVENDORID_MVENDORID_GET(x) (((uint32_t)(x) & CSR_MVENDORID_MVENDORID_MASK) >> CSR_MVENDORID_MVENDORID_SHIFT)
2357 
2358 /* Bitfield definition for register: MARCHID */
2359 /*
2360  * CPU_ID (RO)
2361  *
2362  * CPU ID
2363  */
2364 #define CSR_MARCHID_CPU_ID_MASK (0x7FFFFFFFUL)
2365 #define CSR_MARCHID_CPU_ID_SHIFT (0U)
2366 #define CSR_MARCHID_CPU_ID_GET(x) (((uint32_t)(x) & CSR_MARCHID_CPU_ID_MASK) >> CSR_MARCHID_CPU_ID_SHIFT)
2367 
2368 /* Bitfield definition for register: MIMPID */
2369 /*
2370  * MAJOR (RO)
2371  *
2372  * Revision major
2373  */
2374 #define CSR_MIMPID_MAJOR_MASK (0xFFFFFF00UL)
2375 #define CSR_MIMPID_MAJOR_SHIFT (8U)
2376 #define CSR_MIMPID_MAJOR_GET(x) (((uint32_t)(x) & CSR_MIMPID_MAJOR_MASK) >> CSR_MIMPID_MAJOR_SHIFT)
2377 
2378 /*
2379  * MINOR (RO)
2380  *
2381  * Revision minor
2382  */
2383 #define CSR_MIMPID_MINOR_MASK (0xF0U)
2384 #define CSR_MIMPID_MINOR_SHIFT (4U)
2385 #define CSR_MIMPID_MINOR_GET(x) (((uint32_t)(x) & CSR_MIMPID_MINOR_MASK) >> CSR_MIMPID_MINOR_SHIFT)
2386 
2387 /*
2388  * EXTENSION (RO)
2389  *
2390  * Revision extension
2391  */
2392 #define CSR_MIMPID_EXTENSION_MASK (0xFU)
2393 #define CSR_MIMPID_EXTENSION_SHIFT (0U)
2394 #define CSR_MIMPID_EXTENSION_GET(x) (((uint32_t)(x) & CSR_MIMPID_EXTENSION_MASK) >> CSR_MIMPID_EXTENSION_SHIFT)
2395 
2396 /* Bitfield definition for register: MHARTID */
2397 /*
2398  * MHARTID (RO)
2399  *
2400  * Hart ID
2401  */
2402 #define CSR_MHARTID_MHARTID_MASK (0xFFFFFFFFUL)
2403 #define CSR_MHARTID_MHARTID_SHIFT (0U)
2404 #define CSR_MHARTID_MHARTID_GET(x) (((uint32_t)(x) & CSR_MHARTID_MHARTID_MASK) >> CSR_MHARTID_MHARTID_SHIFT)
2405 
2406 /* NON-STANDARD CRS register bitfiled definitions */
2407 
2408 /* Bitfield definition for register: MCOUNTINHIBIT */
2409 /*
2410  * HPM6 (RW)
2411  *
2412  * See register description.
2413  */
2414 #define CSR_MCOUNTINHIBIT_HPM6_MASK (0x40U)
2415 #define CSR_MCOUNTINHIBIT_HPM6_SHIFT (6U)
2416 #define CSR_MCOUNTINHIBIT_HPM6_SET(x) (((uint32_t)(x) << CSR_MCOUNTINHIBIT_HPM6_SHIFT) & CSR_MCOUNTINHIBIT_HPM6_MASK)
2417 #define CSR_MCOUNTINHIBIT_HPM6_GET(x) (((uint32_t)(x) & CSR_MCOUNTINHIBIT_HPM6_MASK) >> CSR_MCOUNTINHIBIT_HPM6_SHIFT)
2418 
2419 /*
2420  * HPM5 (RW)
2421  *
2422  * See register description.
2423  */
2424 #define CSR_MCOUNTINHIBIT_HPM5_MASK (0x20U)
2425 #define CSR_MCOUNTINHIBIT_HPM5_SHIFT (5U)
2426 #define CSR_MCOUNTINHIBIT_HPM5_SET(x) (((uint32_t)(x) << CSR_MCOUNTINHIBIT_HPM5_SHIFT) & CSR_MCOUNTINHIBIT_HPM5_MASK)
2427 #define CSR_MCOUNTINHIBIT_HPM5_GET(x) (((uint32_t)(x) & CSR_MCOUNTINHIBIT_HPM5_MASK) >> CSR_MCOUNTINHIBIT_HPM5_SHIFT)
2428 
2429 /*
2430  * HPM4 (RW)
2431  *
2432  * See register description.
2433  */
2434 #define CSR_MCOUNTINHIBIT_HPM4_MASK (0x10U)
2435 #define CSR_MCOUNTINHIBIT_HPM4_SHIFT (4U)
2436 #define CSR_MCOUNTINHIBIT_HPM4_SET(x) (((uint32_t)(x) << CSR_MCOUNTINHIBIT_HPM4_SHIFT) & CSR_MCOUNTINHIBIT_HPM4_MASK)
2437 #define CSR_MCOUNTINHIBIT_HPM4_GET(x) (((uint32_t)(x) & CSR_MCOUNTINHIBIT_HPM4_MASK) >> CSR_MCOUNTINHIBIT_HPM4_SHIFT)
2438 
2439 /*
2440  * HPM3 (RW)
2441  *
2442  * See register description.
2443  */
2444 #define CSR_MCOUNTINHIBIT_HPM3_MASK (0x8U)
2445 #define CSR_MCOUNTINHIBIT_HPM3_SHIFT (3U)
2446 #define CSR_MCOUNTINHIBIT_HPM3_SET(x) (((uint32_t)(x) << CSR_MCOUNTINHIBIT_HPM3_SHIFT) & CSR_MCOUNTINHIBIT_HPM3_MASK)
2447 #define CSR_MCOUNTINHIBIT_HPM3_GET(x) (((uint32_t)(x) & CSR_MCOUNTINHIBIT_HPM3_MASK) >> CSR_MCOUNTINHIBIT_HPM3_SHIFT)
2448 
2449 /*
2450  * IR (RW)
2451  *
2452  * See register description.
2453  */
2454 #define CSR_MCOUNTINHIBIT_IR_MASK (0x4U)
2455 #define CSR_MCOUNTINHIBIT_IR_SHIFT (2U)
2456 #define CSR_MCOUNTINHIBIT_IR_SET(x) (((uint32_t)(x) << CSR_MCOUNTINHIBIT_IR_SHIFT) & CSR_MCOUNTINHIBIT_IR_MASK)
2457 #define CSR_MCOUNTINHIBIT_IR_GET(x) (((uint32_t)(x) & CSR_MCOUNTINHIBIT_IR_MASK) >> CSR_MCOUNTINHIBIT_IR_SHIFT)
2458 
2459 /*
2460  * TM (RW)
2461  *
2462  * See register description.
2463  */
2464 #define CSR_MCOUNTINHIBIT_TM_MASK (0x2U)
2465 #define CSR_MCOUNTINHIBIT_TM_SHIFT (1U)
2466 #define CSR_MCOUNTINHIBIT_TM_SET(x) (((uint32_t)(x) << CSR_MCOUNTINHIBIT_TM_SHIFT) & CSR_MCOUNTINHIBIT_TM_MASK)
2467 #define CSR_MCOUNTINHIBIT_TM_GET(x) (((uint32_t)(x) & CSR_MCOUNTINHIBIT_TM_MASK) >> CSR_MCOUNTINHIBIT_TM_SHIFT)
2468 
2469 /*
2470  * CY (RW)
2471  *
2472  * See register description.
2473  */
2474 #define CSR_MCOUNTINHIBIT_CY_MASK (0x1U)
2475 #define CSR_MCOUNTINHIBIT_CY_SHIFT (0U)
2476 #define CSR_MCOUNTINHIBIT_CY_SET(x) (((uint32_t)(x) << CSR_MCOUNTINHIBIT_CY_SHIFT) & CSR_MCOUNTINHIBIT_CY_MASK)
2477 #define CSR_MCOUNTINHIBIT_CY_GET(x) (((uint32_t)(x) & CSR_MCOUNTINHIBIT_CY_MASK) >> CSR_MCOUNTINHIBIT_CY_SHIFT)
2478 
2479 /* Bitfield definition for register: MILMB */
2480 /*
2481  * IBPA (RO)
2482  *
2483  * The base physical address of ILM. It has to be an integer multiple of the ILM size
2484  */
2485 #define CSR_MILMB_IBPA_MASK (0xFFFFFC00UL)
2486 #define CSR_MILMB_IBPA_SHIFT (10U)
2487 #define CSR_MILMB_IBPA_GET(x) (((uint32_t)(x) & CSR_MILMB_IBPA_MASK) >> CSR_MILMB_IBPA_SHIFT)
2488 
2489 /*
2490  * RWECC (RW)
2491  *
2492  * Controls diagnostic accesses of ECC codes of the ILM RAMs. When set, load/store to ILM reads/writes ECC codes to the mecc_code register. This bit can be set for injecting ECC errors to test the ECC handler.
2493  * 0:Disable diagnostic accesses of ECC codes
2494  * 1:Enable diagnostic accesses of ECC codes
2495  */
2496 #define CSR_MILMB_RWECC_MASK (0x8U)
2497 #define CSR_MILMB_RWECC_SHIFT (3U)
2498 #define CSR_MILMB_RWECC_SET(x) (((uint32_t)(x) << CSR_MILMB_RWECC_SHIFT) & CSR_MILMB_RWECC_MASK)
2499 #define CSR_MILMB_RWECC_GET(x) (((uint32_t)(x) & CSR_MILMB_RWECC_MASK) >> CSR_MILMB_RWECC_SHIFT)
2500 
2501 /*
2502  * ECCEN (RW)
2503  *
2504  * Parity/ECC enable control:
2505  * 0:Disable parity/ECC
2506  * 1:Reserved
2507  * 2:Generate exceptions only on uncorrectable parity/ECC errors
2508  * 3:Generate exceptions on any type of parity/ECC errors
2509  */
2510 #define CSR_MILMB_ECCEN_MASK (0x6U)
2511 #define CSR_MILMB_ECCEN_SHIFT (1U)
2512 #define CSR_MILMB_ECCEN_SET(x) (((uint32_t)(x) << CSR_MILMB_ECCEN_SHIFT) & CSR_MILMB_ECCEN_MASK)
2513 #define CSR_MILMB_ECCEN_GET(x) (((uint32_t)(x) & CSR_MILMB_ECCEN_MASK) >> CSR_MILMB_ECCEN_SHIFT)
2514 
2515 /*
2516  * IEN (RO)
2517  *
2518  * ILM enable control:
2519  * 0:ILM is disabled
2520  * 1:ILM is enabled
2521  */
2522 #define CSR_MILMB_IEN_MASK (0x1U)
2523 #define CSR_MILMB_IEN_SHIFT (0U)
2524 #define CSR_MILMB_IEN_GET(x) (((uint32_t)(x) & CSR_MILMB_IEN_MASK) >> CSR_MILMB_IEN_SHIFT)
2525 
2526 /* Bitfield definition for register: MDLMB */
2527 /*
2528  * DBPA (RO)
2529  *
2530  * The base physical address of DLM. It has to be an integer multiple of the DLM size
2531  */
2532 #define CSR_MDLMB_DBPA_MASK (0xFFFFFC00UL)
2533 #define CSR_MDLMB_DBPA_SHIFT (10U)
2534 #define CSR_MDLMB_DBPA_GET(x) (((uint32_t)(x) & CSR_MDLMB_DBPA_MASK) >> CSR_MDLMB_DBPA_SHIFT)
2535 
2536 /*
2537  * RWECC (RW)
2538  *
2539  * Controls diagnostic accesses of ECC codes of the DLM RAMs. When set, load/store to DLM reads/writes ECC codes to the mecc_code register. This bit can be set for injecting ECC errors to test the ECC handler.
2540  * 0:Disable diagnostic accesses of ECC codes
2541  * 1:Enable diagnostic accesses of ECC codes
2542  */
2543 #define CSR_MDLMB_RWECC_MASK (0x8U)
2544 #define CSR_MDLMB_RWECC_SHIFT (3U)
2545 #define CSR_MDLMB_RWECC_SET(x) (((uint32_t)(x) << CSR_MDLMB_RWECC_SHIFT) & CSR_MDLMB_RWECC_MASK)
2546 #define CSR_MDLMB_RWECC_GET(x) (((uint32_t)(x) & CSR_MDLMB_RWECC_MASK) >> CSR_MDLMB_RWECC_SHIFT)
2547 
2548 /*
2549  * ECCEN (RW)
2550  *
2551  * Parity/ECC enable control:
2552  * 0:Disable parity/ECC
2553  * 1:Reserved
2554  * 2:Generate exceptions only on uncorrectable parity/ECC errors
2555  * 3:Generate exceptions on any type of parity/ECC errors
2556  */
2557 #define CSR_MDLMB_ECCEN_MASK (0x6U)
2558 #define CSR_MDLMB_ECCEN_SHIFT (1U)
2559 #define CSR_MDLMB_ECCEN_SET(x) (((uint32_t)(x) << CSR_MDLMB_ECCEN_SHIFT) & CSR_MDLMB_ECCEN_MASK)
2560 #define CSR_MDLMB_ECCEN_GET(x) (((uint32_t)(x) & CSR_MDLMB_ECCEN_MASK) >> CSR_MDLMB_ECCEN_SHIFT)
2561 
2562 /*
2563  * DEN (RO)
2564  *
2565  * DLM enable control:
2566  * 0:DLM is disabled
2567  * 1:DLM is enabled
2568  */
2569 #define CSR_MDLMB_DEN_MASK (0x1U)
2570 #define CSR_MDLMB_DEN_SHIFT (0U)
2571 #define CSR_MDLMB_DEN_GET(x) (((uint32_t)(x) & CSR_MDLMB_DEN_MASK) >> CSR_MDLMB_DEN_SHIFT)
2572 
2573 /* Bitfield definition for register: MECC_CODE */
2574 /*
2575  * INSN (RO)
2576  *
2577  * Indicates if the parity/ECC error is caused by instruction fetch or data access.
2578  * 0:Data access
2579  * 1:Instruction fetch
2580  */
2581 #define CSR_MECC_CODE_INSN_MASK (0x400000UL)
2582 #define CSR_MECC_CODE_INSN_SHIFT (22U)
2583 #define CSR_MECC_CODE_INSN_GET(x) (((uint32_t)(x) & CSR_MECC_CODE_INSN_MASK) >> CSR_MECC_CODE_INSN_SHIFT)
2584 
2585 /*
2586  * RAMID (RO)
2587  *
2588  * The ID of RAM that caused parity/ECC errors.
2589  * This bit is updated on parity/ECC error exceptions.
2590  * 0–1:Reserved
2591  * 2:Tag RAM of I-Cache
2592  * 3:Data RAM of I-Cache
2593  * 4:Tag RAM of D-Cache
2594  * 5:Data RAM of D-Cache
2595  * 6:Tag RAM of TLB
2596  * 7:Data RAM of TLB
2597  * 8:ILM
2598  * 9:DLM
2599  * 10–15:Reserved
2600  */
2601 #define CSR_MECC_CODE_RAMID_MASK (0x3C0000UL)
2602 #define CSR_MECC_CODE_RAMID_SHIFT (18U)
2603 #define CSR_MECC_CODE_RAMID_GET(x) (((uint32_t)(x) & CSR_MECC_CODE_RAMID_MASK) >> CSR_MECC_CODE_RAMID_SHIFT)
2604 
2605 /*
2606  * P (RO)
2607  *
2608  * Precise error. This bit is updated on parity/ECC error exceptions.
2609  * 0:Imprecise error
2610  * 1:Precise error
2611  */
2612 #define CSR_MECC_CODE_P_MASK (0x20000UL)
2613 #define CSR_MECC_CODE_P_SHIFT (17U)
2614 #define CSR_MECC_CODE_P_GET(x) (((uint32_t)(x) & CSR_MECC_CODE_P_MASK) >> CSR_MECC_CODE_P_SHIFT)
2615 
2616 /*
2617  * C (RO)
2618  *
2619  * Correctable error. This bit is updated on parity/ECC error exceptions.
2620  * 0:Uncorrectable error
2621  * 1:Correctable error
2622  */
2623 #define CSR_MECC_CODE_C_MASK (0x10000UL)
2624 #define CSR_MECC_CODE_C_SHIFT (16U)
2625 #define CSR_MECC_CODE_C_GET(x) (((uint32_t)(x) & CSR_MECC_CODE_C_MASK) >> CSR_MECC_CODE_C_SHIFT)
2626 
2627 /*
2628  * CODE (RW)
2629  *
2630  * This field records the ECC value on ECC error exceptions. This field is also used to read/write the ECC codes when diagnostic access of ECC codes are enabled (milmb.RWECC or mdlmb.RWECC is 1).
2631  */
2632 #define CSR_MECC_CODE_CODE_MASK (0x7FU)
2633 #define CSR_MECC_CODE_CODE_SHIFT (0U)
2634 #define CSR_MECC_CODE_CODE_SET(x) (((uint32_t)(x) << CSR_MECC_CODE_CODE_SHIFT) & CSR_MECC_CODE_CODE_MASK)
2635 #define CSR_MECC_CODE_CODE_GET(x) (((uint32_t)(x) & CSR_MECC_CODE_CODE_MASK) >> CSR_MECC_CODE_CODE_SHIFT)
2636 
2637 /* Bitfield definition for register: MNVEC */
2638 /*
2639  * MNVEC (RO)
2640  *
2641  * Base address of the NMI handler. Its value is the zero-extended value of the reset_vector.
2642  */
2643 #define CSR_MNVEC_MNVEC_MASK (0xFFFFFFFFUL)
2644 #define CSR_MNVEC_MNVEC_SHIFT (0U)
2645 #define CSR_MNVEC_MNVEC_GET(x) (((uint32_t)(x) & CSR_MNVEC_MNVEC_MASK) >> CSR_MNVEC_MNVEC_SHIFT)
2646 
2647 /* Bitfield definition for register: MXSTATUS */
2648 /*
2649  * PDME (RW)
2650  *
2651  * For saving previous DME state on entering a trap. This field is hardwired to 0 if data cache and data local memory are not supported.
2652  */
2653 #define CSR_MXSTATUS_PDME_MASK (0x20U)
2654 #define CSR_MXSTATUS_PDME_SHIFT (5U)
2655 #define CSR_MXSTATUS_PDME_SET(x) (((uint32_t)(x) << CSR_MXSTATUS_PDME_SHIFT) & CSR_MXSTATUS_PDME_MASK)
2656 #define CSR_MXSTATUS_PDME_GET(x) (((uint32_t)(x) & CSR_MXSTATUS_PDME_MASK) >> CSR_MXSTATUS_PDME_SHIFT)
2657 
2658 /*
2659  * DME (RW)
2660  *
2661  * Data Machine Error flag. It indicates an exception occurred at the data cache or data local memory (DLM). Load/store accesses will bypass D-Cache when this bit is set. The exception handler should clear this bit after the machine error has been dealt with.
2662  */
2663 #define CSR_MXSTATUS_DME_MASK (0x10U)
2664 #define CSR_MXSTATUS_DME_SHIFT (4U)
2665 #define CSR_MXSTATUS_DME_SET(x) (((uint32_t)(x) << CSR_MXSTATUS_DME_SHIFT) & CSR_MXSTATUS_DME_MASK)
2666 #define CSR_MXSTATUS_DME_GET(x) (((uint32_t)(x) & CSR_MXSTATUS_DME_MASK) >> CSR_MXSTATUS_DME_SHIFT)
2667 
2668 /*
2669  * PIME (RW)
2670  *
2671  * When mcause is imprecise exception (in the form of an interrupt), the PM field records the privileged mode of the instruction that caused the imprecise exception. The PM field encoding
2672  * is defined as follows:
2673  * 0: User mode
2674  * 1: Supervisor mode
2675  * 2: Reserved
2676  * 3: Machine mode
2677  */
2678 #define CSR_MXSTATUS_PIME_MASK (0x8U)
2679 #define CSR_MXSTATUS_PIME_SHIFT (3U)
2680 #define CSR_MXSTATUS_PIME_SET(x) (((uint32_t)(x) << CSR_MXSTATUS_PIME_SHIFT) & CSR_MXSTATUS_PIME_MASK)
2681 #define CSR_MXSTATUS_PIME_GET(x) (((uint32_t)(x) & CSR_MXSTATUS_PIME_MASK) >> CSR_MXSTATUS_PIME_SHIFT)
2682 
2683 /*
2684  * IME (RW)
2685  *
2686  * When mcause is imprecise exception (in the form of an interrupt), the PM field records the privileged mode of the instruction that caused the imprecise exception. The PM field encoding
2687  * is defined as follows:
2688  * 0: User mode
2689  * 1: Supervisor mode
2690  * 2: Reserved
2691  * 3: Machine mode
2692  */
2693 #define CSR_MXSTATUS_IME_MASK (0x4U)
2694 #define CSR_MXSTATUS_IME_SHIFT (2U)
2695 #define CSR_MXSTATUS_IME_SET(x) (((uint32_t)(x) << CSR_MXSTATUS_IME_SHIFT) & CSR_MXSTATUS_IME_MASK)
2696 #define CSR_MXSTATUS_IME_GET(x) (((uint32_t)(x) & CSR_MXSTATUS_IME_MASK) >> CSR_MXSTATUS_IME_SHIFT)
2697 
2698 /*
2699  * PPFT_EN (RW)
2700  *
2701  * When mcause is imprecise exception (in the form of an interrupt), the PM field records the privileged mode of the instruction that caused the imprecise exception. The PM field encoding
2702  * is defined as follows:
2703  * 0: User mode
2704  * 1: Supervisor mode
2705  * 2: Reserved
2706  * 3: Machine mode
2707  */
2708 #define CSR_MXSTATUS_PPFT_EN_MASK (0x2U)
2709 #define CSR_MXSTATUS_PPFT_EN_SHIFT (1U)
2710 #define CSR_MXSTATUS_PPFT_EN_SET(x) (((uint32_t)(x) << CSR_MXSTATUS_PPFT_EN_SHIFT) & CSR_MXSTATUS_PPFT_EN_MASK)
2711 #define CSR_MXSTATUS_PPFT_EN_GET(x) (((uint32_t)(x) & CSR_MXSTATUS_PPFT_EN_MASK) >> CSR_MXSTATUS_PPFT_EN_SHIFT)
2712 
2713 /*
2714  * PFT_EN (RW)
2715  *
2716  * Enable performance throttling. When throttling is enabled, the processor executes instructions at the performance level specified in mpft_ctl.T_LEVEL. On entering a trap:
2717  * PPFT_EN <= PFT_EN;
2718  * PFT_EN <= mpft_ctl.FAST_INT ? 0 :PFT_EN;
2719  * On executing an MRET instruction:
2720  * PFT_EN <= PPFT_EN;
2721  * This field is hardwired to 0 if the PowerBrake feature is not supported.
2722  */
2723 #define CSR_MXSTATUS_PFT_EN_MASK (0x1U)
2724 #define CSR_MXSTATUS_PFT_EN_SHIFT (0U)
2725 #define CSR_MXSTATUS_PFT_EN_SET(x) (((uint32_t)(x) << CSR_MXSTATUS_PFT_EN_SHIFT) & CSR_MXSTATUS_PFT_EN_MASK)
2726 #define CSR_MXSTATUS_PFT_EN_GET(x) (((uint32_t)(x) & CSR_MXSTATUS_PFT_EN_MASK) >> CSR_MXSTATUS_PFT_EN_SHIFT)
2727 
2728 /* Bitfield definition for register: MPFT_CTL */
2729 /*
2730  * FAST_INT (RW)
2731  *
2732  * Fast interrupt response. If this field is set, mxstatus.PFT_EN will be automatically cleared when the processor enters an interrupt handler.
2733  */
2734 #define CSR_MPFT_CTL_FAST_INT_MASK (0x100U)
2735 #define CSR_MPFT_CTL_FAST_INT_SHIFT (8U)
2736 #define CSR_MPFT_CTL_FAST_INT_SET(x) (((uint32_t)(x) << CSR_MPFT_CTL_FAST_INT_SHIFT) & CSR_MPFT_CTL_FAST_INT_MASK)
2737 #define CSR_MPFT_CTL_FAST_INT_GET(x) (((uint32_t)(x) & CSR_MPFT_CTL_FAST_INT_MASK) >> CSR_MPFT_CTL_FAST_INT_SHIFT)
2738 
2739 /*
2740  * T_LEVEL (RW)
2741  *
2742  * Throttling Level. The processor has the highest performance at throttling level 0 and the lowest
2743  * performance at throttling level 15.
2744  * 0:Level 0 (the highest performance)
2745  * 1-14:Level 1-14
2746  * 15:Level 15 (the lowest performance)
2747  */
2748 #define CSR_MPFT_CTL_T_LEVEL_MASK (0xF0U)
2749 #define CSR_MPFT_CTL_T_LEVEL_SHIFT (4U)
2750 #define CSR_MPFT_CTL_T_LEVEL_SET(x) (((uint32_t)(x) << CSR_MPFT_CTL_T_LEVEL_SHIFT) & CSR_MPFT_CTL_T_LEVEL_MASK)
2751 #define CSR_MPFT_CTL_T_LEVEL_GET(x) (((uint32_t)(x) & CSR_MPFT_CTL_T_LEVEL_MASK) >> CSR_MPFT_CTL_T_LEVEL_SHIFT)
2752 
2753 /* Bitfield definition for register: MHSP_CTL */
2754 /*
2755  * M (RW)
2756  *
2757  * Enables the SP protection and recording mechanism in Machine mode
2758  * 0:The mechanism is disabled in Machine mode.
2759  * 1: The mechanism is enabled in Machine mode.
2760  */
2761 #define CSR_MHSP_CTL_M_MASK (0x20U)
2762 #define CSR_MHSP_CTL_M_SHIFT (5U)
2763 #define CSR_MHSP_CTL_M_SET(x) (((uint32_t)(x) << CSR_MHSP_CTL_M_SHIFT) & CSR_MHSP_CTL_M_MASK)
2764 #define CSR_MHSP_CTL_M_GET(x) (((uint32_t)(x) & CSR_MHSP_CTL_M_MASK) >> CSR_MHSP_CTL_M_SHIFT)
2765 
2766 /*
2767  * S (RW)
2768  *
2769  * Enables the SP protection and recording mechanism in Supervisor mode
2770  * 0:The mechanism is disabled in Supervisor mode
2771  * 1:The mechanism is enabled in Supervisor mode
2772  */
2773 #define CSR_MHSP_CTL_S_MASK (0x10U)
2774 #define CSR_MHSP_CTL_S_SHIFT (4U)
2775 #define CSR_MHSP_CTL_S_SET(x) (((uint32_t)(x) << CSR_MHSP_CTL_S_SHIFT) & CSR_MHSP_CTL_S_MASK)
2776 #define CSR_MHSP_CTL_S_GET(x) (((uint32_t)(x) & CSR_MHSP_CTL_S_MASK) >> CSR_MHSP_CTL_S_SHIFT)
2777 
2778 /*
2779  * U (RW)
2780  *
2781  * Enables the SP protection and recording mechanism in User mode
2782  * 0:The mechanism is disabled in User mode
2783  * 1:The mechanism is enabled in User mode.
2784  */
2785 #define CSR_MHSP_CTL_U_MASK (0x8U)
2786 #define CSR_MHSP_CTL_U_SHIFT (3U)
2787 #define CSR_MHSP_CTL_U_SET(x) (((uint32_t)(x) << CSR_MHSP_CTL_U_SHIFT) & CSR_MHSP_CTL_U_MASK)
2788 #define CSR_MHSP_CTL_U_GET(x) (((uint32_t)(x) & CSR_MHSP_CTL_U_MASK) >> CSR_MHSP_CTL_U_SHIFT)
2789 
2790 /*
2791  * SCHM (RW)
2792  *
2793  * Selects the operating scheme of the stack protection and recording mechanism
2794  * 0:Stack overflow/underflow detection
2795  * 1:Top-of-stack recording
2796  */
2797 #define CSR_MHSP_CTL_SCHM_MASK (0x4U)
2798 #define CSR_MHSP_CTL_SCHM_SHIFT (2U)
2799 #define CSR_MHSP_CTL_SCHM_SET(x) (((uint32_t)(x) << CSR_MHSP_CTL_SCHM_SHIFT) & CSR_MHSP_CTL_SCHM_MASK)
2800 #define CSR_MHSP_CTL_SCHM_GET(x) (((uint32_t)(x) & CSR_MHSP_CTL_SCHM_MASK) >> CSR_MHSP_CTL_SCHM_SHIFT)
2801 
2802 /*
2803  * UDF_EN (RW)
2804  *
2805  * Enable bit for the stack underflow protection mechanism. This bit will be cleared to 0 automatically by hardware when a stack protection (overflow or underflow) exception is taken.
2806  * 0:The stack underflow protection is disabled
2807  * 1:The stack underflow protection is enabled.
2808  */
2809 #define CSR_MHSP_CTL_UDF_EN_MASK (0x2U)
2810 #define CSR_MHSP_CTL_UDF_EN_SHIFT (1U)
2811 #define CSR_MHSP_CTL_UDF_EN_SET(x) (((uint32_t)(x) << CSR_MHSP_CTL_UDF_EN_SHIFT) & CSR_MHSP_CTL_UDF_EN_MASK)
2812 #define CSR_MHSP_CTL_UDF_EN_GET(x) (((uint32_t)(x) & CSR_MHSP_CTL_UDF_EN_MASK) >> CSR_MHSP_CTL_UDF_EN_SHIFT)
2813 
2814 /*
2815  * OVF_EN (RW)
2816  *
2817  * Enable bit for the stack overflow protection and recording mechanism. This bit will be cleared to 0 automatically by hardware when a stack protection (overflow or underflow) exception is taken.
2818  * 0:The stack overflow protection and recording mechanism are disabled.
2819  * 1:The stack overflow protection and recording mechanism are enabled.
2820  */
2821 #define CSR_MHSP_CTL_OVF_EN_MASK (0x1U)
2822 #define CSR_MHSP_CTL_OVF_EN_SHIFT (0U)
2823 #define CSR_MHSP_CTL_OVF_EN_SET(x) (((uint32_t)(x) << CSR_MHSP_CTL_OVF_EN_SHIFT) & CSR_MHSP_CTL_OVF_EN_MASK)
2824 #define CSR_MHSP_CTL_OVF_EN_GET(x) (((uint32_t)(x) & CSR_MHSP_CTL_OVF_EN_MASK) >> CSR_MHSP_CTL_OVF_EN_SHIFT)
2825 
2826 /* Bitfield definition for register: MSP_BOUND */
2827 /*
2828  * MSP_BOUND (RW)
2829  *
2830  * Machine SP Bound
2831  */
2832 #define CSR_MSP_BOUND_MSP_BOUND_MASK (0xFFFFFFFFUL)
2833 #define CSR_MSP_BOUND_MSP_BOUND_SHIFT (0U)
2834 #define CSR_MSP_BOUND_MSP_BOUND_SET(x) (((uint32_t)(x) << CSR_MSP_BOUND_MSP_BOUND_SHIFT) & CSR_MSP_BOUND_MSP_BOUND_MASK)
2835 #define CSR_MSP_BOUND_MSP_BOUND_GET(x) (((uint32_t)(x) & CSR_MSP_BOUND_MSP_BOUND_MASK) >> CSR_MSP_BOUND_MSP_BOUND_SHIFT)
2836 
2837 /* Bitfield definition for register: MSP_BASE */
2838 /*
2839  * SP_BASE (RW)
2840  *
2841  * Machine SP base
2842  */
2843 #define CSR_MSP_BASE_SP_BASE_MASK (0xFFFFFFFFUL)
2844 #define CSR_MSP_BASE_SP_BASE_SHIFT (0U)
2845 #define CSR_MSP_BASE_SP_BASE_SET(x) (((uint32_t)(x) << CSR_MSP_BASE_SP_BASE_SHIFT) & CSR_MSP_BASE_SP_BASE_MASK)
2846 #define CSR_MSP_BASE_SP_BASE_GET(x) (((uint32_t)(x) & CSR_MSP_BASE_SP_BASE_MASK) >> CSR_MSP_BASE_SP_BASE_SHIFT)
2847 
2848 /* Bitfield definition for register: MDCAUSE */
2849 /*
2850  * MDCAUSE (RW)
2851  *
2852  * This register further disambiguates causes of traps recorded in the mcause register.
2853  * The value of MDCAUSE for precise exception:
2854  * When mcause == 1 (Instruction access fault):
2855  * 0:Reserved; 1:ECC/Parity error; 2:PMP instruction access violation; 3:Bus error; 4:PMA empty hole access
2856  * When mcause == 2 (Illegal instruction):
2857  * 0:Please parse the mtval CSR; 1:FP disabled exception; 2:ACE disabled exception
2858  * When mcause == 5 (Load access fault):
2859  * 0:Reserved; 1:ECC/Parity error; 2:PMP load access violation; 3:Bus error; 4:Misaligned address; 5:PMA empty hole access; 6:PMA attribute inconsistency; 7:PMA NAMO exception
2860  * When mcause == 7 (Store access fault):
2861  * 0:Reserved; 1:ECC/Parity error; 2:PMP load access violation; 3:Bus error; 4:Misaligned address; 5:PMA empty hole access; 6:PMA attribute inconsistency; 7:PMA NAMO exception
2862  * The value of MDCAUSE for imprecise exception:
2863  * When mcause == Local Interrupt 16 or Local Interrupt 272 (16 + 256) (ECC error local interrupt)
2864  * 0:Reserved; 1:LM slave port ECC/Parity error; 2:Imprecise store ECC/Parity error; 3:Imprecise load ECC/Parity error
2865  * When mcause == Local Interrupt 17 or Local Interrupt 273 (17 + 256) (Bus read/write transaction error local interrupt)
2866  * 0:Reserved; 1:Bus read error; 2:Bus write error; 3:PMP error caused by load instructions; 4:PMP error caused by store instructions; 5:PMA error caused by load instructions; 6:PMA error caused by store instructions
2867  */
2868 #define CSR_MDCAUSE_MDCAUSE_MASK (0x7U)
2869 #define CSR_MDCAUSE_MDCAUSE_SHIFT (0U)
2870 #define CSR_MDCAUSE_MDCAUSE_SET(x) (((uint32_t)(x) << CSR_MDCAUSE_MDCAUSE_SHIFT) & CSR_MDCAUSE_MDCAUSE_MASK)
2871 #define CSR_MDCAUSE_MDCAUSE_GET(x) (((uint32_t)(x) & CSR_MDCAUSE_MDCAUSE_MASK) >> CSR_MDCAUSE_MDCAUSE_SHIFT)
2872 
2873 /* Bitfield definition for register: MCACHE_CTL */
2874 /*
2875  * IC_FIRST_WORD (RO)
2876  *
2877  * Cache miss allocation filling policy
2878  * 0:Cache line data is returned critical (double) word first
2879  * 1:Cache line data is returned the lowest address (double) word first
2880  */
2881 #define CSR_MCACHE_CTL_IC_FIRST_WORD_MASK (0x800U)
2882 #define CSR_MCACHE_CTL_IC_FIRST_WORD_SHIFT (11U)
2883 #define CSR_MCACHE_CTL_IC_FIRST_WORD_GET(x) (((uint32_t)(x) & CSR_MCACHE_CTL_IC_FIRST_WORD_MASK) >> CSR_MCACHE_CTL_IC_FIRST_WORD_SHIFT)
2884 
2885 /*
2886  * CCTL_SUEN (RW)
2887  *
2888  * Enable bit for Superuser-mode and User-mode software to access ucctlbeginaddr and ucctlcommand CSRs
2889  * 0:Disable ucctlbeginaddr and ucctlcommand accesses in S/U mode
2890  * 1:Enable ucctlbeginaddr and ucctlcommand accesses in S/U mode
2891  */
2892 #define CSR_MCACHE_CTL_CCTL_SUEN_MASK (0x100U)
2893 #define CSR_MCACHE_CTL_CCTL_SUEN_SHIFT (8U)
2894 #define CSR_MCACHE_CTL_CCTL_SUEN_SET(x) (((uint32_t)(x) << CSR_MCACHE_CTL_CCTL_SUEN_SHIFT) & CSR_MCACHE_CTL_CCTL_SUEN_MASK)
2895 #define CSR_MCACHE_CTL_CCTL_SUEN_GET(x) (((uint32_t)(x) & CSR_MCACHE_CTL_CCTL_SUEN_MASK) >> CSR_MCACHE_CTL_CCTL_SUEN_SHIFT)
2896 
2897 /*
2898  * DC_RWECC (RW)
2899  *
2900  * Controls diagnostic accesses of ECC codes of the data cache RAMs. It is set to enable CCTL operations to access the ECC codes. This bit can be set for injecting ECC errors to test the ECC handler
2901  * 0:Disable diagnostic accesses of ECC codes
2902  * 1:Enable diagnostic accesses of ECC codes
2903  */
2904 #define CSR_MCACHE_CTL_DC_RWECC_MASK (0x80U)
2905 #define CSR_MCACHE_CTL_DC_RWECC_SHIFT (7U)
2906 #define CSR_MCACHE_CTL_DC_RWECC_SET(x) (((uint32_t)(x) << CSR_MCACHE_CTL_DC_RWECC_SHIFT) & CSR_MCACHE_CTL_DC_RWECC_MASK)
2907 #define CSR_MCACHE_CTL_DC_RWECC_GET(x) (((uint32_t)(x) & CSR_MCACHE_CTL_DC_RWECC_MASK) >> CSR_MCACHE_CTL_DC_RWECC_SHIFT)
2908 
2909 /*
2910  * IC_RWECC (RW)
2911  *
2912  * Controls diagnostic accesses of ECC codes of the instruction cache RAMs. It is set to enable CCTL operations to access the ECC codes . This bit can be set for injecting ECC errors to test the ECC handler.
2913  * 0:Disable diagnostic accesses of ECC codes
2914  * 1:Enable diagnostic accesses of ECC codes
2915  */
2916 #define CSR_MCACHE_CTL_IC_RWECC_MASK (0x40U)
2917 #define CSR_MCACHE_CTL_IC_RWECC_SHIFT (6U)
2918 #define CSR_MCACHE_CTL_IC_RWECC_SET(x) (((uint32_t)(x) << CSR_MCACHE_CTL_IC_RWECC_SHIFT) & CSR_MCACHE_CTL_IC_RWECC_MASK)
2919 #define CSR_MCACHE_CTL_IC_RWECC_GET(x) (((uint32_t)(x) & CSR_MCACHE_CTL_IC_RWECC_MASK) >> CSR_MCACHE_CTL_IC_RWECC_SHIFT)
2920 
2921 /*
2922  * DC_ECCEN (RW)
2923  *
2924  * Parity/ECC error checking enable control for the
2925  * data cache.
2926  * 0:Disable parity/ECC
2927  * 1:Reserved
2928  * 2:Generate exceptions only on uncorrectable parity/ECC errors
2929  * 3:Generate exceptions on any type of parity/ECC errors
2930  */
2931 #define CSR_MCACHE_CTL_DC_ECCEN_MASK (0x30U)
2932 #define CSR_MCACHE_CTL_DC_ECCEN_SHIFT (4U)
2933 #define CSR_MCACHE_CTL_DC_ECCEN_SET(x) (((uint32_t)(x) << CSR_MCACHE_CTL_DC_ECCEN_SHIFT) & CSR_MCACHE_CTL_DC_ECCEN_MASK)
2934 #define CSR_MCACHE_CTL_DC_ECCEN_GET(x) (((uint32_t)(x) & CSR_MCACHE_CTL_DC_ECCEN_MASK) >> CSR_MCACHE_CTL_DC_ECCEN_SHIFT)
2935 
2936 /*
2937  * IC_ECCEN (RW)
2938  *
2939  * Parity/ECC error checking enable control for the
2940  * instruction cache
2941  * 0:Disable parity/ECC
2942  * 1:Reserved
2943  * 2:Generate exceptions only on uncorrectable parity/ECC errors
2944  * 3:Generate exceptions on any type of parity/ECC errors
2945  */
2946 #define CSR_MCACHE_CTL_IC_ECCEN_MASK (0xCU)
2947 #define CSR_MCACHE_CTL_IC_ECCEN_SHIFT (2U)
2948 #define CSR_MCACHE_CTL_IC_ECCEN_SET(x) (((uint32_t)(x) << CSR_MCACHE_CTL_IC_ECCEN_SHIFT) & CSR_MCACHE_CTL_IC_ECCEN_MASK)
2949 #define CSR_MCACHE_CTL_IC_ECCEN_GET(x) (((uint32_t)(x) & CSR_MCACHE_CTL_IC_ECCEN_MASK) >> CSR_MCACHE_CTL_IC_ECCEN_SHIFT)
2950 
2951 /*
2952  * DC_EN (RW)
2953  *
2954  * Controls if the data cache is enabled or not.
2955  * 0:D-Cache is disabled
2956  * 1:D-Cache is enabled
2957  */
2958 #define CSR_MCACHE_CTL_DC_EN_MASK (0x2U)
2959 #define CSR_MCACHE_CTL_DC_EN_SHIFT (1U)
2960 #define CSR_MCACHE_CTL_DC_EN_SET(x) (((uint32_t)(x) << CSR_MCACHE_CTL_DC_EN_SHIFT) & CSR_MCACHE_CTL_DC_EN_MASK)
2961 #define CSR_MCACHE_CTL_DC_EN_GET(x) (((uint32_t)(x) & CSR_MCACHE_CTL_DC_EN_MASK) >> CSR_MCACHE_CTL_DC_EN_SHIFT)
2962 
2963 /*
2964  * IC_EN (RW)
2965  *
2966  * Controls if the instruction cache is enabled or not.
2967  * 0:I-Cache is disabled
2968  * 1:I-Cache is enabled
2969  */
2970 #define CSR_MCACHE_CTL_IC_EN_MASK (0x1U)
2971 #define CSR_MCACHE_CTL_IC_EN_SHIFT (0U)
2972 #define CSR_MCACHE_CTL_IC_EN_SET(x) (((uint32_t)(x) << CSR_MCACHE_CTL_IC_EN_SHIFT) & CSR_MCACHE_CTL_IC_EN_MASK)
2973 #define CSR_MCACHE_CTL_IC_EN_GET(x) (((uint32_t)(x) & CSR_MCACHE_CTL_IC_EN_MASK) >> CSR_MCACHE_CTL_IC_EN_SHIFT)
2974 
2975 /* Bitfield definition for register: MCCTLBEGINADDR */
2976 /*
2977  * VA (RW)
2978  *
2979  * This register holds the address information required by CCTL operations
2980  */
2981 #define CSR_MCCTLBEGINADDR_VA_MASK (0xFFFFFFFFUL)
2982 #define CSR_MCCTLBEGINADDR_VA_SHIFT (0U)
2983 #define CSR_MCCTLBEGINADDR_VA_SET(x) (((uint32_t)(x) << CSR_MCCTLBEGINADDR_VA_SHIFT) & CSR_MCCTLBEGINADDR_VA_MASK)
2984 #define CSR_MCCTLBEGINADDR_VA_GET(x) (((uint32_t)(x) & CSR_MCCTLBEGINADDR_VA_MASK) >> CSR_MCCTLBEGINADDR_VA_SHIFT)
2985 
2986 /* Bitfield definition for register: MCCTLCOMMAND */
2987 /*
2988  * VA (RW)
2989  *
2990  * See CCTL Command Definition Table
2991  */
2992 #define CSR_MCCTLCOMMAND_VA_MASK (0x1FU)
2993 #define CSR_MCCTLCOMMAND_VA_SHIFT (0U)
2994 #define CSR_MCCTLCOMMAND_VA_SET(x) (((uint32_t)(x) << CSR_MCCTLCOMMAND_VA_SHIFT) & CSR_MCCTLCOMMAND_VA_MASK)
2995 #define CSR_MCCTLCOMMAND_VA_GET(x) (((uint32_t)(x) & CSR_MCCTLCOMMAND_VA_MASK) >> CSR_MCCTLCOMMAND_VA_SHIFT)
2996 
2997 /* Bitfield definition for register: MCCTLDATA */
2998 /*
2999  * VA (RW)
3000  *
3001  * See CCTL Commands Which Access mcctldata Table
3002  */
3003 #define CSR_MCCTLDATA_VA_MASK (0x1FU)
3004 #define CSR_MCCTLDATA_VA_SHIFT (0U)
3005 #define CSR_MCCTLDATA_VA_SET(x) (((uint32_t)(x) << CSR_MCCTLDATA_VA_SHIFT) & CSR_MCCTLDATA_VA_MASK)
3006 #define CSR_MCCTLDATA_VA_GET(x) (((uint32_t)(x) & CSR_MCCTLDATA_VA_MASK) >> CSR_MCCTLDATA_VA_SHIFT)
3007 
3008 /* Bitfield definition for register: MCOUNTERWEN */
3009 /*
3010  * HPM6 (RW)
3011  *
3012  * See register description
3013  */
3014 #define CSR_MCOUNTERWEN_HPM6_MASK (0x40U)
3015 #define CSR_MCOUNTERWEN_HPM6_SHIFT (6U)
3016 #define CSR_MCOUNTERWEN_HPM6_SET(x) (((uint32_t)(x) << CSR_MCOUNTERWEN_HPM6_SHIFT) & CSR_MCOUNTERWEN_HPM6_MASK)
3017 #define CSR_MCOUNTERWEN_HPM6_GET(x) (((uint32_t)(x) & CSR_MCOUNTERWEN_HPM6_MASK) >> CSR_MCOUNTERWEN_HPM6_SHIFT)
3018 
3019 /*
3020  * HPM5 (RW)
3021  *
3022  * See register description
3023  */
3024 #define CSR_MCOUNTERWEN_HPM5_MASK (0x20U)
3025 #define CSR_MCOUNTERWEN_HPM5_SHIFT (5U)
3026 #define CSR_MCOUNTERWEN_HPM5_SET(x) (((uint32_t)(x) << CSR_MCOUNTERWEN_HPM5_SHIFT) & CSR_MCOUNTERWEN_HPM5_MASK)
3027 #define CSR_MCOUNTERWEN_HPM5_GET(x) (((uint32_t)(x) & CSR_MCOUNTERWEN_HPM5_MASK) >> CSR_MCOUNTERWEN_HPM5_SHIFT)
3028 
3029 /*
3030  * HPM4 (RW)
3031  *
3032  * See register description
3033  */
3034 #define CSR_MCOUNTERWEN_HPM4_MASK (0x10U)
3035 #define CSR_MCOUNTERWEN_HPM4_SHIFT (4U)
3036 #define CSR_MCOUNTERWEN_HPM4_SET(x) (((uint32_t)(x) << CSR_MCOUNTERWEN_HPM4_SHIFT) & CSR_MCOUNTERWEN_HPM4_MASK)
3037 #define CSR_MCOUNTERWEN_HPM4_GET(x) (((uint32_t)(x) & CSR_MCOUNTERWEN_HPM4_MASK) >> CSR_MCOUNTERWEN_HPM4_SHIFT)
3038 
3039 /*
3040  * HPM3 (RW)
3041  *
3042  * See register description
3043  */
3044 #define CSR_MCOUNTERWEN_HPM3_MASK (0x8U)
3045 #define CSR_MCOUNTERWEN_HPM3_SHIFT (3U)
3046 #define CSR_MCOUNTERWEN_HPM3_SET(x) (((uint32_t)(x) << CSR_MCOUNTERWEN_HPM3_SHIFT) & CSR_MCOUNTERWEN_HPM3_MASK)
3047 #define CSR_MCOUNTERWEN_HPM3_GET(x) (((uint32_t)(x) & CSR_MCOUNTERWEN_HPM3_MASK) >> CSR_MCOUNTERWEN_HPM3_SHIFT)
3048 
3049 /*
3050  * IR (RW)
3051  *
3052  * See register description
3053  */
3054 #define CSR_MCOUNTERWEN_IR_MASK (0x4U)
3055 #define CSR_MCOUNTERWEN_IR_SHIFT (2U)
3056 #define CSR_MCOUNTERWEN_IR_SET(x) (((uint32_t)(x) << CSR_MCOUNTERWEN_IR_SHIFT) & CSR_MCOUNTERWEN_IR_MASK)
3057 #define CSR_MCOUNTERWEN_IR_GET(x) (((uint32_t)(x) & CSR_MCOUNTERWEN_IR_MASK) >> CSR_MCOUNTERWEN_IR_SHIFT)
3058 
3059 /*
3060  * CY (RW)
3061  *
3062  * See register description
3063  */
3064 #define CSR_MCOUNTERWEN_CY_MASK (0x1U)
3065 #define CSR_MCOUNTERWEN_CY_SHIFT (0U)
3066 #define CSR_MCOUNTERWEN_CY_SET(x) (((uint32_t)(x) << CSR_MCOUNTERWEN_CY_SHIFT) & CSR_MCOUNTERWEN_CY_MASK)
3067 #define CSR_MCOUNTERWEN_CY_GET(x) (((uint32_t)(x) & CSR_MCOUNTERWEN_CY_MASK) >> CSR_MCOUNTERWEN_CY_SHIFT)
3068 
3069 /* Bitfield definition for register: MCOUNTERINTEN */
3070 /*
3071  * HPM6 (RW)
3072  *
3073  * See register description
3074  */
3075 #define CSR_MCOUNTERINTEN_HPM6_MASK (0x40U)
3076 #define CSR_MCOUNTERINTEN_HPM6_SHIFT (6U)
3077 #define CSR_MCOUNTERINTEN_HPM6_SET(x) (((uint32_t)(x) << CSR_MCOUNTERINTEN_HPM6_SHIFT) & CSR_MCOUNTERINTEN_HPM6_MASK)
3078 #define CSR_MCOUNTERINTEN_HPM6_GET(x) (((uint32_t)(x) & CSR_MCOUNTERINTEN_HPM6_MASK) >> CSR_MCOUNTERINTEN_HPM6_SHIFT)
3079 
3080 /*
3081  * HPM5 (RW)
3082  *
3083  * See register description
3084  */
3085 #define CSR_MCOUNTERINTEN_HPM5_MASK (0x20U)
3086 #define CSR_MCOUNTERINTEN_HPM5_SHIFT (5U)
3087 #define CSR_MCOUNTERINTEN_HPM5_SET(x) (((uint32_t)(x) << CSR_MCOUNTERINTEN_HPM5_SHIFT) & CSR_MCOUNTERINTEN_HPM5_MASK)
3088 #define CSR_MCOUNTERINTEN_HPM5_GET(x) (((uint32_t)(x) & CSR_MCOUNTERINTEN_HPM5_MASK) >> CSR_MCOUNTERINTEN_HPM5_SHIFT)
3089 
3090 /*
3091  * HPM4 (RW)
3092  *
3093  * See register description
3094  */
3095 #define CSR_MCOUNTERINTEN_HPM4_MASK (0x10U)
3096 #define CSR_MCOUNTERINTEN_HPM4_SHIFT (4U)
3097 #define CSR_MCOUNTERINTEN_HPM4_SET(x) (((uint32_t)(x) << CSR_MCOUNTERINTEN_HPM4_SHIFT) & CSR_MCOUNTERINTEN_HPM4_MASK)
3098 #define CSR_MCOUNTERINTEN_HPM4_GET(x) (((uint32_t)(x) & CSR_MCOUNTERINTEN_HPM4_MASK) >> CSR_MCOUNTERINTEN_HPM4_SHIFT)
3099 
3100 /*
3101  * HPM3 (RW)
3102  *
3103  * See register description
3104  */
3105 #define CSR_MCOUNTERINTEN_HPM3_MASK (0x8U)
3106 #define CSR_MCOUNTERINTEN_HPM3_SHIFT (3U)
3107 #define CSR_MCOUNTERINTEN_HPM3_SET(x) (((uint32_t)(x) << CSR_MCOUNTERINTEN_HPM3_SHIFT) & CSR_MCOUNTERINTEN_HPM3_MASK)
3108 #define CSR_MCOUNTERINTEN_HPM3_GET(x) (((uint32_t)(x) & CSR_MCOUNTERINTEN_HPM3_MASK) >> CSR_MCOUNTERINTEN_HPM3_SHIFT)
3109 
3110 /*
3111  * IR (RW)
3112  *
3113  * See register description
3114  */
3115 #define CSR_MCOUNTERINTEN_IR_MASK (0x4U)
3116 #define CSR_MCOUNTERINTEN_IR_SHIFT (2U)
3117 #define CSR_MCOUNTERINTEN_IR_SET(x) (((uint32_t)(x) << CSR_MCOUNTERINTEN_IR_SHIFT) & CSR_MCOUNTERINTEN_IR_MASK)
3118 #define CSR_MCOUNTERINTEN_IR_GET(x) (((uint32_t)(x) & CSR_MCOUNTERINTEN_IR_MASK) >> CSR_MCOUNTERINTEN_IR_SHIFT)
3119 
3120 /*
3121  * CY (RW)
3122  *
3123  * See register description
3124  */
3125 #define CSR_MCOUNTERINTEN_CY_MASK (0x1U)
3126 #define CSR_MCOUNTERINTEN_CY_SHIFT (0U)
3127 #define CSR_MCOUNTERINTEN_CY_SET(x) (((uint32_t)(x) << CSR_MCOUNTERINTEN_CY_SHIFT) & CSR_MCOUNTERINTEN_CY_MASK)
3128 #define CSR_MCOUNTERINTEN_CY_GET(x) (((uint32_t)(x) & CSR_MCOUNTERINTEN_CY_MASK) >> CSR_MCOUNTERINTEN_CY_SHIFT)
3129 
3130 /* Bitfield definition for register: MMISC_CTL */
3131 /*
3132  * MSA_UNA (RW)
3133  *
3134  * This field controls whether the load/store instructions can access misaligned memory locations without generating Address Misaligned exceptions.
3135  * Supported instructions: LW/LH/LHU/SW/SH
3136  * 0:Misaligned accesses generate Address Misaligned exceptions.
3137  * 1:Misaligned accesses generate Address Misaligned exceptions.
3138  */
3139 #define CSR_MMISC_CTL_MSA_UNA_MASK (0x40U)
3140 #define CSR_MMISC_CTL_MSA_UNA_SHIFT (6U)
3141 #define CSR_MMISC_CTL_MSA_UNA_SET(x) (((uint32_t)(x) << CSR_MMISC_CTL_MSA_UNA_SHIFT) & CSR_MMISC_CTL_MSA_UNA_MASK)
3142 #define CSR_MMISC_CTL_MSA_UNA_GET(x) (((uint32_t)(x) & CSR_MMISC_CTL_MSA_UNA_MASK) >> CSR_MMISC_CTL_MSA_UNA_SHIFT)
3143 
3144 /*
3145  * BRPE (RW)
3146  *
3147  * Branch prediction enable bit. This bit controls all branch prediction structures.
3148  * 0:Disabled
3149  * 1:Enabled
3150  * This bit is hardwired to 0 if branch prediction structure is not supported.
3151  */
3152 #define CSR_MMISC_CTL_BRPE_MASK (0x8U)
3153 #define CSR_MMISC_CTL_BRPE_SHIFT (3U)
3154 #define CSR_MMISC_CTL_BRPE_SET(x) (((uint32_t)(x) << CSR_MMISC_CTL_BRPE_SHIFT) & CSR_MMISC_CTL_BRPE_MASK)
3155 #define CSR_MMISC_CTL_BRPE_GET(x) (((uint32_t)(x) & CSR_MMISC_CTL_BRPE_MASK) >> CSR_MMISC_CTL_BRPE_SHIFT)
3156 
3157 /*
3158  * RVCOMPM (RW)
3159  *
3160  * RISC-V compatibility mode enable bit. If the compatibility mode is turned on, all specific instructions become reserved instructions
3161  * 0:Disabled
3162  * 1:Enabled
3163  */
3164 #define CSR_MMISC_CTL_RVCOMPM_MASK (0x4U)
3165 #define CSR_MMISC_CTL_RVCOMPM_SHIFT (2U)
3166 #define CSR_MMISC_CTL_RVCOMPM_SET(x) (((uint32_t)(x) << CSR_MMISC_CTL_RVCOMPM_SHIFT) & CSR_MMISC_CTL_RVCOMPM_MASK)
3167 #define CSR_MMISC_CTL_RVCOMPM_GET(x) (((uint32_t)(x) & CSR_MMISC_CTL_RVCOMPM_MASK) >> CSR_MMISC_CTL_RVCOMPM_SHIFT)
3168 
3169 /*
3170  * VEC_PLIC (RW)
3171  *
3172  * Selects the operation mode of PLIC:
3173  * 0:Regular mode
3174  * 1:Vector mode
3175  * Please note that both this bit and the vector mode enable bit (VECTORED) of the Feature Enable Register in NCEPLIC100 should be turned on for the vectored interrupt support to work correctly. This bit is hardwired to 0 if the vectored PLIC feature is not supported.
3176  */
3177 #define CSR_MMISC_CTL_VEC_PLIC_MASK (0x2U)
3178 #define CSR_MMISC_CTL_VEC_PLIC_SHIFT (1U)
3179 #define CSR_MMISC_CTL_VEC_PLIC_SET(x) (((uint32_t)(x) << CSR_MMISC_CTL_VEC_PLIC_SHIFT) & CSR_MMISC_CTL_VEC_PLIC_MASK)
3180 #define CSR_MMISC_CTL_VEC_PLIC_GET(x) (((uint32_t)(x) & CSR_MMISC_CTL_VEC_PLIC_MASK) >> CSR_MMISC_CTL_VEC_PLIC_SHIFT)
3181 
3182 /* Bitfield definition for register: MCOUNTERMASK_M */
3183 /*
3184  * HPM6 (RW)
3185  *
3186  * See register description
3187  */
3188 #define CSR_MCOUNTERMASK_M_HPM6_MASK (0x40U)
3189 #define CSR_MCOUNTERMASK_M_HPM6_SHIFT (6U)
3190 #define CSR_MCOUNTERMASK_M_HPM6_SET(x) (((uint32_t)(x) << CSR_MCOUNTERMASK_M_HPM6_SHIFT) & CSR_MCOUNTERMASK_M_HPM6_MASK)
3191 #define CSR_MCOUNTERMASK_M_HPM6_GET(x) (((uint32_t)(x) & CSR_MCOUNTERMASK_M_HPM6_MASK) >> CSR_MCOUNTERMASK_M_HPM6_SHIFT)
3192 
3193 /*
3194  * HPM5 (RW)
3195  *
3196  * See register description
3197  */
3198 #define CSR_MCOUNTERMASK_M_HPM5_MASK (0x20U)
3199 #define CSR_MCOUNTERMASK_M_HPM5_SHIFT (5U)
3200 #define CSR_MCOUNTERMASK_M_HPM5_SET(x) (((uint32_t)(x) << CSR_MCOUNTERMASK_M_HPM5_SHIFT) & CSR_MCOUNTERMASK_M_HPM5_MASK)
3201 #define CSR_MCOUNTERMASK_M_HPM5_GET(x) (((uint32_t)(x) & CSR_MCOUNTERMASK_M_HPM5_MASK) >> CSR_MCOUNTERMASK_M_HPM5_SHIFT)
3202 
3203 /*
3204  * HPM4 (RW)
3205  *
3206  * See register description
3207  */
3208 #define CSR_MCOUNTERMASK_M_HPM4_MASK (0x10U)
3209 #define CSR_MCOUNTERMASK_M_HPM4_SHIFT (4U)
3210 #define CSR_MCOUNTERMASK_M_HPM4_SET(x) (((uint32_t)(x) << CSR_MCOUNTERMASK_M_HPM4_SHIFT) & CSR_MCOUNTERMASK_M_HPM4_MASK)
3211 #define CSR_MCOUNTERMASK_M_HPM4_GET(x) (((uint32_t)(x) & CSR_MCOUNTERMASK_M_HPM4_MASK) >> CSR_MCOUNTERMASK_M_HPM4_SHIFT)
3212 
3213 /*
3214  * HPM3 (RW)
3215  *
3216  * See register description
3217  */
3218 #define CSR_MCOUNTERMASK_M_HPM3_MASK (0x8U)
3219 #define CSR_MCOUNTERMASK_M_HPM3_SHIFT (3U)
3220 #define CSR_MCOUNTERMASK_M_HPM3_SET(x) (((uint32_t)(x) << CSR_MCOUNTERMASK_M_HPM3_SHIFT) & CSR_MCOUNTERMASK_M_HPM3_MASK)
3221 #define CSR_MCOUNTERMASK_M_HPM3_GET(x) (((uint32_t)(x) & CSR_MCOUNTERMASK_M_HPM3_MASK) >> CSR_MCOUNTERMASK_M_HPM3_SHIFT)
3222 
3223 /*
3224  * IR (RW)
3225  *
3226  * See register description
3227  */
3228 #define CSR_MCOUNTERMASK_M_IR_MASK (0x4U)
3229 #define CSR_MCOUNTERMASK_M_IR_SHIFT (2U)
3230 #define CSR_MCOUNTERMASK_M_IR_SET(x) (((uint32_t)(x) << CSR_MCOUNTERMASK_M_IR_SHIFT) & CSR_MCOUNTERMASK_M_IR_MASK)
3231 #define CSR_MCOUNTERMASK_M_IR_GET(x) (((uint32_t)(x) & CSR_MCOUNTERMASK_M_IR_MASK) >> CSR_MCOUNTERMASK_M_IR_SHIFT)
3232 
3233 /*
3234  * CY (RW)
3235  *
3236  * See register description
3237  */
3238 #define CSR_MCOUNTERMASK_M_CY_MASK (0x1U)
3239 #define CSR_MCOUNTERMASK_M_CY_SHIFT (0U)
3240 #define CSR_MCOUNTERMASK_M_CY_SET(x) (((uint32_t)(x) << CSR_MCOUNTERMASK_M_CY_SHIFT) & CSR_MCOUNTERMASK_M_CY_MASK)
3241 #define CSR_MCOUNTERMASK_M_CY_GET(x) (((uint32_t)(x) & CSR_MCOUNTERMASK_M_CY_MASK) >> CSR_MCOUNTERMASK_M_CY_SHIFT)
3242 
3243 /* Bitfield definition for register: MCOUNTERMASK_S */
3244 /*
3245  * HPM6 (RW)
3246  *
3247  * See register description
3248  */
3249 #define CSR_MCOUNTERMASK_S_HPM6_MASK (0x40U)
3250 #define CSR_MCOUNTERMASK_S_HPM6_SHIFT (6U)
3251 #define CSR_MCOUNTERMASK_S_HPM6_SET(x) (((uint32_t)(x) << CSR_MCOUNTERMASK_S_HPM6_SHIFT) & CSR_MCOUNTERMASK_S_HPM6_MASK)
3252 #define CSR_MCOUNTERMASK_S_HPM6_GET(x) (((uint32_t)(x) & CSR_MCOUNTERMASK_S_HPM6_MASK) >> CSR_MCOUNTERMASK_S_HPM6_SHIFT)
3253 
3254 /*
3255  * HPM5 (RW)
3256  *
3257  * See register description
3258  */
3259 #define CSR_MCOUNTERMASK_S_HPM5_MASK (0x20U)
3260 #define CSR_MCOUNTERMASK_S_HPM5_SHIFT (5U)
3261 #define CSR_MCOUNTERMASK_S_HPM5_SET(x) (((uint32_t)(x) << CSR_MCOUNTERMASK_S_HPM5_SHIFT) & CSR_MCOUNTERMASK_S_HPM5_MASK)
3262 #define CSR_MCOUNTERMASK_S_HPM5_GET(x) (((uint32_t)(x) & CSR_MCOUNTERMASK_S_HPM5_MASK) >> CSR_MCOUNTERMASK_S_HPM5_SHIFT)
3263 
3264 /*
3265  * HPM4 (RW)
3266  *
3267  * See register description
3268  */
3269 #define CSR_MCOUNTERMASK_S_HPM4_MASK (0x10U)
3270 #define CSR_MCOUNTERMASK_S_HPM4_SHIFT (4U)
3271 #define CSR_MCOUNTERMASK_S_HPM4_SET(x) (((uint32_t)(x) << CSR_MCOUNTERMASK_S_HPM4_SHIFT) & CSR_MCOUNTERMASK_S_HPM4_MASK)
3272 #define CSR_MCOUNTERMASK_S_HPM4_GET(x) (((uint32_t)(x) & CSR_MCOUNTERMASK_S_HPM4_MASK) >> CSR_MCOUNTERMASK_S_HPM4_SHIFT)
3273 
3274 /*
3275  * HPM3 (RW)
3276  *
3277  * See register description
3278  */
3279 #define CSR_MCOUNTERMASK_S_HPM3_MASK (0x8U)
3280 #define CSR_MCOUNTERMASK_S_HPM3_SHIFT (3U)
3281 #define CSR_MCOUNTERMASK_S_HPM3_SET(x) (((uint32_t)(x) << CSR_MCOUNTERMASK_S_HPM3_SHIFT) & CSR_MCOUNTERMASK_S_HPM3_MASK)
3282 #define CSR_MCOUNTERMASK_S_HPM3_GET(x) (((uint32_t)(x) & CSR_MCOUNTERMASK_S_HPM3_MASK) >> CSR_MCOUNTERMASK_S_HPM3_SHIFT)
3283 
3284 /*
3285  * IR (RW)
3286  *
3287  * See register description
3288  */
3289 #define CSR_MCOUNTERMASK_S_IR_MASK (0x4U)
3290 #define CSR_MCOUNTERMASK_S_IR_SHIFT (2U)
3291 #define CSR_MCOUNTERMASK_S_IR_SET(x) (((uint32_t)(x) << CSR_MCOUNTERMASK_S_IR_SHIFT) & CSR_MCOUNTERMASK_S_IR_MASK)
3292 #define CSR_MCOUNTERMASK_S_IR_GET(x) (((uint32_t)(x) & CSR_MCOUNTERMASK_S_IR_MASK) >> CSR_MCOUNTERMASK_S_IR_SHIFT)
3293 
3294 /*
3295  * CY (RW)
3296  *
3297  * See register description
3298  */
3299 #define CSR_MCOUNTERMASK_S_CY_MASK (0x1U)
3300 #define CSR_MCOUNTERMASK_S_CY_SHIFT (0U)
3301 #define CSR_MCOUNTERMASK_S_CY_SET(x) (((uint32_t)(x) << CSR_MCOUNTERMASK_S_CY_SHIFT) & CSR_MCOUNTERMASK_S_CY_MASK)
3302 #define CSR_MCOUNTERMASK_S_CY_GET(x) (((uint32_t)(x) & CSR_MCOUNTERMASK_S_CY_MASK) >> CSR_MCOUNTERMASK_S_CY_SHIFT)
3303 
3304 /* Bitfield definition for register: MCOUNTERMASK_U */
3305 /*
3306  * HPM6 (RW)
3307  *
3308  * See register description
3309  */
3310 #define CSR_MCOUNTERMASK_U_HPM6_MASK (0x40U)
3311 #define CSR_MCOUNTERMASK_U_HPM6_SHIFT (6U)
3312 #define CSR_MCOUNTERMASK_U_HPM6_SET(x) (((uint32_t)(x) << CSR_MCOUNTERMASK_U_HPM6_SHIFT) & CSR_MCOUNTERMASK_U_HPM6_MASK)
3313 #define CSR_MCOUNTERMASK_U_HPM6_GET(x) (((uint32_t)(x) & CSR_MCOUNTERMASK_U_HPM6_MASK) >> CSR_MCOUNTERMASK_U_HPM6_SHIFT)
3314 
3315 /*
3316  * HPM5 (RW)
3317  *
3318  * See register description
3319  */
3320 #define CSR_MCOUNTERMASK_U_HPM5_MASK (0x20U)
3321 #define CSR_MCOUNTERMASK_U_HPM5_SHIFT (5U)
3322 #define CSR_MCOUNTERMASK_U_HPM5_SET(x) (((uint32_t)(x) << CSR_MCOUNTERMASK_U_HPM5_SHIFT) & CSR_MCOUNTERMASK_U_HPM5_MASK)
3323 #define CSR_MCOUNTERMASK_U_HPM5_GET(x) (((uint32_t)(x) & CSR_MCOUNTERMASK_U_HPM5_MASK) >> CSR_MCOUNTERMASK_U_HPM5_SHIFT)
3324 
3325 /*
3326  * HPM4 (RW)
3327  *
3328  * See register description
3329  */
3330 #define CSR_MCOUNTERMASK_U_HPM4_MASK (0x10U)
3331 #define CSR_MCOUNTERMASK_U_HPM4_SHIFT (4U)
3332 #define CSR_MCOUNTERMASK_U_HPM4_SET(x) (((uint32_t)(x) << CSR_MCOUNTERMASK_U_HPM4_SHIFT) & CSR_MCOUNTERMASK_U_HPM4_MASK)
3333 #define CSR_MCOUNTERMASK_U_HPM4_GET(x) (((uint32_t)(x) & CSR_MCOUNTERMASK_U_HPM4_MASK) >> CSR_MCOUNTERMASK_U_HPM4_SHIFT)
3334 
3335 /*
3336  * HPM3 (RW)
3337  *
3338  * See register description
3339  */
3340 #define CSR_MCOUNTERMASK_U_HPM3_MASK (0x8U)
3341 #define CSR_MCOUNTERMASK_U_HPM3_SHIFT (3U)
3342 #define CSR_MCOUNTERMASK_U_HPM3_SET(x) (((uint32_t)(x) << CSR_MCOUNTERMASK_U_HPM3_SHIFT) & CSR_MCOUNTERMASK_U_HPM3_MASK)
3343 #define CSR_MCOUNTERMASK_U_HPM3_GET(x) (((uint32_t)(x) & CSR_MCOUNTERMASK_U_HPM3_MASK) >> CSR_MCOUNTERMASK_U_HPM3_SHIFT)
3344 
3345 /*
3346  * IR (RW)
3347  *
3348  * See register description
3349  */
3350 #define CSR_MCOUNTERMASK_U_IR_MASK (0x4U)
3351 #define CSR_MCOUNTERMASK_U_IR_SHIFT (2U)
3352 #define CSR_MCOUNTERMASK_U_IR_SET(x) (((uint32_t)(x) << CSR_MCOUNTERMASK_U_IR_SHIFT) & CSR_MCOUNTERMASK_U_IR_MASK)
3353 #define CSR_MCOUNTERMASK_U_IR_GET(x) (((uint32_t)(x) & CSR_MCOUNTERMASK_U_IR_MASK) >> CSR_MCOUNTERMASK_U_IR_SHIFT)
3354 
3355 /*
3356  * CY (RW)
3357  *
3358  * See register description
3359  */
3360 #define CSR_MCOUNTERMASK_U_CY_MASK (0x1U)
3361 #define CSR_MCOUNTERMASK_U_CY_SHIFT (0U)
3362 #define CSR_MCOUNTERMASK_U_CY_SET(x) (((uint32_t)(x) << CSR_MCOUNTERMASK_U_CY_SHIFT) & CSR_MCOUNTERMASK_U_CY_MASK)
3363 #define CSR_MCOUNTERMASK_U_CY_GET(x) (((uint32_t)(x) & CSR_MCOUNTERMASK_U_CY_MASK) >> CSR_MCOUNTERMASK_U_CY_SHIFT)
3364 
3365 /* Bitfield definition for register: MCOUNTEROVF */
3366 /*
3367  * HPM6 (RW)
3368  *
3369  * See register description
3370  */
3371 #define CSR_MCOUNTEROVF_HPM6_MASK (0x40U)
3372 #define CSR_MCOUNTEROVF_HPM6_SHIFT (6U)
3373 #define CSR_MCOUNTEROVF_HPM6_SET(x) (((uint32_t)(x) << CSR_MCOUNTEROVF_HPM6_SHIFT) & CSR_MCOUNTEROVF_HPM6_MASK)
3374 #define CSR_MCOUNTEROVF_HPM6_GET(x) (((uint32_t)(x) & CSR_MCOUNTEROVF_HPM6_MASK) >> CSR_MCOUNTEROVF_HPM6_SHIFT)
3375 
3376 /*
3377  * HPM5 (RW)
3378  *
3379  * See register description
3380  */
3381 #define CSR_MCOUNTEROVF_HPM5_MASK (0x20U)
3382 #define CSR_MCOUNTEROVF_HPM5_SHIFT (5U)
3383 #define CSR_MCOUNTEROVF_HPM5_SET(x) (((uint32_t)(x) << CSR_MCOUNTEROVF_HPM5_SHIFT) & CSR_MCOUNTEROVF_HPM5_MASK)
3384 #define CSR_MCOUNTEROVF_HPM5_GET(x) (((uint32_t)(x) & CSR_MCOUNTEROVF_HPM5_MASK) >> CSR_MCOUNTEROVF_HPM5_SHIFT)
3385 
3386 /*
3387  * HPM4 (RW)
3388  *
3389  * See register description
3390  */
3391 #define CSR_MCOUNTEROVF_HPM4_MASK (0x10U)
3392 #define CSR_MCOUNTEROVF_HPM4_SHIFT (4U)
3393 #define CSR_MCOUNTEROVF_HPM4_SET(x) (((uint32_t)(x) << CSR_MCOUNTEROVF_HPM4_SHIFT) & CSR_MCOUNTEROVF_HPM4_MASK)
3394 #define CSR_MCOUNTEROVF_HPM4_GET(x) (((uint32_t)(x) & CSR_MCOUNTEROVF_HPM4_MASK) >> CSR_MCOUNTEROVF_HPM4_SHIFT)
3395 
3396 /*
3397  * HPM3 (RW)
3398  *
3399  * See register description
3400  */
3401 #define CSR_MCOUNTEROVF_HPM3_MASK (0x8U)
3402 #define CSR_MCOUNTEROVF_HPM3_SHIFT (3U)
3403 #define CSR_MCOUNTEROVF_HPM3_SET(x) (((uint32_t)(x) << CSR_MCOUNTEROVF_HPM3_SHIFT) & CSR_MCOUNTEROVF_HPM3_MASK)
3404 #define CSR_MCOUNTEROVF_HPM3_GET(x) (((uint32_t)(x) & CSR_MCOUNTEROVF_HPM3_MASK) >> CSR_MCOUNTEROVF_HPM3_SHIFT)
3405 
3406 /*
3407  * IR (RW)
3408  *
3409  * See register description
3410  */
3411 #define CSR_MCOUNTEROVF_IR_MASK (0x4U)
3412 #define CSR_MCOUNTEROVF_IR_SHIFT (2U)
3413 #define CSR_MCOUNTEROVF_IR_SET(x) (((uint32_t)(x) << CSR_MCOUNTEROVF_IR_SHIFT) & CSR_MCOUNTEROVF_IR_MASK)
3414 #define CSR_MCOUNTEROVF_IR_GET(x) (((uint32_t)(x) & CSR_MCOUNTEROVF_IR_MASK) >> CSR_MCOUNTEROVF_IR_SHIFT)
3415 
3416 /*
3417  * CY (RW)
3418  *
3419  * See register description
3420  */
3421 #define CSR_MCOUNTEROVF_CY_MASK (0x1U)
3422 #define CSR_MCOUNTEROVF_CY_SHIFT (0U)
3423 #define CSR_MCOUNTEROVF_CY_SET(x) (((uint32_t)(x) << CSR_MCOUNTEROVF_CY_SHIFT) & CSR_MCOUNTEROVF_CY_MASK)
3424 #define CSR_MCOUNTEROVF_CY_GET(x) (((uint32_t)(x) & CSR_MCOUNTEROVF_CY_MASK) >> CSR_MCOUNTEROVF_CY_SHIFT)
3425 
3426 /* Bitfield definition for register: DEXC2DBG */
3427 /*
3428  * PMOV (RW)
3429  *
3430  * Indicates whether performance counter overflow interrupts are redirected to enter Debug Mode
3431  * 0:Do not redirect
3432  * 1:Redirect
3433  */
3434 #define CSR_DEXC2DBG_PMOV_MASK (0x80000UL)
3435 #define CSR_DEXC2DBG_PMOV_SHIFT (19U)
3436 #define CSR_DEXC2DBG_PMOV_SET(x) (((uint32_t)(x) << CSR_DEXC2DBG_PMOV_SHIFT) & CSR_DEXC2DBG_PMOV_MASK)
3437 #define CSR_DEXC2DBG_PMOV_GET(x) (((uint32_t)(x) & CSR_DEXC2DBG_PMOV_MASK) >> CSR_DEXC2DBG_PMOV_SHIFT)
3438 
3439 /*
3440  * BWE (RW)
3441  *
3442  * Indicates whether Bus-write Transaction Error local interrupts are redirected to enter Debug Mode
3443  * 0:Do not redirect
3444  * 1:Redirect
3445  */
3446 #define CSR_DEXC2DBG_BWE_MASK (0x8000U)
3447 #define CSR_DEXC2DBG_BWE_SHIFT (15U)
3448 #define CSR_DEXC2DBG_BWE_SET(x) (((uint32_t)(x) << CSR_DEXC2DBG_BWE_SHIFT) & CSR_DEXC2DBG_BWE_MASK)
3449 #define CSR_DEXC2DBG_BWE_GET(x) (((uint32_t)(x) & CSR_DEXC2DBG_BWE_MASK) >> CSR_DEXC2DBG_BWE_SHIFT)
3450 
3451 /*
3452  * SLPECC (RW)
3453  *
3454  * Indicates whether local memory slave port ECC Error local interrupts are redirected to enter Debug Mode
3455  * 0:Do not redirect
3456  * 1:Redirect
3457  */
3458 #define CSR_DEXC2DBG_SLPECC_MASK (0x4000U)
3459 #define CSR_DEXC2DBG_SLPECC_SHIFT (14U)
3460 #define CSR_DEXC2DBG_SLPECC_SET(x) (((uint32_t)(x) << CSR_DEXC2DBG_SLPECC_SHIFT) & CSR_DEXC2DBG_SLPECC_MASK)
3461 #define CSR_DEXC2DBG_SLPECC_GET(x) (((uint32_t)(x) & CSR_DEXC2DBG_SLPECC_MASK) >> CSR_DEXC2DBG_SLPECC_SHIFT)
3462 
3463 /*
3464  * ACE (RW)
3465  *
3466  * Indicates whether ACE-related exceptions are redirected to enter Debug Mode. This bit is present only when mmsc_cfg.ACE is set
3467  * 0:Do not redirect
3468  * 1:Redirect
3469  */
3470 #define CSR_DEXC2DBG_ACE_MASK (0x2000U)
3471 #define CSR_DEXC2DBG_ACE_SHIFT (13U)
3472 #define CSR_DEXC2DBG_ACE_SET(x) (((uint32_t)(x) << CSR_DEXC2DBG_ACE_SHIFT) & CSR_DEXC2DBG_ACE_MASK)
3473 #define CSR_DEXC2DBG_ACE_GET(x) (((uint32_t)(x) & CSR_DEXC2DBG_ACE_MASK) >> CSR_DEXC2DBG_ACE_SHIFT)
3474 
3475 /*
3476  * HSP (RW)
3477  *
3478  * Indicates whether Stack Protection exceptions are redirected to enter Debug Mode. This bit is present only when mmsc_cfg.HSP is set.
3479  * 0:Do not redirect
3480  * 1:Redirect
3481  */
3482 #define CSR_DEXC2DBG_HSP_MASK (0x1000U)
3483 #define CSR_DEXC2DBG_HSP_SHIFT (12U)
3484 #define CSR_DEXC2DBG_HSP_SET(x) (((uint32_t)(x) << CSR_DEXC2DBG_HSP_SHIFT) & CSR_DEXC2DBG_HSP_MASK)
3485 #define CSR_DEXC2DBG_HSP_GET(x) (((uint32_t)(x) & CSR_DEXC2DBG_HSP_MASK) >> CSR_DEXC2DBG_HSP_SHIFT)
3486 
3487 /*
3488  * MEC (RW)
3489  *
3490  * Indicates whether M-mode Environment Call exceptions are redirected to enter Debug Mode
3491  * 0:Do not redirect
3492  * 1:Redirect
3493  */
3494 #define CSR_DEXC2DBG_MEC_MASK (0x800U)
3495 #define CSR_DEXC2DBG_MEC_SHIFT (11U)
3496 #define CSR_DEXC2DBG_MEC_SET(x) (((uint32_t)(x) << CSR_DEXC2DBG_MEC_SHIFT) & CSR_DEXC2DBG_MEC_MASK)
3497 #define CSR_DEXC2DBG_MEC_GET(x) (((uint32_t)(x) & CSR_DEXC2DBG_MEC_MASK) >> CSR_DEXC2DBG_MEC_SHIFT)
3498 
3499 /*
3500  * UEC (RW)
3501  *
3502  * Indicates whether U-mode Environment Call exceptions are redirected to enter Debug Mode.
3503  * 0:Do not redirect
3504  * 1:Redirect
3505  */
3506 #define CSR_DEXC2DBG_UEC_MASK (0x100U)
3507 #define CSR_DEXC2DBG_UEC_SHIFT (8U)
3508 #define CSR_DEXC2DBG_UEC_SET(x) (((uint32_t)(x) << CSR_DEXC2DBG_UEC_SHIFT) & CSR_DEXC2DBG_UEC_MASK)
3509 #define CSR_DEXC2DBG_UEC_GET(x) (((uint32_t)(x) & CSR_DEXC2DBG_UEC_MASK) >> CSR_DEXC2DBG_UEC_SHIFT)
3510 
3511 /*
3512  * SAF (RW)
3513  *
3514  * Indicates whether Store Access Fault exceptions are redirected to enter Debug Mode.
3515  * 0:Do not redirect
3516  * 1:Redirect
3517  */
3518 #define CSR_DEXC2DBG_SAF_MASK (0x80U)
3519 #define CSR_DEXC2DBG_SAF_SHIFT (7U)
3520 #define CSR_DEXC2DBG_SAF_SET(x) (((uint32_t)(x) << CSR_DEXC2DBG_SAF_SHIFT) & CSR_DEXC2DBG_SAF_MASK)
3521 #define CSR_DEXC2DBG_SAF_GET(x) (((uint32_t)(x) & CSR_DEXC2DBG_SAF_MASK) >> CSR_DEXC2DBG_SAF_SHIFT)
3522 
3523 /*
3524  * SAM (RW)
3525  *
3526  * Indicates whether Store Access Misaligned exceptions are redirected to enter Debug Mode.
3527  * 0:Do not redirect
3528  * 1:Redirect
3529  */
3530 #define CSR_DEXC2DBG_SAM_MASK (0x40U)
3531 #define CSR_DEXC2DBG_SAM_SHIFT (6U)
3532 #define CSR_DEXC2DBG_SAM_SET(x) (((uint32_t)(x) << CSR_DEXC2DBG_SAM_SHIFT) & CSR_DEXC2DBG_SAM_MASK)
3533 #define CSR_DEXC2DBG_SAM_GET(x) (((uint32_t)(x) & CSR_DEXC2DBG_SAM_MASK) >> CSR_DEXC2DBG_SAM_SHIFT)
3534 
3535 /*
3536  * LAF (RW)
3537  *
3538  * Indicates whether Load Access Fault exceptions are redirected to enter Debug Mode.
3539  * 0:Do not redirect
3540  * 1:Redirect
3541  */
3542 #define CSR_DEXC2DBG_LAF_MASK (0x20U)
3543 #define CSR_DEXC2DBG_LAF_SHIFT (5U)
3544 #define CSR_DEXC2DBG_LAF_SET(x) (((uint32_t)(x) << CSR_DEXC2DBG_LAF_SHIFT) & CSR_DEXC2DBG_LAF_MASK)
3545 #define CSR_DEXC2DBG_LAF_GET(x) (((uint32_t)(x) & CSR_DEXC2DBG_LAF_MASK) >> CSR_DEXC2DBG_LAF_SHIFT)
3546 
3547 /*
3548  * LAM (RW)
3549  *
3550  * Indicates whether Load Access Misaligned exceptions are redirected to enter Debug Mode
3551  * 0:Do not redirect
3552  * 1:Redirect
3553  */
3554 #define CSR_DEXC2DBG_LAM_MASK (0x10U)
3555 #define CSR_DEXC2DBG_LAM_SHIFT (4U)
3556 #define CSR_DEXC2DBG_LAM_SET(x) (((uint32_t)(x) << CSR_DEXC2DBG_LAM_SHIFT) & CSR_DEXC2DBG_LAM_MASK)
3557 #define CSR_DEXC2DBG_LAM_GET(x) (((uint32_t)(x) & CSR_DEXC2DBG_LAM_MASK) >> CSR_DEXC2DBG_LAM_SHIFT)
3558 
3559 /*
3560  * NMI (RW)
3561  *
3562  * Indicates whether Non-Maskable Interrupt
3563  * 0:Do not redirect
3564  * 1:Redirect
3565  */
3566 #define CSR_DEXC2DBG_NMI_MASK (0x8U)
3567 #define CSR_DEXC2DBG_NMI_SHIFT (3U)
3568 #define CSR_DEXC2DBG_NMI_SET(x) (((uint32_t)(x) << CSR_DEXC2DBG_NMI_SHIFT) & CSR_DEXC2DBG_NMI_MASK)
3569 #define CSR_DEXC2DBG_NMI_GET(x) (((uint32_t)(x) & CSR_DEXC2DBG_NMI_MASK) >> CSR_DEXC2DBG_NMI_SHIFT)
3570 
3571 /*
3572  * II (RW)
3573  *
3574  * Indicates whether Illegal Instruction exceptions are redirected to enter Debug Mode.
3575  * 0:Do not redirect
3576  * 1:Redirect
3577  */
3578 #define CSR_DEXC2DBG_II_MASK (0x4U)
3579 #define CSR_DEXC2DBG_II_SHIFT (2U)
3580 #define CSR_DEXC2DBG_II_SET(x) (((uint32_t)(x) << CSR_DEXC2DBG_II_SHIFT) & CSR_DEXC2DBG_II_MASK)
3581 #define CSR_DEXC2DBG_II_GET(x) (((uint32_t)(x) & CSR_DEXC2DBG_II_MASK) >> CSR_DEXC2DBG_II_SHIFT)
3582 
3583 /*
3584  * IAF (RW)
3585  *
3586  * Indicates whether Instruction Access Fault exceptions are redirected to enter Debug Mode
3587  * 0:Do not redirect
3588  * 1:Redirect
3589  */
3590 #define CSR_DEXC2DBG_IAF_MASK (0x2U)
3591 #define CSR_DEXC2DBG_IAF_SHIFT (1U)
3592 #define CSR_DEXC2DBG_IAF_SET(x) (((uint32_t)(x) << CSR_DEXC2DBG_IAF_SHIFT) & CSR_DEXC2DBG_IAF_MASK)
3593 #define CSR_DEXC2DBG_IAF_GET(x) (((uint32_t)(x) & CSR_DEXC2DBG_IAF_MASK) >> CSR_DEXC2DBG_IAF_SHIFT)
3594 
3595 /*
3596  * IAM (RW)
3597  *
3598  * Indicates whether Instruction Access Misaligned exceptions are redirected to enter Debug Mode.
3599  * 0:Do not redirect
3600  * 1:Redirect
3601  */
3602 #define CSR_DEXC2DBG_IAM_MASK (0x1U)
3603 #define CSR_DEXC2DBG_IAM_SHIFT (0U)
3604 #define CSR_DEXC2DBG_IAM_SET(x) (((uint32_t)(x) << CSR_DEXC2DBG_IAM_SHIFT) & CSR_DEXC2DBG_IAM_MASK)
3605 #define CSR_DEXC2DBG_IAM_GET(x) (((uint32_t)(x) & CSR_DEXC2DBG_IAM_MASK) >> CSR_DEXC2DBG_IAM_SHIFT)
3606 
3607 /* Bitfield definition for register: DDCAUSE */
3608 /*
3609  * SUBTYPE (RO)
3610  *
3611  * Subtypes for main type.
3612  * The table below lists the subtypes for DCSR.CAUSE==1 and DDCAUSE.MAINTYPE==3.
3613  * 0:Illegal instruction
3614  * 1:Privileged instruction
3615  * 2:Non-existent CSR
3616  * 3:Privilege CSR access
3617  * 4:Read-only CSR update
3618  */
3619 #define CSR_DDCAUSE_SUBTYPE_MASK (0xFF00U)
3620 #define CSR_DDCAUSE_SUBTYPE_SHIFT (8U)
3621 #define CSR_DDCAUSE_SUBTYPE_GET(x) (((uint32_t)(x) & CSR_DDCAUSE_SUBTYPE_MASK) >> CSR_DDCAUSE_SUBTYPE_SHIFT)
3622 
3623 /*
3624  * MAINTYPE (RO)
3625  *
3626  * Cause for redirection to Debug Mode.
3627  * 0:Software Breakpoint (EBREAK)
3628  * 1:Instruction Access Misaligned (IAM)
3629  * 2:Instruction Access Fault (IAF)
3630  * 3:Illegal Instruction (II)
3631  * 4:Non-Maskable Interrupt (NMI)
3632  * 5:Load Access Misaligned (LAM)
3633  * 6:Load Access Fault (LAF)
3634  * 7:Store Access Misaligned (SAM)
3635  * 8:Store Access Fault (SAF)
3636  * 9:U-mode Environment Call (UEC)
3637  * 10:S-mode Environment Call (SEC)
3638  * 11:Instruction page fault
3639  * 12:M-mode Environment Call (MEC)
3640  * 13:Load page fault
3641  * 14:Reserved
3642  * 15:Store/AMO page fault
3643  * 16:Imprecise ECC error
3644  * 17;Bus write transaction error
3645  * 18:Performance Counter overflow
3646  * 19–31:Reserved
3647  * 32:Stack overflow exception
3648  * 33:Stack underflow exception
3649  * 34:ACE disabled exception
3650  * 35–39:Reserved
3651  * 40–47:ACE exception
3652  * ≥48:Reserved
3653  */
3654 #define CSR_DDCAUSE_MAINTYPE_MASK (0xFFU)
3655 #define CSR_DDCAUSE_MAINTYPE_SHIFT (0U)
3656 #define CSR_DDCAUSE_MAINTYPE_GET(x) (((uint32_t)(x) & CSR_DDCAUSE_MAINTYPE_MASK) >> CSR_DDCAUSE_MAINTYPE_SHIFT)
3657 
3658 /* Bitfield definition for register: UITB */
3659 /*
3660  * ADDR (RW)
3661  *
3662  * The base address of the CoDense instruction table. This field is reserved if uitb.HW == 1.
3663  */
3664 #define CSR_UITB_ADDR_MASK (0xFFFFFFFCUL)
3665 #define CSR_UITB_ADDR_SHIFT (2U)
3666 #define CSR_UITB_ADDR_SET(x) (((uint32_t)(x) << CSR_UITB_ADDR_SHIFT) & CSR_UITB_ADDR_MASK)
3667 #define CSR_UITB_ADDR_GET(x) (((uint32_t)(x) & CSR_UITB_ADDR_MASK) >> CSR_UITB_ADDR_SHIFT)
3668 
3669 /*
3670  * HW (RO)
3671  *
3672  * This bit specifies if the CoDense instruction table is hardwired.
3673  * 0:The instruction table is located in memory. uitb.ADDR should be initialized to point to the table before using the CoDense instructions.
3674  * 1:The instruction table is hardwired. Initialization of uitb.ADDR is not needed before using the CoDense instructions.
3675  */
3676 #define CSR_UITB_HW_MASK (0x1U)
3677 #define CSR_UITB_HW_SHIFT (0U)
3678 #define CSR_UITB_HW_GET(x) (((uint32_t)(x) & CSR_UITB_HW_MASK) >> CSR_UITB_HW_SHIFT)
3679 
3680 /* Bitfield definition for register: UCODE */
3681 /*
3682  * OV (RW)
3683  *
3684  * Overflow flag. It will be set by DSP instructions with a saturated result.
3685  * 0:A saturated result is not generated
3686  * 1:A saturated result is generated
3687  */
3688 #define CSR_UCODE_OV_MASK (0x1U)
3689 #define CSR_UCODE_OV_SHIFT (0U)
3690 #define CSR_UCODE_OV_SET(x) (((uint32_t)(x) << CSR_UCODE_OV_SHIFT) & CSR_UCODE_OV_MASK)
3691 #define CSR_UCODE_OV_GET(x) (((uint32_t)(x) & CSR_UCODE_OV_MASK) >> CSR_UCODE_OV_SHIFT)
3692 
3693 /* Bitfield definition for register: UDCAUSE */
3694 /*
3695  * UDCAUSE (RW)
3696  *
3697  * This register further disambiguates causes of traps recorded in the ucause register. See the list below for details.
3698  * The value of UDCAUSE for precise exception:
3699  * When ucause == 1 (Instruction access fault)
3700  * 0:Reserved
3701  * 1:ECC/Parity error
3702  * 2:PMP instruction access violation
3703  * 3:Bus error
3704  * 4:PMA empty hole access
3705  * When ucause == 2 (Illegal instruction)
3706  * 0:Please parse the utval CSR
3707  * 1:FP disabled exception
3708  * 2:ACE disabled exception
3709  * When ucause == 5 (Load access fault)
3710  * 0:Reserved
3711  * 1:ECC/Parity error
3712  * 2:PMP load access violation
3713  * 3:Bus error
3714  * 4:Misaligned address
3715  * 5:PMA empty hole access
3716  * 6:PMA attribute inconsistency
3717  * 7:PMA NAMO exception
3718  * When ucause == 7 (Store access fault)
3719  * 0:Reserved
3720  * 1:ECC/Parity error
3721  * 2:PMP store access violation
3722  * 3:Bus error
3723  * 4:Misaligned address
3724  * 5:PMA empty hole access
3725  * 6:PMA attribute inconsistency
3726  * 7:PMA NAMO exception
3727  */
3728 #define CSR_UDCAUSE_UDCAUSE_MASK (0x7U)
3729 #define CSR_UDCAUSE_UDCAUSE_SHIFT (0U)
3730 #define CSR_UDCAUSE_UDCAUSE_SET(x) (((uint32_t)(x) << CSR_UDCAUSE_UDCAUSE_SHIFT) & CSR_UDCAUSE_UDCAUSE_MASK)
3731 #define CSR_UDCAUSE_UDCAUSE_GET(x) (((uint32_t)(x) & CSR_UDCAUSE_UDCAUSE_MASK) >> CSR_UDCAUSE_UDCAUSE_SHIFT)
3732 
3733 /* Bitfield definition for register: UCCTLBEGINADDR */
3734 /*
3735  * VA (RW)
3736  *
3737  * It is an alias to the mcctlbeginaddr register and it is only accessible to Supervisor-mode and User-mode software when mcache_ctl.CCTL_SUEN is 1. Otherwise illegal instruction exceptions will be triggered.
3738  */
3739 #define CSR_UCCTLBEGINADDR_VA_MASK (0xFFFFFFFFUL)
3740 #define CSR_UCCTLBEGINADDR_VA_SHIFT (0U)
3741 #define CSR_UCCTLBEGINADDR_VA_SET(x) (((uint32_t)(x) << CSR_UCCTLBEGINADDR_VA_SHIFT) & CSR_UCCTLBEGINADDR_VA_MASK)
3742 #define CSR_UCCTLBEGINADDR_VA_GET(x) (((uint32_t)(x) & CSR_UCCTLBEGINADDR_VA_MASK) >> CSR_UCCTLBEGINADDR_VA_SHIFT)
3743 
3744 /* Bitfield definition for register: UCCTLCOMMAND */
3745 /*
3746  * VA (RW)
3747  *
3748  * See User CCTL Command Definition Table
3749  */
3750 #define CSR_UCCTLCOMMAND_VA_MASK (0x1FU)
3751 #define CSR_UCCTLCOMMAND_VA_SHIFT (0U)
3752 #define CSR_UCCTLCOMMAND_VA_SET(x) (((uint32_t)(x) << CSR_UCCTLCOMMAND_VA_SHIFT) & CSR_UCCTLCOMMAND_VA_MASK)
3753 #define CSR_UCCTLCOMMAND_VA_GET(x) (((uint32_t)(x) & CSR_UCCTLCOMMAND_VA_MASK) >> CSR_UCCTLCOMMAND_VA_SHIFT)
3754 
3755 /* Bitfield definition for register: MICM_CFG */
3756 /*
3757  * SETH (RO)
3758  *
3759  * This bit extends the ISET field.
3760  * When instruction cache is not configured, this field should be ignored.
3761  */
3762 #define CSR_MICM_CFG_SETH_MASK (0x1000000UL)
3763 #define CSR_MICM_CFG_SETH_SHIFT (24U)
3764 #define CSR_MICM_CFG_SETH_GET(x) (((uint32_t)(x) & CSR_MICM_CFG_SETH_MASK) >> CSR_MICM_CFG_SETH_SHIFT)
3765 
3766 /*
3767  * ILM_ECC (RO)
3768  *
3769  * ILM soft-error protection scheme
3770  * 0:No parity/ECC
3771  * 1:Parity
3772  * 2:ECC
3773  * 3:Reserved
3774  * ILM is not configured, this field should be ignored.
3775  */
3776 #define CSR_MICM_CFG_ILM_ECC_MASK (0x600000UL)
3777 #define CSR_MICM_CFG_ILM_ECC_SHIFT (21U)
3778 #define CSR_MICM_CFG_ILM_ECC_GET(x) (((uint32_t)(x) & CSR_MICM_CFG_ILM_ECC_MASK) >> CSR_MICM_CFG_ILM_ECC_SHIFT)
3779 
3780 /*
3781  * ILMSZ (RO)
3782  *
3783  * ILM Size
3784  * 0:0 Byte
3785  * 1:1 KiB
3786  * 2:2 KiB
3787  * 3:4 KiB
3788  * 4:8 KiB
3789  * 5:16 KiB
3790  * 6:32 KiB
3791  * 7:64 KiB
3792  * 8:128 KiB
3793  * 9:256 KiB
3794  * 10:512 KiB
3795  * 11:1 MiB
3796  * 12:2 MiB
3797  * 13:4 MiB
3798  * 14:8 MiB
3799  * 15:16 MiB
3800  * 16-31:Reserved
3801  * When ILM is not configured, this field should be ignored.
3802  */
3803 #define CSR_MICM_CFG_ILMSZ_MASK (0xF8000UL)
3804 #define CSR_MICM_CFG_ILMSZ_SHIFT (15U)
3805 #define CSR_MICM_CFG_ILMSZ_GET(x) (((uint32_t)(x) & CSR_MICM_CFG_ILMSZ_MASK) >> CSR_MICM_CFG_ILMSZ_SHIFT)
3806 
3807 /*
3808  * ILMB (RW)
3809  *
3810  * Number of ILM base registers present
3811  * 0:No ILM base register present
3812  * 1:One ILM base register present
3813  * 2-7:Reserved
3814  * When ILM is not configured, this field should be ignored.
3815  */
3816 #define CSR_MICM_CFG_ILMB_MASK (0x7000U)
3817 #define CSR_MICM_CFG_ILMB_SHIFT (12U)
3818 #define CSR_MICM_CFG_ILMB_SET(x) (((uint32_t)(x) << CSR_MICM_CFG_ILMB_SHIFT) & CSR_MICM_CFG_ILMB_MASK)
3819 #define CSR_MICM_CFG_ILMB_GET(x) (((uint32_t)(x) & CSR_MICM_CFG_ILMB_MASK) >> CSR_MICM_CFG_ILMB_SHIFT)
3820 
3821 /*
3822  * IC_ECC (RO)
3823  *
3824  * Cache soft-error protection scheme
3825  * 0:No parity/ECC
3826  * 1:Parity
3827  * 2:ECC
3828  * 3:Reserved
3829  * When instruction cache is not configured, this field should be ignored.
3830  */
3831 #define CSR_MICM_CFG_IC_ECC_MASK (0xC00U)
3832 #define CSR_MICM_CFG_IC_ECC_SHIFT (10U)
3833 #define CSR_MICM_CFG_IC_ECC_GET(x) (((uint32_t)(x) & CSR_MICM_CFG_IC_ECC_MASK) >> CSR_MICM_CFG_IC_ECC_SHIFT)
3834 
3835 /*
3836  * ILCK (RO)
3837  *
3838  * I-Cache locking support
3839  * 0:No locking support
3840  * 1:With locking support
3841  * When instruction cache is not configured, this field should be ignored.
3842  */
3843 #define CSR_MICM_CFG_ILCK_MASK (0x200U)
3844 #define CSR_MICM_CFG_ILCK_SHIFT (9U)
3845 #define CSR_MICM_CFG_ILCK_GET(x) (((uint32_t)(x) & CSR_MICM_CFG_ILCK_MASK) >> CSR_MICM_CFG_ILCK_SHIFT)
3846 
3847 /*
3848  * ISZ (RO)
3849  *
3850  * Cache block (line) size
3851  * 0:No I-Cache
3852  * 1:8 bytes
3853  * 2:16 bytes
3854  * 3:32 bytes
3855  * 4:64 bytes
3856  * 5:128 bytes
3857  * 6-7:Reserved
3858  * When instruction cache is not configured, this field should be ignored.
3859  */
3860 #define CSR_MICM_CFG_ISZ_MASK (0x1C0U)
3861 #define CSR_MICM_CFG_ISZ_SHIFT (6U)
3862 #define CSR_MICM_CFG_ISZ_GET(x) (((uint32_t)(x) & CSR_MICM_CFG_ISZ_MASK) >> CSR_MICM_CFG_ISZ_SHIFT)
3863 
3864 /*
3865  * IWAY (RO)
3866  *
3867  * Associativity of I-Cache
3868  * 0:Direct-mapped
3869  * 1:2-way
3870  * 2:3-way
3871  * 3:4-way
3872  * 4:5-way
3873  * 5:6-way
3874  * 6:7-way
3875  * 7:8-way
3876  * When instruction cache is not configured, this field should be ignored.
3877  */
3878 #define CSR_MICM_CFG_IWAY_MASK (0x38U)
3879 #define CSR_MICM_CFG_IWAY_SHIFT (3U)
3880 #define CSR_MICM_CFG_IWAY_GET(x) (((uint32_t)(x) & CSR_MICM_CFG_IWAY_MASK) >> CSR_MICM_CFG_IWAY_SHIFT)
3881 
3882 /*
3883  * ISET (RO)
3884  *
3885  * I-Cache sets (# of cache lines per way):
3886  * When micm_cfg.SETH==0:
3887  * 0:64
3888  * 1:128
3889  * 2:256
3890  * 3:512
3891  * 4:1024
3892  * 5:2048
3893  * 6:4096
3894  * 7:Reserved
3895  * When micm_cfg.SETH==1:
3896  * 0:32
3897  * 1:16
3898  * 2:8
3899  * 3-7:Reserved
3900  */
3901 #define CSR_MICM_CFG_ISET_MASK (0x7U)
3902 #define CSR_MICM_CFG_ISET_SHIFT (0U)
3903 #define CSR_MICM_CFG_ISET_GET(x) (((uint32_t)(x) & CSR_MICM_CFG_ISET_MASK) >> CSR_MICM_CFG_ISET_SHIFT)
3904 
3905 /* Bitfield definition for register: MDCM_CFG */
3906 /*
3907  * SETH (RO)
3908  *
3909  * This bit extends the DSET field.
3910  * When data cache is not configured, this field should be ignored
3911  */
3912 #define CSR_MDCM_CFG_SETH_MASK (0x1000000UL)
3913 #define CSR_MDCM_CFG_SETH_SHIFT (24U)
3914 #define CSR_MDCM_CFG_SETH_GET(x) (((uint32_t)(x) & CSR_MDCM_CFG_SETH_MASK) >> CSR_MDCM_CFG_SETH_SHIFT)
3915 
3916 /*
3917  * DLM_ECC (RO)
3918  *
3919  * DLM soft-error protection scheme
3920  * 0:No parity/ECC
3921  * 1:Parity
3922  * 2:ECC
3923  * 3:Reserved
3924  * When DLM is not configured, this field should be ignored.
3925  */
3926 #define CSR_MDCM_CFG_DLM_ECC_MASK (0x600000UL)
3927 #define CSR_MDCM_CFG_DLM_ECC_SHIFT (21U)
3928 #define CSR_MDCM_CFG_DLM_ECC_GET(x) (((uint32_t)(x) & CSR_MDCM_CFG_DLM_ECC_MASK) >> CSR_MDCM_CFG_DLM_ECC_SHIFT)
3929 
3930 /*
3931  * DLMSZ (RO)
3932  *
3933  * DLM Size
3934  * 0:0 Byte
3935  * 1:1 KiB
3936  * 2:2 KiB
3937  * 3:4 KiB
3938  * 4:8 KiB
3939  * 5:16 KiB
3940  * 6:32 KiB
3941  * 7:64 KiB
3942  * 8:128 KiB
3943  * 9:256 KiB
3944  * 10:512 KiB
3945  * 11:1 MiB
3946  * 12:2 MiB
3947  * 13:4 MiB
3948  * 14:8 MiB
3949  * 15:16 MiB
3950  * 16-31:Reserved
3951  * When ILM is not configured, this field should be ignored.
3952  */
3953 #define CSR_MDCM_CFG_DLMSZ_MASK (0xF8000UL)
3954 #define CSR_MDCM_CFG_DLMSZ_SHIFT (15U)
3955 #define CSR_MDCM_CFG_DLMSZ_GET(x) (((uint32_t)(x) & CSR_MDCM_CFG_DLMSZ_MASK) >> CSR_MDCM_CFG_DLMSZ_SHIFT)
3956 
3957 /*
3958  * DLMB (RO)
3959  *
3960  * Number of DLM base registers present
3961  * 0:No DLM base register present
3962  * 1:One DLM base register present
3963  * 2-7:Reserved
3964  * When DLM is not configured, this field should be ignored
3965  */
3966 #define CSR_MDCM_CFG_DLMB_MASK (0x7000U)
3967 #define CSR_MDCM_CFG_DLMB_SHIFT (12U)
3968 #define CSR_MDCM_CFG_DLMB_GET(x) (((uint32_t)(x) & CSR_MDCM_CFG_DLMB_MASK) >> CSR_MDCM_CFG_DLMB_SHIFT)
3969 
3970 /*
3971  * DC_ECC (RO)
3972  *
3973  * Cache soft-error protection scheme
3974  * 0:No parity/ECC support
3975  * 1:Has parity support
3976  * 2:Has ECC support
3977  * 3:Reserved
3978  * When data cache is not configured, this field should be ignored.
3979  */
3980 #define CSR_MDCM_CFG_DC_ECC_MASK (0xC00U)
3981 #define CSR_MDCM_CFG_DC_ECC_SHIFT (10U)
3982 #define CSR_MDCM_CFG_DC_ECC_GET(x) (((uint32_t)(x) & CSR_MDCM_CFG_DC_ECC_MASK) >> CSR_MDCM_CFG_DC_ECC_SHIFT)
3983 
3984 /*
3985  * DLCK (RO)
3986  *
3987  * D-Cache locking support
3988  * 0:No locking support
3989  * 1:With locking support
3990  * When data cache is not configured, this field should be ignored.
3991  */
3992 #define CSR_MDCM_CFG_DLCK_MASK (0x200U)
3993 #define CSR_MDCM_CFG_DLCK_SHIFT (9U)
3994 #define CSR_MDCM_CFG_DLCK_GET(x) (((uint32_t)(x) & CSR_MDCM_CFG_DLCK_MASK) >> CSR_MDCM_CFG_DLCK_SHIFT)
3995 
3996 /*
3997  * DSZ (RO)
3998  *
3999  * Cache block (line) size
4000  * 0:No I-Cache
4001  * 1:8 bytes
4002  * 2:16 bytes
4003  * 3:32 bytes
4004  * 4:64 bytes
4005  * 5:128 bytes
4006  * 6-7:Reserved
4007  * When instruction cache is not configured, this field should be ignored.
4008  */
4009 #define CSR_MDCM_CFG_DSZ_MASK (0x1C0U)
4010 #define CSR_MDCM_CFG_DSZ_SHIFT (6U)
4011 #define CSR_MDCM_CFG_DSZ_GET(x) (((uint32_t)(x) & CSR_MDCM_CFG_DSZ_MASK) >> CSR_MDCM_CFG_DSZ_SHIFT)
4012 
4013 /*
4014  * DWAY (RO)
4015  *
4016  * Associativity of D-Cache
4017  * 0:Direct-mapped
4018  * 1:2-way
4019  * 2:3-way
4020  * 3:4-way
4021  * 4:5-way
4022  * 5:6-way
4023  * 6:7-way
4024  * 7:8-way
4025  * When data cache is not configured, this field should be ignored.
4026  */
4027 #define CSR_MDCM_CFG_DWAY_MASK (0x38U)
4028 #define CSR_MDCM_CFG_DWAY_SHIFT (3U)
4029 #define CSR_MDCM_CFG_DWAY_GET(x) (((uint32_t)(x) & CSR_MDCM_CFG_DWAY_MASK) >> CSR_MDCM_CFG_DWAY_SHIFT)
4030 
4031 /*
4032  * DSET (RO)
4033  *
4034  * D-Cache sets (# of cache lines per way):
4035  * When mdcm_cfg.SETH==0:
4036  * 0:64
4037  * 1:128
4038  * 2:256
4039  * 3:512
4040  * 4:1024
4041  * 5:2048
4042  * 6:4096
4043  * 7:Reserved
4044  * When mdcm_cfg.SETH==1:
4045  * 0:32
4046  * 1:16
4047  * 2:8
4048  * 3-7:Reserved
4049  * When data cache is not configured, this field should be ignored
4050  */
4051 #define CSR_MDCM_CFG_DSET_MASK (0x7U)
4052 #define CSR_MDCM_CFG_DSET_SHIFT (0U)
4053 #define CSR_MDCM_CFG_DSET_GET(x) (((uint32_t)(x) & CSR_MDCM_CFG_DSET_MASK) >> CSR_MDCM_CFG_DSET_SHIFT)
4054 
4055 /* Bitfield definition for register: MMSC_CFG */
4056 /*
4057  * MSC_EXT (RO)
4058  *
4059  * Indicates if the mmsc_cfg2 CSR is present or not.
4060  * 0:The mmsc_cfg2 CSR is not present.
4061  * 1:The mmsc_cfg2 CSR is present
4062  */
4063 #define CSR_MMSC_CFG_MSC_EXT_MASK (0x80000000UL)
4064 #define CSR_MMSC_CFG_MSC_EXT_SHIFT (31U)
4065 #define CSR_MMSC_CFG_MSC_EXT_GET(x) (((uint32_t)(x) & CSR_MMSC_CFG_MSC_EXT_MASK) >> CSR_MMSC_CFG_MSC_EXT_SHIFT)
4066 
4067 /*
4068  * PPMA (RO)
4069  *
4070  * Indicates if programmable PMA setup with PMA region CSRs is supported or not
4071  * 0:Programmable PMA setup is not supported.
4072  * 1:Programmable PMA setup is supported.
4073  */
4074 #define CSR_MMSC_CFG_PPMA_MASK (0x40000000UL)
4075 #define CSR_MMSC_CFG_PPMA_SHIFT (30U)
4076 #define CSR_MMSC_CFG_PPMA_GET(x) (((uint32_t)(x) & CSR_MMSC_CFG_PPMA_MASK) >> CSR_MMSC_CFG_PPMA_SHIFT)
4077 
4078 /*
4079  * EDSP (RO)
4080  *
4081  * Indicates if the DSP extension is supported or not
4082  * 0:The DSP extension is not supported.
4083  * 1:The DSP extension is supported.
4084  */
4085 #define CSR_MMSC_CFG_EDSP_MASK (0x20000000UL)
4086 #define CSR_MMSC_CFG_EDSP_SHIFT (29U)
4087 #define CSR_MMSC_CFG_EDSP_GET(x) (((uint32_t)(x) & CSR_MMSC_CFG_EDSP_MASK) >> CSR_MMSC_CFG_EDSP_SHIFT)
4088 
4089 /*
4090  * VCCTL (RO)
4091  *
4092  * Indicates the version number of CCTL command operation scheme supported by an implementation
4093  * 0:instruction cache and data cache are not configured.
4094  * 1:instruction cache or data cache is configured.
4095  */
4096 #define CSR_MMSC_CFG_VCCTL_MASK (0xC0000UL)
4097 #define CSR_MMSC_CFG_VCCTL_SHIFT (18U)
4098 #define CSR_MMSC_CFG_VCCTL_GET(x) (((uint32_t)(x) & CSR_MMSC_CFG_VCCTL_MASK) >> CSR_MMSC_CFG_VCCTL_SHIFT)
4099 
4100 /*
4101  * EFHW (RO)
4102  *
4103  * Indicates the support of FLHW and FSHW instructions
4104  * 0:FLHW and FSHW instructions are not supported
4105  * 1:FLHW and FSHW instructions are supported.
4106  */
4107 #define CSR_MMSC_CFG_EFHW_MASK (0x20000UL)
4108 #define CSR_MMSC_CFG_EFHW_SHIFT (17U)
4109 #define CSR_MMSC_CFG_EFHW_GET(x) (((uint32_t)(x) & CSR_MMSC_CFG_EFHW_MASK) >> CSR_MMSC_CFG_EFHW_SHIFT)
4110 
4111 /*
4112  * CCTLCSR (RO)
4113  *
4114  * Indicates the presence of CSRs for CCTL operations.
4115  * 0:Feature of CSRs for CCTL operations is not supported.
4116  * 1:Feature of CSRs for CCTL operations is supported.
4117  */
4118 #define CSR_MMSC_CFG_CCTLCSR_MASK (0x10000UL)
4119 #define CSR_MMSC_CFG_CCTLCSR_SHIFT (16U)
4120 #define CSR_MMSC_CFG_CCTLCSR_GET(x) (((uint32_t)(x) & CSR_MMSC_CFG_CCTLCSR_MASK) >> CSR_MMSC_CFG_CCTLCSR_SHIFT)
4121 
4122 /*
4123  * PMNDS (RO)
4124  *
4125  * Indicates if Andes-enhanced performance monitoring feature is present or no.
4126  * 0:Andes-enhanced performance monitoring feature is not supported.
4127  * 1:Andes-enhanced performance monitoring feature is supported.
4128  */
4129 #define CSR_MMSC_CFG_PMNDS_MASK (0x8000U)
4130 #define CSR_MMSC_CFG_PMNDS_SHIFT (15U)
4131 #define CSR_MMSC_CFG_PMNDS_GET(x) (((uint32_t)(x) & CSR_MMSC_CFG_PMNDS_MASK) >> CSR_MMSC_CFG_PMNDS_SHIFT)
4132 
4133 /*
4134  * LMSLVP (RO)
4135  *
4136  * Indicates if local memory slave port is present or not.
4137  * 0:Local memory slave port is not present.
4138  * 1:Local memory slave port is implemented.
4139  */
4140 #define CSR_MMSC_CFG_LMSLVP_MASK (0x4000U)
4141 #define CSR_MMSC_CFG_LMSLVP_SHIFT (14U)
4142 #define CSR_MMSC_CFG_LMSLVP_GET(x) (((uint32_t)(x) & CSR_MMSC_CFG_LMSLVP_MASK) >> CSR_MMSC_CFG_LMSLVP_SHIFT)
4143 
4144 /*
4145  * EV5PE (RO)
4146  *
4147  * Indicates whether AndeStar V5 Performance Extension is implemented or not. D45 always implements AndeStar V5 Performance Extension.
4148  * 0:Not implemented.
4149  * 1:Implemented.
4150  */
4151 #define CSR_MMSC_CFG_EV5PE_MASK (0x2000U)
4152 #define CSR_MMSC_CFG_EV5PE_SHIFT (13U)
4153 #define CSR_MMSC_CFG_EV5PE_GET(x) (((uint32_t)(x) & CSR_MMSC_CFG_EV5PE_MASK) >> CSR_MMSC_CFG_EV5PE_SHIFT)
4154 
4155 /*
4156  * VPLIC (RO)
4157  *
4158  * Indicates whether the Andes Vectored PLIC Extension is implemented or not.
4159  * 0:Not implemented.
4160  * 1:Implemented.
4161  */
4162 #define CSR_MMSC_CFG_VPLIC_MASK (0x1000U)
4163 #define CSR_MMSC_CFG_VPLIC_SHIFT (12U)
4164 #define CSR_MMSC_CFG_VPLIC_GET(x) (((uint32_t)(x) & CSR_MMSC_CFG_VPLIC_MASK) >> CSR_MMSC_CFG_VPLIC_SHIFT)
4165 
4166 /*
4167  * ACE (RO)
4168  *
4169  * Indicates whether the Andes StackSafe hardware stack protection extension is implemented or not.
4170  * 0:Not implemented.
4171  * 1:Implemented.
4172  */
4173 #define CSR_MMSC_CFG_ACE_MASK (0x40U)
4174 #define CSR_MMSC_CFG_ACE_SHIFT (6U)
4175 #define CSR_MMSC_CFG_ACE_GET(x) (((uint32_t)(x) & CSR_MMSC_CFG_ACE_MASK) >> CSR_MMSC_CFG_ACE_SHIFT)
4176 
4177 /*
4178  * HSP (RO)
4179  *
4180  * Indicates whether the Andes PowerBrake (Performance Throttling) power/performance scaling extension is implemented or not.
4181  * 0:Not implemented.
4182  * 1:Implemented.
4183  */
4184 #define CSR_MMSC_CFG_HSP_MASK (0x20U)
4185 #define CSR_MMSC_CFG_HSP_SHIFT (5U)
4186 #define CSR_MMSC_CFG_HSP_GET(x) (((uint32_t)(x) & CSR_MMSC_CFG_HSP_MASK) >> CSR_MMSC_CFG_HSP_SHIFT)
4187 
4188 /*
4189  * PFT (RO)
4190  *
4191  * Indicates whether the Andes PowerBrake (Performance Throttling) power/performance scaling extension is implemented or not
4192  * 0:Not implemented.
4193  * 1:Implemented.
4194  */
4195 #define CSR_MMSC_CFG_PFT_MASK (0x10U)
4196 #define CSR_MMSC_CFG_PFT_SHIFT (4U)
4197 #define CSR_MMSC_CFG_PFT_GET(x) (((uint32_t)(x) & CSR_MMSC_CFG_PFT_MASK) >> CSR_MMSC_CFG_PFT_SHIFT)
4198 
4199 /*
4200  * ECD (RO)
4201  *
4202  * Indicates whether the Andes CoDense Extension is implemented or not.
4203  * 0:Not implemented.
4204  * 1:Implemented.
4205  */
4206 #define CSR_MMSC_CFG_ECD_MASK (0x8U)
4207 #define CSR_MMSC_CFG_ECD_SHIFT (3U)
4208 #define CSR_MMSC_CFG_ECD_GET(x) (((uint32_t)(x) & CSR_MMSC_CFG_ECD_MASK) >> CSR_MMSC_CFG_ECD_SHIFT)
4209 
4210 /*
4211  * TLB_ECC (RO)
4212  *
4213  * TLB parity/ECC support configuration.
4214  * 0:No parity/ECC
4215  * 1:Parity
4216  * 2:ECC
4217  * 3:Reserved
4218  */
4219 #define CSR_MMSC_CFG_TLB_ECC_MASK (0x6U)
4220 #define CSR_MMSC_CFG_TLB_ECC_SHIFT (1U)
4221 #define CSR_MMSC_CFG_TLB_ECC_GET(x) (((uint32_t)(x) & CSR_MMSC_CFG_TLB_ECC_MASK) >> CSR_MMSC_CFG_TLB_ECC_SHIFT)
4222 
4223 /*
4224  * ECC (RO)
4225  *
4226  * Indicates whether the parity/ECC soft-error protection is implemented or not.
4227  * 0:Not implemented.
4228  * 1:Implemented.
4229  * The specific parity/ECC scheme used for each protected RAM is specified by the control bits in the following list.
4230  * micm_cfg.IC_ECC
4231  * micm_cfg.ILM_ECC
4232  * mdcm_cfg.DC_ECC
4233  * mdcm_cfg.DLM_ECC
4234  * mmsc_cfg.TLB_ECC
4235  */
4236 #define CSR_MMSC_CFG_ECC_MASK (0x1U)
4237 #define CSR_MMSC_CFG_ECC_SHIFT (0U)
4238 #define CSR_MMSC_CFG_ECC_GET(x) (((uint32_t)(x) & CSR_MMSC_CFG_ECC_MASK) >> CSR_MMSC_CFG_ECC_SHIFT)
4239 
4240 /* Bitfield definition for register: MMSC_CFG2 */
4241 /*
4242  * FINV (RO)
4243  *
4244  * Indicates if scalar FPU is implemented in VPU
4245  * 0:Scalar FPU is not implemented in VPU
4246  * 1:Scalar FPU is implemented in VPU
4247  */
4248 #define CSR_MMSC_CFG2_FINV_MASK (0x20U)
4249 #define CSR_MMSC_CFG2_FINV_SHIFT (5U)
4250 #define CSR_MMSC_CFG2_FINV_GET(x) (((uint32_t)(x) & CSR_MMSC_CFG2_FINV_MASK) >> CSR_MMSC_CFG2_FINV_SHIFT)
4251 
4252 /*
4253  * ZFH (RO)
4254  *
4255  * Indicates if the FP16 half-precision floating-point extension (Zfh) is supported or not.
4256  * 0:The FP16 extension is not supported.
4257  * 1:The FP16 extension is supported
4258  */
4259 #define CSR_MMSC_CFG2_ZFH_MASK (0x2U)
4260 #define CSR_MMSC_CFG2_ZFH_SHIFT (1U)
4261 #define CSR_MMSC_CFG2_ZFH_GET(x) (((uint32_t)(x) & CSR_MMSC_CFG2_ZFH_MASK) >> CSR_MMSC_CFG2_ZFH_SHIFT)
4262 
4263 /*
4264  * BF16CVT (RO)
4265  *
4266  * Indicates if the BFLOAT16 conversion extension
4267  * is supported or not.
4268  * 0:The BFLOAT16 conversion extension is not supported
4269  * 1:The BFLOAT16 conversion extension is supported
4270  */
4271 #define CSR_MMSC_CFG2_BF16CVT_MASK (0x1U)
4272 #define CSR_MMSC_CFG2_BF16CVT_SHIFT (0U)
4273 #define CSR_MMSC_CFG2_BF16CVT_GET(x) (((uint32_t)(x) & CSR_MMSC_CFG2_BF16CVT_MASK) >> CSR_MMSC_CFG2_BF16CVT_SHIFT)
4274 
4275 
4276 #endif /* HPM_CSR_H */