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_SSTATUS (0x100)
22 #define CSR_SEDELEG (0x102)
23 #define CSR_SIDELEG (0x103)
24 #define CSR_SIE (0x104)
25 #define CSR_STVEC (0x105)
26 #define CSR_SSCRATCH (0x140)
27 #define CSR_SEPC (0x141)
28 #define CSR_SCAUSE (0x142)
29 #define CSR_STVAL (0x143)
30 #define CSR_SIP (0x144)
31 #define CSR_SATP (0x180)
32 #define CSR_MSTATUS (0x300)
33 #define CSR_MISA (0x301)
34 #define CSR_MEDELEG (0x302)
35 #define CSR_MIDELEG (0x303)
36 #define CSR_MIE (0x304)
37 #define CSR_MTVEC (0x305)
38 #define CSR_MCOUNTEREN (0x306)
39 #define CSR_MHPMEVENT3 (0x323)
40 #define CSR_MHPMEVENT4 (0x324)
41 #define CSR_MHPMEVENT5 (0x325)
42 #define CSR_MHPMEVENT6 (0x326)
43 #define CSR_MSCRATCH (0x340)
44 #define CSR_MEPC (0x341)
45 #define CSR_MCAUSE (0x342)
46 #define CSR_MTVAL (0x343)
47 #define CSR_MIP (0x344)
48 #define CSR_PMPCFG0 (0x3A0)
49 #define CSR_PMPCFG1 (0x3A1)
50 #define CSR_PMPCFG2 (0x3A2)
51 #define CSR_PMPCFG3 (0x3A3)
52 #define CSR_PMPADDR0 (0x3B0)
53 #define CSR_PMPADDR1 (0x3B1)
54 #define CSR_PMPADDR2 (0x3B2)
55 #define CSR_PMPADDR3 (0x3B3)
56 #define CSR_PMPADDR4 (0x3B4)
57 #define CSR_PMPADDR5 (0x3B5)
58 #define CSR_PMPADDR6 (0x3B6)
59 #define CSR_PMPADDR7 (0x3B7)
60 #define CSR_PMPADDR8 (0x3B8)
61 #define CSR_PMPADDR9 (0x3B9)
62 #define CSR_PMPADDR10 (0x3BA)
63 #define CSR_PMPADDR11 (0x3BB)
64 #define CSR_PMPADDR12 (0x3BC)
65 #define CSR_PMPADDR13 (0x3BD)
66 #define CSR_PMPADDR14 (0x3BE)
67 #define CSR_PMPADDR15 (0x3BF)
68 #define CSR_TSELECT (0x7A0)
69 #define CSR_TDATA1 (0x7A1)
70 #define CSR_MCONTROL (0x7A1)
71 #define CSR_ICOUNT (0x7A1)
72 #define CSR_ITRIGGER (0x7A1)
73 #define CSR_ETRIGGER (0x7A1)
74 #define CSR_TDATA2 (0x7A2)
75 #define CSR_TDATA3 (0x7A3)
76 #define CSR_TEXTRA (0x7A3)
77 #define CSR_TINFO (0x7A4)
78 #define CSR_TCONTROL (0x7A5)
79 #define CSR_MCONTEXT (0x7A8)
80 #define CSR_SCONTEXT (0x7AA)
81 #define CSR_DCSR (0x7B0)
82 #define CSR_DPC (0x7B1)
83 #define CSR_DSCRATCH0 (0x7B2)
84 #define CSR_DSCRATCH1 (0x7B3)
85 #define CSR_MCYCLE (0xB00)
86 #define CSR_MINSTRET (0xB02)
87 #define CSR_MHPMCOUNTER3 (0xB03)
88 #define CSR_MHPMCOUNTER4 (0xB04)
89 #define CSR_MHPMCOUNTER5 (0xB05)
90 #define CSR_MHPMCOUNTER6 (0xB06)
91 #define CSR_MCYCLEH (0xB80)
92 #define CSR_MINSTRETH (0xB82)
93 #define CSR_MHPMCOUNTER3H (0xB83)
94 #define CSR_MHPMCOUNTER4H (0xB84)
95 #define CSR_MHPMCOUNTER5H (0xB85)
96 #define CSR_MHPMCOUNTER6H (0xB86)
97 #define CSR_PMACFG0 (0xBC0)
98 #define CSR_PMACFG1 (0xBC1)
99 #define CSR_PMACFG2 (0xBC2)
100 #define CSR_PMACFG3 (0xBC3)
101 #define CSR_PMAADDR0 (0xBD0)
102 #define CSR_PMAADDR1 (0xBD1)
103 #define CSR_PMAADDR2 (0xBD2)
104 #define CSR_PMAADDR3 (0xBD3)
105 #define CSR_PMAADDR4 (0xBD4)
106 #define CSR_PMAADDR5 (0xBD5)
107 #define CSR_PMAADDR6 (0xBD6)
108 #define CSR_PMAADDR7 (0xBD7)
109 #define CSR_PMAADDR8 (0xBD8)
110 #define CSR_PMAADDR9 (0xBD9)
111 #define CSR_PMAADDR10 (0xBDA)
112 #define CSR_PMAADDR11 (0xBDB)
113 #define CSR_PMAADDR12 (0xBDC)
114 #define CSR_PMAADDR13 (0xBDD)
115 #define CSR_PMAADDR14 (0xBDE)
116 #define CSR_PMAADDR15 (0xBDF)
117 #define CSR_CYCLE (0xC00)
118 #define CSR_CYCLEH (0xC80)
119 #define CSR_MVENDORID (0xF11)
120 #define CSR_MARCHID (0xF12)
121 #define CSR_MIMPID (0xF13)
122 #define CSR_MHARTID (0xF14)
123 
124 /* NON-STANDARD CRS address definition */
125 #define CSR_SCOUNTEREN (0x106)
126 #define CSR_MCOUNTINHIBIT (0x320)
127 #define CSR_MILMB (0x7C0)
128 #define CSR_MDLMB (0x7C1)
129 #define CSR_MECC_CODE (0x7C2)
130 #define CSR_MNVEC (0x7C3)
131 #define CSR_MXSTATUS (0x7C4)
132 #define CSR_MPFT_CTL (0x7C5)
133 #define CSR_MHSP_CTL (0x7C6)
134 #define CSR_MSP_BOUND (0x7C7)
135 #define CSR_MSP_BASE (0x7C8)
136 #define CSR_MDCAUSE (0x7C9)
137 #define CSR_MCACHE_CTL (0x7CA)
138 #define CSR_MCCTLBEGINADDR (0x7CB)
139 #define CSR_MCCTLCOMMAND (0x7CC)
140 #define CSR_MCCTLDATA (0x7CD)
141 #define CSR_MCOUNTERWEN (0x7CE)
142 #define CSR_MCOUNTERINTEN (0x7CF)
143 #define CSR_MMISC_CTL (0x7D0)
144 #define CSR_MCOUNTERMASK_M (0x7D1)
145 #define CSR_MCOUNTERMASK_S (0x7D2)
146 #define CSR_MCOUNTERMASK_U (0x7D3)
147 #define CSR_MCOUNTEROVF (0x7D4)
148 #define CSR_MSLIDELEG (0x7D5)
149 #define CSR_MCLK_CTL (0x7DF)
150 #define CSR_DEXC2DBG (0x7E0)
151 #define CSR_DDCAUSE (0x7E1)
152 #define CSR_UITB (0x800)
153 #define CSR_UCODE (0x801)
154 #define CSR_UDCAUSE (0x809)
155 #define CSR_UCCTLBEGINADDR (0x80B)
156 #define CSR_UCCTLCOMMAND (0x80C)
157 #define CSR_SLIE (0x9C4)
158 #define CSR_SLIP (0x9C5)
159 #define CSR_SDCAUSE (0x9C9)
160 #define CSR_SCCTLDATA (0x9CD)
161 #define CSR_SCOUNTERINTEN (0x9CF)
162 #define CSR_SCOUNTERMASK_M (0x9D1)
163 #define CSR_SCOUNTERMASK_S (0x9D2)
164 #define CSR_SCOUNTERMASK_U (0x9D3)
165 #define CSR_SCOUNTEROVF (0x9D4)
166 #define CSR_SCOUNTINHIBIT (0x9E0)
167 #define CSR_SHPMEVENT3 (0x9E3)
168 #define CSR_SHPMEVENT4 (0x9E4)
169 #define CSR_SHPMEVENT5 (0x9E5)
170 #define CSR_SHPMEVENT6 (0x9E6)
171 #define CSR_MICM_CFG (0xFC0)
172 #define CSR_MDCM_CFG (0xFC1)
173 #define CSR_MMSC_CFG (0xFC2)
174 #define CSR_MMSC_CFG2 (0xFC3)
175 
176 /* STANDARD CRS register bitfiled definitions */
177 
178 /* Bitfield definition for register: USTATUS */
179 /*
180  * UPIE (RW)
181  *
182  * UPIE holds the value of the UIE bit prior to a trap.
183  */
184 #define CSR_USTATUS_UPIE_MASK (0x10U)
185 #define CSR_USTATUS_UPIE_SHIFT (4U)
186 #define CSR_USTATUS_UPIE_SET(x) (((uint32_t)(x) << CSR_USTATUS_UPIE_SHIFT) & CSR_USTATUS_UPIE_MASK)
187 #define CSR_USTATUS_UPIE_GET(x) (((uint32_t)(x) & CSR_USTATUS_UPIE_MASK) >> CSR_USTATUS_UPIE_SHIFT)
188 
189 /*
190  * UIE (RW)
191  *
192  * U mode interrupt enable bit.
193  * 0:Disabled
194  * 1:Enabled
195  */
196 #define CSR_USTATUS_UIE_MASK (0x1U)
197 #define CSR_USTATUS_UIE_SHIFT (0U)
198 #define CSR_USTATUS_UIE_SET(x) (((uint32_t)(x) << CSR_USTATUS_UIE_SHIFT) & CSR_USTATUS_UIE_MASK)
199 #define CSR_USTATUS_UIE_GET(x) (((uint32_t)(x) & CSR_USTATUS_UIE_MASK) >> CSR_USTATUS_UIE_SHIFT)
200 
201 /* Bitfield definition for register: UIE */
202 /*
203  * UEIE (RW)
204  *
205  * U mode external interrupt enable bit
206  * 0:Disabled
207  * 1:Enabled
208  */
209 #define CSR_UIE_UEIE_MASK (0x100U)
210 #define CSR_UIE_UEIE_SHIFT (8U)
211 #define CSR_UIE_UEIE_SET(x) (((uint32_t)(x) << CSR_UIE_UEIE_SHIFT) & CSR_UIE_UEIE_MASK)
212 #define CSR_UIE_UEIE_GET(x) (((uint32_t)(x) & CSR_UIE_UEIE_MASK) >> CSR_UIE_UEIE_SHIFT)
213 
214 /*
215  * UTIE (RW)
216  *
217  * U mode timer interrupt enable bit.
218  * 0:Disabled
219  * 1:Enabled
220  */
221 #define CSR_UIE_UTIE_MASK (0x10U)
222 #define CSR_UIE_UTIE_SHIFT (4U)
223 #define CSR_UIE_UTIE_SET(x) (((uint32_t)(x) << CSR_UIE_UTIE_SHIFT) & CSR_UIE_UTIE_MASK)
224 #define CSR_UIE_UTIE_GET(x) (((uint32_t)(x) & CSR_UIE_UTIE_MASK) >> CSR_UIE_UTIE_SHIFT)
225 
226 /*
227  * USIE (RW)
228  *
229  * U mode software interrupt enable bit.
230  * 0:Disabled
231  * 1:Enabled
232  */
233 #define CSR_UIE_USIE_MASK (0x1U)
234 #define CSR_UIE_USIE_SHIFT (0U)
235 #define CSR_UIE_USIE_SET(x) (((uint32_t)(x) << CSR_UIE_USIE_SHIFT) & CSR_UIE_USIE_MASK)
236 #define CSR_UIE_USIE_GET(x) (((uint32_t)(x) & CSR_UIE_USIE_MASK) >> CSR_UIE_USIE_SHIFT)
237 
238 /* Bitfield definition for register: UTVEC */
239 /*
240  * BASE_31_2 (RW)
241  *
242  * Base address for interrupt and exception handlers. See description above for alignment requirements when PLIC is in the vector mode.
243  */
244 #define CSR_UTVEC_BASE_31_2_MASK (0xFFFFFFFCUL)
245 #define CSR_UTVEC_BASE_31_2_SHIFT (2U)
246 #define CSR_UTVEC_BASE_31_2_SET(x) (((uint32_t)(x) << CSR_UTVEC_BASE_31_2_SHIFT) & CSR_UTVEC_BASE_31_2_MASK)
247 #define CSR_UTVEC_BASE_31_2_GET(x) (((uint32_t)(x) & CSR_UTVEC_BASE_31_2_MASK) >> CSR_UTVEC_BASE_31_2_SHIFT)
248 
249 /* Bitfield definition for register: USCRATCH */
250 /*
251  * USCRATCH (RW)
252  *
253  * Scratch register storage.
254  */
255 #define CSR_USCRATCH_USCRATCH_MASK (0xFFFFFFFFUL)
256 #define CSR_USCRATCH_USCRATCH_SHIFT (0U)
257 #define CSR_USCRATCH_USCRATCH_SET(x) (((uint32_t)(x) << CSR_USCRATCH_USCRATCH_SHIFT) & CSR_USCRATCH_USCRATCH_MASK)
258 #define CSR_USCRATCH_USCRATCH_GET(x) (((uint32_t)(x) & CSR_USCRATCH_USCRATCH_MASK) >> CSR_USCRATCH_USCRATCH_SHIFT)
259 
260 /* Bitfield definition for register: UEPC */
261 /*
262  * EPC (RW)
263  *
264  * Exception program counter.
265  */
266 #define CSR_UEPC_EPC_MASK (0xFFFFFFFEUL)
267 #define CSR_UEPC_EPC_SHIFT (1U)
268 #define CSR_UEPC_EPC_SET(x) (((uint32_t)(x) << CSR_UEPC_EPC_SHIFT) & CSR_UEPC_EPC_MASK)
269 #define CSR_UEPC_EPC_GET(x) (((uint32_t)(x) & CSR_UEPC_EPC_MASK) >> CSR_UEPC_EPC_SHIFT)
270 
271 /* Bitfield definition for register: UCAUSE */
272 /*
273  * INTERRUPT (RW)
274  *
275  * Interrupt.
276  */
277 #define CSR_UCAUSE_INTERRUPT_MASK (0x80000000UL)
278 #define CSR_UCAUSE_INTERRUPT_SHIFT (31U)
279 #define CSR_UCAUSE_INTERRUPT_SET(x) (((uint32_t)(x) << CSR_UCAUSE_INTERRUPT_SHIFT) & CSR_UCAUSE_INTERRUPT_MASK)
280 #define CSR_UCAUSE_INTERRUPT_GET(x) (((uint32_t)(x) & CSR_UCAUSE_INTERRUPT_MASK) >> CSR_UCAUSE_INTERRUPT_SHIFT)
281 
282 /*
283  * EXCEPTION_CODE (RW)
284  *
285  * Exception Code.
286  * When interrupt is 1:
287  * 0:User software interrupt
288  * 4:User timer interrupt
289  * 8:User external interrupt
290  * When interrupt is 0:
291  * 0:Instruction address misaligned
292  * 1:Instruction access fault
293  * 2:Illegal instruction
294  * 3:Breakpoint
295  * 4:Load address misaligned
296  * 5:Load access fault
297  * 6:Store/AMO address misaligned
298  * 7:Store/AMO access fault
299  * 8:Environment call from U-mode
300  * 9-11:Reserved
301  * 12:Instruction page fault
302  * 13:Load page fault
303  * 14:Reserved
304  * 15:Store/AMO page fault
305  * 32:Stack overflow exception
306  * 33:Stack underflow exception
307  * 40-47:Reserved
308  */
309 #define CSR_UCAUSE_EXCEPTION_CODE_MASK (0x3FFU)
310 #define CSR_UCAUSE_EXCEPTION_CODE_SHIFT (0U)
311 #define CSR_UCAUSE_EXCEPTION_CODE_SET(x) (((uint32_t)(x) << CSR_UCAUSE_EXCEPTION_CODE_SHIFT) & CSR_UCAUSE_EXCEPTION_CODE_MASK)
312 #define CSR_UCAUSE_EXCEPTION_CODE_GET(x) (((uint32_t)(x) & CSR_UCAUSE_EXCEPTION_CODE_MASK) >> CSR_UCAUSE_EXCEPTION_CODE_SHIFT)
313 
314 /* Bitfield definition for register: UTVAL */
315 /*
316  * UTVAL (RW)
317  *
318  * Exception-specific information for software trap handling.
319  */
320 #define CSR_UTVAL_UTVAL_MASK (0xFFFFFFFFUL)
321 #define CSR_UTVAL_UTVAL_SHIFT (0U)
322 #define CSR_UTVAL_UTVAL_SET(x) (((uint32_t)(x) << CSR_UTVAL_UTVAL_SHIFT) & CSR_UTVAL_UTVAL_MASK)
323 #define CSR_UTVAL_UTVAL_GET(x) (((uint32_t)(x) & CSR_UTVAL_UTVAL_MASK) >> CSR_UTVAL_UTVAL_SHIFT)
324 
325 /* Bitfield definition for register: UIP */
326 /*
327  * UEIP (RW)
328  *
329  * U mode external interrupt pending bit.
330  * 0:Not pending
331  * 1:Pending
332  */
333 #define CSR_UIP_UEIP_MASK (0x100U)
334 #define CSR_UIP_UEIP_SHIFT (8U)
335 #define CSR_UIP_UEIP_SET(x) (((uint32_t)(x) << CSR_UIP_UEIP_SHIFT) & CSR_UIP_UEIP_MASK)
336 #define CSR_UIP_UEIP_GET(x) (((uint32_t)(x) & CSR_UIP_UEIP_MASK) >> CSR_UIP_UEIP_SHIFT)
337 
338 /*
339  * UTIP (RW)
340  *
341  * U mode timer interrupt pending bit.
342  * 0:Not pending
343  * 1:Pending
344  */
345 #define CSR_UIP_UTIP_MASK (0x10U)
346 #define CSR_UIP_UTIP_SHIFT (4U)
347 #define CSR_UIP_UTIP_SET(x) (((uint32_t)(x) << CSR_UIP_UTIP_SHIFT) & CSR_UIP_UTIP_MASK)
348 #define CSR_UIP_UTIP_GET(x) (((uint32_t)(x) & CSR_UIP_UTIP_MASK) >> CSR_UIP_UTIP_SHIFT)
349 
350 /*
351  * USIP (RW)
352  *
353  * U mode software interrupt pending bit.
354  * 0:Not pending
355  * 1:Pending
356  */
357 #define CSR_UIP_USIP_MASK (0x1U)
358 #define CSR_UIP_USIP_SHIFT (0U)
359 #define CSR_UIP_USIP_SET(x) (((uint32_t)(x) << CSR_UIP_USIP_SHIFT) & CSR_UIP_USIP_MASK)
360 #define CSR_UIP_USIP_GET(x) (((uint32_t)(x) & CSR_UIP_USIP_MASK) >> CSR_UIP_USIP_SHIFT)
361 
362 /* Bitfield definition for register: SSTATUS */
363 /*
364  * SD (RO)
365  *
366  * SD summarizes whether either the FS field or XS field is dirty.
367  */
368 #define CSR_SSTATUS_SD_MASK (0x80000000UL)
369 #define CSR_SSTATUS_SD_SHIFT (31U)
370 #define CSR_SSTATUS_SD_GET(x) (((uint32_t)(x) & CSR_SSTATUS_SD_MASK) >> CSR_SSTATUS_SD_SHIFT)
371 
372 /*
373  * MXR (RW)
374  *
375  * MXR controls whether execute-only pages are readable. It has no effect when page-based virtual memory is not in effect.
376  * 0:Execute-only pages are not readable
377  * 1:Execute-only pages are readable
378  */
379 #define CSR_SSTATUS_MXR_MASK (0x80000UL)
380 #define CSR_SSTATUS_MXR_SHIFT (19U)
381 #define CSR_SSTATUS_MXR_SET(x) (((uint32_t)(x) << CSR_SSTATUS_MXR_SHIFT) & CSR_SSTATUS_MXR_MASK)
382 #define CSR_SSTATUS_MXR_GET(x) (((uint32_t)(x) & CSR_SSTATUS_MXR_MASK) >> CSR_SSTATUS_MXR_SHIFT)
383 
384 /*
385  * SUM (RW)
386  *
387  * SUM controls whether a S-mode load/store instruction to a user accessible page is allowed or not when page translation is enabled. It is in effect in two scenarios: (a) M-mode with MPRV=1 and MPP=S, and (b) in S-mode. It has no effect when page-based virtual memory is not in effect. A page is user accessible when the U bit of the corresponding PTE entry is 1.
388  * 0:Not Allowed
389  * 1:Allowed
390  */
391 #define CSR_SSTATUS_SUM_MASK (0x40000UL)
392 #define CSR_SSTATUS_SUM_SHIFT (18U)
393 #define CSR_SSTATUS_SUM_SET(x) (((uint32_t)(x) << CSR_SSTATUS_SUM_SHIFT) & CSR_SSTATUS_SUM_MASK)
394 #define CSR_SSTATUS_SUM_GET(x) (((uint32_t)(x) & CSR_SSTATUS_SUM_MASK) >> CSR_SSTATUS_SUM_SHIFT)
395 
396 /*
397  * XS (RO)
398  *
399  * 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.
400  * This field is primarily managed by software. The processor hardware assists the state managements in two regards:
401  * Illegal instruction exceptions are triggeredwhen XS is Off.
402  * XS is updated to the Dirty state with the execution of ACE instructions when XS is not Off.
403  * 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.
404  * The same copy of XS bits are shared by both mstatus and sstatus. Normally the supervisor mode privileged software would use the XS bits to manage deferred context switches of ACE states. Machine mode software should be more conservative in managing context switches using XS bits
405  * 0:Off
406  * 1:Initial
407  * 2:Clean
408  * 3:Dirty
409  */
410 #define CSR_SSTATUS_XS_MASK (0x18000UL)
411 #define CSR_SSTATUS_XS_SHIFT (15U)
412 #define CSR_SSTATUS_XS_GET(x) (((uint32_t)(x) & CSR_SSTATUS_XS_MASK) >> CSR_SSTATUS_XS_SHIFT)
413 
414 /*
415  * FS (RW)
416  *
417  * 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.
418  * This field is primarily managed by software. The processor hardware assists the state managements in two regards:
419  * Attempts to access fcsr or any f register raise an illegal-instruction exception when FS is Off.
420  * Otherwise, FS is updated to the Dirty state by any instruction that updates fcsr or any f register.
421  * 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.
422  * The same copy of FS bits are shared by both mstatus and sstatus. Normally the supervisor mode privileged software would use the FS bits to manage deferred context switches of FPU states. Machine mode software should be more conservative in managing context switches using FS bits.
423  * 0:Off
424  * 1:Initial
425  * 2:Clean
426  * 3:Dirty
427  */
428 #define CSR_SSTATUS_FS_MASK (0x6000U)
429 #define CSR_SSTATUS_FS_SHIFT (13U)
430 #define CSR_SSTATUS_FS_SET(x) (((uint32_t)(x) << CSR_SSTATUS_FS_SHIFT) & CSR_SSTATUS_FS_MASK)
431 #define CSR_SSTATUS_FS_GET(x) (((uint32_t)(x) & CSR_SSTATUS_FS_MASK) >> CSR_SSTATUS_FS_SHIFT)
432 
433 /*
434  * SPP (RW)
435  *
436  * SPP holds the privilege mode prior to a trap. Encoding is 1 for S-mode and 0 for U-mode.
437  */
438 #define CSR_SSTATUS_SPP_MASK (0x100U)
439 #define CSR_SSTATUS_SPP_SHIFT (8U)
440 #define CSR_SSTATUS_SPP_SET(x) (((uint32_t)(x) << CSR_SSTATUS_SPP_SHIFT) & CSR_SSTATUS_SPP_MASK)
441 #define CSR_SSTATUS_SPP_GET(x) (((uint32_t)(x) & CSR_SSTATUS_SPP_MASK) >> CSR_SSTATUS_SPP_SHIFT)
442 
443 /*
444  * SPIE (RW)
445  *
446  * SPIE holds the value of the SIE bit prior to a trap.
447  */
448 #define CSR_SSTATUS_SPIE_MASK (0x20U)
449 #define CSR_SSTATUS_SPIE_SHIFT (5U)
450 #define CSR_SSTATUS_SPIE_SET(x) (((uint32_t)(x) << CSR_SSTATUS_SPIE_SHIFT) & CSR_SSTATUS_SPIE_MASK)
451 #define CSR_SSTATUS_SPIE_GET(x) (((uint32_t)(x) & CSR_SSTATUS_SPIE_MASK) >> CSR_SSTATUS_SPIE_SHIFT)
452 
453 /*
454  * UPIE (RW)
455  *
456  * UPIE holds the value of the UIE bit prior to a trap.
457  */
458 #define CSR_SSTATUS_UPIE_MASK (0x10U)
459 #define CSR_SSTATUS_UPIE_SHIFT (4U)
460 #define CSR_SSTATUS_UPIE_SET(x) (((uint32_t)(x) << CSR_SSTATUS_UPIE_SHIFT) & CSR_SSTATUS_UPIE_MASK)
461 #define CSR_SSTATUS_UPIE_GET(x) (((uint32_t)(x) & CSR_SSTATUS_UPIE_MASK) >> CSR_SSTATUS_UPIE_SHIFT)
462 
463 /*
464  * SIE (RW)
465  *
466  * S mode interrupt enable bit
467  * 0 Disabled
468  * 1 Enabled
469  */
470 #define CSR_SSTATUS_SIE_MASK (0x2U)
471 #define CSR_SSTATUS_SIE_SHIFT (1U)
472 #define CSR_SSTATUS_SIE_SET(x) (((uint32_t)(x) << CSR_SSTATUS_SIE_SHIFT) & CSR_SSTATUS_SIE_MASK)
473 #define CSR_SSTATUS_SIE_GET(x) (((uint32_t)(x) & CSR_SSTATUS_SIE_MASK) >> CSR_SSTATUS_SIE_SHIFT)
474 
475 /*
476  * UIE (RW)
477  *
478  * U mode interrupt enable bit.
479  * 0 Disabled
480  * 1 Enabled
481  */
482 #define CSR_SSTATUS_UIE_MASK (0x1U)
483 #define CSR_SSTATUS_UIE_SHIFT (0U)
484 #define CSR_SSTATUS_UIE_SET(x) (((uint32_t)(x) << CSR_SSTATUS_UIE_SHIFT) & CSR_SSTATUS_UIE_MASK)
485 #define CSR_SSTATUS_UIE_GET(x) (((uint32_t)(x) & CSR_SSTATUS_UIE_MASK) >> CSR_SSTATUS_UIE_SHIFT)
486 
487 /* Bitfield definition for register: SEDELEG */
488 /*
489  * SPF (RW)
490  *
491  * SPF indicates whether a Store/AMO Page Fault exception will be delegated to U-mode
492  * 0:Do not redirect
493  * 1:Redirect
494  */
495 #define CSR_SEDELEG_SPF_MASK (0x8000U)
496 #define CSR_SEDELEG_SPF_SHIFT (15U)
497 #define CSR_SEDELEG_SPF_SET(x) (((uint32_t)(x) << CSR_SEDELEG_SPF_SHIFT) & CSR_SEDELEG_SPF_MASK)
498 #define CSR_SEDELEG_SPF_GET(x) (((uint32_t)(x) & CSR_SEDELEG_SPF_MASK) >> CSR_SEDELEG_SPF_SHIFT)
499 
500 /*
501  * LPF (RW)
502  *
503  * LPF indicates whether a Load Page Fault exception will be delegated to U-mode
504  * 0:Do not redirect
505  * 1:Redirect
506  */
507 #define CSR_SEDELEG_LPF_MASK (0x2000U)
508 #define CSR_SEDELEG_LPF_SHIFT (13U)
509 #define CSR_SEDELEG_LPF_SET(x) (((uint32_t)(x) << CSR_SEDELEG_LPF_SHIFT) & CSR_SEDELEG_LPF_MASK)
510 #define CSR_SEDELEG_LPF_GET(x) (((uint32_t)(x) & CSR_SEDELEG_LPF_MASK) >> CSR_SEDELEG_LPF_SHIFT)
511 
512 /*
513  * IPF (RW)
514  *
515  * IPF indicates whether an Instruction Page Fault exception will be delegated to U-mode
516  * 0:Do not redirect
517  * 1:Redirect
518  */
519 #define CSR_SEDELEG_IPF_MASK (0x1000U)
520 #define CSR_SEDELEG_IPF_SHIFT (12U)
521 #define CSR_SEDELEG_IPF_SET(x) (((uint32_t)(x) << CSR_SEDELEG_IPF_SHIFT) & CSR_SEDELEG_IPF_MASK)
522 #define CSR_SEDELEG_IPF_GET(x) (((uint32_t)(x) & CSR_SEDELEG_IPF_MASK) >> CSR_SEDELEG_IPF_SHIFT)
523 
524 /*
525  * UEC (RW)
526  *
527  * UEC indicates whether an exception triggered by environment call from U-mode will be delegated to U-mode
528  * 0:Do not redirect
529  * 1:Redirect
530  */
531 #define CSR_SEDELEG_UEC_MASK (0x100U)
532 #define CSR_SEDELEG_UEC_SHIFT (8U)
533 #define CSR_SEDELEG_UEC_SET(x) (((uint32_t)(x) << CSR_SEDELEG_UEC_SHIFT) & CSR_SEDELEG_UEC_MASK)
534 #define CSR_SEDELEG_UEC_GET(x) (((uint32_t)(x) & CSR_SEDELEG_UEC_MASK) >> CSR_SEDELEG_UEC_SHIFT)
535 
536 /*
537  * SAF (RW)
538  *
539  * SAF indicates whether a Store/AMO Access Fault exception will be delegated to U-mode
540  * 0:Do not redirect
541  * 1:Redirect
542  */
543 #define CSR_SEDELEG_SAF_MASK (0x80U)
544 #define CSR_SEDELEG_SAF_SHIFT (7U)
545 #define CSR_SEDELEG_SAF_SET(x) (((uint32_t)(x) << CSR_SEDELEG_SAF_SHIFT) & CSR_SEDELEG_SAF_MASK)
546 #define CSR_SEDELEG_SAF_GET(x) (((uint32_t)(x) & CSR_SEDELEG_SAF_MASK) >> CSR_SEDELEG_SAF_SHIFT)
547 
548 /*
549  * SAM (RW)
550  *
551  * SAM indicates whether a Store/AMO Address Misaligned exception will be delegated to U-mode
552  * 0:Do not redirect
553  * 1:Redirect
554  */
555 #define CSR_SEDELEG_SAM_MASK (0x40U)
556 #define CSR_SEDELEG_SAM_SHIFT (6U)
557 #define CSR_SEDELEG_SAM_SET(x) (((uint32_t)(x) << CSR_SEDELEG_SAM_SHIFT) & CSR_SEDELEG_SAM_MASK)
558 #define CSR_SEDELEG_SAM_GET(x) (((uint32_t)(x) & CSR_SEDELEG_SAM_MASK) >> CSR_SEDELEG_SAM_SHIFT)
559 
560 /*
561  * LAF (RW)
562  *
563  * LAF indicates whether a Load Access Fault exception will be delegated to U-mode
564  * 0:Do not redirect
565  * 1:Redirect
566  */
567 #define CSR_SEDELEG_LAF_MASK (0x20U)
568 #define CSR_SEDELEG_LAF_SHIFT (5U)
569 #define CSR_SEDELEG_LAF_SET(x) (((uint32_t)(x) << CSR_SEDELEG_LAF_SHIFT) & CSR_SEDELEG_LAF_MASK)
570 #define CSR_SEDELEG_LAF_GET(x) (((uint32_t)(x) & CSR_SEDELEG_LAF_MASK) >> CSR_SEDELEG_LAF_SHIFT)
571 
572 /*
573  * LAM (RW)
574  *
575  * LAM indicates whether a Load Address Misaligned exception will be delegated to U-mode
576  * 0:Do not redirect
577  * 1:Redirect
578  */
579 #define CSR_SEDELEG_LAM_MASK (0x10U)
580 #define CSR_SEDELEG_LAM_SHIFT (4U)
581 #define CSR_SEDELEG_LAM_SET(x) (((uint32_t)(x) << CSR_SEDELEG_LAM_SHIFT) & CSR_SEDELEG_LAM_MASK)
582 #define CSR_SEDELEG_LAM_GET(x) (((uint32_t)(x) & CSR_SEDELEG_LAM_MASK) >> CSR_SEDELEG_LAM_SHIFT)
583 
584 /*
585  * B (RW)
586  *
587  * B indicates whether an exception triggered by breakpoint will be delegated to U-mode
588  * 0:Do not redirect
589  * 1:Redirect
590  */
591 #define CSR_SEDELEG_B_MASK (0x8U)
592 #define CSR_SEDELEG_B_SHIFT (3U)
593 #define CSR_SEDELEG_B_SET(x) (((uint32_t)(x) << CSR_SEDELEG_B_SHIFT) & CSR_SEDELEG_B_MASK)
594 #define CSR_SEDELEG_B_GET(x) (((uint32_t)(x) & CSR_SEDELEG_B_MASK) >> CSR_SEDELEG_B_SHIFT)
595 
596 /*
597  * II (RW)
598  *
599  * II indicates whether an Illegal Instruction exception will be delegated to U-mode
600  * 0:Do not redirect
601  * 1:Redirect
602  */
603 #define CSR_SEDELEG_II_MASK (0x4U)
604 #define CSR_SEDELEG_II_SHIFT (2U)
605 #define CSR_SEDELEG_II_SET(x) (((uint32_t)(x) << CSR_SEDELEG_II_SHIFT) & CSR_SEDELEG_II_MASK)
606 #define CSR_SEDELEG_II_GET(x) (((uint32_t)(x) & CSR_SEDELEG_II_MASK) >> CSR_SEDELEG_II_SHIFT)
607 
608 /*
609  * IAF (RW)
610  *
611  * IAF indicates whether an Instruction Access Fault exception will be delegated to U-mode
612  * 0:Do not redirect
613  * 1:Redirect
614  */
615 #define CSR_SEDELEG_IAF_MASK (0x2U)
616 #define CSR_SEDELEG_IAF_SHIFT (1U)
617 #define CSR_SEDELEG_IAF_SET(x) (((uint32_t)(x) << CSR_SEDELEG_IAF_SHIFT) & CSR_SEDELEG_IAF_MASK)
618 #define CSR_SEDELEG_IAF_GET(x) (((uint32_t)(x) & CSR_SEDELEG_IAF_MASK) >> CSR_SEDELEG_IAF_SHIFT)
619 
620 /*
621  * IAM (RW)
622  *
623  * IAM indicates whether an Instruction Address Misaligned exception will be delegated to U-mode..
624  * 0:Do not redirect
625  * 1:Redirect
626  */
627 #define CSR_SEDELEG_IAM_MASK (0x1U)
628 #define CSR_SEDELEG_IAM_SHIFT (0U)
629 #define CSR_SEDELEG_IAM_SET(x) (((uint32_t)(x) << CSR_SEDELEG_IAM_SHIFT) & CSR_SEDELEG_IAM_MASK)
630 #define CSR_SEDELEG_IAM_GET(x) (((uint32_t)(x) & CSR_SEDELEG_IAM_MASK) >> CSR_SEDELEG_IAM_SHIFT)
631 
632 /* Bitfield definition for register: SIDELEG */
633 /*
634  * UEI (RW)
635  *
636  * UEI indicates whether an U-mode external interrupt will be delegated to S-mode
637  * 0:Do not redirect
638  * 1:Redirect
639  */
640 #define CSR_SIDELEG_UEI_MASK (0x100U)
641 #define CSR_SIDELEG_UEI_SHIFT (8U)
642 #define CSR_SIDELEG_UEI_SET(x) (((uint32_t)(x) << CSR_SIDELEG_UEI_SHIFT) & CSR_SIDELEG_UEI_MASK)
643 #define CSR_SIDELEG_UEI_GET(x) (((uint32_t)(x) & CSR_SIDELEG_UEI_MASK) >> CSR_SIDELEG_UEI_SHIFT)
644 
645 /*
646  * UTI (RW)
647  *
648  * UTI indicates whether an U-mode timer interrupt will be delegated to S-mode
649  * 0:Do not redirect
650  * 1:Redirect
651  */
652 #define CSR_SIDELEG_UTI_MASK (0x10U)
653 #define CSR_SIDELEG_UTI_SHIFT (4U)
654 #define CSR_SIDELEG_UTI_SET(x) (((uint32_t)(x) << CSR_SIDELEG_UTI_SHIFT) & CSR_SIDELEG_UTI_MASK)
655 #define CSR_SIDELEG_UTI_GET(x) (((uint32_t)(x) & CSR_SIDELEG_UTI_MASK) >> CSR_SIDELEG_UTI_SHIFT)
656 
657 /*
658  * USI (RW)
659  *
660  * USI indicates whether an U-mode software interrupt will be delegated to S-mode.
661  * 0:Do not redirect
662  * 1:Redirect
663  */
664 #define CSR_SIDELEG_USI_MASK (0x1U)
665 #define CSR_SIDELEG_USI_SHIFT (0U)
666 #define CSR_SIDELEG_USI_SET(x) (((uint32_t)(x) << CSR_SIDELEG_USI_SHIFT) & CSR_SIDELEG_USI_MASK)
667 #define CSR_SIDELEG_USI_GET(x) (((uint32_t)(x) & CSR_SIDELEG_USI_MASK) >> CSR_SIDELEG_USI_SHIFT)
668 
669 /* Bitfield definition for register: SIE */
670 /*
671  * SEIE (RW)
672  *
673  * S mode external interrupt enable bit
674  * 0:Disabled
675  * 1:Enabled
676  */
677 #define CSR_SIE_SEIE_MASK (0x200U)
678 #define CSR_SIE_SEIE_SHIFT (9U)
679 #define CSR_SIE_SEIE_SET(x) (((uint32_t)(x) << CSR_SIE_SEIE_SHIFT) & CSR_SIE_SEIE_MASK)
680 #define CSR_SIE_SEIE_GET(x) (((uint32_t)(x) & CSR_SIE_SEIE_MASK) >> CSR_SIE_SEIE_SHIFT)
681 
682 /*
683  * UEIE (RW)
684  *
685  * U mode external interrupt enable bit
686  * 0:Disabled
687  * 1:Enabled
688  */
689 #define CSR_SIE_UEIE_MASK (0x100U)
690 #define CSR_SIE_UEIE_SHIFT (8U)
691 #define CSR_SIE_UEIE_SET(x) (((uint32_t)(x) << CSR_SIE_UEIE_SHIFT) & CSR_SIE_UEIE_MASK)
692 #define CSR_SIE_UEIE_GET(x) (((uint32_t)(x) & CSR_SIE_UEIE_MASK) >> CSR_SIE_UEIE_SHIFT)
693 
694 /*
695  * STIE (RW)
696  *
697  * S mode timer interrupt enable bit.
698  * 0:Disabled
699  * 1:Enabled
700  */
701 #define CSR_SIE_STIE_MASK (0x20U)
702 #define CSR_SIE_STIE_SHIFT (5U)
703 #define CSR_SIE_STIE_SET(x) (((uint32_t)(x) << CSR_SIE_STIE_SHIFT) & CSR_SIE_STIE_MASK)
704 #define CSR_SIE_STIE_GET(x) (((uint32_t)(x) & CSR_SIE_STIE_MASK) >> CSR_SIE_STIE_SHIFT)
705 
706 /*
707  * UTIE (RW)
708  *
709  * U mode timer interrupt enable bit
710  * 0:Disabled
711  * 1:Enabled
712  */
713 #define CSR_SIE_UTIE_MASK (0x10U)
714 #define CSR_SIE_UTIE_SHIFT (4U)
715 #define CSR_SIE_UTIE_SET(x) (((uint32_t)(x) << CSR_SIE_UTIE_SHIFT) & CSR_SIE_UTIE_MASK)
716 #define CSR_SIE_UTIE_GET(x) (((uint32_t)(x) & CSR_SIE_UTIE_MASK) >> CSR_SIE_UTIE_SHIFT)
717 
718 /*
719  * SSIE (RW)
720  *
721  * S mode software interrupt enable bit.
722  * 0:Disabled
723  * 1:Enabled
724  */
725 #define CSR_SIE_SSIE_MASK (0x2U)
726 #define CSR_SIE_SSIE_SHIFT (1U)
727 #define CSR_SIE_SSIE_SET(x) (((uint32_t)(x) << CSR_SIE_SSIE_SHIFT) & CSR_SIE_SSIE_MASK)
728 #define CSR_SIE_SSIE_GET(x) (((uint32_t)(x) & CSR_SIE_SSIE_MASK) >> CSR_SIE_SSIE_SHIFT)
729 
730 /*
731  * USIE (RW)
732  *
733  * U mode software interrupt enable bit.
734  * 0:Disabled
735  * 1:Enabled
736  */
737 #define CSR_SIE_USIE_MASK (0x1U)
738 #define CSR_SIE_USIE_SHIFT (0U)
739 #define CSR_SIE_USIE_SET(x) (((uint32_t)(x) << CSR_SIE_USIE_SHIFT) & CSR_SIE_USIE_MASK)
740 #define CSR_SIE_USIE_GET(x) (((uint32_t)(x) & CSR_SIE_USIE_MASK) >> CSR_SIE_USIE_SHIFT)
741 
742 /* Bitfield definition for register: STVEC */
743 /*
744  * BASE_31_2 (RW)
745  *
746  * Base address for interrupt and exception handlers. See description above for alignment requirements when PLIC is in the vector mode.
747  */
748 #define CSR_STVEC_BASE_31_2_MASK (0xFFFFFFFCUL)
749 #define CSR_STVEC_BASE_31_2_SHIFT (2U)
750 #define CSR_STVEC_BASE_31_2_SET(x) (((uint32_t)(x) << CSR_STVEC_BASE_31_2_SHIFT) & CSR_STVEC_BASE_31_2_MASK)
751 #define CSR_STVEC_BASE_31_2_GET(x) (((uint32_t)(x) & CSR_STVEC_BASE_31_2_MASK) >> CSR_STVEC_BASE_31_2_SHIFT)
752 
753 /* Bitfield definition for register: SSCRATCH */
754 /*
755  * SSCRATCH (RW)
756  *
757  * Scratch register storage.
758  */
759 #define CSR_SSCRATCH_SSCRATCH_MASK (0xFFFFFFFFUL)
760 #define CSR_SSCRATCH_SSCRATCH_SHIFT (0U)
761 #define CSR_SSCRATCH_SSCRATCH_SET(x) (((uint32_t)(x) << CSR_SSCRATCH_SSCRATCH_SHIFT) & CSR_SSCRATCH_SSCRATCH_MASK)
762 #define CSR_SSCRATCH_SSCRATCH_GET(x) (((uint32_t)(x) & CSR_SSCRATCH_SSCRATCH_MASK) >> CSR_SSCRATCH_SSCRATCH_SHIFT)
763 
764 /* Bitfield definition for register: SEPC */
765 /*
766  * EPC (RW)
767  *
768  * Exception program counter.
769  */
770 #define CSR_SEPC_EPC_MASK (0xFFFFFFFEUL)
771 #define CSR_SEPC_EPC_SHIFT (1U)
772 #define CSR_SEPC_EPC_SET(x) (((uint32_t)(x) << CSR_SEPC_EPC_SHIFT) & CSR_SEPC_EPC_MASK)
773 #define CSR_SEPC_EPC_GET(x) (((uint32_t)(x) & CSR_SEPC_EPC_MASK) >> CSR_SEPC_EPC_SHIFT)
774 
775 /* Bitfield definition for register: SCAUSE */
776 /*
777  * INTERRUPT (RW)
778  *
779  * Interrupt.
780  */
781 #define CSR_SCAUSE_INTERRUPT_MASK (0x80000000UL)
782 #define CSR_SCAUSE_INTERRUPT_SHIFT (31U)
783 #define CSR_SCAUSE_INTERRUPT_SET(x) (((uint32_t)(x) << CSR_SCAUSE_INTERRUPT_SHIFT) & CSR_SCAUSE_INTERRUPT_MASK)
784 #define CSR_SCAUSE_INTERRUPT_GET(x) (((uint32_t)(x) & CSR_SCAUSE_INTERRUPT_MASK) >> CSR_SCAUSE_INTERRUPT_SHIFT)
785 
786 /*
787  * EXCEPTION_CODE (RW)
788  *
789  * Exception Code.
790  * When interrupt is 1:
791  * 0:User software interrupt
792  * 1:Supervisor software interrupt
793  * 4:User timer interrupt
794  * 5:Supervisor timer interrupt
795  * 8:User external interrupt
796  * 9:Supervisor external interrupt
797  * 256+16:Slave port ECC error interrupt (S-mode)
798  * 256+17:Bus write transaction error interrupt (S-mode)
799  * 256+18:Performance monitor overflow interrupt(S-mode)
800  * When interrupt is 0:
801  * 0:Instruction address misaligned
802  * 1:Instruction access fault
803  * 2:Illegal instruction
804  * 3:Breakpoint
805  * 4:Load address misaligned
806  * 5:Load access fault
807  * 6:Store/AMO address misaligned
808  * 7:Store/AMO access fault
809  * 8:Environment call from U-mode
810  * 9:Environment call from S-mode
811  * 11:10:Reserved
812  * 12:Instruction page fault
813  * 13:Load page fault
814  * 14:Reserved
815  * 15:Store/AMO page fault
816  * 32:Stack overflow exception
817  * 33:Stack underflow exception
818  * 40-47:Reserved
819  */
820 #define CSR_SCAUSE_EXCEPTION_CODE_MASK (0x3FFU)
821 #define CSR_SCAUSE_EXCEPTION_CODE_SHIFT (0U)
822 #define CSR_SCAUSE_EXCEPTION_CODE_SET(x) (((uint32_t)(x) << CSR_SCAUSE_EXCEPTION_CODE_SHIFT) & CSR_SCAUSE_EXCEPTION_CODE_MASK)
823 #define CSR_SCAUSE_EXCEPTION_CODE_GET(x) (((uint32_t)(x) & CSR_SCAUSE_EXCEPTION_CODE_MASK) >> CSR_SCAUSE_EXCEPTION_CODE_SHIFT)
824 
825 /* Bitfield definition for register: STVAL */
826 /*
827  * STVAL (RW)
828  *
829  * Exception-specific information for software trap handling.
830  */
831 #define CSR_STVAL_STVAL_MASK (0xFFFFFFFFUL)
832 #define CSR_STVAL_STVAL_SHIFT (0U)
833 #define CSR_STVAL_STVAL_SET(x) (((uint32_t)(x) << CSR_STVAL_STVAL_SHIFT) & CSR_STVAL_STVAL_MASK)
834 #define CSR_STVAL_STVAL_GET(x) (((uint32_t)(x) & CSR_STVAL_STVAL_MASK) >> CSR_STVAL_STVAL_SHIFT)
835 
836 /* Bitfield definition for register: SIP */
837 /*
838  * SEIP (RO)
839  *
840  * S mode external interrupt pending bit.
841  * 0:Not pending
842  * 1:Pending
843  */
844 #define CSR_SIP_SEIP_MASK (0x200U)
845 #define CSR_SIP_SEIP_SHIFT (9U)
846 #define CSR_SIP_SEIP_GET(x) (((uint32_t)(x) & CSR_SIP_SEIP_MASK) >> CSR_SIP_SEIP_SHIFT)
847 
848 /*
849  * UEIP (RW)
850  *
851  * U mode external interrupt pending bit.
852  * 0:Not pending
853  * 1:Pending
854  */
855 #define CSR_SIP_UEIP_MASK (0x100U)
856 #define CSR_SIP_UEIP_SHIFT (8U)
857 #define CSR_SIP_UEIP_SET(x) (((uint32_t)(x) << CSR_SIP_UEIP_SHIFT) & CSR_SIP_UEIP_MASK)
858 #define CSR_SIP_UEIP_GET(x) (((uint32_t)(x) & CSR_SIP_UEIP_MASK) >> CSR_SIP_UEIP_SHIFT)
859 
860 /*
861  * STIP (RO)
862  *
863  * S mode timer interrupt pending bit.
864  * 0:Not pending
865  * 1:Pending
866  */
867 #define CSR_SIP_STIP_MASK (0x20U)
868 #define CSR_SIP_STIP_SHIFT (5U)
869 #define CSR_SIP_STIP_GET(x) (((uint32_t)(x) & CSR_SIP_STIP_MASK) >> CSR_SIP_STIP_SHIFT)
870 
871 /*
872  * UTIP (RO)
873  *
874  * U mode timer interrupt pending bit
875  * 0:Not pending
876  * 1:Pending
877  */
878 #define CSR_SIP_UTIP_MASK (0x10U)
879 #define CSR_SIP_UTIP_SHIFT (4U)
880 #define CSR_SIP_UTIP_GET(x) (((uint32_t)(x) & CSR_SIP_UTIP_MASK) >> CSR_SIP_UTIP_SHIFT)
881 
882 /*
883  * SSIP (RW)
884  *
885  * S mode software interrupt pending bit.
886  * 0:Not pending
887  * 1:Pending
888  */
889 #define CSR_SIP_SSIP_MASK (0x2U)
890 #define CSR_SIP_SSIP_SHIFT (1U)
891 #define CSR_SIP_SSIP_SET(x) (((uint32_t)(x) << CSR_SIP_SSIP_SHIFT) & CSR_SIP_SSIP_MASK)
892 #define CSR_SIP_SSIP_GET(x) (((uint32_t)(x) & CSR_SIP_SSIP_MASK) >> CSR_SIP_SSIP_SHIFT)
893 
894 /*
895  * USIP (RW)
896  *
897  * U mode software interrupt pending bit.
898  * 0:Not pending
899  * 1:Pending
900  */
901 #define CSR_SIP_USIP_MASK (0x1U)
902 #define CSR_SIP_USIP_SHIFT (0U)
903 #define CSR_SIP_USIP_SET(x) (((uint32_t)(x) << CSR_SIP_USIP_SHIFT) & CSR_SIP_USIP_MASK)
904 #define CSR_SIP_USIP_GET(x) (((uint32_t)(x) & CSR_SIP_USIP_MASK) >> CSR_SIP_USIP_SHIFT)
905 
906 /* Bitfield definition for register: SATP */
907 /*
908  * MODE (RW)
909  *
910  * MODE holds the page translation mode. When MODE is Bare, virtual addresses are equal to physical addresses in S-mode. When MMU is
911  * not supported in the product, this CSR will be
912  * hardwired to 0.
913  * 0:No page translation
914  * 1:Page-based 32-bit virtual addressing
915  */
916 #define CSR_SATP_MODE_MASK (0x80000000UL)
917 #define CSR_SATP_MODE_SHIFT (31U)
918 #define CSR_SATP_MODE_SET(x) (((uint32_t)(x) << CSR_SATP_MODE_SHIFT) & CSR_SATP_MODE_MASK)
919 #define CSR_SATP_MODE_GET(x) (((uint32_t)(x) & CSR_SATP_MODE_MASK) >> CSR_SATP_MODE_SHIFT)
920 
921 /*
922  * ASID (RW)
923  *
924  * ASID holds the address space identifier.
925  */
926 #define CSR_SATP_ASID_MASK (0x7FC00000UL)
927 #define CSR_SATP_ASID_SHIFT (22U)
928 #define CSR_SATP_ASID_SET(x) (((uint32_t)(x) << CSR_SATP_ASID_SHIFT) & CSR_SATP_ASID_MASK)
929 #define CSR_SATP_ASID_GET(x) (((uint32_t)(x) & CSR_SATP_ASID_MASK) >> CSR_SATP_ASID_SHIFT)
930 
931 /*
932  * PPN (RW)
933  *
934  * PPN holds the physical page number of the root page table.
935  */
936 #define CSR_SATP_PPN_MASK (0x3FFFFFUL)
937 #define CSR_SATP_PPN_SHIFT (0U)
938 #define CSR_SATP_PPN_SET(x) (((uint32_t)(x) << CSR_SATP_PPN_SHIFT) & CSR_SATP_PPN_MASK)
939 #define CSR_SATP_PPN_GET(x) (((uint32_t)(x) & CSR_SATP_PPN_MASK) >> CSR_SATP_PPN_SHIFT)
940 
941 /* Bitfield definition for register: MSTATUS */
942 /*
943  * SD (RO)
944  *
945  * SD summarizes whether either the FS field or XS field is dirty.
946  */
947 #define CSR_MSTATUS_SD_MASK (0x80000000UL)
948 #define CSR_MSTATUS_SD_SHIFT (31U)
949 #define CSR_MSTATUS_SD_GET(x) (((uint32_t)(x) & CSR_MSTATUS_SD_MASK) >> CSR_MSTATUS_SD_SHIFT)
950 
951 /*
952  * TSR (RW)
953  *
954  * TSR controls whether executing SRET instructions in S-mode will raise illegal instruction exceptions. It is hardwired to 0 when S-mode is not supported.
955  * 0: Normal execution
956  * 1: Raising exceptions
957  */
958 #define CSR_MSTATUS_TSR_MASK (0x400000UL)
959 #define CSR_MSTATUS_TSR_SHIFT (22U)
960 #define CSR_MSTATUS_TSR_SET(x) (((uint32_t)(x) << CSR_MSTATUS_TSR_SHIFT) & CSR_MSTATUS_TSR_MASK)
961 #define CSR_MSTATUS_TSR_GET(x) (((uint32_t)(x) & CSR_MSTATUS_TSR_MASK) >> CSR_MSTATUS_TSR_SHIFT)
962 
963 /*
964  * TW (RW)
965  *
966  * TW controls whether executing WFI instructions in S-mode will raise illegal instruction exceptions. It is hardwired to 0 when S-mode is not supported.
967  * 0: Normal execution
968  * 1: Raising exceptions
969  */
970 #define CSR_MSTATUS_TW_MASK (0x200000UL)
971 #define CSR_MSTATUS_TW_SHIFT (21U)
972 #define CSR_MSTATUS_TW_SET(x) (((uint32_t)(x) << CSR_MSTATUS_TW_SHIFT) & CSR_MSTATUS_TW_MASK)
973 #define CSR_MSTATUS_TW_GET(x) (((uint32_t)(x) & CSR_MSTATUS_TW_MASK) >> CSR_MSTATUS_TW_SHIFT)
974 
975 /*
976  * TVM (RW)
977  *
978  * TVM controls whether performing certain virtual memory operations in S-mode will raise illegal instruction exceptions. The operations include accessing the satp register and executing the SFENCE.VMA instruction. It is hardwired to 0 when S-mode is not supported.
979  * 0:Normal execution
980  * 1:Raising exceptions
981  */
982 #define CSR_MSTATUS_TVM_MASK (0x100000UL)
983 #define CSR_MSTATUS_TVM_SHIFT (20U)
984 #define CSR_MSTATUS_TVM_SET(x) (((uint32_t)(x) << CSR_MSTATUS_TVM_SHIFT) & CSR_MSTATUS_TVM_MASK)
985 #define CSR_MSTATUS_TVM_GET(x) (((uint32_t)(x) & CSR_MSTATUS_TVM_MASK) >> CSR_MSTATUS_TVM_SHIFT)
986 
987 /*
988  * MXR (RW)
989  *
990  * MXR controls whether execute-only pages are readable. It has no effect when page-based virtual memory is not in effect
991  * 0:Execute-only pages are not readable
992  * 1:Execute-only pages are readable
993  */
994 #define CSR_MSTATUS_MXR_MASK (0x80000UL)
995 #define CSR_MSTATUS_MXR_SHIFT (19U)
996 #define CSR_MSTATUS_MXR_SET(x) (((uint32_t)(x) << CSR_MSTATUS_MXR_SHIFT) & CSR_MSTATUS_MXR_MASK)
997 #define CSR_MSTATUS_MXR_GET(x) (((uint32_t)(x) & CSR_MSTATUS_MXR_MASK) >> CSR_MSTATUS_MXR_SHIFT)
998 
999 /*
1000  * SUM (RW)
1001  *
1002  * SUM controls whether a S-mode load/store instruction to a user accessible page is allowed or not when page translation is enabled. It is in effect in two scenarios: (a) M-mode with MPRV=1 and MPP=S, and (b) in S-mode. It has no effect when page-based virtual memory is not in effect. A page is user accessible when the U bit of the corresponding PTE entry is 1. It is hardwired to 0 when S-mode is not supported.
1003  * 0:Not Allowed
1004  * 1:Allowed
1005  */
1006 #define CSR_MSTATUS_SUM_MASK (0x40000UL)
1007 #define CSR_MSTATUS_SUM_SHIFT (18U)
1008 #define CSR_MSTATUS_SUM_SET(x) (((uint32_t)(x) << CSR_MSTATUS_SUM_SHIFT) & CSR_MSTATUS_SUM_MASK)
1009 #define CSR_MSTATUS_SUM_GET(x) (((uint32_t)(x) & CSR_MSTATUS_SUM_MASK) >> CSR_MSTATUS_SUM_SHIFT)
1010 
1011 /*
1012  * MPRV (RW)
1013  *
1014  * 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.
1015  */
1016 #define CSR_MSTATUS_MPRV_MASK (0x20000UL)
1017 #define CSR_MSTATUS_MPRV_SHIFT (17U)
1018 #define CSR_MSTATUS_MPRV_SET(x) (((uint32_t)(x) << CSR_MSTATUS_MPRV_SHIFT) & CSR_MSTATUS_MPRV_MASK)
1019 #define CSR_MSTATUS_MPRV_GET(x) (((uint32_t)(x) & CSR_MSTATUS_MPRV_MASK) >> CSR_MSTATUS_MPRV_SHIFT)
1020 
1021 /*
1022  * XS (RO)
1023  *
1024  * 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:
1025  * Illegal instruction exceptions are triggered when XS is Off.
1026  * 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.
1027  * 0:Off
1028  * 1:Initial
1029  * 2:Clean
1030  * 3:Dirty
1031  */
1032 #define CSR_MSTATUS_XS_MASK (0x18000UL)
1033 #define CSR_MSTATUS_XS_SHIFT (15U)
1034 #define CSR_MSTATUS_XS_GET(x) (((uint32_t)(x) & CSR_MSTATUS_XS_MASK) >> CSR_MSTATUS_XS_SHIFT)
1035 
1036 /*
1037  * FS (RW)
1038  *
1039  * 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
1040  * managements in two regards:
1041  * Attempts to access fcsr or any f register raise an illegal-instruction exception when FS is Off.
1042  * 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.
1043  * 0:Off
1044  * 1:Initial
1045  * 2:Clean
1046  * 3:Dirty
1047  */
1048 #define CSR_MSTATUS_FS_MASK (0x6000U)
1049 #define CSR_MSTATUS_FS_SHIFT (13U)
1050 #define CSR_MSTATUS_FS_SET(x) (((uint32_t)(x) << CSR_MSTATUS_FS_SHIFT) & CSR_MSTATUS_FS_MASK)
1051 #define CSR_MSTATUS_FS_GET(x) (((uint32_t)(x) & CSR_MSTATUS_FS_MASK) >> CSR_MSTATUS_FS_SHIFT)
1052 
1053 /*
1054  * MPP (RW)
1055  *
1056  * 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.
1057  */
1058 #define CSR_MSTATUS_MPP_MASK (0x1800U)
1059 #define CSR_MSTATUS_MPP_SHIFT (11U)
1060 #define CSR_MSTATUS_MPP_SET(x) (((uint32_t)(x) << CSR_MSTATUS_MPP_SHIFT) & CSR_MSTATUS_MPP_MASK)
1061 #define CSR_MSTATUS_MPP_GET(x) (((uint32_t)(x) & CSR_MSTATUS_MPP_MASK) >> CSR_MSTATUS_MPP_SHIFT)
1062 
1063 /*
1064  * SPP (RW)
1065  *
1066  * SPP holds the privilege mode prior to a trap. Encoding is 1 for S-mode and 0 for U-mode.
1067  */
1068 #define CSR_MSTATUS_SPP_MASK (0x100U)
1069 #define CSR_MSTATUS_SPP_SHIFT (8U)
1070 #define CSR_MSTATUS_SPP_SET(x) (((uint32_t)(x) << CSR_MSTATUS_SPP_SHIFT) & CSR_MSTATUS_SPP_MASK)
1071 #define CSR_MSTATUS_SPP_GET(x) (((uint32_t)(x) & CSR_MSTATUS_SPP_MASK) >> CSR_MSTATUS_SPP_SHIFT)
1072 
1073 /*
1074  * MPIE (RW)
1075  *
1076  * MPIE holds the value of the MIE bit prior to a trap.
1077  */
1078 #define CSR_MSTATUS_MPIE_MASK (0x80U)
1079 #define CSR_MSTATUS_MPIE_SHIFT (7U)
1080 #define CSR_MSTATUS_MPIE_SET(x) (((uint32_t)(x) << CSR_MSTATUS_MPIE_SHIFT) & CSR_MSTATUS_MPIE_MASK)
1081 #define CSR_MSTATUS_MPIE_GET(x) (((uint32_t)(x) & CSR_MSTATUS_MPIE_MASK) >> CSR_MSTATUS_MPIE_SHIFT)
1082 
1083 /*
1084  * SPIE (RW)
1085  *
1086  * SPIE holds the value of the SIE bit prior to a trap.
1087  */
1088 #define CSR_MSTATUS_SPIE_MASK (0x20U)
1089 #define CSR_MSTATUS_SPIE_SHIFT (5U)
1090 #define CSR_MSTATUS_SPIE_SET(x) (((uint32_t)(x) << CSR_MSTATUS_SPIE_SHIFT) & CSR_MSTATUS_SPIE_MASK)
1091 #define CSR_MSTATUS_SPIE_GET(x) (((uint32_t)(x) & CSR_MSTATUS_SPIE_MASK) >> CSR_MSTATUS_SPIE_SHIFT)
1092 
1093 /*
1094  * UPIE (RW)
1095  *
1096  * UPIE holds the value of the UIE bit prior to a trap.
1097  */
1098 #define CSR_MSTATUS_UPIE_MASK (0x10U)
1099 #define CSR_MSTATUS_UPIE_SHIFT (4U)
1100 #define CSR_MSTATUS_UPIE_SET(x) (((uint32_t)(x) << CSR_MSTATUS_UPIE_SHIFT) & CSR_MSTATUS_UPIE_MASK)
1101 #define CSR_MSTATUS_UPIE_GET(x) (((uint32_t)(x) & CSR_MSTATUS_UPIE_MASK) >> CSR_MSTATUS_UPIE_SHIFT)
1102 
1103 /*
1104  * MIE (RW)
1105  *
1106  * M mode interrupt enable bit.
1107  * 0: Disabled
1108  * 1: Enabled
1109  */
1110 #define CSR_MSTATUS_MIE_MASK (0x8U)
1111 #define CSR_MSTATUS_MIE_SHIFT (3U)
1112 #define CSR_MSTATUS_MIE_SET(x) (((uint32_t)(x) << CSR_MSTATUS_MIE_SHIFT) & CSR_MSTATUS_MIE_MASK)
1113 #define CSR_MSTATUS_MIE_GET(x) (((uint32_t)(x) & CSR_MSTATUS_MIE_MASK) >> CSR_MSTATUS_MIE_SHIFT)
1114 
1115 /*
1116  * SIE (RW)
1117  *
1118  * S mode interrupt enable bit.
1119  * 0: Disabled
1120  * 1: Enabled
1121  */
1122 #define CSR_MSTATUS_SIE_MASK (0x2U)
1123 #define CSR_MSTATUS_SIE_SHIFT (1U)
1124 #define CSR_MSTATUS_SIE_SET(x) (((uint32_t)(x) << CSR_MSTATUS_SIE_SHIFT) & CSR_MSTATUS_SIE_MASK)
1125 #define CSR_MSTATUS_SIE_GET(x) (((uint32_t)(x) & CSR_MSTATUS_SIE_MASK) >> CSR_MSTATUS_SIE_SHIFT)
1126 
1127 /*
1128  * UIE (RW)
1129  *
1130  * U mode interrupt enable bit.
1131  * 0: Disabled
1132  * 1: Enabled
1133  */
1134 #define CSR_MSTATUS_UIE_MASK (0x1U)
1135 #define CSR_MSTATUS_UIE_SHIFT (0U)
1136 #define CSR_MSTATUS_UIE_SET(x) (((uint32_t)(x) << CSR_MSTATUS_UIE_SHIFT) & CSR_MSTATUS_UIE_MASK)
1137 #define CSR_MSTATUS_UIE_GET(x) (((uint32_t)(x) & CSR_MSTATUS_UIE_MASK) >> CSR_MSTATUS_UIE_SHIFT)
1138 
1139 /* Bitfield definition for register: MISA */
1140 /*
1141  * BASE (RO)
1142  *
1143  * The general-purpose register width of the native base integer ISA.
1144  * 0:Reserved
1145  * 1:32
1146  * 2:64
1147  * 3:128
1148  */
1149 #define CSR_MISA_BASE_MASK (0xC0000000UL)
1150 #define CSR_MISA_BASE_SHIFT (30U)
1151 #define CSR_MISA_BASE_GET(x) (((uint32_t)(x) & CSR_MISA_BASE_MASK) >> CSR_MISA_BASE_SHIFT)
1152 
1153 /*
1154  * Z (RO)
1155  *
1156  * Reserved
1157  */
1158 #define CSR_MISA_Z_MASK (0x2000000UL)
1159 #define CSR_MISA_Z_SHIFT (25U)
1160 #define CSR_MISA_Z_GET(x) (((uint32_t)(x) & CSR_MISA_Z_MASK) >> CSR_MISA_Z_SHIFT)
1161 
1162 /*
1163  * Y (RO)
1164  *
1165  * Reserved
1166  */
1167 #define CSR_MISA_Y_MASK (0x1000000UL)
1168 #define CSR_MISA_Y_SHIFT (24U)
1169 #define CSR_MISA_Y_GET(x) (((uint32_t)(x) & CSR_MISA_Y_MASK) >> CSR_MISA_Y_SHIFT)
1170 
1171 /*
1172  * X (RO)
1173  *
1174  * Non-standard extensions present
1175  */
1176 #define CSR_MISA_X_MASK (0x800000UL)
1177 #define CSR_MISA_X_SHIFT (23U)
1178 #define CSR_MISA_X_GET(x) (((uint32_t)(x) & CSR_MISA_X_MASK) >> CSR_MISA_X_SHIFT)
1179 
1180 /*
1181  * W (RO)
1182  *
1183  * Reserved
1184  */
1185 #define CSR_MISA_W_MASK (0x400000UL)
1186 #define CSR_MISA_W_SHIFT (22U)
1187 #define CSR_MISA_W_GET(x) (((uint32_t)(x) & CSR_MISA_W_MASK) >> CSR_MISA_W_SHIFT)
1188 
1189 /*
1190  * V (RO)
1191  *
1192  * Tentatively reserved for Vector extension
1193  */
1194 #define CSR_MISA_V_MASK (0x200000UL)
1195 #define CSR_MISA_V_SHIFT (21U)
1196 #define CSR_MISA_V_GET(x) (((uint32_t)(x) & CSR_MISA_V_MASK) >> CSR_MISA_V_SHIFT)
1197 
1198 /*
1199  * U (RO)
1200  *
1201  * User mode implemented
1202  * 0:Machine
1203  * 1:Machine + User / Machine + Supervisor + User
1204  */
1205 #define CSR_MISA_U_MASK (0x100000UL)
1206 #define CSR_MISA_U_SHIFT (20U)
1207 #define CSR_MISA_U_GET(x) (((uint32_t)(x) & CSR_MISA_U_MASK) >> CSR_MISA_U_SHIFT)
1208 
1209 /*
1210  * T (RO)
1211  *
1212  * Tentatively reserved for Transactional Memory extension
1213  */
1214 #define CSR_MISA_T_MASK (0x80000UL)
1215 #define CSR_MISA_T_SHIFT (19U)
1216 #define CSR_MISA_T_GET(x) (((uint32_t)(x) & CSR_MISA_T_MASK) >> CSR_MISA_T_SHIFT)
1217 
1218 /*
1219  * S (RO)
1220  *
1221  * Supervisor mode implemented
1222  * 0:Machine / Machine + User
1223  * 1:Machine + Supervisor + User
1224  */
1225 #define CSR_MISA_S_MASK (0x40000UL)
1226 #define CSR_MISA_S_SHIFT (18U)
1227 #define CSR_MISA_S_GET(x) (((uint32_t)(x) & CSR_MISA_S_MASK) >> CSR_MISA_S_SHIFT)
1228 
1229 /*
1230  * R (RO)
1231  *
1232  * Reserved
1233  */
1234 #define CSR_MISA_R_MASK (0x20000UL)
1235 #define CSR_MISA_R_SHIFT (17U)
1236 #define CSR_MISA_R_GET(x) (((uint32_t)(x) & CSR_MISA_R_MASK) >> CSR_MISA_R_SHIFT)
1237 
1238 /*
1239  * Q (RO)
1240  *
1241  * Quad-precision floating-point extension
1242  */
1243 #define CSR_MISA_Q_MASK (0x10000UL)
1244 #define CSR_MISA_Q_SHIFT (16U)
1245 #define CSR_MISA_Q_GET(x) (((uint32_t)(x) & CSR_MISA_Q_MASK) >> CSR_MISA_Q_SHIFT)
1246 
1247 /*
1248  * P (RO)
1249  *
1250  * Tentatively reserved for Packed-SIMD extension
1251  */
1252 #define CSR_MISA_P_MASK (0x8000U)
1253 #define CSR_MISA_P_SHIFT (15U)
1254 #define CSR_MISA_P_GET(x) (((uint32_t)(x) & CSR_MISA_P_MASK) >> CSR_MISA_P_SHIFT)
1255 
1256 /*
1257  * O (RO)
1258  *
1259  * Reserved
1260  */
1261 #define CSR_MISA_O_MASK (0x4000U)
1262 #define CSR_MISA_O_SHIFT (14U)
1263 #define CSR_MISA_O_GET(x) (((uint32_t)(x) & CSR_MISA_O_MASK) >> CSR_MISA_O_SHIFT)
1264 
1265 /*
1266  * N (RO)
1267  *
1268  * User-level interrupts supported
1269  * 0:no
1270  * 1:yes
1271  */
1272 #define CSR_MISA_N_MASK (0x2000U)
1273 #define CSR_MISA_N_SHIFT (13U)
1274 #define CSR_MISA_N_GET(x) (((uint32_t)(x) & CSR_MISA_N_MASK) >> CSR_MISA_N_SHIFT)
1275 
1276 /*
1277  * M (RO)
1278  *
1279  * Integer Multiply/Divide extension
1280  */
1281 #define CSR_MISA_M_MASK (0x1000U)
1282 #define CSR_MISA_M_SHIFT (12U)
1283 #define CSR_MISA_M_GET(x) (((uint32_t)(x) & CSR_MISA_M_MASK) >> CSR_MISA_M_SHIFT)
1284 
1285 /*
1286  * L (RO)
1287  *
1288  * Tentatively reserved for Decimal Floating-Point extension
1289  */
1290 #define CSR_MISA_L_MASK (0x800U)
1291 #define CSR_MISA_L_SHIFT (11U)
1292 #define CSR_MISA_L_GET(x) (((uint32_t)(x) & CSR_MISA_L_MASK) >> CSR_MISA_L_SHIFT)
1293 
1294 /*
1295  * K (RO)
1296  *
1297  * Reserved
1298  */
1299 #define CSR_MISA_K_MASK (0x400U)
1300 #define CSR_MISA_K_SHIFT (10U)
1301 #define CSR_MISA_K_GET(x) (((uint32_t)(x) & CSR_MISA_K_MASK) >> CSR_MISA_K_SHIFT)
1302 
1303 /*
1304  * J (RO)
1305  *
1306  * Tentatively reserved for Dynamically Translated Languages extension
1307  */
1308 #define CSR_MISA_J_MASK (0x200U)
1309 #define CSR_MISA_J_SHIFT (9U)
1310 #define CSR_MISA_J_GET(x) (((uint32_t)(x) & CSR_MISA_J_MASK) >> CSR_MISA_J_SHIFT)
1311 
1312 /*
1313  * I (RO)
1314  *
1315  * RV32I/64I/128I base ISA
1316  */
1317 #define CSR_MISA_I_MASK (0x100U)
1318 #define CSR_MISA_I_SHIFT (8U)
1319 #define CSR_MISA_I_GET(x) (((uint32_t)(x) & CSR_MISA_I_MASK) >> CSR_MISA_I_SHIFT)
1320 
1321 /*
1322  * H (RO)
1323  *
1324  * Reserved
1325  */
1326 #define CSR_MISA_H_MASK (0x80U)
1327 #define CSR_MISA_H_SHIFT (7U)
1328 #define CSR_MISA_H_GET(x) (((uint32_t)(x) & CSR_MISA_H_MASK) >> CSR_MISA_H_SHIFT)
1329 
1330 /*
1331  * G (RO)
1332  *
1333  * Additional standard extensions present
1334  */
1335 #define CSR_MISA_G_MASK (0x40U)
1336 #define CSR_MISA_G_SHIFT (6U)
1337 #define CSR_MISA_G_GET(x) (((uint32_t)(x) & CSR_MISA_G_MASK) >> CSR_MISA_G_SHIFT)
1338 
1339 /*
1340  * F (RO)
1341  *
1342  * Single-precision floating-point extension
1343  * 0:none
1344  * 1:double+single precision / single precision
1345  */
1346 #define CSR_MISA_F_MASK (0x20U)
1347 #define CSR_MISA_F_SHIFT (5U)
1348 #define CSR_MISA_F_GET(x) (((uint32_t)(x) & CSR_MISA_F_MASK) >> CSR_MISA_F_SHIFT)
1349 
1350 /*
1351  * E (RO)
1352  *
1353  * RV32E base ISA
1354  */
1355 #define CSR_MISA_E_MASK (0x10U)
1356 #define CSR_MISA_E_SHIFT (4U)
1357 #define CSR_MISA_E_GET(x) (((uint32_t)(x) & CSR_MISA_E_MASK) >> CSR_MISA_E_SHIFT)
1358 
1359 /*
1360  * D (RO)
1361  *
1362  * Double-precision floating-point extension
1363  * 0:single precision / none
1364  * 1:double+single precision
1365  */
1366 #define CSR_MISA_D_MASK (0x8U)
1367 #define CSR_MISA_D_SHIFT (3U)
1368 #define CSR_MISA_D_GET(x) (((uint32_t)(x) & CSR_MISA_D_MASK) >> CSR_MISA_D_SHIFT)
1369 
1370 /*
1371  * C (RO)
1372  *
1373  * Compressed extension
1374  */
1375 #define CSR_MISA_C_MASK (0x4U)
1376 #define CSR_MISA_C_SHIFT (2U)
1377 #define CSR_MISA_C_GET(x) (((uint32_t)(x) & CSR_MISA_C_MASK) >> CSR_MISA_C_SHIFT)
1378 
1379 /*
1380  * B (RO)
1381  *
1382  * Tentatively reserved for Bit operations extension
1383  */
1384 #define CSR_MISA_B_MASK (0x2U)
1385 #define CSR_MISA_B_SHIFT (1U)
1386 #define CSR_MISA_B_GET(x) (((uint32_t)(x) & CSR_MISA_B_MASK) >> CSR_MISA_B_SHIFT)
1387 
1388 /*
1389  * A (RO)
1390  *
1391  * Atomic extension
1392  * 0:no
1393  * 1:yes
1394  */
1395 #define CSR_MISA_A_MASK (0x1U)
1396 #define CSR_MISA_A_SHIFT (0U)
1397 #define CSR_MISA_A_GET(x) (((uint32_t)(x) & CSR_MISA_A_MASK) >> CSR_MISA_A_SHIFT)
1398 
1399 /* Bitfield definition for register: MEDELEG */
1400 /*
1401  * SPF (RW)
1402  *
1403  * SPF indicates whether a Store/AMO Page Fault exception will be delegated to S-mode.
1404  * 0:Not delegate
1405  * 1:delegate
1406  */
1407 #define CSR_MEDELEG_SPF_MASK (0x8000U)
1408 #define CSR_MEDELEG_SPF_SHIFT (15U)
1409 #define CSR_MEDELEG_SPF_SET(x) (((uint32_t)(x) << CSR_MEDELEG_SPF_SHIFT) & CSR_MEDELEG_SPF_MASK)
1410 #define CSR_MEDELEG_SPF_GET(x) (((uint32_t)(x) & CSR_MEDELEG_SPF_MASK) >> CSR_MEDELEG_SPF_SHIFT)
1411 
1412 /*
1413  * LPF (RW)
1414  *
1415  * LPF indicates whether a Load Page Fault exception will be delegated to S-mode.
1416  * 0:Not delegate
1417  * 1:delegate
1418  */
1419 #define CSR_MEDELEG_LPF_MASK (0x2000U)
1420 #define CSR_MEDELEG_LPF_SHIFT (13U)
1421 #define CSR_MEDELEG_LPF_SET(x) (((uint32_t)(x) << CSR_MEDELEG_LPF_SHIFT) & CSR_MEDELEG_LPF_MASK)
1422 #define CSR_MEDELEG_LPF_GET(x) (((uint32_t)(x) & CSR_MEDELEG_LPF_MASK) >> CSR_MEDELEG_LPF_SHIFT)
1423 
1424 /*
1425  * IPF (RW)
1426  *
1427  * IPF indicates whether an Instruction Page Fault exception will be delegated to S-mode.
1428  * 0:Not delegate
1429  * 1:delegate
1430  */
1431 #define CSR_MEDELEG_IPF_MASK (0x1000U)
1432 #define CSR_MEDELEG_IPF_SHIFT (12U)
1433 #define CSR_MEDELEG_IPF_SET(x) (((uint32_t)(x) << CSR_MEDELEG_IPF_SHIFT) & CSR_MEDELEG_IPF_MASK)
1434 #define CSR_MEDELEG_IPF_GET(x) (((uint32_t)(x) & CSR_MEDELEG_IPF_MASK) >> CSR_MEDELEG_IPF_SHIFT)
1435 
1436 /*
1437  * SEC (RW)
1438  *
1439  * SEC indicates whether an exception triggered by environment call from S-mode will be delegated to S-mode.
1440  * 0:Not delegate
1441  * 1:delegate
1442  */
1443 #define CSR_MEDELEG_SEC_MASK (0x200U)
1444 #define CSR_MEDELEG_SEC_SHIFT (9U)
1445 #define CSR_MEDELEG_SEC_SET(x) (((uint32_t)(x) << CSR_MEDELEG_SEC_SHIFT) & CSR_MEDELEG_SEC_MASK)
1446 #define CSR_MEDELEG_SEC_GET(x) (((uint32_t)(x) & CSR_MEDELEG_SEC_MASK) >> CSR_MEDELEG_SEC_SHIFT)
1447 
1448 /*
1449  * UEC (RW)
1450  *
1451  * UEC indicates whether an exception triggered by environment call from U-mode will be delegated to S-mode.
1452  * 0:Not delegate
1453  * 1:delegate
1454  */
1455 #define CSR_MEDELEG_UEC_MASK (0x100U)
1456 #define CSR_MEDELEG_UEC_SHIFT (8U)
1457 #define CSR_MEDELEG_UEC_SET(x) (((uint32_t)(x) << CSR_MEDELEG_UEC_SHIFT) & CSR_MEDELEG_UEC_MASK)
1458 #define CSR_MEDELEG_UEC_GET(x) (((uint32_t)(x) & CSR_MEDELEG_UEC_MASK) >> CSR_MEDELEG_UEC_SHIFT)
1459 
1460 /*
1461  * SAF (RW)
1462  *
1463  * SAF indicates whether a Store/AMO Access Fault exception will be delegated to S-mode.
1464  * 0:Not delegate
1465  * 1:delegate
1466  */
1467 #define CSR_MEDELEG_SAF_MASK (0x80U)
1468 #define CSR_MEDELEG_SAF_SHIFT (7U)
1469 #define CSR_MEDELEG_SAF_SET(x) (((uint32_t)(x) << CSR_MEDELEG_SAF_SHIFT) & CSR_MEDELEG_SAF_MASK)
1470 #define CSR_MEDELEG_SAF_GET(x) (((uint32_t)(x) & CSR_MEDELEG_SAF_MASK) >> CSR_MEDELEG_SAF_SHIFT)
1471 
1472 /*
1473  * SAM (RW)
1474  *
1475  * SAM indicates whether a Store/AMO Address Misaligned exception will be delegated to S-mode
1476  * 0:Not delegate
1477  * 1:delegate
1478  */
1479 #define CSR_MEDELEG_SAM_MASK (0x40U)
1480 #define CSR_MEDELEG_SAM_SHIFT (6U)
1481 #define CSR_MEDELEG_SAM_SET(x) (((uint32_t)(x) << CSR_MEDELEG_SAM_SHIFT) & CSR_MEDELEG_SAM_MASK)
1482 #define CSR_MEDELEG_SAM_GET(x) (((uint32_t)(x) & CSR_MEDELEG_SAM_MASK) >> CSR_MEDELEG_SAM_SHIFT)
1483 
1484 /*
1485  * LAF (RW)
1486  *
1487  * LAF indicates whether a Load Access Fault exception will be delegated to S-mode.
1488  * 0:Not delegate
1489  * 1:delegate
1490  */
1491 #define CSR_MEDELEG_LAF_MASK (0x20U)
1492 #define CSR_MEDELEG_LAF_SHIFT (5U)
1493 #define CSR_MEDELEG_LAF_SET(x) (((uint32_t)(x) << CSR_MEDELEG_LAF_SHIFT) & CSR_MEDELEG_LAF_MASK)
1494 #define CSR_MEDELEG_LAF_GET(x) (((uint32_t)(x) & CSR_MEDELEG_LAF_MASK) >> CSR_MEDELEG_LAF_SHIFT)
1495 
1496 /*
1497  * LAM (RW)
1498  *
1499  * LAM indicates whether a Load Address Misaligned exception will be delegated to S-mode.
1500  * 0:Not delegate
1501  * 1:delegate
1502  */
1503 #define CSR_MEDELEG_LAM_MASK (0x10U)
1504 #define CSR_MEDELEG_LAM_SHIFT (4U)
1505 #define CSR_MEDELEG_LAM_SET(x) (((uint32_t)(x) << CSR_MEDELEG_LAM_SHIFT) & CSR_MEDELEG_LAM_MASK)
1506 #define CSR_MEDELEG_LAM_GET(x) (((uint32_t)(x) & CSR_MEDELEG_LAM_MASK) >> CSR_MEDELEG_LAM_SHIFT)
1507 
1508 /*
1509  * II (RW)
1510  *
1511  * II indicates whether an Illegal Instruction exception will be delegated to S-mode.
1512  * 0:Not delegate
1513  * 1:delegate
1514  */
1515 #define CSR_MEDELEG_II_MASK (0x4U)
1516 #define CSR_MEDELEG_II_SHIFT (2U)
1517 #define CSR_MEDELEG_II_SET(x) (((uint32_t)(x) << CSR_MEDELEG_II_SHIFT) & CSR_MEDELEG_II_MASK)
1518 #define CSR_MEDELEG_II_GET(x) (((uint32_t)(x) & CSR_MEDELEG_II_MASK) >> CSR_MEDELEG_II_SHIFT)
1519 
1520 /*
1521  * IAF (RW)
1522  *
1523  * IAF indicates whether an Instruction Access Fault exception will be delegated to S-mode.
1524  * 0:Not delegate
1525  * 1:delegate
1526  */
1527 #define CSR_MEDELEG_IAF_MASK (0x2U)
1528 #define CSR_MEDELEG_IAF_SHIFT (1U)
1529 #define CSR_MEDELEG_IAF_SET(x) (((uint32_t)(x) << CSR_MEDELEG_IAF_SHIFT) & CSR_MEDELEG_IAF_MASK)
1530 #define CSR_MEDELEG_IAF_GET(x) (((uint32_t)(x) & CSR_MEDELEG_IAF_MASK) >> CSR_MEDELEG_IAF_SHIFT)
1531 
1532 /*
1533  * IAM (RW)
1534  *
1535  * IAM indicates whether an Instruction Address Misaligned exception will be delegated to S-Mode
1536  * 0:Not delegate
1537  * 1:delegate
1538  */
1539 #define CSR_MEDELEG_IAM_MASK (0x1U)
1540 #define CSR_MEDELEG_IAM_SHIFT (0U)
1541 #define CSR_MEDELEG_IAM_SET(x) (((uint32_t)(x) << CSR_MEDELEG_IAM_SHIFT) & CSR_MEDELEG_IAM_MASK)
1542 #define CSR_MEDELEG_IAM_GET(x) (((uint32_t)(x) & CSR_MEDELEG_IAM_MASK) >> CSR_MEDELEG_IAM_SHIFT)
1543 
1544 /* Bitfield definition for register: MIDELEG */
1545 /*
1546  * SEI (RW)
1547  *
1548  * SEI indicates whether an S-mode external interrupt will be delegated to S-mode.
1549  * 0:Not delegate
1550  * 1:delegate
1551  */
1552 #define CSR_MIDELEG_SEI_MASK (0x200U)
1553 #define CSR_MIDELEG_SEI_SHIFT (9U)
1554 #define CSR_MIDELEG_SEI_SET(x) (((uint32_t)(x) << CSR_MIDELEG_SEI_SHIFT) & CSR_MIDELEG_SEI_MASK)
1555 #define CSR_MIDELEG_SEI_GET(x) (((uint32_t)(x) & CSR_MIDELEG_SEI_MASK) >> CSR_MIDELEG_SEI_SHIFT)
1556 
1557 /*
1558  * UEI (RW)
1559  *
1560  * UEI indicates whether an U-mode external interrupt will be delegated to S-mode.
1561  * 0:Not delegate
1562  * 1:delegate
1563  */
1564 #define CSR_MIDELEG_UEI_MASK (0x100U)
1565 #define CSR_MIDELEG_UEI_SHIFT (8U)
1566 #define CSR_MIDELEG_UEI_SET(x) (((uint32_t)(x) << CSR_MIDELEG_UEI_SHIFT) & CSR_MIDELEG_UEI_MASK)
1567 #define CSR_MIDELEG_UEI_GET(x) (((uint32_t)(x) & CSR_MIDELEG_UEI_MASK) >> CSR_MIDELEG_UEI_SHIFT)
1568 
1569 /*
1570  * STI (RW)
1571  *
1572  * STI indicates whether an S-mode timer interrupt will be delegated to S-mode.
1573  * 0:Not delegate
1574  * 1:delegate
1575  */
1576 #define CSR_MIDELEG_STI_MASK (0x20U)
1577 #define CSR_MIDELEG_STI_SHIFT (5U)
1578 #define CSR_MIDELEG_STI_SET(x) (((uint32_t)(x) << CSR_MIDELEG_STI_SHIFT) & CSR_MIDELEG_STI_MASK)
1579 #define CSR_MIDELEG_STI_GET(x) (((uint32_t)(x) & CSR_MIDELEG_STI_MASK) >> CSR_MIDELEG_STI_SHIFT)
1580 
1581 /*
1582  * UTI (RW)
1583  *
1584  * UTI indicates whether an U-mode timer interrupt will be delegated to S-mode.
1585  * 0:Not delegate
1586  * 1:delegate
1587  */
1588 #define CSR_MIDELEG_UTI_MASK (0x10U)
1589 #define CSR_MIDELEG_UTI_SHIFT (4U)
1590 #define CSR_MIDELEG_UTI_SET(x) (((uint32_t)(x) << CSR_MIDELEG_UTI_SHIFT) & CSR_MIDELEG_UTI_MASK)
1591 #define CSR_MIDELEG_UTI_GET(x) (((uint32_t)(x) & CSR_MIDELEG_UTI_MASK) >> CSR_MIDELEG_UTI_SHIFT)
1592 
1593 /*
1594  * SSI (RW)
1595  *
1596  * SSI indicates whether an S-mode software interrupt will be delegated to S-mode.
1597  * 0:Not delegate
1598  * 1:delegate
1599  */
1600 #define CSR_MIDELEG_SSI_MASK (0x2U)
1601 #define CSR_MIDELEG_SSI_SHIFT (1U)
1602 #define CSR_MIDELEG_SSI_SET(x) (((uint32_t)(x) << CSR_MIDELEG_SSI_SHIFT) & CSR_MIDELEG_SSI_MASK)
1603 #define CSR_MIDELEG_SSI_GET(x) (((uint32_t)(x) & CSR_MIDELEG_SSI_MASK) >> CSR_MIDELEG_SSI_SHIFT)
1604 
1605 /*
1606  * USI (RW)
1607  *
1608  * USI indicates whether an U-mode software interrupt will be delegated to S-mode.
1609  * 0:Not delegate
1610  * 1:delegate
1611  */
1612 #define CSR_MIDELEG_USI_MASK (0x1U)
1613 #define CSR_MIDELEG_USI_SHIFT (0U)
1614 #define CSR_MIDELEG_USI_SET(x) (((uint32_t)(x) << CSR_MIDELEG_USI_SHIFT) & CSR_MIDELEG_USI_MASK)
1615 #define CSR_MIDELEG_USI_GET(x) (((uint32_t)(x) & CSR_MIDELEG_USI_MASK) >> CSR_MIDELEG_USI_SHIFT)
1616 
1617 /* Bitfield definition for register: MIE */
1618 /*
1619  * PMOVI (RW)
1620  *
1621  * Performance monitor overflow local interrupt enable bit
1622  * 0:Disabled
1623  * 1:Enabled
1624  */
1625 #define CSR_MIE_PMOVI_MASK (0x40000UL)
1626 #define CSR_MIE_PMOVI_SHIFT (18U)
1627 #define CSR_MIE_PMOVI_SET(x) (((uint32_t)(x) << CSR_MIE_PMOVI_SHIFT) & CSR_MIE_PMOVI_MASK)
1628 #define CSR_MIE_PMOVI_GET(x) (((uint32_t)(x) & CSR_MIE_PMOVI_MASK) >> CSR_MIE_PMOVI_SHIFT)
1629 
1630 /*
1631  * BWEI (RW)
1632  *
1633  * Bus read/write transaction error local interrupt enable bit. The processor may receive bus errors on load/store instructions or cache writebacks.
1634  * 0:Disabled
1635  * 1:Enabled
1636  */
1637 #define CSR_MIE_BWEI_MASK (0x20000UL)
1638 #define CSR_MIE_BWEI_SHIFT (17U)
1639 #define CSR_MIE_BWEI_SET(x) (((uint32_t)(x) << CSR_MIE_BWEI_SHIFT) & CSR_MIE_BWEI_MASK)
1640 #define CSR_MIE_BWEI_GET(x) (((uint32_t)(x) & CSR_MIE_BWEI_MASK) >> CSR_MIE_BWEI_SHIFT)
1641 
1642 /*
1643  * IMECCI (RW)
1644  *
1645  * Imprecise ECC error local interrupt enable bit. The processor may receive imprecise ECC errors on slave port accesses or cache writebacks.
1646  * 0:Disabled
1647  * 1:Enabled
1648  */
1649 #define CSR_MIE_IMECCI_MASK (0x10000UL)
1650 #define CSR_MIE_IMECCI_SHIFT (16U)
1651 #define CSR_MIE_IMECCI_SET(x) (((uint32_t)(x) << CSR_MIE_IMECCI_SHIFT) & CSR_MIE_IMECCI_MASK)
1652 #define CSR_MIE_IMECCI_GET(x) (((uint32_t)(x) & CSR_MIE_IMECCI_MASK) >> CSR_MIE_IMECCI_SHIFT)
1653 
1654 /*
1655  * MEIE (RW)
1656  *
1657  * M mode external interrupt enable bit
1658  * 0:Disabled
1659  * 1:Enabled
1660  */
1661 #define CSR_MIE_MEIE_MASK (0x800U)
1662 #define CSR_MIE_MEIE_SHIFT (11U)
1663 #define CSR_MIE_MEIE_SET(x) (((uint32_t)(x) << CSR_MIE_MEIE_SHIFT) & CSR_MIE_MEIE_MASK)
1664 #define CSR_MIE_MEIE_GET(x) (((uint32_t)(x) & CSR_MIE_MEIE_MASK) >> CSR_MIE_MEIE_SHIFT)
1665 
1666 /*
1667  * SEIE (RW)
1668  *
1669  * S mode external interrupt enable bit
1670  * 0:Disabled
1671  * 1:Enabled
1672  */
1673 #define CSR_MIE_SEIE_MASK (0x200U)
1674 #define CSR_MIE_SEIE_SHIFT (9U)
1675 #define CSR_MIE_SEIE_SET(x) (((uint32_t)(x) << CSR_MIE_SEIE_SHIFT) & CSR_MIE_SEIE_MASK)
1676 #define CSR_MIE_SEIE_GET(x) (((uint32_t)(x) & CSR_MIE_SEIE_MASK) >> CSR_MIE_SEIE_SHIFT)
1677 
1678 /*
1679  * UEIE (RW)
1680  *
1681  * U mode external interrupt enable bit
1682  * 0:Disabled
1683  * 1:Enabled
1684  */
1685 #define CSR_MIE_UEIE_MASK (0x100U)
1686 #define CSR_MIE_UEIE_SHIFT (8U)
1687 #define CSR_MIE_UEIE_SET(x) (((uint32_t)(x) << CSR_MIE_UEIE_SHIFT) & CSR_MIE_UEIE_MASK)
1688 #define CSR_MIE_UEIE_GET(x) (((uint32_t)(x) & CSR_MIE_UEIE_MASK) >> CSR_MIE_UEIE_SHIFT)
1689 
1690 /*
1691  * MTIE (RW)
1692  *
1693  * M mode timer interrupt enable bit.
1694  * 0:Disabled
1695  * 1:Enabled
1696  */
1697 #define CSR_MIE_MTIE_MASK (0x80U)
1698 #define CSR_MIE_MTIE_SHIFT (7U)
1699 #define CSR_MIE_MTIE_SET(x) (((uint32_t)(x) << CSR_MIE_MTIE_SHIFT) & CSR_MIE_MTIE_MASK)
1700 #define CSR_MIE_MTIE_GET(x) (((uint32_t)(x) & CSR_MIE_MTIE_MASK) >> CSR_MIE_MTIE_SHIFT)
1701 
1702 /*
1703  * STIE (RW)
1704  *
1705  * S mode timer interrupt enable bit.
1706  * 0:Disabled
1707  * 1:Enabled
1708  */
1709 #define CSR_MIE_STIE_MASK (0x20U)
1710 #define CSR_MIE_STIE_SHIFT (5U)
1711 #define CSR_MIE_STIE_SET(x) (((uint32_t)(x) << CSR_MIE_STIE_SHIFT) & CSR_MIE_STIE_MASK)
1712 #define CSR_MIE_STIE_GET(x) (((uint32_t)(x) & CSR_MIE_STIE_MASK) >> CSR_MIE_STIE_SHIFT)
1713 
1714 /*
1715  * UTIE (RW)
1716  *
1717  * U mode timer interrupt enable bit.
1718  * 0:Disabled
1719  * 1:Enabled
1720  */
1721 #define CSR_MIE_UTIE_MASK (0x10U)
1722 #define CSR_MIE_UTIE_SHIFT (4U)
1723 #define CSR_MIE_UTIE_SET(x) (((uint32_t)(x) << CSR_MIE_UTIE_SHIFT) & CSR_MIE_UTIE_MASK)
1724 #define CSR_MIE_UTIE_GET(x) (((uint32_t)(x) & CSR_MIE_UTIE_MASK) >> CSR_MIE_UTIE_SHIFT)
1725 
1726 /*
1727  * MSIE (RW)
1728  *
1729  * M mode software interrupt enable bit
1730  * 0:Disabled
1731  * 1:Enabled
1732  */
1733 #define CSR_MIE_MSIE_MASK (0x8U)
1734 #define CSR_MIE_MSIE_SHIFT (3U)
1735 #define CSR_MIE_MSIE_SET(x) (((uint32_t)(x) << CSR_MIE_MSIE_SHIFT) & CSR_MIE_MSIE_MASK)
1736 #define CSR_MIE_MSIE_GET(x) (((uint32_t)(x) & CSR_MIE_MSIE_MASK) >> CSR_MIE_MSIE_SHIFT)
1737 
1738 /*
1739  * SSIE (RW)
1740  *
1741  * S mode software interrupt enable bit.
1742  * 0:Disabled
1743  * 1:Enabled
1744  */
1745 #define CSR_MIE_SSIE_MASK (0x2U)
1746 #define CSR_MIE_SSIE_SHIFT (1U)
1747 #define CSR_MIE_SSIE_SET(x) (((uint32_t)(x) << CSR_MIE_SSIE_SHIFT) & CSR_MIE_SSIE_MASK)
1748 #define CSR_MIE_SSIE_GET(x) (((uint32_t)(x) & CSR_MIE_SSIE_MASK) >> CSR_MIE_SSIE_SHIFT)
1749 
1750 /*
1751  * USIE (RW)
1752  *
1753  * U mode software interrupt enable bit.
1754  * 0:Disabled
1755  * 1:Enabled
1756  */
1757 #define CSR_MIE_USIE_MASK (0x1U)
1758 #define CSR_MIE_USIE_SHIFT (0U)
1759 #define CSR_MIE_USIE_SET(x) (((uint32_t)(x) << CSR_MIE_USIE_SHIFT) & CSR_MIE_USIE_MASK)
1760 #define CSR_MIE_USIE_GET(x) (((uint32_t)(x) & CSR_MIE_USIE_MASK) >> CSR_MIE_USIE_SHIFT)
1761 
1762 /* Bitfield definition for register: MTVEC */
1763 /*
1764  * BASE_31_2 (RW)
1765  *
1766  * Base address for interrupt and exception handlers. See description above for alignment requirements when PLIC is in the vector mode
1767  */
1768 #define CSR_MTVEC_BASE_31_2_MASK (0xFFFFFFFCUL)
1769 #define CSR_MTVEC_BASE_31_2_SHIFT (2U)
1770 #define CSR_MTVEC_BASE_31_2_SET(x) (((uint32_t)(x) << CSR_MTVEC_BASE_31_2_SHIFT) & CSR_MTVEC_BASE_31_2_MASK)
1771 #define CSR_MTVEC_BASE_31_2_GET(x) (((uint32_t)(x) & CSR_MTVEC_BASE_31_2_MASK) >> CSR_MTVEC_BASE_31_2_SHIFT)
1772 
1773 /* Bitfield definition for register: MCOUNTEREN */
1774 /*
1775  * HPM6 (RW)
1776  *
1777  * See register description
1778  */
1779 #define CSR_MCOUNTEREN_HPM6_MASK (0x40U)
1780 #define CSR_MCOUNTEREN_HPM6_SHIFT (6U)
1781 #define CSR_MCOUNTEREN_HPM6_SET(x) (((uint32_t)(x) << CSR_MCOUNTEREN_HPM6_SHIFT) & CSR_MCOUNTEREN_HPM6_MASK)
1782 #define CSR_MCOUNTEREN_HPM6_GET(x) (((uint32_t)(x) & CSR_MCOUNTEREN_HPM6_MASK) >> CSR_MCOUNTEREN_HPM6_SHIFT)
1783 
1784 /*
1785  * HPM5 (RW)
1786  *
1787  * See register description
1788  */
1789 #define CSR_MCOUNTEREN_HPM5_MASK (0x20U)
1790 #define CSR_MCOUNTEREN_HPM5_SHIFT (5U)
1791 #define CSR_MCOUNTEREN_HPM5_SET(x) (((uint32_t)(x) << CSR_MCOUNTEREN_HPM5_SHIFT) & CSR_MCOUNTEREN_HPM5_MASK)
1792 #define CSR_MCOUNTEREN_HPM5_GET(x) (((uint32_t)(x) & CSR_MCOUNTEREN_HPM5_MASK) >> CSR_MCOUNTEREN_HPM5_SHIFT)
1793 
1794 /*
1795  * HPM4 (RW)
1796  *
1797  * See register description
1798  */
1799 #define CSR_MCOUNTEREN_HPM4_MASK (0x10U)
1800 #define CSR_MCOUNTEREN_HPM4_SHIFT (4U)
1801 #define CSR_MCOUNTEREN_HPM4_SET(x) (((uint32_t)(x) << CSR_MCOUNTEREN_HPM4_SHIFT) & CSR_MCOUNTEREN_HPM4_MASK)
1802 #define CSR_MCOUNTEREN_HPM4_GET(x) (((uint32_t)(x) & CSR_MCOUNTEREN_HPM4_MASK) >> CSR_MCOUNTEREN_HPM4_SHIFT)
1803 
1804 /*
1805  * HPM3 (RW)
1806  *
1807  * See register description
1808  */
1809 #define CSR_MCOUNTEREN_HPM3_MASK (0x8U)
1810 #define CSR_MCOUNTEREN_HPM3_SHIFT (3U)
1811 #define CSR_MCOUNTEREN_HPM3_SET(x) (((uint32_t)(x) << CSR_MCOUNTEREN_HPM3_SHIFT) & CSR_MCOUNTEREN_HPM3_MASK)
1812 #define CSR_MCOUNTEREN_HPM3_GET(x) (((uint32_t)(x) & CSR_MCOUNTEREN_HPM3_MASK) >> CSR_MCOUNTEREN_HPM3_SHIFT)
1813 
1814 /*
1815  * IR (RW)
1816  *
1817  * See register description
1818  */
1819 #define CSR_MCOUNTEREN_IR_MASK (0x4U)
1820 #define CSR_MCOUNTEREN_IR_SHIFT (2U)
1821 #define CSR_MCOUNTEREN_IR_SET(x) (((uint32_t)(x) << CSR_MCOUNTEREN_IR_SHIFT) & CSR_MCOUNTEREN_IR_MASK)
1822 #define CSR_MCOUNTEREN_IR_GET(x) (((uint32_t)(x) & CSR_MCOUNTEREN_IR_MASK) >> CSR_MCOUNTEREN_IR_SHIFT)
1823 
1824 /*
1825  * TM (RW)
1826  *
1827  * See register description
1828  */
1829 #define CSR_MCOUNTEREN_TM_MASK (0x2U)
1830 #define CSR_MCOUNTEREN_TM_SHIFT (1U)
1831 #define CSR_MCOUNTEREN_TM_SET(x) (((uint32_t)(x) << CSR_MCOUNTEREN_TM_SHIFT) & CSR_MCOUNTEREN_TM_MASK)
1832 #define CSR_MCOUNTEREN_TM_GET(x) (((uint32_t)(x) & CSR_MCOUNTEREN_TM_MASK) >> CSR_MCOUNTEREN_TM_SHIFT)
1833 
1834 /*
1835  * CY (RW)
1836  *
1837  * See register description
1838  */
1839 #define CSR_MCOUNTEREN_CY_MASK (0x1U)
1840 #define CSR_MCOUNTEREN_CY_SHIFT (0U)
1841 #define CSR_MCOUNTEREN_CY_SET(x) (((uint32_t)(x) << CSR_MCOUNTEREN_CY_SHIFT) & CSR_MCOUNTEREN_CY_MASK)
1842 #define CSR_MCOUNTEREN_CY_GET(x) (((uint32_t)(x) & CSR_MCOUNTEREN_CY_MASK) >> CSR_MCOUNTEREN_CY_SHIFT)
1843 
1844 /* Bitfield definition for register: MHPMEVENT3 */
1845 /*
1846  * SEL (RW)
1847  *
1848  * See Event Selectors table
1849  */
1850 #define CSR_MHPMEVENT3_SEL_MASK (0x1F0U)
1851 #define CSR_MHPMEVENT3_SEL_SHIFT (4U)
1852 #define CSR_MHPMEVENT3_SEL_SET(x) (((uint32_t)(x) << CSR_MHPMEVENT3_SEL_SHIFT) & CSR_MHPMEVENT3_SEL_MASK)
1853 #define CSR_MHPMEVENT3_SEL_GET(x) (((uint32_t)(x) & CSR_MHPMEVENT3_SEL_MASK) >> CSR_MHPMEVENT3_SEL_SHIFT)
1854 
1855 /*
1856  * TYPE (RW)
1857  *
1858  * See Event Selectors table
1859  */
1860 #define CSR_MHPMEVENT3_TYPE_MASK (0xFU)
1861 #define CSR_MHPMEVENT3_TYPE_SHIFT (0U)
1862 #define CSR_MHPMEVENT3_TYPE_SET(x) (((uint32_t)(x) << CSR_MHPMEVENT3_TYPE_SHIFT) & CSR_MHPMEVENT3_TYPE_MASK)
1863 #define CSR_MHPMEVENT3_TYPE_GET(x) (((uint32_t)(x) & CSR_MHPMEVENT3_TYPE_MASK) >> CSR_MHPMEVENT3_TYPE_SHIFT)
1864 
1865 /* Bitfield definition for register: MHPMEVENT4 */
1866 /*
1867  * SEL (RW)
1868  *
1869  * See Event Selectors table
1870  */
1871 #define CSR_MHPMEVENT4_SEL_MASK (0x1F0U)
1872 #define CSR_MHPMEVENT4_SEL_SHIFT (4U)
1873 #define CSR_MHPMEVENT4_SEL_SET(x) (((uint32_t)(x) << CSR_MHPMEVENT4_SEL_SHIFT) & CSR_MHPMEVENT4_SEL_MASK)
1874 #define CSR_MHPMEVENT4_SEL_GET(x) (((uint32_t)(x) & CSR_MHPMEVENT4_SEL_MASK) >> CSR_MHPMEVENT4_SEL_SHIFT)
1875 
1876 /*
1877  * TYPE (RW)
1878  *
1879  * See Event Selectors table
1880  */
1881 #define CSR_MHPMEVENT4_TYPE_MASK (0xFU)
1882 #define CSR_MHPMEVENT4_TYPE_SHIFT (0U)
1883 #define CSR_MHPMEVENT4_TYPE_SET(x) (((uint32_t)(x) << CSR_MHPMEVENT4_TYPE_SHIFT) & CSR_MHPMEVENT4_TYPE_MASK)
1884 #define CSR_MHPMEVENT4_TYPE_GET(x) (((uint32_t)(x) & CSR_MHPMEVENT4_TYPE_MASK) >> CSR_MHPMEVENT4_TYPE_SHIFT)
1885 
1886 /* Bitfield definition for register: MHPMEVENT5 */
1887 /*
1888  * SEL (RW)
1889  *
1890  * See Event Selectors table
1891  */
1892 #define CSR_MHPMEVENT5_SEL_MASK (0x1F0U)
1893 #define CSR_MHPMEVENT5_SEL_SHIFT (4U)
1894 #define CSR_MHPMEVENT5_SEL_SET(x) (((uint32_t)(x) << CSR_MHPMEVENT5_SEL_SHIFT) & CSR_MHPMEVENT5_SEL_MASK)
1895 #define CSR_MHPMEVENT5_SEL_GET(x) (((uint32_t)(x) & CSR_MHPMEVENT5_SEL_MASK) >> CSR_MHPMEVENT5_SEL_SHIFT)
1896 
1897 /*
1898  * TYPE (RW)
1899  *
1900  * See Event Selectors table
1901  */
1902 #define CSR_MHPMEVENT5_TYPE_MASK (0xFU)
1903 #define CSR_MHPMEVENT5_TYPE_SHIFT (0U)
1904 #define CSR_MHPMEVENT5_TYPE_SET(x) (((uint32_t)(x) << CSR_MHPMEVENT5_TYPE_SHIFT) & CSR_MHPMEVENT5_TYPE_MASK)
1905 #define CSR_MHPMEVENT5_TYPE_GET(x) (((uint32_t)(x) & CSR_MHPMEVENT5_TYPE_MASK) >> CSR_MHPMEVENT5_TYPE_SHIFT)
1906 
1907 /* Bitfield definition for register: MHPMEVENT6 */
1908 /*
1909  * SEL (RW)
1910  *
1911  * See Event Selectors table
1912  */
1913 #define CSR_MHPMEVENT6_SEL_MASK (0x1F0U)
1914 #define CSR_MHPMEVENT6_SEL_SHIFT (4U)
1915 #define CSR_MHPMEVENT6_SEL_SET(x) (((uint32_t)(x) << CSR_MHPMEVENT6_SEL_SHIFT) & CSR_MHPMEVENT6_SEL_MASK)
1916 #define CSR_MHPMEVENT6_SEL_GET(x) (((uint32_t)(x) & CSR_MHPMEVENT6_SEL_MASK) >> CSR_MHPMEVENT6_SEL_SHIFT)
1917 
1918 /*
1919  * TYPE (RW)
1920  *
1921  * See Event Selectors table
1922  */
1923 #define CSR_MHPMEVENT6_TYPE_MASK (0xFU)
1924 #define CSR_MHPMEVENT6_TYPE_SHIFT (0U)
1925 #define CSR_MHPMEVENT6_TYPE_SET(x) (((uint32_t)(x) << CSR_MHPMEVENT6_TYPE_SHIFT) & CSR_MHPMEVENT6_TYPE_MASK)
1926 #define CSR_MHPMEVENT6_TYPE_GET(x) (((uint32_t)(x) & CSR_MHPMEVENT6_TYPE_MASK) >> CSR_MHPMEVENT6_TYPE_SHIFT)
1927 
1928 /* Bitfield definition for register: MSCRATCH */
1929 /*
1930  * MSCRATCH (RW)
1931  *
1932  * Scratch register storage.
1933  */
1934 #define CSR_MSCRATCH_MSCRATCH_MASK (0xFFFFFFFFUL)
1935 #define CSR_MSCRATCH_MSCRATCH_SHIFT (0U)
1936 #define CSR_MSCRATCH_MSCRATCH_SET(x) (((uint32_t)(x) << CSR_MSCRATCH_MSCRATCH_SHIFT) & CSR_MSCRATCH_MSCRATCH_MASK)
1937 #define CSR_MSCRATCH_MSCRATCH_GET(x) (((uint32_t)(x) & CSR_MSCRATCH_MSCRATCH_MASK) >> CSR_MSCRATCH_MSCRATCH_SHIFT)
1938 
1939 /* Bitfield definition for register: MEPC */
1940 /*
1941  * EPC (RW)
1942  *
1943  * Exception program counter.
1944  */
1945 #define CSR_MEPC_EPC_MASK (0xFFFFFFFEUL)
1946 #define CSR_MEPC_EPC_SHIFT (1U)
1947 #define CSR_MEPC_EPC_SET(x) (((uint32_t)(x) << CSR_MEPC_EPC_SHIFT) & CSR_MEPC_EPC_MASK)
1948 #define CSR_MEPC_EPC_GET(x) (((uint32_t)(x) & CSR_MEPC_EPC_MASK) >> CSR_MEPC_EPC_SHIFT)
1949 
1950 /* Bitfield definition for register: MCAUSE */
1951 /*
1952  * INTERRUPT (RW)
1953  *
1954  * Interrupt
1955  */
1956 #define CSR_MCAUSE_INTERRUPT_MASK (0x80000000UL)
1957 #define CSR_MCAUSE_INTERRUPT_SHIFT (31U)
1958 #define CSR_MCAUSE_INTERRUPT_SET(x) (((uint32_t)(x) << CSR_MCAUSE_INTERRUPT_SHIFT) & CSR_MCAUSE_INTERRUPT_MASK)
1959 #define CSR_MCAUSE_INTERRUPT_GET(x) (((uint32_t)(x) & CSR_MCAUSE_INTERRUPT_MASK) >> CSR_MCAUSE_INTERRUPT_SHIFT)
1960 
1961 /*
1962  * EXCEPTION_CODE (RW)
1963  *
1964  * Exception code
1965  * When interrupt is 1, the value means:
1966  * 0:User software interrupt
1967  * 1:Supervisor software interrupt
1968  * 3:Machine software interrupt
1969  * 4:User timer interrupt
1970  * 5:Supervisor timer interrupt
1971  * 7:Machine timer interrupt
1972  * 8:User external interrupt
1973  * 9:Supervisor external interrupt
1974  * 11:Machine external interrupt
1975  * 16:Imprecise ECC error interrupt (slave port accesses, D-Cache evictions, and nonblocking load/stores) (M-mode)
1976  * 17:Bus read/write transaction error interrupt (M-mode)
1977  * 18:Performance monitor overflow interrupt (M-mode)
1978  * 256+16:Imprecise ECC error interrupt (slave port accesses, D-Cache evictions, and nonblocking load/stores) (S-mode)
1979  * 256+17:Bus write transaction error interrupt (S-mode)
1980  * 256+18:Performance monitor overflow interrupt (S-mode)
1981  * When interrupt bit is 0, the value means:
1982  * 0:Instruction address misaligned
1983  * 1:Instruction access fault
1984  * 2:Illegal instruction
1985  * 3:Breakpoint
1986  * 4:Load address misaligned
1987  * 5:Load access fault
1988  * 6:Store/AMO address misaligned
1989  * 7:Store/AMO access fault
1990  * 8:Environment call from U-mode
1991  * 9:Environment call from S-mode
1992  * 11:Environment call from M-mode
1993  * 32:Stack overflow exception
1994  * 33:Stack underflow exception
1995  * 40-47:Reserved
1996  */
1997 #define CSR_MCAUSE_EXCEPTION_CODE_MASK (0xFFFU)
1998 #define CSR_MCAUSE_EXCEPTION_CODE_SHIFT (0U)
1999 #define CSR_MCAUSE_EXCEPTION_CODE_SET(x) (((uint32_t)(x) << CSR_MCAUSE_EXCEPTION_CODE_SHIFT) & CSR_MCAUSE_EXCEPTION_CODE_MASK)
2000 #define CSR_MCAUSE_EXCEPTION_CODE_GET(x) (((uint32_t)(x) & CSR_MCAUSE_EXCEPTION_CODE_MASK) >> CSR_MCAUSE_EXCEPTION_CODE_SHIFT)
2001 
2002 /* Bitfield definition for register: MTVAL */
2003 /*
2004  * MTVAL (RW)
2005  *
2006  * Exception-specific information for software trap handling.
2007  */
2008 #define CSR_MTVAL_MTVAL_MASK (0xFFFFFFFFUL)
2009 #define CSR_MTVAL_MTVAL_SHIFT (0U)
2010 #define CSR_MTVAL_MTVAL_SET(x) (((uint32_t)(x) << CSR_MTVAL_MTVAL_SHIFT) & CSR_MTVAL_MTVAL_MASK)
2011 #define CSR_MTVAL_MTVAL_GET(x) (((uint32_t)(x) & CSR_MTVAL_MTVAL_MASK) >> CSR_MTVAL_MTVAL_SHIFT)
2012 
2013 /* Bitfield definition for register: MIP */
2014 /*
2015  * PMOVI (RW)
2016  *
2017  * Performance monitor overflow local interrupt pending bit.
2018  * 0:Not pending
2019  * 1:Pending
2020  */
2021 #define CSR_MIP_PMOVI_MASK (0x40000UL)
2022 #define CSR_MIP_PMOVI_SHIFT (18U)
2023 #define CSR_MIP_PMOVI_SET(x) (((uint32_t)(x) << CSR_MIP_PMOVI_SHIFT) & CSR_MIP_PMOVI_MASK)
2024 #define CSR_MIP_PMOVI_GET(x) (((uint32_t)(x) & CSR_MIP_PMOVI_MASK) >> CSR_MIP_PMOVI_SHIFT)
2025 
2026 /*
2027  * BWEI (RW)
2028  *
2029  * Bus read/write transaction error local interrupt pending bit. The processor may receive bus errors on load/store instructions or cache writebacks.
2030  * 0:Not pending
2031  * 1:Pending
2032  */
2033 #define CSR_MIP_BWEI_MASK (0x20000UL)
2034 #define CSR_MIP_BWEI_SHIFT (17U)
2035 #define CSR_MIP_BWEI_SET(x) (((uint32_t)(x) << CSR_MIP_BWEI_SHIFT) & CSR_MIP_BWEI_MASK)
2036 #define CSR_MIP_BWEI_GET(x) (((uint32_t)(x) & CSR_MIP_BWEI_MASK) >> CSR_MIP_BWEI_SHIFT)
2037 
2038 /*
2039  * IMECCI (RW)
2040  *
2041  * Imprecise ECC error local interrupt enable bit. The processor may receive imprecise ECC errors on slave port accesses or cache writebacks.
2042  * 0:Not pending
2043  * 1:Pending
2044  */
2045 #define CSR_MIP_IMECCI_MASK (0x10000UL)
2046 #define CSR_MIP_IMECCI_SHIFT (16U)
2047 #define CSR_MIP_IMECCI_SET(x) (((uint32_t)(x) << CSR_MIP_IMECCI_SHIFT) & CSR_MIP_IMECCI_MASK)
2048 #define CSR_MIP_IMECCI_GET(x) (((uint32_t)(x) & CSR_MIP_IMECCI_MASK) >> CSR_MIP_IMECCI_SHIFT)
2049 
2050 /*
2051  * MEIP (RW)
2052  *
2053  * M mode external interrupt pending bit.
2054  * 0:Not pending
2055  * 1:Pending
2056  */
2057 #define CSR_MIP_MEIP_MASK (0x800U)
2058 #define CSR_MIP_MEIP_SHIFT (11U)
2059 #define CSR_MIP_MEIP_SET(x) (((uint32_t)(x) << CSR_MIP_MEIP_SHIFT) & CSR_MIP_MEIP_MASK)
2060 #define CSR_MIP_MEIP_GET(x) (((uint32_t)(x) & CSR_MIP_MEIP_MASK) >> CSR_MIP_MEIP_SHIFT)
2061 
2062 /*
2063  * SEIP (RW)
2064  *
2065  * S mode external interrupt pending bit.
2066  * 0:Not pending
2067  * 1:Pending
2068  */
2069 #define CSR_MIP_SEIP_MASK (0x200U)
2070 #define CSR_MIP_SEIP_SHIFT (9U)
2071 #define CSR_MIP_SEIP_SET(x) (((uint32_t)(x) << CSR_MIP_SEIP_SHIFT) & CSR_MIP_SEIP_MASK)
2072 #define CSR_MIP_SEIP_GET(x) (((uint32_t)(x) & CSR_MIP_SEIP_MASK) >> CSR_MIP_SEIP_SHIFT)
2073 
2074 /*
2075  * UEIP (RW)
2076  *
2077  * U mode external interrupt pending bit.
2078  * 0:Not pending
2079  * 1:Pending
2080  */
2081 #define CSR_MIP_UEIP_MASK (0x100U)
2082 #define CSR_MIP_UEIP_SHIFT (8U)
2083 #define CSR_MIP_UEIP_SET(x) (((uint32_t)(x) << CSR_MIP_UEIP_SHIFT) & CSR_MIP_UEIP_MASK)
2084 #define CSR_MIP_UEIP_GET(x) (((uint32_t)(x) & CSR_MIP_UEIP_MASK) >> CSR_MIP_UEIP_SHIFT)
2085 
2086 /*
2087  * MTIP (RW)
2088  *
2089  * M mode timer interrupt pending bit.
2090  * 0:Not pending
2091  * 1:Pending
2092  */
2093 #define CSR_MIP_MTIP_MASK (0x80U)
2094 #define CSR_MIP_MTIP_SHIFT (7U)
2095 #define CSR_MIP_MTIP_SET(x) (((uint32_t)(x) << CSR_MIP_MTIP_SHIFT) & CSR_MIP_MTIP_MASK)
2096 #define CSR_MIP_MTIP_GET(x) (((uint32_t)(x) & CSR_MIP_MTIP_MASK) >> CSR_MIP_MTIP_SHIFT)
2097 
2098 /*
2099  * STIP (RW)
2100  *
2101  * S mode timer interrupt pending bit.
2102  * 0:Not pending
2103  * 1:Pending
2104  */
2105 #define CSR_MIP_STIP_MASK (0x20U)
2106 #define CSR_MIP_STIP_SHIFT (5U)
2107 #define CSR_MIP_STIP_SET(x) (((uint32_t)(x) << CSR_MIP_STIP_SHIFT) & CSR_MIP_STIP_MASK)
2108 #define CSR_MIP_STIP_GET(x) (((uint32_t)(x) & CSR_MIP_STIP_MASK) >> CSR_MIP_STIP_SHIFT)
2109 
2110 /*
2111  * UTIP (RW)
2112  *
2113  * U mode timer interrupt pending bit
2114  * 0:Not pending
2115  * 1:Pending
2116  */
2117 #define CSR_MIP_UTIP_MASK (0x10U)
2118 #define CSR_MIP_UTIP_SHIFT (4U)
2119 #define CSR_MIP_UTIP_SET(x) (((uint32_t)(x) << CSR_MIP_UTIP_SHIFT) & CSR_MIP_UTIP_MASK)
2120 #define CSR_MIP_UTIP_GET(x) (((uint32_t)(x) & CSR_MIP_UTIP_MASK) >> CSR_MIP_UTIP_SHIFT)
2121 
2122 /*
2123  * MSIP (RW)
2124  *
2125  * M mode software interrupt pending bit.
2126  * 0:Not pending
2127  * 1:Pending
2128  */
2129 #define CSR_MIP_MSIP_MASK (0x8U)
2130 #define CSR_MIP_MSIP_SHIFT (3U)
2131 #define CSR_MIP_MSIP_SET(x) (((uint32_t)(x) << CSR_MIP_MSIP_SHIFT) & CSR_MIP_MSIP_MASK)
2132 #define CSR_MIP_MSIP_GET(x) (((uint32_t)(x) & CSR_MIP_MSIP_MASK) >> CSR_MIP_MSIP_SHIFT)
2133 
2134 /*
2135  * SSIP (RW)
2136  *
2137  * S mode software interrupt pending bit.
2138  * 0:Not pending
2139  * 1:Pending
2140  */
2141 #define CSR_MIP_SSIP_MASK (0x2U)
2142 #define CSR_MIP_SSIP_SHIFT (1U)
2143 #define CSR_MIP_SSIP_SET(x) (((uint32_t)(x) << CSR_MIP_SSIP_SHIFT) & CSR_MIP_SSIP_MASK)
2144 #define CSR_MIP_SSIP_GET(x) (((uint32_t)(x) & CSR_MIP_SSIP_MASK) >> CSR_MIP_SSIP_SHIFT)
2145 
2146 /*
2147  * USIP (RW)
2148  *
2149  * U mode software interrupt pending bit.
2150  * 0:Not pending
2151  * 1:Pending
2152  */
2153 #define CSR_MIP_USIP_MASK (0x1U)
2154 #define CSR_MIP_USIP_SHIFT (0U)
2155 #define CSR_MIP_USIP_SET(x) (((uint32_t)(x) << CSR_MIP_USIP_SHIFT) & CSR_MIP_USIP_MASK)
2156 #define CSR_MIP_USIP_GET(x) (((uint32_t)(x) & CSR_MIP_USIP_MASK) >> CSR_MIP_USIP_SHIFT)
2157 
2158 /* Bitfield definition for register: PMPCFG0 */
2159 /*
2160  * PMP3CFG (RW)
2161  *
2162  * See PMPCFG Table
2163  */
2164 #define CSR_PMPCFG0_PMP3CFG_MASK (0xFF000000UL)
2165 #define CSR_PMPCFG0_PMP3CFG_SHIFT (24U)
2166 #define CSR_PMPCFG0_PMP3CFG_SET(x) (((uint32_t)(x) << CSR_PMPCFG0_PMP3CFG_SHIFT) & CSR_PMPCFG0_PMP3CFG_MASK)
2167 #define CSR_PMPCFG0_PMP3CFG_GET(x) (((uint32_t)(x) & CSR_PMPCFG0_PMP3CFG_MASK) >> CSR_PMPCFG0_PMP3CFG_SHIFT)
2168 
2169 /*
2170  * PMP2CFG (RW)
2171  *
2172  * See PMPCFG Table
2173  */
2174 #define CSR_PMPCFG0_PMP2CFG_MASK (0xFF0000UL)
2175 #define CSR_PMPCFG0_PMP2CFG_SHIFT (16U)
2176 #define CSR_PMPCFG0_PMP2CFG_SET(x) (((uint32_t)(x) << CSR_PMPCFG0_PMP2CFG_SHIFT) & CSR_PMPCFG0_PMP2CFG_MASK)
2177 #define CSR_PMPCFG0_PMP2CFG_GET(x) (((uint32_t)(x) & CSR_PMPCFG0_PMP2CFG_MASK) >> CSR_PMPCFG0_PMP2CFG_SHIFT)
2178 
2179 /*
2180  * PMP1CFG (RW)
2181  *
2182  * See PMPCFG Table
2183  */
2184 #define CSR_PMPCFG0_PMP1CFG_MASK (0xFF00U)
2185 #define CSR_PMPCFG0_PMP1CFG_SHIFT (8U)
2186 #define CSR_PMPCFG0_PMP1CFG_SET(x) (((uint32_t)(x) << CSR_PMPCFG0_PMP1CFG_SHIFT) & CSR_PMPCFG0_PMP1CFG_MASK)
2187 #define CSR_PMPCFG0_PMP1CFG_GET(x) (((uint32_t)(x) & CSR_PMPCFG0_PMP1CFG_MASK) >> CSR_PMPCFG0_PMP1CFG_SHIFT)
2188 
2189 /*
2190  * PMP0CFG (RW)
2191  *
2192  * See PMPCFG Table
2193  */
2194 #define CSR_PMPCFG0_PMP0CFG_MASK (0xFFU)
2195 #define CSR_PMPCFG0_PMP0CFG_SHIFT (0U)
2196 #define CSR_PMPCFG0_PMP0CFG_SET(x) (((uint32_t)(x) << CSR_PMPCFG0_PMP0CFG_SHIFT) & CSR_PMPCFG0_PMP0CFG_MASK)
2197 #define CSR_PMPCFG0_PMP0CFG_GET(x) (((uint32_t)(x) & CSR_PMPCFG0_PMP0CFG_MASK) >> CSR_PMPCFG0_PMP0CFG_SHIFT)
2198 
2199 /* Bitfield definition for register: PMPCFG1 */
2200 /*
2201  * PMP7CFG (RW)
2202  *
2203  * See PMPCFG Table
2204  */
2205 #define CSR_PMPCFG1_PMP7CFG_MASK (0xFF000000UL)
2206 #define CSR_PMPCFG1_PMP7CFG_SHIFT (24U)
2207 #define CSR_PMPCFG1_PMP7CFG_SET(x) (((uint32_t)(x) << CSR_PMPCFG1_PMP7CFG_SHIFT) & CSR_PMPCFG1_PMP7CFG_MASK)
2208 #define CSR_PMPCFG1_PMP7CFG_GET(x) (((uint32_t)(x) & CSR_PMPCFG1_PMP7CFG_MASK) >> CSR_PMPCFG1_PMP7CFG_SHIFT)
2209 
2210 /*
2211  * PMP6CFG (RW)
2212  *
2213  * See PMPCFG Table
2214  */
2215 #define CSR_PMPCFG1_PMP6CFG_MASK (0xFF0000UL)
2216 #define CSR_PMPCFG1_PMP6CFG_SHIFT (16U)
2217 #define CSR_PMPCFG1_PMP6CFG_SET(x) (((uint32_t)(x) << CSR_PMPCFG1_PMP6CFG_SHIFT) & CSR_PMPCFG1_PMP6CFG_MASK)
2218 #define CSR_PMPCFG1_PMP6CFG_GET(x) (((uint32_t)(x) & CSR_PMPCFG1_PMP6CFG_MASK) >> CSR_PMPCFG1_PMP6CFG_SHIFT)
2219 
2220 /*
2221  * PMP5CFG (RW)
2222  *
2223  * See PMPCFG Table
2224  */
2225 #define CSR_PMPCFG1_PMP5CFG_MASK (0xFF00U)
2226 #define CSR_PMPCFG1_PMP5CFG_SHIFT (8U)
2227 #define CSR_PMPCFG1_PMP5CFG_SET(x) (((uint32_t)(x) << CSR_PMPCFG1_PMP5CFG_SHIFT) & CSR_PMPCFG1_PMP5CFG_MASK)
2228 #define CSR_PMPCFG1_PMP5CFG_GET(x) (((uint32_t)(x) & CSR_PMPCFG1_PMP5CFG_MASK) >> CSR_PMPCFG1_PMP5CFG_SHIFT)
2229 
2230 /*
2231  * PMP4CFG (RW)
2232  *
2233  * See PMPCFG Table
2234  */
2235 #define CSR_PMPCFG1_PMP4CFG_MASK (0xFFU)
2236 #define CSR_PMPCFG1_PMP4CFG_SHIFT (0U)
2237 #define CSR_PMPCFG1_PMP4CFG_SET(x) (((uint32_t)(x) << CSR_PMPCFG1_PMP4CFG_SHIFT) & CSR_PMPCFG1_PMP4CFG_MASK)
2238 #define CSR_PMPCFG1_PMP4CFG_GET(x) (((uint32_t)(x) & CSR_PMPCFG1_PMP4CFG_MASK) >> CSR_PMPCFG1_PMP4CFG_SHIFT)
2239 
2240 /* Bitfield definition for register: PMPCFG2 */
2241 /*
2242  * PMP11CFG (RW)
2243  *
2244  * See PMPCFG Table
2245  */
2246 #define CSR_PMPCFG2_PMP11CFG_MASK (0xFF000000UL)
2247 #define CSR_PMPCFG2_PMP11CFG_SHIFT (24U)
2248 #define CSR_PMPCFG2_PMP11CFG_SET(x) (((uint32_t)(x) << CSR_PMPCFG2_PMP11CFG_SHIFT) & CSR_PMPCFG2_PMP11CFG_MASK)
2249 #define CSR_PMPCFG2_PMP11CFG_GET(x) (((uint32_t)(x) & CSR_PMPCFG2_PMP11CFG_MASK) >> CSR_PMPCFG2_PMP11CFG_SHIFT)
2250 
2251 /*
2252  * PMP10CFG (RW)
2253  *
2254  * See PMPCFG Table
2255  */
2256 #define CSR_PMPCFG2_PMP10CFG_MASK (0xFF0000UL)
2257 #define CSR_PMPCFG2_PMP10CFG_SHIFT (16U)
2258 #define CSR_PMPCFG2_PMP10CFG_SET(x) (((uint32_t)(x) << CSR_PMPCFG2_PMP10CFG_SHIFT) & CSR_PMPCFG2_PMP10CFG_MASK)
2259 #define CSR_PMPCFG2_PMP10CFG_GET(x) (((uint32_t)(x) & CSR_PMPCFG2_PMP10CFG_MASK) >> CSR_PMPCFG2_PMP10CFG_SHIFT)
2260 
2261 /*
2262  * PMP9CFG (RW)
2263  *
2264  * See PMPCFG Table
2265  */
2266 #define CSR_PMPCFG2_PMP9CFG_MASK (0xFF00U)
2267 #define CSR_PMPCFG2_PMP9CFG_SHIFT (8U)
2268 #define CSR_PMPCFG2_PMP9CFG_SET(x) (((uint32_t)(x) << CSR_PMPCFG2_PMP9CFG_SHIFT) & CSR_PMPCFG2_PMP9CFG_MASK)
2269 #define CSR_PMPCFG2_PMP9CFG_GET(x) (((uint32_t)(x) & CSR_PMPCFG2_PMP9CFG_MASK) >> CSR_PMPCFG2_PMP9CFG_SHIFT)
2270 
2271 /*
2272  * PMP8CFG (RW)
2273  *
2274  * See PMPCFG Table
2275  */
2276 #define CSR_PMPCFG2_PMP8CFG_MASK (0xFFU)
2277 #define CSR_PMPCFG2_PMP8CFG_SHIFT (0U)
2278 #define CSR_PMPCFG2_PMP8CFG_SET(x) (((uint32_t)(x) << CSR_PMPCFG2_PMP8CFG_SHIFT) & CSR_PMPCFG2_PMP8CFG_MASK)
2279 #define CSR_PMPCFG2_PMP8CFG_GET(x) (((uint32_t)(x) & CSR_PMPCFG2_PMP8CFG_MASK) >> CSR_PMPCFG2_PMP8CFG_SHIFT)
2280 
2281 /* Bitfield definition for register: PMPCFG3 */
2282 /*
2283  * PMP15CFG (RW)
2284  *
2285  * See PMPCFG Table
2286  */
2287 #define CSR_PMPCFG3_PMP15CFG_MASK (0xFF000000UL)
2288 #define CSR_PMPCFG3_PMP15CFG_SHIFT (24U)
2289 #define CSR_PMPCFG3_PMP15CFG_SET(x) (((uint32_t)(x) << CSR_PMPCFG3_PMP15CFG_SHIFT) & CSR_PMPCFG3_PMP15CFG_MASK)
2290 #define CSR_PMPCFG3_PMP15CFG_GET(x) (((uint32_t)(x) & CSR_PMPCFG3_PMP15CFG_MASK) >> CSR_PMPCFG3_PMP15CFG_SHIFT)
2291 
2292 /*
2293  * PMP14CFG (RW)
2294  *
2295  * See PMPCFG Table
2296  */
2297 #define CSR_PMPCFG3_PMP14CFG_MASK (0xFF0000UL)
2298 #define CSR_PMPCFG3_PMP14CFG_SHIFT (16U)
2299 #define CSR_PMPCFG3_PMP14CFG_SET(x) (((uint32_t)(x) << CSR_PMPCFG3_PMP14CFG_SHIFT) & CSR_PMPCFG3_PMP14CFG_MASK)
2300 #define CSR_PMPCFG3_PMP14CFG_GET(x) (((uint32_t)(x) & CSR_PMPCFG3_PMP14CFG_MASK) >> CSR_PMPCFG3_PMP14CFG_SHIFT)
2301 
2302 /*
2303  * PMP13CFG (RW)
2304  *
2305  * See PMPCFG Table
2306  */
2307 #define CSR_PMPCFG3_PMP13CFG_MASK (0xFF00U)
2308 #define CSR_PMPCFG3_PMP13CFG_SHIFT (8U)
2309 #define CSR_PMPCFG3_PMP13CFG_SET(x) (((uint32_t)(x) << CSR_PMPCFG3_PMP13CFG_SHIFT) & CSR_PMPCFG3_PMP13CFG_MASK)
2310 #define CSR_PMPCFG3_PMP13CFG_GET(x) (((uint32_t)(x) & CSR_PMPCFG3_PMP13CFG_MASK) >> CSR_PMPCFG3_PMP13CFG_SHIFT)
2311 
2312 /*
2313  * PMP12CFG (RW)
2314  *
2315  * See PMPCFG Table
2316  */
2317 #define CSR_PMPCFG3_PMP12CFG_MASK (0xFFU)
2318 #define CSR_PMPCFG3_PMP12CFG_SHIFT (0U)
2319 #define CSR_PMPCFG3_PMP12CFG_SET(x) (((uint32_t)(x) << CSR_PMPCFG3_PMP12CFG_SHIFT) & CSR_PMPCFG3_PMP12CFG_MASK)
2320 #define CSR_PMPCFG3_PMP12CFG_GET(x) (((uint32_t)(x) & CSR_PMPCFG3_PMP12CFG_MASK) >> CSR_PMPCFG3_PMP12CFG_SHIFT)
2321 
2322 /* Bitfield definition for register array: PMPADDR */
2323 /*
2324  * PMPADDR_31_2 (RW)
2325  *
2326  * Register Content : Match Size(Byte)
2327  * aaaa. . . aaa0 8
2328  * aaaa. . . aa01 16
2329  * aaaa. . . a011 32
2330  * . . . . . .
2331  * aa01. . . 1111 2^{XLEN}
2332  * a011. . . 1111 2^{XLEN+1}
2333  * 0111. . . 1111 2^{XLEN+2}
2334  * 1111. . . 1111 2^{XLEN+3*1}
2335  */
2336 #define CSR_PMPADDR0_PMPADDR_31_2_MASK (0xFFFFFFFCUL)
2337 #define CSR_PMPADDR0_PMPADDR_31_2_SHIFT (2U)
2338 #define CSR_PMPADDR0_PMPADDR_31_2_SET(x) (((uint32_t)(x) << CSR_PMPADDR0_PMPADDR_31_2_SHIFT) & CSR_PMPADDR0_PMPADDR_31_2_MASK)
2339 #define CSR_PMPADDR0_PMPADDR_31_2_GET(x) (((uint32_t)(x) & CSR_PMPADDR0_PMPADDR_31_2_MASK) >> CSR_PMPADDR0_PMPADDR_31_2_SHIFT)
2340 
2341 /* Bitfield definition for register array: PMPADDR */
2342 /*
2343  * PMPADDR_31_2 (RW)
2344  *
2345  * same as pmpaddr0
2346  */
2347 #define CSR_PMPADDR1_PMPADDR_31_2_MASK (0xFFFFFFFCUL)
2348 #define CSR_PMPADDR1_PMPADDR_31_2_SHIFT (2U)
2349 #define CSR_PMPADDR1_PMPADDR_31_2_SET(x) (((uint32_t)(x) << CSR_PMPADDR1_PMPADDR_31_2_SHIFT) & CSR_PMPADDR1_PMPADDR_31_2_MASK)
2350 #define CSR_PMPADDR1_PMPADDR_31_2_GET(x) (((uint32_t)(x) & CSR_PMPADDR1_PMPADDR_31_2_MASK) >> CSR_PMPADDR1_PMPADDR_31_2_SHIFT)
2351 
2352 /* Bitfield definition for register array: PMPADDR */
2353 /*
2354  * PMPADDR_31_2 (RW)
2355  *
2356  * same as pmpaddr0
2357  */
2358 #define CSR_PMPADDR2_PMPADDR_31_2_MASK (0xFFFFFFFCUL)
2359 #define CSR_PMPADDR2_PMPADDR_31_2_SHIFT (2U)
2360 #define CSR_PMPADDR2_PMPADDR_31_2_SET(x) (((uint32_t)(x) << CSR_PMPADDR2_PMPADDR_31_2_SHIFT) & CSR_PMPADDR2_PMPADDR_31_2_MASK)
2361 #define CSR_PMPADDR2_PMPADDR_31_2_GET(x) (((uint32_t)(x) & CSR_PMPADDR2_PMPADDR_31_2_MASK) >> CSR_PMPADDR2_PMPADDR_31_2_SHIFT)
2362 
2363 /* Bitfield definition for register array: PMPADDR */
2364 /*
2365  * PMPADDR_31_2 (RW)
2366  *
2367  * same as pmpaddr0
2368  */
2369 #define CSR_PMPADDR3_PMPADDR_31_2_MASK (0xFFFFFFFCUL)
2370 #define CSR_PMPADDR3_PMPADDR_31_2_SHIFT (2U)
2371 #define CSR_PMPADDR3_PMPADDR_31_2_SET(x) (((uint32_t)(x) << CSR_PMPADDR3_PMPADDR_31_2_SHIFT) & CSR_PMPADDR3_PMPADDR_31_2_MASK)
2372 #define CSR_PMPADDR3_PMPADDR_31_2_GET(x) (((uint32_t)(x) & CSR_PMPADDR3_PMPADDR_31_2_MASK) >> CSR_PMPADDR3_PMPADDR_31_2_SHIFT)
2373 
2374 /* Bitfield definition for register array: PMPADDR */
2375 /*
2376  * PMPADDR_31_2 (RW)
2377  *
2378  * same as pmpaddr0
2379  */
2380 #define CSR_PMPADDR4_PMPADDR_31_2_MASK (0xFFFFFFFCUL)
2381 #define CSR_PMPADDR4_PMPADDR_31_2_SHIFT (2U)
2382 #define CSR_PMPADDR4_PMPADDR_31_2_SET(x) (((uint32_t)(x) << CSR_PMPADDR4_PMPADDR_31_2_SHIFT) & CSR_PMPADDR4_PMPADDR_31_2_MASK)
2383 #define CSR_PMPADDR4_PMPADDR_31_2_GET(x) (((uint32_t)(x) & CSR_PMPADDR4_PMPADDR_31_2_MASK) >> CSR_PMPADDR4_PMPADDR_31_2_SHIFT)
2384 
2385 /* Bitfield definition for register array: PMPADDR */
2386 /*
2387  * PMPADDR_31_2 (RW)
2388  *
2389  * same as pmpaddr0
2390  */
2391 #define CSR_PMPADDR5_PMPADDR_31_2_MASK (0xFFFFFFFCUL)
2392 #define CSR_PMPADDR5_PMPADDR_31_2_SHIFT (2U)
2393 #define CSR_PMPADDR5_PMPADDR_31_2_SET(x) (((uint32_t)(x) << CSR_PMPADDR5_PMPADDR_31_2_SHIFT) & CSR_PMPADDR5_PMPADDR_31_2_MASK)
2394 #define CSR_PMPADDR5_PMPADDR_31_2_GET(x) (((uint32_t)(x) & CSR_PMPADDR5_PMPADDR_31_2_MASK) >> CSR_PMPADDR5_PMPADDR_31_2_SHIFT)
2395 
2396 /* Bitfield definition for register array: PMPADDR */
2397 /*
2398  * PMPADDR_31_2 (RW)
2399  *
2400  * same as pmpaddr0
2401  */
2402 #define CSR_PMPADDR6_PMPADDR_31_2_MASK (0xFFFFFFFCUL)
2403 #define CSR_PMPADDR6_PMPADDR_31_2_SHIFT (2U)
2404 #define CSR_PMPADDR6_PMPADDR_31_2_SET(x) (((uint32_t)(x) << CSR_PMPADDR6_PMPADDR_31_2_SHIFT) & CSR_PMPADDR6_PMPADDR_31_2_MASK)
2405 #define CSR_PMPADDR6_PMPADDR_31_2_GET(x) (((uint32_t)(x) & CSR_PMPADDR6_PMPADDR_31_2_MASK) >> CSR_PMPADDR6_PMPADDR_31_2_SHIFT)
2406 
2407 /* Bitfield definition for register array: PMPADDR */
2408 /*
2409  * PMPADDR_31_2 (RW)
2410  *
2411  * same as pmpaddr0
2412  */
2413 #define CSR_PMPADDR7_PMPADDR_31_2_MASK (0xFFFFFFFCUL)
2414 #define CSR_PMPADDR7_PMPADDR_31_2_SHIFT (2U)
2415 #define CSR_PMPADDR7_PMPADDR_31_2_SET(x) (((uint32_t)(x) << CSR_PMPADDR7_PMPADDR_31_2_SHIFT) & CSR_PMPADDR7_PMPADDR_31_2_MASK)
2416 #define CSR_PMPADDR7_PMPADDR_31_2_GET(x) (((uint32_t)(x) & CSR_PMPADDR7_PMPADDR_31_2_MASK) >> CSR_PMPADDR7_PMPADDR_31_2_SHIFT)
2417 
2418 /* Bitfield definition for register array: PMPADDR */
2419 /*
2420  * PMPADDR_31_2 (RW)
2421  *
2422  * same as pmpaddr0
2423  */
2424 #define CSR_PMPADDR8_PMPADDR_31_2_MASK (0xFFFFFFFCUL)
2425 #define CSR_PMPADDR8_PMPADDR_31_2_SHIFT (2U)
2426 #define CSR_PMPADDR8_PMPADDR_31_2_SET(x) (((uint32_t)(x) << CSR_PMPADDR8_PMPADDR_31_2_SHIFT) & CSR_PMPADDR8_PMPADDR_31_2_MASK)
2427 #define CSR_PMPADDR8_PMPADDR_31_2_GET(x) (((uint32_t)(x) & CSR_PMPADDR8_PMPADDR_31_2_MASK) >> CSR_PMPADDR8_PMPADDR_31_2_SHIFT)
2428 
2429 /* Bitfield definition for register array: PMPADDR */
2430 /*
2431  * PMPADDR_31_2 (RW)
2432  *
2433  * same as pmpaddr0
2434  */
2435 #define CSR_PMPADDR9_PMPADDR_31_2_MASK (0xFFFFFFFCUL)
2436 #define CSR_PMPADDR9_PMPADDR_31_2_SHIFT (2U)
2437 #define CSR_PMPADDR9_PMPADDR_31_2_SET(x) (((uint32_t)(x) << CSR_PMPADDR9_PMPADDR_31_2_SHIFT) & CSR_PMPADDR9_PMPADDR_31_2_MASK)
2438 #define CSR_PMPADDR9_PMPADDR_31_2_GET(x) (((uint32_t)(x) & CSR_PMPADDR9_PMPADDR_31_2_MASK) >> CSR_PMPADDR9_PMPADDR_31_2_SHIFT)
2439 
2440 /* Bitfield definition for register array: PMPADDR */
2441 /*
2442  * PMPADDR_31_2 (RW)
2443  *
2444  * same as pmpaddr0
2445  */
2446 #define CSR_PMPADDR10_PMPADDR_31_2_MASK (0xFFFFFFFCUL)
2447 #define CSR_PMPADDR10_PMPADDR_31_2_SHIFT (2U)
2448 #define CSR_PMPADDR10_PMPADDR_31_2_SET(x) (((uint32_t)(x) << CSR_PMPADDR10_PMPADDR_31_2_SHIFT) & CSR_PMPADDR10_PMPADDR_31_2_MASK)
2449 #define CSR_PMPADDR10_PMPADDR_31_2_GET(x) (((uint32_t)(x) & CSR_PMPADDR10_PMPADDR_31_2_MASK) >> CSR_PMPADDR10_PMPADDR_31_2_SHIFT)
2450 
2451 /* Bitfield definition for register array: PMPADDR */
2452 /*
2453  * PMPADDR_31_2 (RW)
2454  *
2455  * same as pmpaddr0
2456  */
2457 #define CSR_PMPADDR11_PMPADDR_31_2_MASK (0xFFFFFFFCUL)
2458 #define CSR_PMPADDR11_PMPADDR_31_2_SHIFT (2U)
2459 #define CSR_PMPADDR11_PMPADDR_31_2_SET(x) (((uint32_t)(x) << CSR_PMPADDR11_PMPADDR_31_2_SHIFT) & CSR_PMPADDR11_PMPADDR_31_2_MASK)
2460 #define CSR_PMPADDR11_PMPADDR_31_2_GET(x) (((uint32_t)(x) & CSR_PMPADDR11_PMPADDR_31_2_MASK) >> CSR_PMPADDR11_PMPADDR_31_2_SHIFT)
2461 
2462 /* Bitfield definition for register array: PMPADDR */
2463 /*
2464  * PMPADDR_31_2 (RW)
2465  *
2466  * same as pmpaddr0
2467  */
2468 #define CSR_PMPADDR12_PMPADDR_31_2_MASK (0xFFFFFFFCUL)
2469 #define CSR_PMPADDR12_PMPADDR_31_2_SHIFT (2U)
2470 #define CSR_PMPADDR12_PMPADDR_31_2_SET(x) (((uint32_t)(x) << CSR_PMPADDR12_PMPADDR_31_2_SHIFT) & CSR_PMPADDR12_PMPADDR_31_2_MASK)
2471 #define CSR_PMPADDR12_PMPADDR_31_2_GET(x) (((uint32_t)(x) & CSR_PMPADDR12_PMPADDR_31_2_MASK) >> CSR_PMPADDR12_PMPADDR_31_2_SHIFT)
2472 
2473 /* Bitfield definition for register array: PMPADDR */
2474 /*
2475  * PMPADDR_31_2 (RW)
2476  *
2477  * same as pmpaddr0
2478  */
2479 #define CSR_PMPADDR13_PMPADDR_31_2_MASK (0xFFFFFFFCUL)
2480 #define CSR_PMPADDR13_PMPADDR_31_2_SHIFT (2U)
2481 #define CSR_PMPADDR13_PMPADDR_31_2_SET(x) (((uint32_t)(x) << CSR_PMPADDR13_PMPADDR_31_2_SHIFT) & CSR_PMPADDR13_PMPADDR_31_2_MASK)
2482 #define CSR_PMPADDR13_PMPADDR_31_2_GET(x) (((uint32_t)(x) & CSR_PMPADDR13_PMPADDR_31_2_MASK) >> CSR_PMPADDR13_PMPADDR_31_2_SHIFT)
2483 
2484 /* Bitfield definition for register array: PMPADDR */
2485 /*
2486  * PMPADDR_31_2 (RW)
2487  *
2488  * same as pmpaddr0
2489  */
2490 #define CSR_PMPADDR14_PMPADDR_31_2_MASK (0xFFFFFFFCUL)
2491 #define CSR_PMPADDR14_PMPADDR_31_2_SHIFT (2U)
2492 #define CSR_PMPADDR14_PMPADDR_31_2_SET(x) (((uint32_t)(x) << CSR_PMPADDR14_PMPADDR_31_2_SHIFT) & CSR_PMPADDR14_PMPADDR_31_2_MASK)
2493 #define CSR_PMPADDR14_PMPADDR_31_2_GET(x) (((uint32_t)(x) & CSR_PMPADDR14_PMPADDR_31_2_MASK) >> CSR_PMPADDR14_PMPADDR_31_2_SHIFT)
2494 
2495 /* Bitfield definition for register array: PMPADDR */
2496 /*
2497  * PMPADDR_31_2 (RW)
2498  *
2499  * same as pmpaddr0
2500  */
2501 #define CSR_PMPADDR15_PMPADDR_31_2_MASK (0xFFFFFFFCUL)
2502 #define CSR_PMPADDR15_PMPADDR_31_2_SHIFT (2U)
2503 #define CSR_PMPADDR15_PMPADDR_31_2_SET(x) (((uint32_t)(x) << CSR_PMPADDR15_PMPADDR_31_2_SHIFT) & CSR_PMPADDR15_PMPADDR_31_2_MASK)
2504 #define CSR_PMPADDR15_PMPADDR_31_2_GET(x) (((uint32_t)(x) & CSR_PMPADDR15_PMPADDR_31_2_MASK) >> CSR_PMPADDR15_PMPADDR_31_2_SHIFT)
2505 
2506 /* Bitfield definition for register: TSELECT */
2507 /*
2508  * TRIGGER_INDEX (RW)
2509  *
2510  * This register determines which trigger is accessible through other trigger registers.
2511  */
2512 #define CSR_TSELECT_TRIGGER_INDEX_MASK (0xFFFFFFFFUL)
2513 #define CSR_TSELECT_TRIGGER_INDEX_SHIFT (0U)
2514 #define CSR_TSELECT_TRIGGER_INDEX_SET(x) (((uint32_t)(x) << CSR_TSELECT_TRIGGER_INDEX_SHIFT) & CSR_TSELECT_TRIGGER_INDEX_MASK)
2515 #define CSR_TSELECT_TRIGGER_INDEX_GET(x) (((uint32_t)(x) & CSR_TSELECT_TRIGGER_INDEX_MASK) >> CSR_TSELECT_TRIGGER_INDEX_SHIFT)
2516 
2517 /* Bitfield definition for register: TDATA1 */
2518 /*
2519  * TYPE (RW)
2520  *
2521  * Indicates the trigger type.
2522  * 0:The selected trigger is invalid.
2523  * 2:The selected trigger is an address/data match trigger.
2524  * 3:The selected trigger is an instruction count trigger
2525  * 4:The selected trigger is an interrupt trigger.
2526  * 5:The selected trigger is an exception trigger.
2527  */
2528 #define CSR_TDATA1_TYPE_MASK (0xF0000000UL)
2529 #define CSR_TDATA1_TYPE_SHIFT (28U)
2530 #define CSR_TDATA1_TYPE_SET(x) (((uint32_t)(x) << CSR_TDATA1_TYPE_SHIFT) & CSR_TDATA1_TYPE_MASK)
2531 #define CSR_TDATA1_TYPE_GET(x) (((uint32_t)(x) & CSR_TDATA1_TYPE_MASK) >> CSR_TDATA1_TYPE_SHIFT)
2532 
2533 /*
2534  * DMODE (RW)
2535  *
2536  * Setting this field to indicate the trigger is used by Debug Mode.
2537  * 0:Both Debug-mode and M-mode can write the currently selected trigger registers.
2538  * 1:Only Debug Mode can write the currently selected trigger registers. Writes from M-mode is ignored.
2539  */
2540 #define CSR_TDATA1_DMODE_MASK (0x8000000UL)
2541 #define CSR_TDATA1_DMODE_SHIFT (27U)
2542 #define CSR_TDATA1_DMODE_SET(x) (((uint32_t)(x) << CSR_TDATA1_DMODE_SHIFT) & CSR_TDATA1_DMODE_MASK)
2543 #define CSR_TDATA1_DMODE_GET(x) (((uint32_t)(x) & CSR_TDATA1_DMODE_MASK) >> CSR_TDATA1_DMODE_SHIFT)
2544 
2545 /*
2546  * DATA (RW)
2547  *
2548  * Trigger-specific data
2549  */
2550 #define CSR_TDATA1_DATA_MASK (0x7FFFFFFUL)
2551 #define CSR_TDATA1_DATA_SHIFT (0U)
2552 #define CSR_TDATA1_DATA_SET(x) (((uint32_t)(x) << CSR_TDATA1_DATA_SHIFT) & CSR_TDATA1_DATA_MASK)
2553 #define CSR_TDATA1_DATA_GET(x) (((uint32_t)(x) & CSR_TDATA1_DATA_MASK) >> CSR_TDATA1_DATA_SHIFT)
2554 
2555 /* Bitfield definition for register: MCONTROL */
2556 /*
2557  * TYPE (RW)
2558  *
2559  * Indicates the trigger type.
2560  * 0:The selected trigger is invalid.
2561  * 2:The selected trigger is an address/data match trigger.
2562  */
2563 #define CSR_MCONTROL_TYPE_MASK (0xF0000000UL)
2564 #define CSR_MCONTROL_TYPE_SHIFT (28U)
2565 #define CSR_MCONTROL_TYPE_SET(x) (((uint32_t)(x) << CSR_MCONTROL_TYPE_SHIFT) & CSR_MCONTROL_TYPE_MASK)
2566 #define CSR_MCONTROL_TYPE_GET(x) (((uint32_t)(x) & CSR_MCONTROL_TYPE_MASK) >> CSR_MCONTROL_TYPE_SHIFT)
2567 
2568 /*
2569  * DMODE (RW)
2570  *
2571  * Setting this field to indicate the trigger is used by Debug Mode.
2572  * 0:Both Debug-mode and M-mode can write the currently selected trigger registers
2573  * 1:Only Debug Mode can write the currently selected trigger registers. Writes from M-mode is ignored.
2574  */
2575 #define CSR_MCONTROL_DMODE_MASK (0x8000000UL)
2576 #define CSR_MCONTROL_DMODE_SHIFT (27U)
2577 #define CSR_MCONTROL_DMODE_SET(x) (((uint32_t)(x) << CSR_MCONTROL_DMODE_SHIFT) & CSR_MCONTROL_DMODE_MASK)
2578 #define CSR_MCONTROL_DMODE_GET(x) (((uint32_t)(x) & CSR_MCONTROL_DMODE_MASK) >> CSR_MCONTROL_DMODE_SHIFT)
2579 
2580 /*
2581  * MASKMAX (RO)
2582  *
2583  * Indicates the largest naturally aligned range supported by the hardware is 2ˆ12 bytes.
2584  */
2585 #define CSR_MCONTROL_MASKMAX_MASK (0x7E00000UL)
2586 #define CSR_MCONTROL_MASKMAX_SHIFT (21U)
2587 #define CSR_MCONTROL_MASKMAX_GET(x) (((uint32_t)(x) & CSR_MCONTROL_MASKMAX_MASK) >> CSR_MCONTROL_MASKMAX_SHIFT)
2588 
2589 /*
2590  * ACTION (RW)
2591  *
2592  * Setting this field to select what happens when this trigger matches.
2593  * 0:Raise a breakpoint exception
2594  * 1:Enter Debug Mode. (Only supported when DMODE is 1.)
2595  */
2596 #define CSR_MCONTROL_ACTION_MASK (0xF000U)
2597 #define CSR_MCONTROL_ACTION_SHIFT (12U)
2598 #define CSR_MCONTROL_ACTION_SET(x) (((uint32_t)(x) << CSR_MCONTROL_ACTION_SHIFT) & CSR_MCONTROL_ACTION_MASK)
2599 #define CSR_MCONTROL_ACTION_GET(x) (((uint32_t)(x) & CSR_MCONTROL_ACTION_MASK) >> CSR_MCONTROL_ACTION_SHIFT)
2600 
2601 /*
2602  * CHAIN (RW)
2603  *
2604  * Setting this field to enable trigger chain.
2605  * 0:When this trigger matches, the configured action is taken.
2606  * 1:While this trigger does not match, it prevents the trigger with the next index from matching.
2607  * If Number of Triggers is 2, this field is hardwired to 0 on trigger 1 (tselect = 1).
2608  * If Number of Triggers is 4, this field is hardwired
2609  * to 0 on trigger 3 (tselect = 3).
2610  * If Number of Triggers is 8, this field is hardwired to 0 on trigger 3 and trigger 7 (tselect = 3 or 7).
2611  */
2612 #define CSR_MCONTROL_CHAIN_MASK (0x800U)
2613 #define CSR_MCONTROL_CHAIN_SHIFT (11U)
2614 #define CSR_MCONTROL_CHAIN_SET(x) (((uint32_t)(x) << CSR_MCONTROL_CHAIN_SHIFT) & CSR_MCONTROL_CHAIN_MASK)
2615 #define CSR_MCONTROL_CHAIN_GET(x) (((uint32_t)(x) & CSR_MCONTROL_CHAIN_MASK) >> CSR_MCONTROL_CHAIN_SHIFT)
2616 
2617 /*
2618  * MATCH (RW)
2619  *
2620  * 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.
2621  * 2:Matches when the value is greater than (unsigned) or equal to tdata2.
2622  * 3:Matches when the value is less than (unsigned) tdata2
2623  */
2624 #define CSR_MCONTROL_MATCH_MASK (0x780U)
2625 #define CSR_MCONTROL_MATCH_SHIFT (7U)
2626 #define CSR_MCONTROL_MATCH_SET(x) (((uint32_t)(x) << CSR_MCONTROL_MATCH_SHIFT) & CSR_MCONTROL_MATCH_MASK)
2627 #define CSR_MCONTROL_MATCH_GET(x) (((uint32_t)(x) & CSR_MCONTROL_MATCH_MASK) >> CSR_MCONTROL_MATCH_SHIFT)
2628 
2629 /*
2630  * M (RW)
2631  *
2632  * Setting this field to enable this trigger in M-mode.
2633  */
2634 #define CSR_MCONTROL_M_MASK (0x40U)
2635 #define CSR_MCONTROL_M_SHIFT (6U)
2636 #define CSR_MCONTROL_M_SET(x) (((uint32_t)(x) << CSR_MCONTROL_M_SHIFT) & CSR_MCONTROL_M_MASK)
2637 #define CSR_MCONTROL_M_GET(x) (((uint32_t)(x) & CSR_MCONTROL_M_MASK) >> CSR_MCONTROL_M_SHIFT)
2638 
2639 /*
2640  * S (RW)
2641  *
2642  * Setting this field to enable this trigger in S-mode.
2643  */
2644 #define CSR_MCONTROL_S_MASK (0x10U)
2645 #define CSR_MCONTROL_S_SHIFT (4U)
2646 #define CSR_MCONTROL_S_SET(x) (((uint32_t)(x) << CSR_MCONTROL_S_SHIFT) & CSR_MCONTROL_S_MASK)
2647 #define CSR_MCONTROL_S_GET(x) (((uint32_t)(x) & CSR_MCONTROL_S_MASK) >> CSR_MCONTROL_S_SHIFT)
2648 
2649 /*
2650  * U (RW)
2651  *
2652  * Setting this field to enable this trigger in U-mode.
2653  */
2654 #define CSR_MCONTROL_U_MASK (0x8U)
2655 #define CSR_MCONTROL_U_SHIFT (3U)
2656 #define CSR_MCONTROL_U_SET(x) (((uint32_t)(x) << CSR_MCONTROL_U_SHIFT) & CSR_MCONTROL_U_MASK)
2657 #define CSR_MCONTROL_U_GET(x) (((uint32_t)(x) & CSR_MCONTROL_U_MASK) >> CSR_MCONTROL_U_SHIFT)
2658 
2659 /*
2660  * EXECUTE (RW)
2661  *
2662  * Setting this field to enable this trigger to compare virtual address of an instruction.
2663  */
2664 #define CSR_MCONTROL_EXECUTE_MASK (0x4U)
2665 #define CSR_MCONTROL_EXECUTE_SHIFT (2U)
2666 #define CSR_MCONTROL_EXECUTE_SET(x) (((uint32_t)(x) << CSR_MCONTROL_EXECUTE_SHIFT) & CSR_MCONTROL_EXECUTE_MASK)
2667 #define CSR_MCONTROL_EXECUTE_GET(x) (((uint32_t)(x) & CSR_MCONTROL_EXECUTE_MASK) >> CSR_MCONTROL_EXECUTE_SHIFT)
2668 
2669 /*
2670  * STORE (RW)
2671  *
2672  * Setting this field to enable this trigger to compare virtual address of a store.
2673  */
2674 #define CSR_MCONTROL_STORE_MASK (0x2U)
2675 #define CSR_MCONTROL_STORE_SHIFT (1U)
2676 #define CSR_MCONTROL_STORE_SET(x) (((uint32_t)(x) << CSR_MCONTROL_STORE_SHIFT) & CSR_MCONTROL_STORE_MASK)
2677 #define CSR_MCONTROL_STORE_GET(x) (((uint32_t)(x) & CSR_MCONTROL_STORE_MASK) >> CSR_MCONTROL_STORE_SHIFT)
2678 
2679 /*
2680  * LOAD (RW)
2681  *
2682  * Setting this field to enable this trigger to compare virtual address of a load.
2683  */
2684 #define CSR_MCONTROL_LOAD_MASK (0x1U)
2685 #define CSR_MCONTROL_LOAD_SHIFT (0U)
2686 #define CSR_MCONTROL_LOAD_SET(x) (((uint32_t)(x) << CSR_MCONTROL_LOAD_SHIFT) & CSR_MCONTROL_LOAD_MASK)
2687 #define CSR_MCONTROL_LOAD_GET(x) (((uint32_t)(x) & CSR_MCONTROL_LOAD_MASK) >> CSR_MCONTROL_LOAD_SHIFT)
2688 
2689 /* Bitfield definition for register: ICOUNT */
2690 /*
2691  * TYPE (RW)
2692  *
2693  * The selected trigger is an instruction count trigger.
2694  */
2695 #define CSR_ICOUNT_TYPE_MASK (0xF0000000UL)
2696 #define CSR_ICOUNT_TYPE_SHIFT (28U)
2697 #define CSR_ICOUNT_TYPE_SET(x) (((uint32_t)(x) << CSR_ICOUNT_TYPE_SHIFT) & CSR_ICOUNT_TYPE_MASK)
2698 #define CSR_ICOUNT_TYPE_GET(x) (((uint32_t)(x) & CSR_ICOUNT_TYPE_MASK) >> CSR_ICOUNT_TYPE_SHIFT)
2699 
2700 /*
2701  * DMODE (RW)
2702  *
2703  * Setting this field to indicate the trigger is used by Debug Mode.
2704  * 0:Both Debug-mode and M-mode can write the currently selected trigger registers.
2705  * 1:Only Debug Mode can write the currently selected trigger registers. Writes from M-mode is ignored.
2706  */
2707 #define CSR_ICOUNT_DMODE_MASK (0x8000000UL)
2708 #define CSR_ICOUNT_DMODE_SHIFT (27U)
2709 #define CSR_ICOUNT_DMODE_SET(x) (((uint32_t)(x) << CSR_ICOUNT_DMODE_SHIFT) & CSR_ICOUNT_DMODE_MASK)
2710 #define CSR_ICOUNT_DMODE_GET(x) (((uint32_t)(x) & CSR_ICOUNT_DMODE_MASK) >> CSR_ICOUNT_DMODE_SHIFT)
2711 
2712 /*
2713  * COUNT (RO)
2714  *
2715  * This field is hardwired to 1 for single-stepping support
2716  */
2717 #define CSR_ICOUNT_COUNT_MASK (0x400U)
2718 #define CSR_ICOUNT_COUNT_SHIFT (10U)
2719 #define CSR_ICOUNT_COUNT_GET(x) (((uint32_t)(x) & CSR_ICOUNT_COUNT_MASK) >> CSR_ICOUNT_COUNT_SHIFT)
2720 
2721 /*
2722  * M (RW)
2723  *
2724  * Setting this field to enable this trigger in M-mode.
2725  */
2726 #define CSR_ICOUNT_M_MASK (0x200U)
2727 #define CSR_ICOUNT_M_SHIFT (9U)
2728 #define CSR_ICOUNT_M_SET(x) (((uint32_t)(x) << CSR_ICOUNT_M_SHIFT) & CSR_ICOUNT_M_MASK)
2729 #define CSR_ICOUNT_M_GET(x) (((uint32_t)(x) & CSR_ICOUNT_M_MASK) >> CSR_ICOUNT_M_SHIFT)
2730 
2731 /*
2732  * S (RW)
2733  *
2734  * Setting this field to enable this trigger in S-mode.
2735  */
2736 #define CSR_ICOUNT_S_MASK (0x80U)
2737 #define CSR_ICOUNT_S_SHIFT (7U)
2738 #define CSR_ICOUNT_S_SET(x) (((uint32_t)(x) << CSR_ICOUNT_S_SHIFT) & CSR_ICOUNT_S_MASK)
2739 #define CSR_ICOUNT_S_GET(x) (((uint32_t)(x) & CSR_ICOUNT_S_MASK) >> CSR_ICOUNT_S_SHIFT)
2740 
2741 /*
2742  * U (RW)
2743  *
2744  * Setting this field to enable this trigger in U-mode.
2745  */
2746 #define CSR_ICOUNT_U_MASK (0x40U)
2747 #define CSR_ICOUNT_U_SHIFT (6U)
2748 #define CSR_ICOUNT_U_SET(x) (((uint32_t)(x) << CSR_ICOUNT_U_SHIFT) & CSR_ICOUNT_U_MASK)
2749 #define CSR_ICOUNT_U_GET(x) (((uint32_t)(x) & CSR_ICOUNT_U_MASK) >> CSR_ICOUNT_U_SHIFT)
2750 
2751 /*
2752  * ACTION (RW)
2753  *
2754  * Setting this field to select what happens when this trigger matches.
2755  * 0:Raise a breakpoint exception
2756  * 1:Enter Debug Mode. (Only supported when DMODE is 1.)
2757  */
2758 #define CSR_ICOUNT_ACTION_MASK (0x3FU)
2759 #define CSR_ICOUNT_ACTION_SHIFT (0U)
2760 #define CSR_ICOUNT_ACTION_SET(x) (((uint32_t)(x) << CSR_ICOUNT_ACTION_SHIFT) & CSR_ICOUNT_ACTION_MASK)
2761 #define CSR_ICOUNT_ACTION_GET(x) (((uint32_t)(x) & CSR_ICOUNT_ACTION_MASK) >> CSR_ICOUNT_ACTION_SHIFT)
2762 
2763 /* Bitfield definition for register: ITRIGGER */
2764 /*
2765  * TYPE (RW)
2766  *
2767  * The selected trigger is an interrupt trigger.
2768  */
2769 #define CSR_ITRIGGER_TYPE_MASK (0xF0000000UL)
2770 #define CSR_ITRIGGER_TYPE_SHIFT (28U)
2771 #define CSR_ITRIGGER_TYPE_SET(x) (((uint32_t)(x) << CSR_ITRIGGER_TYPE_SHIFT) & CSR_ITRIGGER_TYPE_MASK)
2772 #define CSR_ITRIGGER_TYPE_GET(x) (((uint32_t)(x) & CSR_ITRIGGER_TYPE_MASK) >> CSR_ITRIGGER_TYPE_SHIFT)
2773 
2774 /*
2775  * DMODE (RW)
2776  *
2777  * Setting this field to indicate the trigger is used by Debug Mode.
2778  * 0:Both Debug-mode and M-mode can write the currently selected trigger registers.
2779  * 1:Only Debug Mode can write the currently selected trigger registers. Writes from M-mode is ignored.
2780  */
2781 #define CSR_ITRIGGER_DMODE_MASK (0x8000000UL)
2782 #define CSR_ITRIGGER_DMODE_SHIFT (27U)
2783 #define CSR_ITRIGGER_DMODE_SET(x) (((uint32_t)(x) << CSR_ITRIGGER_DMODE_SHIFT) & CSR_ITRIGGER_DMODE_MASK)
2784 #define CSR_ITRIGGER_DMODE_GET(x) (((uint32_t)(x) & CSR_ITRIGGER_DMODE_MASK) >> CSR_ITRIGGER_DMODE_SHIFT)
2785 
2786 /*
2787  * M (RW)
2788  *
2789  * Setting this field to enable this trigger in M-mode.
2790  */
2791 #define CSR_ITRIGGER_M_MASK (0x200U)
2792 #define CSR_ITRIGGER_M_SHIFT (9U)
2793 #define CSR_ITRIGGER_M_SET(x) (((uint32_t)(x) << CSR_ITRIGGER_M_SHIFT) & CSR_ITRIGGER_M_MASK)
2794 #define CSR_ITRIGGER_M_GET(x) (((uint32_t)(x) & CSR_ITRIGGER_M_MASK) >> CSR_ITRIGGER_M_SHIFT)
2795 
2796 /*
2797  * S (RW)
2798  *
2799  * Setting this field to enable this trigger in S-mode.
2800  */
2801 #define CSR_ITRIGGER_S_MASK (0x80U)
2802 #define CSR_ITRIGGER_S_SHIFT (7U)
2803 #define CSR_ITRIGGER_S_SET(x) (((uint32_t)(x) << CSR_ITRIGGER_S_SHIFT) & CSR_ITRIGGER_S_MASK)
2804 #define CSR_ITRIGGER_S_GET(x) (((uint32_t)(x) & CSR_ITRIGGER_S_MASK) >> CSR_ITRIGGER_S_SHIFT)
2805 
2806 /*
2807  * U (RW)
2808  *
2809  * Setting this field to enable this trigger in U-mode.
2810  */
2811 #define CSR_ITRIGGER_U_MASK (0x40U)
2812 #define CSR_ITRIGGER_U_SHIFT (6U)
2813 #define CSR_ITRIGGER_U_SET(x) (((uint32_t)(x) << CSR_ITRIGGER_U_SHIFT) & CSR_ITRIGGER_U_MASK)
2814 #define CSR_ITRIGGER_U_GET(x) (((uint32_t)(x) & CSR_ITRIGGER_U_MASK) >> CSR_ITRIGGER_U_SHIFT)
2815 
2816 /*
2817  * ACTION (RW)
2818  *
2819  * Setting this field to select what happens when this trigger matches.
2820  * 0:Raise a breakpoint exception.
2821  * 1:Enter Debug Mode. (Only supported when DMODE is 1.)
2822  */
2823 #define CSR_ITRIGGER_ACTION_MASK (0x3FU)
2824 #define CSR_ITRIGGER_ACTION_SHIFT (0U)
2825 #define CSR_ITRIGGER_ACTION_SET(x) (((uint32_t)(x) << CSR_ITRIGGER_ACTION_SHIFT) & CSR_ITRIGGER_ACTION_MASK)
2826 #define CSR_ITRIGGER_ACTION_GET(x) (((uint32_t)(x) & CSR_ITRIGGER_ACTION_MASK) >> CSR_ITRIGGER_ACTION_SHIFT)
2827 
2828 /* Bitfield definition for register: ETRIGGER */
2829 /*
2830  * TYPE (RW)
2831  *
2832  * The selected trigger is an exception trigger.
2833  */
2834 #define CSR_ETRIGGER_TYPE_MASK (0xF0000000UL)
2835 #define CSR_ETRIGGER_TYPE_SHIFT (28U)
2836 #define CSR_ETRIGGER_TYPE_SET(x) (((uint32_t)(x) << CSR_ETRIGGER_TYPE_SHIFT) & CSR_ETRIGGER_TYPE_MASK)
2837 #define CSR_ETRIGGER_TYPE_GET(x) (((uint32_t)(x) & CSR_ETRIGGER_TYPE_MASK) >> CSR_ETRIGGER_TYPE_SHIFT)
2838 
2839 /*
2840  * DMODE (RW)
2841  *
2842  * Setting this field to indicate the trigger is used by Debug Mode.
2843  * 0:Both Debug-mode and M-mode can write the currently selected trigger registers.
2844  * 1:Only Debug Mode can write the currently selected trigger registers. Writes from M-mode is ignored.
2845  */
2846 #define CSR_ETRIGGER_DMODE_MASK (0x8000000UL)
2847 #define CSR_ETRIGGER_DMODE_SHIFT (27U)
2848 #define CSR_ETRIGGER_DMODE_SET(x) (((uint32_t)(x) << CSR_ETRIGGER_DMODE_SHIFT) & CSR_ETRIGGER_DMODE_MASK)
2849 #define CSR_ETRIGGER_DMODE_GET(x) (((uint32_t)(x) & CSR_ETRIGGER_DMODE_MASK) >> CSR_ETRIGGER_DMODE_SHIFT)
2850 
2851 /*
2852  * NMI (RW)
2853  *
2854  * Setting this field to enable this trigger in non-maskable interrupts, regardless of the values of s, u, and m.
2855  */
2856 #define CSR_ETRIGGER_NMI_MASK (0x400U)
2857 #define CSR_ETRIGGER_NMI_SHIFT (10U)
2858 #define CSR_ETRIGGER_NMI_SET(x) (((uint32_t)(x) << CSR_ETRIGGER_NMI_SHIFT) & CSR_ETRIGGER_NMI_MASK)
2859 #define CSR_ETRIGGER_NMI_GET(x) (((uint32_t)(x) & CSR_ETRIGGER_NMI_MASK) >> CSR_ETRIGGER_NMI_SHIFT)
2860 
2861 /*
2862  * M (RW)
2863  *
2864  * Setting this field to enable this trigger in M-mode.
2865  */
2866 #define CSR_ETRIGGER_M_MASK (0x200U)
2867 #define CSR_ETRIGGER_M_SHIFT (9U)
2868 #define CSR_ETRIGGER_M_SET(x) (((uint32_t)(x) << CSR_ETRIGGER_M_SHIFT) & CSR_ETRIGGER_M_MASK)
2869 #define CSR_ETRIGGER_M_GET(x) (((uint32_t)(x) & CSR_ETRIGGER_M_MASK) >> CSR_ETRIGGER_M_SHIFT)
2870 
2871 /*
2872  * S (RW)
2873  *
2874  * Setting this field to enable this trigger in S-mode.
2875  */
2876 #define CSR_ETRIGGER_S_MASK (0x80U)
2877 #define CSR_ETRIGGER_S_SHIFT (7U)
2878 #define CSR_ETRIGGER_S_SET(x) (((uint32_t)(x) << CSR_ETRIGGER_S_SHIFT) & CSR_ETRIGGER_S_MASK)
2879 #define CSR_ETRIGGER_S_GET(x) (((uint32_t)(x) & CSR_ETRIGGER_S_MASK) >> CSR_ETRIGGER_S_SHIFT)
2880 
2881 /*
2882  * U (RW)
2883  *
2884  * Setting this field to enable this trigger in U-mode.
2885  */
2886 #define CSR_ETRIGGER_U_MASK (0x40U)
2887 #define CSR_ETRIGGER_U_SHIFT (6U)
2888 #define CSR_ETRIGGER_U_SET(x) (((uint32_t)(x) << CSR_ETRIGGER_U_SHIFT) & CSR_ETRIGGER_U_MASK)
2889 #define CSR_ETRIGGER_U_GET(x) (((uint32_t)(x) & CSR_ETRIGGER_U_MASK) >> CSR_ETRIGGER_U_SHIFT)
2890 
2891 /*
2892  * ACTION (RW)
2893  *
2894  * Setting this field to select what happens when this trigger matches.
2895  * 0:Raise a breakpoint exception
2896  * 1:Enter Debug Mode. (Only supported when DMODE is 1.)
2897  */
2898 #define CSR_ETRIGGER_ACTION_MASK (0x3FU)
2899 #define CSR_ETRIGGER_ACTION_SHIFT (0U)
2900 #define CSR_ETRIGGER_ACTION_SET(x) (((uint32_t)(x) << CSR_ETRIGGER_ACTION_SHIFT) & CSR_ETRIGGER_ACTION_MASK)
2901 #define CSR_ETRIGGER_ACTION_GET(x) (((uint32_t)(x) & CSR_ETRIGGER_ACTION_MASK) >> CSR_ETRIGGER_ACTION_SHIFT)
2902 
2903 /* Bitfield definition for register: TDATA2 */
2904 /*
2905  * DATA (RW)
2906  *
2907  * 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..
2908  */
2909 #define CSR_TDATA2_DATA_MASK (0xFFFFFFFFUL)
2910 #define CSR_TDATA2_DATA_SHIFT (0U)
2911 #define CSR_TDATA2_DATA_SET(x) (((uint32_t)(x) << CSR_TDATA2_DATA_SHIFT) & CSR_TDATA2_DATA_MASK)
2912 #define CSR_TDATA2_DATA_GET(x) (((uint32_t)(x) & CSR_TDATA2_DATA_MASK) >> CSR_TDATA2_DATA_SHIFT)
2913 
2914 /* Bitfield definition for register: TDATA3 */
2915 /*
2916  * DATA (RW)
2917  *
2918  * 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..
2919  */
2920 #define CSR_TDATA3_DATA_MASK (0xFFFFFFFFUL)
2921 #define CSR_TDATA3_DATA_SHIFT (0U)
2922 #define CSR_TDATA3_DATA_SET(x) (((uint32_t)(x) << CSR_TDATA3_DATA_SHIFT) & CSR_TDATA3_DATA_MASK)
2923 #define CSR_TDATA3_DATA_GET(x) (((uint32_t)(x) & CSR_TDATA3_DATA_MASK) >> CSR_TDATA3_DATA_SHIFT)
2924 
2925 /* Bitfield definition for register: TEXTRA */
2926 /*
2927  * MVALUE (RW)
2928  *
2929  * Data used together with MSELECT.
2930  */
2931 #define CSR_TEXTRA_MVALUE_MASK (0xFC000000UL)
2932 #define CSR_TEXTRA_MVALUE_SHIFT (26U)
2933 #define CSR_TEXTRA_MVALUE_SET(x) (((uint32_t)(x) << CSR_TEXTRA_MVALUE_SHIFT) & CSR_TEXTRA_MVALUE_MASK)
2934 #define CSR_TEXTRA_MVALUE_GET(x) (((uint32_t)(x) & CSR_TEXTRA_MVALUE_MASK) >> CSR_TEXTRA_MVALUE_SHIFT)
2935 
2936 /*
2937  * MSELECT (RW)
2938  *
2939  * 0:Ignore MVALUE.
2940  * 1:This trigger will only match if the lower bits of mcontext equal MVALUE.
2941  */
2942 #define CSR_TEXTRA_MSELECT_MASK (0x2000000UL)
2943 #define CSR_TEXTRA_MSELECT_SHIFT (25U)
2944 #define CSR_TEXTRA_MSELECT_SET(x) (((uint32_t)(x) << CSR_TEXTRA_MSELECT_SHIFT) & CSR_TEXTRA_MSELECT_MASK)
2945 #define CSR_TEXTRA_MSELECT_GET(x) (((uint32_t)(x) & CSR_TEXTRA_MSELECT_MASK) >> CSR_TEXTRA_MSELECT_SHIFT)
2946 
2947 /*
2948  * SVALUE (RW)
2949  *
2950  * Data used together with SSELECT.
2951  */
2952 #define CSR_TEXTRA_SVALUE_MASK (0x7FCU)
2953 #define CSR_TEXTRA_SVALUE_SHIFT (2U)
2954 #define CSR_TEXTRA_SVALUE_SET(x) (((uint32_t)(x) << CSR_TEXTRA_SVALUE_SHIFT) & CSR_TEXTRA_SVALUE_MASK)
2955 #define CSR_TEXTRA_SVALUE_GET(x) (((uint32_t)(x) & CSR_TEXTRA_SVALUE_MASK) >> CSR_TEXTRA_SVALUE_SHIFT)
2956 
2957 /*
2958  * SSELECT (RW)
2959  *
2960  * 0:Ignore MVALUE
2961  * 1:This trigger will only match if the lower bits of scontext equal SVALUE
2962  * 2This trigger will only match if satp.ASID equals SVALUE.
2963  */
2964 #define CSR_TEXTRA_SSELECT_MASK (0x3U)
2965 #define CSR_TEXTRA_SSELECT_SHIFT (0U)
2966 #define CSR_TEXTRA_SSELECT_SET(x) (((uint32_t)(x) << CSR_TEXTRA_SSELECT_SHIFT) & CSR_TEXTRA_SSELECT_MASK)
2967 #define CSR_TEXTRA_SSELECT_GET(x) (((uint32_t)(x) & CSR_TEXTRA_SSELECT_MASK) >> CSR_TEXTRA_SSELECT_SHIFT)
2968 
2969 /* Bitfield definition for register: TINFO */
2970 /*
2971  * INFO (RO)
2972  *
2973  * One bit for each possible type in tdata1. Bit N corresponds to type N. If the bit is set, then that
2974  * type is supported by the currently selected trigger. If the currently selected trigger does not exist, this field contains 1.
2975  * 0:When this bit is set, there is no trigger at this tselect
2976  * 1:Reserved and hardwired to 0.
2977  * 2:When this bit is set, the selected trigger supports type of address/data match trigger
2978  * 3:When this bit is set, the selected trigger supports type of instruction count trigger.
2979  * 4:When this bit is set, the selected trigger supports type of interrupt trigger
2980  * 5:When this bit is set, the selected trigger supports type of exception trigger
2981  * 15:When this bit is set, the selected trigger exists (so enumeration shouldn’t terminate), but is not currently available.
2982  * Others:Reserved for future use.
2983  */
2984 #define CSR_TINFO_INFO_MASK (0xFFFFU)
2985 #define CSR_TINFO_INFO_SHIFT (0U)
2986 #define CSR_TINFO_INFO_GET(x) (((uint32_t)(x) & CSR_TINFO_INFO_MASK) >> CSR_TINFO_INFO_SHIFT)
2987 
2988 /* Bitfield definition for register: TCONTROL */
2989 /*
2990  * MPTE (RW)
2991  *
2992  * M-mode previous trigger enable field. When a trap into M-mode is taken, MPTE is set to the value of MTE.
2993  */
2994 #define CSR_TCONTROL_MPTE_MASK (0x80U)
2995 #define CSR_TCONTROL_MPTE_SHIFT (7U)
2996 #define CSR_TCONTROL_MPTE_SET(x) (((uint32_t)(x) << CSR_TCONTROL_MPTE_SHIFT) & CSR_TCONTROL_MPTE_MASK)
2997 #define CSR_TCONTROL_MPTE_GET(x) (((uint32_t)(x) & CSR_TCONTROL_MPTE_MASK) >> CSR_TCONTROL_MPTE_SHIFT)
2998 
2999 /*
3000  * MTE (RW)
3001  *
3002  * 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.
3003  * 0:Triggers do not match/fire while the hart is in M-mode.
3004  * 1:Triggers do match/fire while the hart is in M-mode.
3005  */
3006 #define CSR_TCONTROL_MTE_MASK (0x8U)
3007 #define CSR_TCONTROL_MTE_SHIFT (3U)
3008 #define CSR_TCONTROL_MTE_SET(x) (((uint32_t)(x) << CSR_TCONTROL_MTE_SHIFT) & CSR_TCONTROL_MTE_MASK)
3009 #define CSR_TCONTROL_MTE_GET(x) (((uint32_t)(x) & CSR_TCONTROL_MTE_MASK) >> CSR_TCONTROL_MTE_SHIFT)
3010 
3011 /* Bitfield definition for register: MCONTEXT */
3012 /*
3013  * MCONTEXT (RW)
3014  *
3015  * 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.
3016  */
3017 #define CSR_MCONTEXT_MCONTEXT_MASK (0x3FU)
3018 #define CSR_MCONTEXT_MCONTEXT_SHIFT (0U)
3019 #define CSR_MCONTEXT_MCONTEXT_SET(x) (((uint32_t)(x) << CSR_MCONTEXT_MCONTEXT_SHIFT) & CSR_MCONTEXT_MCONTEXT_MASK)
3020 #define CSR_MCONTEXT_MCONTEXT_GET(x) (((uint32_t)(x) & CSR_MCONTEXT_MCONTEXT_MASK) >> CSR_MCONTEXT_MCONTEXT_SHIFT)
3021 
3022 /* Bitfield definition for register: SCONTEXT */
3023 /*
3024  * SCONTEXT (RW)
3025  *
3026  * 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.
3027  */
3028 #define CSR_SCONTEXT_SCONTEXT_MASK (0x1FFU)
3029 #define CSR_SCONTEXT_SCONTEXT_SHIFT (0U)
3030 #define CSR_SCONTEXT_SCONTEXT_SET(x) (((uint32_t)(x) << CSR_SCONTEXT_SCONTEXT_SHIFT) & CSR_SCONTEXT_SCONTEXT_MASK)
3031 #define CSR_SCONTEXT_SCONTEXT_GET(x) (((uint32_t)(x) & CSR_SCONTEXT_SCONTEXT_MASK) >> CSR_SCONTEXT_SCONTEXT_SHIFT)
3032 
3033 /* Bitfield definition for register: DCSR */
3034 /*
3035  * XDEBUGVER (RO)
3036  *
3037  * 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
3038  */
3039 #define CSR_DCSR_XDEBUGVER_MASK (0xF0000000UL)
3040 #define CSR_DCSR_XDEBUGVER_SHIFT (28U)
3041 #define CSR_DCSR_XDEBUGVER_GET(x) (((uint32_t)(x) & CSR_DCSR_XDEBUGVER_MASK) >> CSR_DCSR_XDEBUGVER_SHIFT)
3042 
3043 /*
3044  * EBREAKM (RW)
3045  *
3046  * This bit controls the behavior of EBREAK instructions in Machine Mode
3047  * 0:Generate a regular breakpoint exception
3048  * 1:Enter Debug Mode
3049  */
3050 #define CSR_DCSR_EBREAKM_MASK (0x8000U)
3051 #define CSR_DCSR_EBREAKM_SHIFT (15U)
3052 #define CSR_DCSR_EBREAKM_SET(x) (((uint32_t)(x) << CSR_DCSR_EBREAKM_SHIFT) & CSR_DCSR_EBREAKM_MASK)
3053 #define CSR_DCSR_EBREAKM_GET(x) (((uint32_t)(x) & CSR_DCSR_EBREAKM_MASK) >> CSR_DCSR_EBREAKM_SHIFT)
3054 
3055 /*
3056  * EBREAKS (RW)
3057  *
3058  * This bit controls the behavior of EBREAK instructions in Supervisor Mode.
3059  * 0:Generate a regular breakpoint exception
3060  * 1:Enter Debug Mode
3061  */
3062 #define CSR_DCSR_EBREAKS_MASK (0x2000U)
3063 #define CSR_DCSR_EBREAKS_SHIFT (13U)
3064 #define CSR_DCSR_EBREAKS_SET(x) (((uint32_t)(x) << CSR_DCSR_EBREAKS_SHIFT) & CSR_DCSR_EBREAKS_MASK)
3065 #define CSR_DCSR_EBREAKS_GET(x) (((uint32_t)(x) & CSR_DCSR_EBREAKS_MASK) >> CSR_DCSR_EBREAKS_SHIFT)
3066 
3067 /*
3068  * EBREAKU (RW)
3069  *
3070  * This bit controls the behavior of EBREAK instructions in User/Application Mode
3071  * 0:Generate a regular breakpoint exception
3072  * 1:Enter Debug Mode
3073  */
3074 #define CSR_DCSR_EBREAKU_MASK (0x1000U)
3075 #define CSR_DCSR_EBREAKU_SHIFT (12U)
3076 #define CSR_DCSR_EBREAKU_SET(x) (((uint32_t)(x) << CSR_DCSR_EBREAKU_SHIFT) & CSR_DCSR_EBREAKU_MASK)
3077 #define CSR_DCSR_EBREAKU_GET(x) (((uint32_t)(x) & CSR_DCSR_EBREAKU_MASK) >> CSR_DCSR_EBREAKU_SHIFT)
3078 
3079 /*
3080  * STEPIE (RW)
3081  *
3082  * This bit controls whether interrupts are enabled during single stepping
3083  * 0:Disable interrupts during single stepping
3084  * 1:Allow interrupts in single stepping
3085  */
3086 #define CSR_DCSR_STEPIE_MASK (0x800U)
3087 #define CSR_DCSR_STEPIE_SHIFT (11U)
3088 #define CSR_DCSR_STEPIE_SET(x) (((uint32_t)(x) << CSR_DCSR_STEPIE_SHIFT) & CSR_DCSR_STEPIE_MASK)
3089 #define CSR_DCSR_STEPIE_GET(x) (((uint32_t)(x) & CSR_DCSR_STEPIE_MASK) >> CSR_DCSR_STEPIE_SHIFT)
3090 
3091 /*
3092  * STOPCOUNT (RW)
3093  *
3094  * This bit controls whether performance counters are stopped in Debug Mode.
3095  * 0:Do not stop counters in Debug Mode
3096  * 1:Stop counters in Debug Mode
3097  */
3098 #define CSR_DCSR_STOPCOUNT_MASK (0x400U)
3099 #define CSR_DCSR_STOPCOUNT_SHIFT (10U)
3100 #define CSR_DCSR_STOPCOUNT_SET(x) (((uint32_t)(x) << CSR_DCSR_STOPCOUNT_SHIFT) & CSR_DCSR_STOPCOUNT_MASK)
3101 #define CSR_DCSR_STOPCOUNT_GET(x) (((uint32_t)(x) & CSR_DCSR_STOPCOUNT_MASK) >> CSR_DCSR_STOPCOUNT_SHIFT)
3102 
3103 /*
3104  * STOPTIME (RW)
3105  *
3106  * 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.
3107  * 0:Do not stop timers in Debug Mode
3108  * 1:Stop timers in Debug Mode
3109  */
3110 #define CSR_DCSR_STOPTIME_MASK (0x200U)
3111 #define CSR_DCSR_STOPTIME_SHIFT (9U)
3112 #define CSR_DCSR_STOPTIME_SET(x) (((uint32_t)(x) << CSR_DCSR_STOPTIME_SHIFT) & CSR_DCSR_STOPTIME_MASK)
3113 #define CSR_DCSR_STOPTIME_GET(x) (((uint32_t)(x) & CSR_DCSR_STOPTIME_MASK) >> CSR_DCSR_STOPTIME_SHIFT)
3114 
3115 /*
3116  * CAUSE (RO)
3117  *
3118  * 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
3119  * 0:Reserved
3120  * 1:EBREAK
3121  * 2:Trigger module
3122  * 3:Halt request
3123  * 4:Single step
3124  * 5:Halt-on-reset
3125  * 6-7:Reserved
3126  */
3127 #define CSR_DCSR_CAUSE_MASK (0x1C0U)
3128 #define CSR_DCSR_CAUSE_SHIFT (6U)
3129 #define CSR_DCSR_CAUSE_GET(x) (((uint32_t)(x) & CSR_DCSR_CAUSE_MASK) >> CSR_DCSR_CAUSE_SHIFT)
3130 
3131 /*
3132  * MPRVEN (RW)
3133  *
3134  * This bit controls whether mstatus.MPRV takes effect in Debug Mode.
3135  * 0:MPRV in mstatus is ignored in Debug Mode.
3136  * 1:MPRV in mstatus takes effect in Debug Mode.
3137  */
3138 #define CSR_DCSR_MPRVEN_MASK (0x10U)
3139 #define CSR_DCSR_MPRVEN_SHIFT (4U)
3140 #define CSR_DCSR_MPRVEN_SET(x) (((uint32_t)(x) << CSR_DCSR_MPRVEN_SHIFT) & CSR_DCSR_MPRVEN_MASK)
3141 #define CSR_DCSR_MPRVEN_GET(x) (((uint32_t)(x) & CSR_DCSR_MPRVEN_MASK) >> CSR_DCSR_MPRVEN_SHIFT)
3142 
3143 /*
3144  * NMIP (RO)
3145  *
3146  * 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.
3147  */
3148 #define CSR_DCSR_NMIP_MASK (0x8U)
3149 #define CSR_DCSR_NMIP_SHIFT (3U)
3150 #define CSR_DCSR_NMIP_GET(x) (((uint32_t)(x) & CSR_DCSR_NMIP_MASK) >> CSR_DCSR_NMIP_SHIFT)
3151 
3152 /*
3153  * STEP (RW)
3154  *
3155  * 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.
3156  * 0:Single Step Mode is off
3157  * 1:Single Step Mode is on
3158  */
3159 #define CSR_DCSR_STEP_MASK (0x4U)
3160 #define CSR_DCSR_STEP_SHIFT (2U)
3161 #define CSR_DCSR_STEP_SET(x) (((uint32_t)(x) << CSR_DCSR_STEP_SHIFT) & CSR_DCSR_STEP_MASK)
3162 #define CSR_DCSR_STEP_GET(x) (((uint32_t)(x) & CSR_DCSR_STEP_MASK) >> CSR_DCSR_STEP_SHIFT)
3163 
3164 /*
3165  * PRV (RW)
3166  *
3167  * 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.
3168  * 0:User/Application
3169  * 1:Supervisor
3170  * 2:Reserved
3171  * 3:Machine
3172  */
3173 #define CSR_DCSR_PRV_MASK (0x3U)
3174 #define CSR_DCSR_PRV_SHIFT (0U)
3175 #define CSR_DCSR_PRV_SET(x) (((uint32_t)(x) << CSR_DCSR_PRV_SHIFT) & CSR_DCSR_PRV_MASK)
3176 #define CSR_DCSR_PRV_GET(x) (((uint32_t)(x) & CSR_DCSR_PRV_MASK) >> CSR_DCSR_PRV_SHIFT)
3177 
3178 /* Bitfield definition for register: DPC */
3179 /*
3180  * DPC (RW)
3181  *
3182  * Debug Program Counter. Bit 0 is hardwired to 0.
3183  */
3184 #define CSR_DPC_DPC_MASK (0xFFFFFFFFUL)
3185 #define CSR_DPC_DPC_SHIFT (0U)
3186 #define CSR_DPC_DPC_SET(x) (((uint32_t)(x) << CSR_DPC_DPC_SHIFT) & CSR_DPC_DPC_MASK)
3187 #define CSR_DPC_DPC_GET(x) (((uint32_t)(x) & CSR_DPC_DPC_MASK) >> CSR_DPC_DPC_SHIFT)
3188 
3189 /* Bitfield definition for register: DSCRATCH0 */
3190 /*
3191  * DSCRATCH (RO)
3192  *
3193  * A scratch register that is reserved for use by Debug Module.
3194  */
3195 #define CSR_DSCRATCH0_DSCRATCH_MASK (0xFFFFFFFFUL)
3196 #define CSR_DSCRATCH0_DSCRATCH_SHIFT (0U)
3197 #define CSR_DSCRATCH0_DSCRATCH_GET(x) (((uint32_t)(x) & CSR_DSCRATCH0_DSCRATCH_MASK) >> CSR_DSCRATCH0_DSCRATCH_SHIFT)
3198 
3199 /* Bitfield definition for register: DSCRATCH1 */
3200 /*
3201  * DSCRATCH (RO)
3202  *
3203  * A scratch register that is reserved for use by Debug Module.
3204  */
3205 #define CSR_DSCRATCH1_DSCRATCH_MASK (0xFFFFFFFFUL)
3206 #define CSR_DSCRATCH1_DSCRATCH_SHIFT (0U)
3207 #define CSR_DSCRATCH1_DSCRATCH_GET(x) (((uint32_t)(x) & CSR_DSCRATCH1_DSCRATCH_MASK) >> CSR_DSCRATCH1_DSCRATCH_SHIFT)
3208 
3209 /* Bitfield definition for register: MCYCLE */
3210 /*
3211  * COUNTER (RW)
3212  *
3213  * the lower 32 bits of Machine Cycle Counter
3214  */
3215 #define CSR_MCYCLE_COUNTER_MASK (0xFFFFFFFFUL)
3216 #define CSR_MCYCLE_COUNTER_SHIFT (0U)
3217 #define CSR_MCYCLE_COUNTER_SET(x) (((uint32_t)(x) << CSR_MCYCLE_COUNTER_SHIFT) & CSR_MCYCLE_COUNTER_MASK)
3218 #define CSR_MCYCLE_COUNTER_GET(x) (((uint32_t)(x) & CSR_MCYCLE_COUNTER_MASK) >> CSR_MCYCLE_COUNTER_SHIFT)
3219 
3220 /* Bitfield definition for register: MINSTRET */
3221 /*
3222  * COUNTER (RW)
3223  *
3224  * the lower 32 bits of Machine Instruction-Retired Counter
3225  */
3226 #define CSR_MINSTRET_COUNTER_MASK (0xFFFFFFFFUL)
3227 #define CSR_MINSTRET_COUNTER_SHIFT (0U)
3228 #define CSR_MINSTRET_COUNTER_SET(x) (((uint32_t)(x) << CSR_MINSTRET_COUNTER_SHIFT) & CSR_MINSTRET_COUNTER_MASK)
3229 #define CSR_MINSTRET_COUNTER_GET(x) (((uint32_t)(x) & CSR_MINSTRET_COUNTER_MASK) >> CSR_MINSTRET_COUNTER_SHIFT)
3230 
3231 /* Bitfield definition for register: MHPMCOUNTER3 */
3232 /*
3233  * COUNTER (RW)
3234  *
3235  * count the num- ber of events selected by mhpmevent3
3236  */
3237 #define CSR_MHPMCOUNTER3_COUNTER_MASK (0xFFFFFFFFUL)
3238 #define CSR_MHPMCOUNTER3_COUNTER_SHIFT (0U)
3239 #define CSR_MHPMCOUNTER3_COUNTER_SET(x) (((uint32_t)(x) << CSR_MHPMCOUNTER3_COUNTER_SHIFT) & CSR_MHPMCOUNTER3_COUNTER_MASK)
3240 #define CSR_MHPMCOUNTER3_COUNTER_GET(x) (((uint32_t)(x) & CSR_MHPMCOUNTER3_COUNTER_MASK) >> CSR_MHPMCOUNTER3_COUNTER_SHIFT)
3241 
3242 /* Bitfield definition for register: MHPMCOUNTER4 */
3243 /*
3244  * COUNTER (RW)
3245  *
3246  * count the num- ber of events selected by mhpmevent4
3247  */
3248 #define CSR_MHPMCOUNTER4_COUNTER_MASK (0xFFFFFFFFUL)
3249 #define CSR_MHPMCOUNTER4_COUNTER_SHIFT (0U)
3250 #define CSR_MHPMCOUNTER4_COUNTER_SET(x) (((uint32_t)(x) << CSR_MHPMCOUNTER4_COUNTER_SHIFT) & CSR_MHPMCOUNTER4_COUNTER_MASK)
3251 #define CSR_MHPMCOUNTER4_COUNTER_GET(x) (((uint32_t)(x) & CSR_MHPMCOUNTER4_COUNTER_MASK) >> CSR_MHPMCOUNTER4_COUNTER_SHIFT)
3252 
3253 /* Bitfield definition for register: MHPMCOUNTER5 */
3254 /*
3255  * COUNTER (RW)
3256  *
3257  * count the num- ber of events selected by mhpmevent5
3258  */
3259 #define CSR_MHPMCOUNTER5_COUNTER_MASK (0xFFFFFFFFUL)
3260 #define CSR_MHPMCOUNTER5_COUNTER_SHIFT (0U)
3261 #define CSR_MHPMCOUNTER5_COUNTER_SET(x) (((uint32_t)(x) << CSR_MHPMCOUNTER5_COUNTER_SHIFT) & CSR_MHPMCOUNTER5_COUNTER_MASK)
3262 #define CSR_MHPMCOUNTER5_COUNTER_GET(x) (((uint32_t)(x) & CSR_MHPMCOUNTER5_COUNTER_MASK) >> CSR_MHPMCOUNTER5_COUNTER_SHIFT)
3263 
3264 /* Bitfield definition for register: MHPMCOUNTER6 */
3265 /*
3266  * COUNTER (RW)
3267  *
3268  * count the num- ber of events selected by mhpmevent6
3269  */
3270 #define CSR_MHPMCOUNTER6_COUNTER_MASK (0xFFFFFFFFUL)
3271 #define CSR_MHPMCOUNTER6_COUNTER_SHIFT (0U)
3272 #define CSR_MHPMCOUNTER6_COUNTER_SET(x) (((uint32_t)(x) << CSR_MHPMCOUNTER6_COUNTER_SHIFT) & CSR_MHPMCOUNTER6_COUNTER_MASK)
3273 #define CSR_MHPMCOUNTER6_COUNTER_GET(x) (((uint32_t)(x) & CSR_MHPMCOUNTER6_COUNTER_MASK) >> CSR_MHPMCOUNTER6_COUNTER_SHIFT)
3274 
3275 /* Bitfield definition for register: MCYCLEH */
3276 /*
3277  * COUNTER (RW)
3278  *
3279  * the higher 32 bits of Machine Cycle Counter
3280  */
3281 #define CSR_MCYCLEH_COUNTER_MASK (0xFFFFFFFFUL)
3282 #define CSR_MCYCLEH_COUNTER_SHIFT (0U)
3283 #define CSR_MCYCLEH_COUNTER_SET(x) (((uint32_t)(x) << CSR_MCYCLEH_COUNTER_SHIFT) & CSR_MCYCLEH_COUNTER_MASK)
3284 #define CSR_MCYCLEH_COUNTER_GET(x) (((uint32_t)(x) & CSR_MCYCLEH_COUNTER_MASK) >> CSR_MCYCLEH_COUNTER_SHIFT)
3285 
3286 /* Bitfield definition for register: MINSTRETH */
3287 /*
3288  * COUNTER (RW)
3289  *
3290  * the higher 32 bits of Machine Instruction-Retired Counter
3291  */
3292 #define CSR_MINSTRETH_COUNTER_MASK (0xFFFFFFFFUL)
3293 #define CSR_MINSTRETH_COUNTER_SHIFT (0U)
3294 #define CSR_MINSTRETH_COUNTER_SET(x) (((uint32_t)(x) << CSR_MINSTRETH_COUNTER_SHIFT) & CSR_MINSTRETH_COUNTER_MASK)
3295 #define CSR_MINSTRETH_COUNTER_GET(x) (((uint32_t)(x) & CSR_MINSTRETH_COUNTER_MASK) >> CSR_MINSTRETH_COUNTER_SHIFT)
3296 
3297 /* Bitfield definition for register: MHPMCOUNTER3H */
3298 /*
3299  * COUNTER (RW)
3300  *
3301  * count the num- ber of events selected by mhpmevent3
3302  */
3303 #define CSR_MHPMCOUNTER3H_COUNTER_MASK (0xFFFFFFFFUL)
3304 #define CSR_MHPMCOUNTER3H_COUNTER_SHIFT (0U)
3305 #define CSR_MHPMCOUNTER3H_COUNTER_SET(x) (((uint32_t)(x) << CSR_MHPMCOUNTER3H_COUNTER_SHIFT) & CSR_MHPMCOUNTER3H_COUNTER_MASK)
3306 #define CSR_MHPMCOUNTER3H_COUNTER_GET(x) (((uint32_t)(x) & CSR_MHPMCOUNTER3H_COUNTER_MASK) >> CSR_MHPMCOUNTER3H_COUNTER_SHIFT)
3307 
3308 /* Bitfield definition for register: MHPMCOUNTER4H */
3309 /*
3310  * COUNTER (RW)
3311  *
3312  * count the num- ber of events selected by mhpmevent4
3313  */
3314 #define CSR_MHPMCOUNTER4H_COUNTER_MASK (0xFFFFFFFFUL)
3315 #define CSR_MHPMCOUNTER4H_COUNTER_SHIFT (0U)
3316 #define CSR_MHPMCOUNTER4H_COUNTER_SET(x) (((uint32_t)(x) << CSR_MHPMCOUNTER4H_COUNTER_SHIFT) & CSR_MHPMCOUNTER4H_COUNTER_MASK)
3317 #define CSR_MHPMCOUNTER4H_COUNTER_GET(x) (((uint32_t)(x) & CSR_MHPMCOUNTER4H_COUNTER_MASK) >> CSR_MHPMCOUNTER4H_COUNTER_SHIFT)
3318 
3319 /* Bitfield definition for register: MHPMCOUNTER5H */
3320 /*
3321  * COUNTER (RW)
3322  *
3323  * count the num- ber of events selected by mhpmevent5
3324  */
3325 #define CSR_MHPMCOUNTER5H_COUNTER_MASK (0xFFFFFFFFUL)
3326 #define CSR_MHPMCOUNTER5H_COUNTER_SHIFT (0U)
3327 #define CSR_MHPMCOUNTER5H_COUNTER_SET(x) (((uint32_t)(x) << CSR_MHPMCOUNTER5H_COUNTER_SHIFT) & CSR_MHPMCOUNTER5H_COUNTER_MASK)
3328 #define CSR_MHPMCOUNTER5H_COUNTER_GET(x) (((uint32_t)(x) & CSR_MHPMCOUNTER5H_COUNTER_MASK) >> CSR_MHPMCOUNTER5H_COUNTER_SHIFT)
3329 
3330 /* Bitfield definition for register: MHPMCOUNTER6H */
3331 /*
3332  * COUNTER (RW)
3333  *
3334  * count the num- ber of events selected by mhpmevent6
3335  */
3336 #define CSR_MHPMCOUNTER6H_COUNTER_MASK (0xFFFFFFFFUL)
3337 #define CSR_MHPMCOUNTER6H_COUNTER_SHIFT (0U)
3338 #define CSR_MHPMCOUNTER6H_COUNTER_SET(x) (((uint32_t)(x) << CSR_MHPMCOUNTER6H_COUNTER_SHIFT) & CSR_MHPMCOUNTER6H_COUNTER_MASK)
3339 #define CSR_MHPMCOUNTER6H_COUNTER_GET(x) (((uint32_t)(x) & CSR_MHPMCOUNTER6H_COUNTER_MASK) >> CSR_MHPMCOUNTER6H_COUNTER_SHIFT)
3340 
3341 /* Bitfield definition for register: PMACFG0 */
3342 /*
3343  * PMA3CFG (RW)
3344  *
3345  * See PMACFG Table
3346  */
3347 #define CSR_PMACFG0_PMA3CFG_MASK (0xFF000000UL)
3348 #define CSR_PMACFG0_PMA3CFG_SHIFT (24U)
3349 #define CSR_PMACFG0_PMA3CFG_SET(x) (((uint32_t)(x) << CSR_PMACFG0_PMA3CFG_SHIFT) & CSR_PMACFG0_PMA3CFG_MASK)
3350 #define CSR_PMACFG0_PMA3CFG_GET(x) (((uint32_t)(x) & CSR_PMACFG0_PMA3CFG_MASK) >> CSR_PMACFG0_PMA3CFG_SHIFT)
3351 
3352 /*
3353  * PMA2CFG (RW)
3354  *
3355  * See PMACFG Table
3356  */
3357 #define CSR_PMACFG0_PMA2CFG_MASK (0xFF0000UL)
3358 #define CSR_PMACFG0_PMA2CFG_SHIFT (16U)
3359 #define CSR_PMACFG0_PMA2CFG_SET(x) (((uint32_t)(x) << CSR_PMACFG0_PMA2CFG_SHIFT) & CSR_PMACFG0_PMA2CFG_MASK)
3360 #define CSR_PMACFG0_PMA2CFG_GET(x) (((uint32_t)(x) & CSR_PMACFG0_PMA2CFG_MASK) >> CSR_PMACFG0_PMA2CFG_SHIFT)
3361 
3362 /*
3363  * PMA1CFG (RW)
3364  *
3365  * See PMACFG Table
3366  */
3367 #define CSR_PMACFG0_PMA1CFG_MASK (0xFF00U)
3368 #define CSR_PMACFG0_PMA1CFG_SHIFT (8U)
3369 #define CSR_PMACFG0_PMA1CFG_SET(x) (((uint32_t)(x) << CSR_PMACFG0_PMA1CFG_SHIFT) & CSR_PMACFG0_PMA1CFG_MASK)
3370 #define CSR_PMACFG0_PMA1CFG_GET(x) (((uint32_t)(x) & CSR_PMACFG0_PMA1CFG_MASK) >> CSR_PMACFG0_PMA1CFG_SHIFT)
3371 
3372 /*
3373  * PMA0CFG (RW)
3374  *
3375  * See PMACFG Table
3376  */
3377 #define CSR_PMACFG0_PMA0CFG_MASK (0xFFU)
3378 #define CSR_PMACFG0_PMA0CFG_SHIFT (0U)
3379 #define CSR_PMACFG0_PMA0CFG_SET(x) (((uint32_t)(x) << CSR_PMACFG0_PMA0CFG_SHIFT) & CSR_PMACFG0_PMA0CFG_MASK)
3380 #define CSR_PMACFG0_PMA0CFG_GET(x) (((uint32_t)(x) & CSR_PMACFG0_PMA0CFG_MASK) >> CSR_PMACFG0_PMA0CFG_SHIFT)
3381 
3382 /* Bitfield definition for register: PMACFG1 */
3383 /*
3384  * PMA7CFG (RW)
3385  *
3386  * See PMACFG Table
3387  */
3388 #define CSR_PMACFG1_PMA7CFG_MASK (0xFF000000UL)
3389 #define CSR_PMACFG1_PMA7CFG_SHIFT (24U)
3390 #define CSR_PMACFG1_PMA7CFG_SET(x) (((uint32_t)(x) << CSR_PMACFG1_PMA7CFG_SHIFT) & CSR_PMACFG1_PMA7CFG_MASK)
3391 #define CSR_PMACFG1_PMA7CFG_GET(x) (((uint32_t)(x) & CSR_PMACFG1_PMA7CFG_MASK) >> CSR_PMACFG1_PMA7CFG_SHIFT)
3392 
3393 /*
3394  * PMA6CFG (RW)
3395  *
3396  * See PMACFG Table
3397  */
3398 #define CSR_PMACFG1_PMA6CFG_MASK (0xFF0000UL)
3399 #define CSR_PMACFG1_PMA6CFG_SHIFT (16U)
3400 #define CSR_PMACFG1_PMA6CFG_SET(x) (((uint32_t)(x) << CSR_PMACFG1_PMA6CFG_SHIFT) & CSR_PMACFG1_PMA6CFG_MASK)
3401 #define CSR_PMACFG1_PMA6CFG_GET(x) (((uint32_t)(x) & CSR_PMACFG1_PMA6CFG_MASK) >> CSR_PMACFG1_PMA6CFG_SHIFT)
3402 
3403 /*
3404  * PMA5CFG (RW)
3405  *
3406  * See PMACFG Table
3407  */
3408 #define CSR_PMACFG1_PMA5CFG_MASK (0xFF00U)
3409 #define CSR_PMACFG1_PMA5CFG_SHIFT (8U)
3410 #define CSR_PMACFG1_PMA5CFG_SET(x) (((uint32_t)(x) << CSR_PMACFG1_PMA5CFG_SHIFT) & CSR_PMACFG1_PMA5CFG_MASK)
3411 #define CSR_PMACFG1_PMA5CFG_GET(x) (((uint32_t)(x) & CSR_PMACFG1_PMA5CFG_MASK) >> CSR_PMACFG1_PMA5CFG_SHIFT)
3412 
3413 /*
3414  * PMA4CFG (RW)
3415  *
3416  * See PMACFG Table
3417  */
3418 #define CSR_PMACFG1_PMA4CFG_MASK (0xFFU)
3419 #define CSR_PMACFG1_PMA4CFG_SHIFT (0U)
3420 #define CSR_PMACFG1_PMA4CFG_SET(x) (((uint32_t)(x) << CSR_PMACFG1_PMA4CFG_SHIFT) & CSR_PMACFG1_PMA4CFG_MASK)
3421 #define CSR_PMACFG1_PMA4CFG_GET(x) (((uint32_t)(x) & CSR_PMACFG1_PMA4CFG_MASK) >> CSR_PMACFG1_PMA4CFG_SHIFT)
3422 
3423 /* Bitfield definition for register: PMACFG2 */
3424 /*
3425  * PMA11CFG (RW)
3426  *
3427  * See PMACFG Table
3428  */
3429 #define CSR_PMACFG2_PMA11CFG_MASK (0xFF000000UL)
3430 #define CSR_PMACFG2_PMA11CFG_SHIFT (24U)
3431 #define CSR_PMACFG2_PMA11CFG_SET(x) (((uint32_t)(x) << CSR_PMACFG2_PMA11CFG_SHIFT) & CSR_PMACFG2_PMA11CFG_MASK)
3432 #define CSR_PMACFG2_PMA11CFG_GET(x) (((uint32_t)(x) & CSR_PMACFG2_PMA11CFG_MASK) >> CSR_PMACFG2_PMA11CFG_SHIFT)
3433 
3434 /*
3435  * PMA10CFG (RW)
3436  *
3437  * See PMACFG Table
3438  */
3439 #define CSR_PMACFG2_PMA10CFG_MASK (0xFF0000UL)
3440 #define CSR_PMACFG2_PMA10CFG_SHIFT (16U)
3441 #define CSR_PMACFG2_PMA10CFG_SET(x) (((uint32_t)(x) << CSR_PMACFG2_PMA10CFG_SHIFT) & CSR_PMACFG2_PMA10CFG_MASK)
3442 #define CSR_PMACFG2_PMA10CFG_GET(x) (((uint32_t)(x) & CSR_PMACFG2_PMA10CFG_MASK) >> CSR_PMACFG2_PMA10CFG_SHIFT)
3443 
3444 /*
3445  * PMA9CFG (RW)
3446  *
3447  * See PMACFG Table
3448  */
3449 #define CSR_PMACFG2_PMA9CFG_MASK (0xFF00U)
3450 #define CSR_PMACFG2_PMA9CFG_SHIFT (8U)
3451 #define CSR_PMACFG2_PMA9CFG_SET(x) (((uint32_t)(x) << CSR_PMACFG2_PMA9CFG_SHIFT) & CSR_PMACFG2_PMA9CFG_MASK)
3452 #define CSR_PMACFG2_PMA9CFG_GET(x) (((uint32_t)(x) & CSR_PMACFG2_PMA9CFG_MASK) >> CSR_PMACFG2_PMA9CFG_SHIFT)
3453 
3454 /*
3455  * PMA8CFG (RW)
3456  *
3457  * See PMACFG Table
3458  */
3459 #define CSR_PMACFG2_PMA8CFG_MASK (0xFFU)
3460 #define CSR_PMACFG2_PMA8CFG_SHIFT (0U)
3461 #define CSR_PMACFG2_PMA8CFG_SET(x) (((uint32_t)(x) << CSR_PMACFG2_PMA8CFG_SHIFT) & CSR_PMACFG2_PMA8CFG_MASK)
3462 #define CSR_PMACFG2_PMA8CFG_GET(x) (((uint32_t)(x) & CSR_PMACFG2_PMA8CFG_MASK) >> CSR_PMACFG2_PMA8CFG_SHIFT)
3463 
3464 /* Bitfield definition for register: PMACFG3 */
3465 /*
3466  * PMA15CFG (RW)
3467  *
3468  * See PMACFG Table
3469  */
3470 #define CSR_PMACFG3_PMA15CFG_MASK (0xFF000000UL)
3471 #define CSR_PMACFG3_PMA15CFG_SHIFT (24U)
3472 #define CSR_PMACFG3_PMA15CFG_SET(x) (((uint32_t)(x) << CSR_PMACFG3_PMA15CFG_SHIFT) & CSR_PMACFG3_PMA15CFG_MASK)
3473 #define CSR_PMACFG3_PMA15CFG_GET(x) (((uint32_t)(x) & CSR_PMACFG3_PMA15CFG_MASK) >> CSR_PMACFG3_PMA15CFG_SHIFT)
3474 
3475 /*
3476  * PMA14CFG (RW)
3477  *
3478  * See PMACFG Table
3479  */
3480 #define CSR_PMACFG3_PMA14CFG_MASK (0xFF0000UL)
3481 #define CSR_PMACFG3_PMA14CFG_SHIFT (16U)
3482 #define CSR_PMACFG3_PMA14CFG_SET(x) (((uint32_t)(x) << CSR_PMACFG3_PMA14CFG_SHIFT) & CSR_PMACFG3_PMA14CFG_MASK)
3483 #define CSR_PMACFG3_PMA14CFG_GET(x) (((uint32_t)(x) & CSR_PMACFG3_PMA14CFG_MASK) >> CSR_PMACFG3_PMA14CFG_SHIFT)
3484 
3485 /*
3486  * PMA13CFG (RW)
3487  *
3488  * See PMACFG Table
3489  */
3490 #define CSR_PMACFG3_PMA13CFG_MASK (0xFF00U)
3491 #define CSR_PMACFG3_PMA13CFG_SHIFT (8U)
3492 #define CSR_PMACFG3_PMA13CFG_SET(x) (((uint32_t)(x) << CSR_PMACFG3_PMA13CFG_SHIFT) & CSR_PMACFG3_PMA13CFG_MASK)
3493 #define CSR_PMACFG3_PMA13CFG_GET(x) (((uint32_t)(x) & CSR_PMACFG3_PMA13CFG_MASK) >> CSR_PMACFG3_PMA13CFG_SHIFT)
3494 
3495 /*
3496  * PMA12CFG (RW)
3497  *
3498  * See PMACFG Table
3499  */
3500 #define CSR_PMACFG3_PMA12CFG_MASK (0xFFU)
3501 #define CSR_PMACFG3_PMA12CFG_SHIFT (0U)
3502 #define CSR_PMACFG3_PMA12CFG_SET(x) (((uint32_t)(x) << CSR_PMACFG3_PMA12CFG_SHIFT) & CSR_PMACFG3_PMA12CFG_MASK)
3503 #define CSR_PMACFG3_PMA12CFG_GET(x) (((uint32_t)(x) & CSR_PMACFG3_PMA12CFG_MASK) >> CSR_PMACFG3_PMA12CFG_SHIFT)
3504 
3505 /* Bitfield definition for register array: PMAADDR */
3506 /*
3507  * PMAADDR_31_2 (RW)
3508  *
3509  * Register Content : Match Size(Byte)
3510  * aaaa. . . aaaaaaaaaaa Reserved
3511  * . . . . . .
3512  * aaaa. . . aa011111111 Reserved
3513  * aaaa. . . a0111111111 2^{12}
3514  * aaaa. . . 01111111111 2^{13}
3515  * . . . . . .
3516  * aa01. . . 11111111111 2^{XLEN}
3517  * a011. . . 11111111111 2^{XLEN+1}
3518  * 0111. . . 11111111111 2^{XLEN+2}
3519  * 1111. . . 11111111111 Reserved
3520  */
3521 #define CSR_PMAADDR0_PMAADDR_31_2_MASK (0xFFFFFFFCUL)
3522 #define CSR_PMAADDR0_PMAADDR_31_2_SHIFT (2U)
3523 #define CSR_PMAADDR0_PMAADDR_31_2_SET(x) (((uint32_t)(x) << CSR_PMAADDR0_PMAADDR_31_2_SHIFT) & CSR_PMAADDR0_PMAADDR_31_2_MASK)
3524 #define CSR_PMAADDR0_PMAADDR_31_2_GET(x) (((uint32_t)(x) & CSR_PMAADDR0_PMAADDR_31_2_MASK) >> CSR_PMAADDR0_PMAADDR_31_2_SHIFT)
3525 
3526 /* Bitfield definition for register array: PMAADDR */
3527 /*
3528  * PMAADDR_31_2 (RW)
3529  *
3530  * same as PMAADDR0
3531  */
3532 #define CSR_PMAADDR1_PMAADDR_31_2_MASK (0xFFFFFFFCUL)
3533 #define CSR_PMAADDR1_PMAADDR_31_2_SHIFT (2U)
3534 #define CSR_PMAADDR1_PMAADDR_31_2_SET(x) (((uint32_t)(x) << CSR_PMAADDR1_PMAADDR_31_2_SHIFT) & CSR_PMAADDR1_PMAADDR_31_2_MASK)
3535 #define CSR_PMAADDR1_PMAADDR_31_2_GET(x) (((uint32_t)(x) & CSR_PMAADDR1_PMAADDR_31_2_MASK) >> CSR_PMAADDR1_PMAADDR_31_2_SHIFT)
3536 
3537 /* Bitfield definition for register array: PMAADDR */
3538 /*
3539  * PMAADDR_31_2 (RW)
3540  *
3541  * same as PMAADDR0
3542  */
3543 #define CSR_PMAADDR2_PMAADDR_31_2_MASK (0xFFFFFFFCUL)
3544 #define CSR_PMAADDR2_PMAADDR_31_2_SHIFT (2U)
3545 #define CSR_PMAADDR2_PMAADDR_31_2_SET(x) (((uint32_t)(x) << CSR_PMAADDR2_PMAADDR_31_2_SHIFT) & CSR_PMAADDR2_PMAADDR_31_2_MASK)
3546 #define CSR_PMAADDR2_PMAADDR_31_2_GET(x) (((uint32_t)(x) & CSR_PMAADDR2_PMAADDR_31_2_MASK) >> CSR_PMAADDR2_PMAADDR_31_2_SHIFT)
3547 
3548 /* Bitfield definition for register array: PMAADDR */
3549 /*
3550  * PMAADDR_31_2 (RW)
3551  *
3552  * same as PMAADDR0
3553  */
3554 #define CSR_PMAADDR3_PMAADDR_31_2_MASK (0xFFFFFFFCUL)
3555 #define CSR_PMAADDR3_PMAADDR_31_2_SHIFT (2U)
3556 #define CSR_PMAADDR3_PMAADDR_31_2_SET(x) (((uint32_t)(x) << CSR_PMAADDR3_PMAADDR_31_2_SHIFT) & CSR_PMAADDR3_PMAADDR_31_2_MASK)
3557 #define CSR_PMAADDR3_PMAADDR_31_2_GET(x) (((uint32_t)(x) & CSR_PMAADDR3_PMAADDR_31_2_MASK) >> CSR_PMAADDR3_PMAADDR_31_2_SHIFT)
3558 
3559 /* Bitfield definition for register array: PMAADDR */
3560 /*
3561  * PMAADDR_31_2 (RW)
3562  *
3563  * same as PMAADDR0
3564  */
3565 #define CSR_PMAADDR4_PMAADDR_31_2_MASK (0xFFFFFFFCUL)
3566 #define CSR_PMAADDR4_PMAADDR_31_2_SHIFT (2U)
3567 #define CSR_PMAADDR4_PMAADDR_31_2_SET(x) (((uint32_t)(x) << CSR_PMAADDR4_PMAADDR_31_2_SHIFT) & CSR_PMAADDR4_PMAADDR_31_2_MASK)
3568 #define CSR_PMAADDR4_PMAADDR_31_2_GET(x) (((uint32_t)(x) & CSR_PMAADDR4_PMAADDR_31_2_MASK) >> CSR_PMAADDR4_PMAADDR_31_2_SHIFT)
3569 
3570 /* Bitfield definition for register array: PMAADDR */
3571 /*
3572  * PMAADDR_31_2 (RW)
3573  *
3574  * same as PMAADDR0
3575  */
3576 #define CSR_PMAADDR5_PMAADDR_31_2_MASK (0xFFFFFFFCUL)
3577 #define CSR_PMAADDR5_PMAADDR_31_2_SHIFT (2U)
3578 #define CSR_PMAADDR5_PMAADDR_31_2_SET(x) (((uint32_t)(x) << CSR_PMAADDR5_PMAADDR_31_2_SHIFT) & CSR_PMAADDR5_PMAADDR_31_2_MASK)
3579 #define CSR_PMAADDR5_PMAADDR_31_2_GET(x) (((uint32_t)(x) & CSR_PMAADDR5_PMAADDR_31_2_MASK) >> CSR_PMAADDR5_PMAADDR_31_2_SHIFT)
3580 
3581 /* Bitfield definition for register array: PMAADDR */
3582 /*
3583  * PMAADDR_31_2 (RW)
3584  *
3585  * same as PMAADDR0
3586  */
3587 #define CSR_PMAADDR6_PMAADDR_31_2_MASK (0xFFFFFFFCUL)
3588 #define CSR_PMAADDR6_PMAADDR_31_2_SHIFT (2U)
3589 #define CSR_PMAADDR6_PMAADDR_31_2_SET(x) (((uint32_t)(x) << CSR_PMAADDR6_PMAADDR_31_2_SHIFT) & CSR_PMAADDR6_PMAADDR_31_2_MASK)
3590 #define CSR_PMAADDR6_PMAADDR_31_2_GET(x) (((uint32_t)(x) & CSR_PMAADDR6_PMAADDR_31_2_MASK) >> CSR_PMAADDR6_PMAADDR_31_2_SHIFT)
3591 
3592 /* Bitfield definition for register array: PMAADDR */
3593 /*
3594  * PMAADDR_31_2 (RW)
3595  *
3596  * same as PMAADDR0
3597  */
3598 #define CSR_PMAADDR7_PMAADDR_31_2_MASK (0xFFFFFFFCUL)
3599 #define CSR_PMAADDR7_PMAADDR_31_2_SHIFT (2U)
3600 #define CSR_PMAADDR7_PMAADDR_31_2_SET(x) (((uint32_t)(x) << CSR_PMAADDR7_PMAADDR_31_2_SHIFT) & CSR_PMAADDR7_PMAADDR_31_2_MASK)
3601 #define CSR_PMAADDR7_PMAADDR_31_2_GET(x) (((uint32_t)(x) & CSR_PMAADDR7_PMAADDR_31_2_MASK) >> CSR_PMAADDR7_PMAADDR_31_2_SHIFT)
3602 
3603 /* Bitfield definition for register array: PMAADDR */
3604 /*
3605  * PMAADDR_31_2 (RW)
3606  *
3607  * same as PMAADDR0
3608  */
3609 #define CSR_PMAADDR8_PMAADDR_31_2_MASK (0xFFFFFFFCUL)
3610 #define CSR_PMAADDR8_PMAADDR_31_2_SHIFT (2U)
3611 #define CSR_PMAADDR8_PMAADDR_31_2_SET(x) (((uint32_t)(x) << CSR_PMAADDR8_PMAADDR_31_2_SHIFT) & CSR_PMAADDR8_PMAADDR_31_2_MASK)
3612 #define CSR_PMAADDR8_PMAADDR_31_2_GET(x) (((uint32_t)(x) & CSR_PMAADDR8_PMAADDR_31_2_MASK) >> CSR_PMAADDR8_PMAADDR_31_2_SHIFT)
3613 
3614 /* Bitfield definition for register array: PMAADDR */
3615 /*
3616  * PMAADDR_31_2 (RW)
3617  *
3618  * same as PMAADDR0
3619  */
3620 #define CSR_PMAADDR9_PMAADDR_31_2_MASK (0xFFFFFFFCUL)
3621 #define CSR_PMAADDR9_PMAADDR_31_2_SHIFT (2U)
3622 #define CSR_PMAADDR9_PMAADDR_31_2_SET(x) (((uint32_t)(x) << CSR_PMAADDR9_PMAADDR_31_2_SHIFT) & CSR_PMAADDR9_PMAADDR_31_2_MASK)
3623 #define CSR_PMAADDR9_PMAADDR_31_2_GET(x) (((uint32_t)(x) & CSR_PMAADDR9_PMAADDR_31_2_MASK) >> CSR_PMAADDR9_PMAADDR_31_2_SHIFT)
3624 
3625 /* Bitfield definition for register array: PMAADDR */
3626 /*
3627  * PMAADDR_31_2 (RW)
3628  *
3629  * same as PMAADDR0
3630  */
3631 #define CSR_PMAADDR10_PMAADDR_31_2_MASK (0xFFFFFFFCUL)
3632 #define CSR_PMAADDR10_PMAADDR_31_2_SHIFT (2U)
3633 #define CSR_PMAADDR10_PMAADDR_31_2_SET(x) (((uint32_t)(x) << CSR_PMAADDR10_PMAADDR_31_2_SHIFT) & CSR_PMAADDR10_PMAADDR_31_2_MASK)
3634 #define CSR_PMAADDR10_PMAADDR_31_2_GET(x) (((uint32_t)(x) & CSR_PMAADDR10_PMAADDR_31_2_MASK) >> CSR_PMAADDR10_PMAADDR_31_2_SHIFT)
3635 
3636 /* Bitfield definition for register array: PMAADDR */
3637 /*
3638  * PMAADDR_31_2 (RW)
3639  *
3640  * same as PMAADDR0
3641  */
3642 #define CSR_PMAADDR11_PMAADDR_31_2_MASK (0xFFFFFFFCUL)
3643 #define CSR_PMAADDR11_PMAADDR_31_2_SHIFT (2U)
3644 #define CSR_PMAADDR11_PMAADDR_31_2_SET(x) (((uint32_t)(x) << CSR_PMAADDR11_PMAADDR_31_2_SHIFT) & CSR_PMAADDR11_PMAADDR_31_2_MASK)
3645 #define CSR_PMAADDR11_PMAADDR_31_2_GET(x) (((uint32_t)(x) & CSR_PMAADDR11_PMAADDR_31_2_MASK) >> CSR_PMAADDR11_PMAADDR_31_2_SHIFT)
3646 
3647 /* Bitfield definition for register array: PMAADDR */
3648 /*
3649  * PMAADDR_31_2 (RW)
3650  *
3651  * same as PMAADDR0
3652  */
3653 #define CSR_PMAADDR12_PMAADDR_31_2_MASK (0xFFFFFFFCUL)
3654 #define CSR_PMAADDR12_PMAADDR_31_2_SHIFT (2U)
3655 #define CSR_PMAADDR12_PMAADDR_31_2_SET(x) (((uint32_t)(x) << CSR_PMAADDR12_PMAADDR_31_2_SHIFT) & CSR_PMAADDR12_PMAADDR_31_2_MASK)
3656 #define CSR_PMAADDR12_PMAADDR_31_2_GET(x) (((uint32_t)(x) & CSR_PMAADDR12_PMAADDR_31_2_MASK) >> CSR_PMAADDR12_PMAADDR_31_2_SHIFT)
3657 
3658 /* Bitfield definition for register array: PMAADDR */
3659 /*
3660  * PMAADDR_31_2 (RW)
3661  *
3662  * same as PMAADDR0
3663  */
3664 #define CSR_PMAADDR13_PMAADDR_31_2_MASK (0xFFFFFFFCUL)
3665 #define CSR_PMAADDR13_PMAADDR_31_2_SHIFT (2U)
3666 #define CSR_PMAADDR13_PMAADDR_31_2_SET(x) (((uint32_t)(x) << CSR_PMAADDR13_PMAADDR_31_2_SHIFT) & CSR_PMAADDR13_PMAADDR_31_2_MASK)
3667 #define CSR_PMAADDR13_PMAADDR_31_2_GET(x) (((uint32_t)(x) & CSR_PMAADDR13_PMAADDR_31_2_MASK) >> CSR_PMAADDR13_PMAADDR_31_2_SHIFT)
3668 
3669 /* Bitfield definition for register array: PMAADDR */
3670 /*
3671  * PMAADDR_31_2 (RW)
3672  *
3673  * same as PMAADDR0
3674  */
3675 #define CSR_PMAADDR14_PMAADDR_31_2_MASK (0xFFFFFFFCUL)
3676 #define CSR_PMAADDR14_PMAADDR_31_2_SHIFT (2U)
3677 #define CSR_PMAADDR14_PMAADDR_31_2_SET(x) (((uint32_t)(x) << CSR_PMAADDR14_PMAADDR_31_2_SHIFT) & CSR_PMAADDR14_PMAADDR_31_2_MASK)
3678 #define CSR_PMAADDR14_PMAADDR_31_2_GET(x) (((uint32_t)(x) & CSR_PMAADDR14_PMAADDR_31_2_MASK) >> CSR_PMAADDR14_PMAADDR_31_2_SHIFT)
3679 
3680 /* Bitfield definition for register array: PMAADDR */
3681 /*
3682  * PMAADDR_31_2 (RW)
3683  *
3684  * same as PMAADDR0
3685  */
3686 #define CSR_PMAADDR15_PMAADDR_31_2_MASK (0xFFFFFFFCUL)
3687 #define CSR_PMAADDR15_PMAADDR_31_2_SHIFT (2U)
3688 #define CSR_PMAADDR15_PMAADDR_31_2_SET(x) (((uint32_t)(x) << CSR_PMAADDR15_PMAADDR_31_2_SHIFT) & CSR_PMAADDR15_PMAADDR_31_2_MASK)
3689 #define CSR_PMAADDR15_PMAADDR_31_2_GET(x) (((uint32_t)(x) & CSR_PMAADDR15_PMAADDR_31_2_MASK) >> CSR_PMAADDR15_PMAADDR_31_2_SHIFT)
3690 
3691 /* Bitfield definition for register: CYCLE */
3692 /*
3693  * CYCLE (RW)
3694  *
3695  * Cycle Counter
3696  */
3697 #define CSR_CYCLE_CYCLE_MASK (0xFFFFFFFFUL)
3698 #define CSR_CYCLE_CYCLE_SHIFT (0U)
3699 #define CSR_CYCLE_CYCLE_SET(x) (((uint32_t)(x) << CSR_CYCLE_CYCLE_SHIFT) & CSR_CYCLE_CYCLE_MASK)
3700 #define CSR_CYCLE_CYCLE_GET(x) (((uint32_t)(x) & CSR_CYCLE_CYCLE_MASK) >> CSR_CYCLE_CYCLE_SHIFT)
3701 
3702 /* Bitfield definition for register: CYCLEH */
3703 /*
3704  * CYCLEH (RW)
3705  *
3706  * Cycle Counter Higher 32-bit
3707  */
3708 #define CSR_CYCLEH_CYCLEH_MASK (0xFFFFFFFFUL)
3709 #define CSR_CYCLEH_CYCLEH_SHIFT (0U)
3710 #define CSR_CYCLEH_CYCLEH_SET(x) (((uint32_t)(x) << CSR_CYCLEH_CYCLEH_SHIFT) & CSR_CYCLEH_CYCLEH_MASK)
3711 #define CSR_CYCLEH_CYCLEH_GET(x) (((uint32_t)(x) & CSR_CYCLEH_CYCLEH_MASK) >> CSR_CYCLEH_CYCLEH_SHIFT)
3712 
3713 /* Bitfield definition for register: MVENDORID */
3714 /*
3715  * MVENDORID (RO)
3716  *
3717  * The manufacturer ID
3718  */
3719 #define CSR_MVENDORID_MVENDORID_MASK (0xFFFFFFFFUL)
3720 #define CSR_MVENDORID_MVENDORID_SHIFT (0U)
3721 #define CSR_MVENDORID_MVENDORID_GET(x) (((uint32_t)(x) & CSR_MVENDORID_MVENDORID_MASK) >> CSR_MVENDORID_MVENDORID_SHIFT)
3722 
3723 /* Bitfield definition for register: MARCHID */
3724 /*
3725  * CPU_ID (RO)
3726  *
3727  * CPU ID
3728  */
3729 #define CSR_MARCHID_CPU_ID_MASK (0x7FFFFFFFUL)
3730 #define CSR_MARCHID_CPU_ID_SHIFT (0U)
3731 #define CSR_MARCHID_CPU_ID_GET(x) (((uint32_t)(x) & CSR_MARCHID_CPU_ID_MASK) >> CSR_MARCHID_CPU_ID_SHIFT)
3732 
3733 /* Bitfield definition for register: MIMPID */
3734 /*
3735  * MAJOR (RO)
3736  *
3737  * Revision major
3738  */
3739 #define CSR_MIMPID_MAJOR_MASK (0xFFFFFF00UL)
3740 #define CSR_MIMPID_MAJOR_SHIFT (8U)
3741 #define CSR_MIMPID_MAJOR_GET(x) (((uint32_t)(x) & CSR_MIMPID_MAJOR_MASK) >> CSR_MIMPID_MAJOR_SHIFT)
3742 
3743 /*
3744  * MINOR (RO)
3745  *
3746  * Revision minor
3747  */
3748 #define CSR_MIMPID_MINOR_MASK (0xF0U)
3749 #define CSR_MIMPID_MINOR_SHIFT (4U)
3750 #define CSR_MIMPID_MINOR_GET(x) (((uint32_t)(x) & CSR_MIMPID_MINOR_MASK) >> CSR_MIMPID_MINOR_SHIFT)
3751 
3752 /*
3753  * EXTENSION (RO)
3754  *
3755  * Revision extension
3756  */
3757 #define CSR_MIMPID_EXTENSION_MASK (0xFU)
3758 #define CSR_MIMPID_EXTENSION_SHIFT (0U)
3759 #define CSR_MIMPID_EXTENSION_GET(x) (((uint32_t)(x) & CSR_MIMPID_EXTENSION_MASK) >> CSR_MIMPID_EXTENSION_SHIFT)
3760 
3761 /* Bitfield definition for register: MHARTID */
3762 /*
3763  * MHARTID (RO)
3764  *
3765  * Hart ID
3766  */
3767 #define CSR_MHARTID_MHARTID_MASK (0xFFFFFFFFUL)
3768 #define CSR_MHARTID_MHARTID_SHIFT (0U)
3769 #define CSR_MHARTID_MHARTID_GET(x) (((uint32_t)(x) & CSR_MHARTID_MHARTID_MASK) >> CSR_MHARTID_MHARTID_SHIFT)
3770 
3771 /* NON-STANDARD CRS register bitfiled definitions */
3772 
3773 /* Bitfield definition for register: SCOUNTEREN */
3774 /*
3775  * HPM6 (RW)
3776  *
3777  * See register description
3778  */
3779 #define CSR_SCOUNTEREN_HPM6_MASK (0x40U)
3780 #define CSR_SCOUNTEREN_HPM6_SHIFT (6U)
3781 #define CSR_SCOUNTEREN_HPM6_SET(x) (((uint32_t)(x) << CSR_SCOUNTEREN_HPM6_SHIFT) & CSR_SCOUNTEREN_HPM6_MASK)
3782 #define CSR_SCOUNTEREN_HPM6_GET(x) (((uint32_t)(x) & CSR_SCOUNTEREN_HPM6_MASK) >> CSR_SCOUNTEREN_HPM6_SHIFT)
3783 
3784 /*
3785  * HPM5 (RW)
3786  *
3787  * See register description
3788  */
3789 #define CSR_SCOUNTEREN_HPM5_MASK (0x20U)
3790 #define CSR_SCOUNTEREN_HPM5_SHIFT (5U)
3791 #define CSR_SCOUNTEREN_HPM5_SET(x) (((uint32_t)(x) << CSR_SCOUNTEREN_HPM5_SHIFT) & CSR_SCOUNTEREN_HPM5_MASK)
3792 #define CSR_SCOUNTEREN_HPM5_GET(x) (((uint32_t)(x) & CSR_SCOUNTEREN_HPM5_MASK) >> CSR_SCOUNTEREN_HPM5_SHIFT)
3793 
3794 /*
3795  * HPM4 (RW)
3796  *
3797  * See register description
3798  */
3799 #define CSR_SCOUNTEREN_HPM4_MASK (0x10U)
3800 #define CSR_SCOUNTEREN_HPM4_SHIFT (4U)
3801 #define CSR_SCOUNTEREN_HPM4_SET(x) (((uint32_t)(x) << CSR_SCOUNTEREN_HPM4_SHIFT) & CSR_SCOUNTEREN_HPM4_MASK)
3802 #define CSR_SCOUNTEREN_HPM4_GET(x) (((uint32_t)(x) & CSR_SCOUNTEREN_HPM4_MASK) >> CSR_SCOUNTEREN_HPM4_SHIFT)
3803 
3804 /*
3805  * HPM3 (RW)
3806  *
3807  * See register description
3808  */
3809 #define CSR_SCOUNTEREN_HPM3_MASK (0x8U)
3810 #define CSR_SCOUNTEREN_HPM3_SHIFT (3U)
3811 #define CSR_SCOUNTEREN_HPM3_SET(x) (((uint32_t)(x) << CSR_SCOUNTEREN_HPM3_SHIFT) & CSR_SCOUNTEREN_HPM3_MASK)
3812 #define CSR_SCOUNTEREN_HPM3_GET(x) (((uint32_t)(x) & CSR_SCOUNTEREN_HPM3_MASK) >> CSR_SCOUNTEREN_HPM3_SHIFT)
3813 
3814 /*
3815  * IR (RW)
3816  *
3817  * See register description
3818  */
3819 #define CSR_SCOUNTEREN_IR_MASK (0x4U)
3820 #define CSR_SCOUNTEREN_IR_SHIFT (2U)
3821 #define CSR_SCOUNTEREN_IR_SET(x) (((uint32_t)(x) << CSR_SCOUNTEREN_IR_SHIFT) & CSR_SCOUNTEREN_IR_MASK)
3822 #define CSR_SCOUNTEREN_IR_GET(x) (((uint32_t)(x) & CSR_SCOUNTEREN_IR_MASK) >> CSR_SCOUNTEREN_IR_SHIFT)
3823 
3824 /*
3825  * CY (RW)
3826  *
3827  * See register description
3828  */
3829 #define CSR_SCOUNTEREN_CY_MASK (0x1U)
3830 #define CSR_SCOUNTEREN_CY_SHIFT (0U)
3831 #define CSR_SCOUNTEREN_CY_SET(x) (((uint32_t)(x) << CSR_SCOUNTEREN_CY_SHIFT) & CSR_SCOUNTEREN_CY_MASK)
3832 #define CSR_SCOUNTEREN_CY_GET(x) (((uint32_t)(x) & CSR_SCOUNTEREN_CY_MASK) >> CSR_SCOUNTEREN_CY_SHIFT)
3833 
3834 /* Bitfield definition for register: MCOUNTINHIBIT */
3835 /*
3836  * HPM6 (RW)
3837  *
3838  * See register description.
3839  */
3840 #define CSR_MCOUNTINHIBIT_HPM6_MASK (0x40U)
3841 #define CSR_MCOUNTINHIBIT_HPM6_SHIFT (6U)
3842 #define CSR_MCOUNTINHIBIT_HPM6_SET(x) (((uint32_t)(x) << CSR_MCOUNTINHIBIT_HPM6_SHIFT) & CSR_MCOUNTINHIBIT_HPM6_MASK)
3843 #define CSR_MCOUNTINHIBIT_HPM6_GET(x) (((uint32_t)(x) & CSR_MCOUNTINHIBIT_HPM6_MASK) >> CSR_MCOUNTINHIBIT_HPM6_SHIFT)
3844 
3845 /*
3846  * HPM5 (RW)
3847  *
3848  * See register description.
3849  */
3850 #define CSR_MCOUNTINHIBIT_HPM5_MASK (0x20U)
3851 #define CSR_MCOUNTINHIBIT_HPM5_SHIFT (5U)
3852 #define CSR_MCOUNTINHIBIT_HPM5_SET(x) (((uint32_t)(x) << CSR_MCOUNTINHIBIT_HPM5_SHIFT) & CSR_MCOUNTINHIBIT_HPM5_MASK)
3853 #define CSR_MCOUNTINHIBIT_HPM5_GET(x) (((uint32_t)(x) & CSR_MCOUNTINHIBIT_HPM5_MASK) >> CSR_MCOUNTINHIBIT_HPM5_SHIFT)
3854 
3855 /*
3856  * HPM4 (RW)
3857  *
3858  * See register description.
3859  */
3860 #define CSR_MCOUNTINHIBIT_HPM4_MASK (0x10U)
3861 #define CSR_MCOUNTINHIBIT_HPM4_SHIFT (4U)
3862 #define CSR_MCOUNTINHIBIT_HPM4_SET(x) (((uint32_t)(x) << CSR_MCOUNTINHIBIT_HPM4_SHIFT) & CSR_MCOUNTINHIBIT_HPM4_MASK)
3863 #define CSR_MCOUNTINHIBIT_HPM4_GET(x) (((uint32_t)(x) & CSR_MCOUNTINHIBIT_HPM4_MASK) >> CSR_MCOUNTINHIBIT_HPM4_SHIFT)
3864 
3865 /*
3866  * HPM3 (RW)
3867  *
3868  * See register description.
3869  */
3870 #define CSR_MCOUNTINHIBIT_HPM3_MASK (0x8U)
3871 #define CSR_MCOUNTINHIBIT_HPM3_SHIFT (3U)
3872 #define CSR_MCOUNTINHIBIT_HPM3_SET(x) (((uint32_t)(x) << CSR_MCOUNTINHIBIT_HPM3_SHIFT) & CSR_MCOUNTINHIBIT_HPM3_MASK)
3873 #define CSR_MCOUNTINHIBIT_HPM3_GET(x) (((uint32_t)(x) & CSR_MCOUNTINHIBIT_HPM3_MASK) >> CSR_MCOUNTINHIBIT_HPM3_SHIFT)
3874 
3875 /*
3876  * IR (RW)
3877  *
3878  * See register description.
3879  */
3880 #define CSR_MCOUNTINHIBIT_IR_MASK (0x4U)
3881 #define CSR_MCOUNTINHIBIT_IR_SHIFT (2U)
3882 #define CSR_MCOUNTINHIBIT_IR_SET(x) (((uint32_t)(x) << CSR_MCOUNTINHIBIT_IR_SHIFT) & CSR_MCOUNTINHIBIT_IR_MASK)
3883 #define CSR_MCOUNTINHIBIT_IR_GET(x) (((uint32_t)(x) & CSR_MCOUNTINHIBIT_IR_MASK) >> CSR_MCOUNTINHIBIT_IR_SHIFT)
3884 
3885 /*
3886  * TM (RW)
3887  *
3888  * See register description.
3889  */
3890 #define CSR_MCOUNTINHIBIT_TM_MASK (0x2U)
3891 #define CSR_MCOUNTINHIBIT_TM_SHIFT (1U)
3892 #define CSR_MCOUNTINHIBIT_TM_SET(x) (((uint32_t)(x) << CSR_MCOUNTINHIBIT_TM_SHIFT) & CSR_MCOUNTINHIBIT_TM_MASK)
3893 #define CSR_MCOUNTINHIBIT_TM_GET(x) (((uint32_t)(x) & CSR_MCOUNTINHIBIT_TM_MASK) >> CSR_MCOUNTINHIBIT_TM_SHIFT)
3894 
3895 /*
3896  * CY (RW)
3897  *
3898  * See register description.
3899  */
3900 #define CSR_MCOUNTINHIBIT_CY_MASK (0x1U)
3901 #define CSR_MCOUNTINHIBIT_CY_SHIFT (0U)
3902 #define CSR_MCOUNTINHIBIT_CY_SET(x) (((uint32_t)(x) << CSR_MCOUNTINHIBIT_CY_SHIFT) & CSR_MCOUNTINHIBIT_CY_MASK)
3903 #define CSR_MCOUNTINHIBIT_CY_GET(x) (((uint32_t)(x) & CSR_MCOUNTINHIBIT_CY_MASK) >> CSR_MCOUNTINHIBIT_CY_SHIFT)
3904 
3905 /* Bitfield definition for register: MILMB */
3906 /*
3907  * IBPA (RO)
3908  *
3909  * The base physical address of ILM. It has to be an integer multiple of the ILM size
3910  */
3911 #define CSR_MILMB_IBPA_MASK (0xFFFFFC00UL)
3912 #define CSR_MILMB_IBPA_SHIFT (10U)
3913 #define CSR_MILMB_IBPA_GET(x) (((uint32_t)(x) & CSR_MILMB_IBPA_MASK) >> CSR_MILMB_IBPA_SHIFT)
3914 
3915 /*
3916  * RWECC (RW)
3917  *
3918  * 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.
3919  * 0:Disable diagnostic accesses of ECC codes
3920  * 1:Enable diagnostic accesses of ECC codes
3921  */
3922 #define CSR_MILMB_RWECC_MASK (0x8U)
3923 #define CSR_MILMB_RWECC_SHIFT (3U)
3924 #define CSR_MILMB_RWECC_SET(x) (((uint32_t)(x) << CSR_MILMB_RWECC_SHIFT) & CSR_MILMB_RWECC_MASK)
3925 #define CSR_MILMB_RWECC_GET(x) (((uint32_t)(x) & CSR_MILMB_RWECC_MASK) >> CSR_MILMB_RWECC_SHIFT)
3926 
3927 /*
3928  * ECCEN (RW)
3929  *
3930  * Parity/ECC enable control:
3931  * 0:Disable parity/ECC
3932  * 1:Reserved
3933  * 2:Generate exceptions only on uncorrectable parity/ECC errors
3934  * 3:Generate exceptions on any type of parity/ECC errors
3935  */
3936 #define CSR_MILMB_ECCEN_MASK (0x6U)
3937 #define CSR_MILMB_ECCEN_SHIFT (1U)
3938 #define CSR_MILMB_ECCEN_SET(x) (((uint32_t)(x) << CSR_MILMB_ECCEN_SHIFT) & CSR_MILMB_ECCEN_MASK)
3939 #define CSR_MILMB_ECCEN_GET(x) (((uint32_t)(x) & CSR_MILMB_ECCEN_MASK) >> CSR_MILMB_ECCEN_SHIFT)
3940 
3941 /*
3942  * IEN (RO)
3943  *
3944  * ILM enable control:
3945  * 0:ILM is disabled
3946  * 1:ILM is enabled
3947  */
3948 #define CSR_MILMB_IEN_MASK (0x1U)
3949 #define CSR_MILMB_IEN_SHIFT (0U)
3950 #define CSR_MILMB_IEN_GET(x) (((uint32_t)(x) & CSR_MILMB_IEN_MASK) >> CSR_MILMB_IEN_SHIFT)
3951 
3952 /* Bitfield definition for register: MDLMB */
3953 /*
3954  * DBPA (RO)
3955  *
3956  * The base physical address of DLM. It has to be an integer multiple of the DLM size
3957  */
3958 #define CSR_MDLMB_DBPA_MASK (0xFFFFFC00UL)
3959 #define CSR_MDLMB_DBPA_SHIFT (10U)
3960 #define CSR_MDLMB_DBPA_GET(x) (((uint32_t)(x) & CSR_MDLMB_DBPA_MASK) >> CSR_MDLMB_DBPA_SHIFT)
3961 
3962 /*
3963  * RWECC (RW)
3964  *
3965  * 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.
3966  * 0:Disable diagnostic accesses of ECC codes
3967  * 1:Enable diagnostic accesses of ECC codes
3968  */
3969 #define CSR_MDLMB_RWECC_MASK (0x8U)
3970 #define CSR_MDLMB_RWECC_SHIFT (3U)
3971 #define CSR_MDLMB_RWECC_SET(x) (((uint32_t)(x) << CSR_MDLMB_RWECC_SHIFT) & CSR_MDLMB_RWECC_MASK)
3972 #define CSR_MDLMB_RWECC_GET(x) (((uint32_t)(x) & CSR_MDLMB_RWECC_MASK) >> CSR_MDLMB_RWECC_SHIFT)
3973 
3974 /*
3975  * ECCEN (RW)
3976  *
3977  * Parity/ECC enable control:
3978  * 0:Disable parity/ECC
3979  * 1:Reserved
3980  * 2:Generate exceptions only on uncorrectable parity/ECC errors
3981  * 3:Generate exceptions on any type of parity/ECC errors
3982  */
3983 #define CSR_MDLMB_ECCEN_MASK (0x6U)
3984 #define CSR_MDLMB_ECCEN_SHIFT (1U)
3985 #define CSR_MDLMB_ECCEN_SET(x) (((uint32_t)(x) << CSR_MDLMB_ECCEN_SHIFT) & CSR_MDLMB_ECCEN_MASK)
3986 #define CSR_MDLMB_ECCEN_GET(x) (((uint32_t)(x) & CSR_MDLMB_ECCEN_MASK) >> CSR_MDLMB_ECCEN_SHIFT)
3987 
3988 /*
3989  * DEN (RO)
3990  *
3991  * DLM enable control:
3992  * 0:DLM is disabled
3993  * 1:DLM is enabled
3994  */
3995 #define CSR_MDLMB_DEN_MASK (0x1U)
3996 #define CSR_MDLMB_DEN_SHIFT (0U)
3997 #define CSR_MDLMB_DEN_GET(x) (((uint32_t)(x) & CSR_MDLMB_DEN_MASK) >> CSR_MDLMB_DEN_SHIFT)
3998 
3999 /* Bitfield definition for register: MECC_CODE */
4000 /*
4001  * INSN (RO)
4002  *
4003  * Indicates if the parity/ECC error is caused by instruction fetch or data access.
4004  * 0:Data access
4005  * 1:Instruction fetch
4006  */
4007 #define CSR_MECC_CODE_INSN_MASK (0x400000UL)
4008 #define CSR_MECC_CODE_INSN_SHIFT (22U)
4009 #define CSR_MECC_CODE_INSN_GET(x) (((uint32_t)(x) & CSR_MECC_CODE_INSN_MASK) >> CSR_MECC_CODE_INSN_SHIFT)
4010 
4011 /*
4012  * RAMID (RO)
4013  *
4014  * The ID of RAM that caused parity/ECC errors.
4015  * This bit is updated on parity/ECC error exceptions.
4016  * 0–1:Reserved
4017  * 2:Tag RAM of I-Cache
4018  * 3:Data RAM of I-Cache
4019  * 4:Tag RAM of D-Cache
4020  * 5:Data RAM of D-Cache
4021  * 6:Tag RAM of TLB
4022  * 7:Data RAM of TLB
4023  * 8:ILM
4024  * 9:DLM
4025  * 10–15:Reserved
4026  */
4027 #define CSR_MECC_CODE_RAMID_MASK (0x3C0000UL)
4028 #define CSR_MECC_CODE_RAMID_SHIFT (18U)
4029 #define CSR_MECC_CODE_RAMID_GET(x) (((uint32_t)(x) & CSR_MECC_CODE_RAMID_MASK) >> CSR_MECC_CODE_RAMID_SHIFT)
4030 
4031 /*
4032  * P (RO)
4033  *
4034  * Precise error. This bit is updated on parity/ECC error exceptions.
4035  * 0:Imprecise error
4036  * 1:Precise error
4037  */
4038 #define CSR_MECC_CODE_P_MASK (0x20000UL)
4039 #define CSR_MECC_CODE_P_SHIFT (17U)
4040 #define CSR_MECC_CODE_P_GET(x) (((uint32_t)(x) & CSR_MECC_CODE_P_MASK) >> CSR_MECC_CODE_P_SHIFT)
4041 
4042 /*
4043  * C (RO)
4044  *
4045  * Correctable error. This bit is updated on parity/ECC error exceptions.
4046  * 0:Uncorrectable error
4047  * 1:Correctable error
4048  */
4049 #define CSR_MECC_CODE_C_MASK (0x10000UL)
4050 #define CSR_MECC_CODE_C_SHIFT (16U)
4051 #define CSR_MECC_CODE_C_GET(x) (((uint32_t)(x) & CSR_MECC_CODE_C_MASK) >> CSR_MECC_CODE_C_SHIFT)
4052 
4053 /*
4054  * CODE (RW)
4055  *
4056  * 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).
4057  */
4058 #define CSR_MECC_CODE_CODE_MASK (0x7FU)
4059 #define CSR_MECC_CODE_CODE_SHIFT (0U)
4060 #define CSR_MECC_CODE_CODE_SET(x) (((uint32_t)(x) << CSR_MECC_CODE_CODE_SHIFT) & CSR_MECC_CODE_CODE_MASK)
4061 #define CSR_MECC_CODE_CODE_GET(x) (((uint32_t)(x) & CSR_MECC_CODE_CODE_MASK) >> CSR_MECC_CODE_CODE_SHIFT)
4062 
4063 /* Bitfield definition for register: MNVEC */
4064 /*
4065  * MNVEC (RO)
4066  *
4067  * Base address of the NMI handler. Its value is the zero-extended value of the reset_vector.
4068  */
4069 #define CSR_MNVEC_MNVEC_MASK (0xFFFFFFFFUL)
4070 #define CSR_MNVEC_MNVEC_SHIFT (0U)
4071 #define CSR_MNVEC_MNVEC_GET(x) (((uint32_t)(x) & CSR_MNVEC_MNVEC_MASK) >> CSR_MNVEC_MNVEC_SHIFT)
4072 
4073 /* Bitfield definition for register: MXSTATUS */
4074 /*
4075  * PDME (RW)
4076  *
4077  * 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.
4078  */
4079 #define CSR_MXSTATUS_PDME_MASK (0x20U)
4080 #define CSR_MXSTATUS_PDME_SHIFT (5U)
4081 #define CSR_MXSTATUS_PDME_SET(x) (((uint32_t)(x) << CSR_MXSTATUS_PDME_SHIFT) & CSR_MXSTATUS_PDME_MASK)
4082 #define CSR_MXSTATUS_PDME_GET(x) (((uint32_t)(x) & CSR_MXSTATUS_PDME_MASK) >> CSR_MXSTATUS_PDME_SHIFT)
4083 
4084 /*
4085  * DME (RW)
4086  *
4087  * 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.
4088  */
4089 #define CSR_MXSTATUS_DME_MASK (0x10U)
4090 #define CSR_MXSTATUS_DME_SHIFT (4U)
4091 #define CSR_MXSTATUS_DME_SET(x) (((uint32_t)(x) << CSR_MXSTATUS_DME_SHIFT) & CSR_MXSTATUS_DME_MASK)
4092 #define CSR_MXSTATUS_DME_GET(x) (((uint32_t)(x) & CSR_MXSTATUS_DME_MASK) >> CSR_MXSTATUS_DME_SHIFT)
4093 
4094 /*
4095  * PPFT_EN (RW)
4096  *
4097  * 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
4098  * is defined as follows:
4099  * 0: User mode
4100  * 1: Supervisor mode
4101  * 2: Reserved
4102  * 3: Machine mode
4103  */
4104 #define CSR_MXSTATUS_PPFT_EN_MASK (0x2U)
4105 #define CSR_MXSTATUS_PPFT_EN_SHIFT (1U)
4106 #define CSR_MXSTATUS_PPFT_EN_SET(x) (((uint32_t)(x) << CSR_MXSTATUS_PPFT_EN_SHIFT) & CSR_MXSTATUS_PPFT_EN_MASK)
4107 #define CSR_MXSTATUS_PPFT_EN_GET(x) (((uint32_t)(x) & CSR_MXSTATUS_PPFT_EN_MASK) >> CSR_MXSTATUS_PPFT_EN_SHIFT)
4108 
4109 /*
4110  * PFT_EN (RW)
4111  *
4112  * 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:
4113  * PPFT_EN <= PFT_EN;
4114  * PFT_EN <= mpft_ctl.FAST_INT ? 0 :PFT_EN;
4115  * On executing an MRET instruction:
4116  * PFT_EN <= PPFT_EN;
4117  * This field is hardwired to 0 if the PowerBrake feature is not supported.
4118  */
4119 #define CSR_MXSTATUS_PFT_EN_MASK (0x1U)
4120 #define CSR_MXSTATUS_PFT_EN_SHIFT (0U)
4121 #define CSR_MXSTATUS_PFT_EN_SET(x) (((uint32_t)(x) << CSR_MXSTATUS_PFT_EN_SHIFT) & CSR_MXSTATUS_PFT_EN_MASK)
4122 #define CSR_MXSTATUS_PFT_EN_GET(x) (((uint32_t)(x) & CSR_MXSTATUS_PFT_EN_MASK) >> CSR_MXSTATUS_PFT_EN_SHIFT)
4123 
4124 /* Bitfield definition for register: MPFT_CTL */
4125 /*
4126  * FAST_INT (RW)
4127  *
4128  * Fast interrupt response. If this field is set, mxstatus.PFT_EN will be automatically cleared when the processor enters an interrupt handler.
4129  */
4130 #define CSR_MPFT_CTL_FAST_INT_MASK (0x100U)
4131 #define CSR_MPFT_CTL_FAST_INT_SHIFT (8U)
4132 #define CSR_MPFT_CTL_FAST_INT_SET(x) (((uint32_t)(x) << CSR_MPFT_CTL_FAST_INT_SHIFT) & CSR_MPFT_CTL_FAST_INT_MASK)
4133 #define CSR_MPFT_CTL_FAST_INT_GET(x) (((uint32_t)(x) & CSR_MPFT_CTL_FAST_INT_MASK) >> CSR_MPFT_CTL_FAST_INT_SHIFT)
4134 
4135 /*
4136  * T_LEVEL (RW)
4137  *
4138  * Throttling Level. The processor has the highest performance at throttling level 0 and the lowest
4139  * performance at throttling level 15.
4140  * 0:Level 0 (the highest performance)
4141  * 1-14:Level 1-14
4142  * 15:Level 15 (the lowest performance)
4143  */
4144 #define CSR_MPFT_CTL_T_LEVEL_MASK (0xF0U)
4145 #define CSR_MPFT_CTL_T_LEVEL_SHIFT (4U)
4146 #define CSR_MPFT_CTL_T_LEVEL_SET(x) (((uint32_t)(x) << CSR_MPFT_CTL_T_LEVEL_SHIFT) & CSR_MPFT_CTL_T_LEVEL_MASK)
4147 #define CSR_MPFT_CTL_T_LEVEL_GET(x) (((uint32_t)(x) & CSR_MPFT_CTL_T_LEVEL_MASK) >> CSR_MPFT_CTL_T_LEVEL_SHIFT)
4148 
4149 /* Bitfield definition for register: MHSP_CTL */
4150 /*
4151  * M (RW)
4152  *
4153  * Enables the SP protection and recording mechanism in Machine mode
4154  * 0:The mechanism is disabled in Machine mode.
4155  * 1: The mechanism is enabled in Machine mode.
4156  */
4157 #define CSR_MHSP_CTL_M_MASK (0x20U)
4158 #define CSR_MHSP_CTL_M_SHIFT (5U)
4159 #define CSR_MHSP_CTL_M_SET(x) (((uint32_t)(x) << CSR_MHSP_CTL_M_SHIFT) & CSR_MHSP_CTL_M_MASK)
4160 #define CSR_MHSP_CTL_M_GET(x) (((uint32_t)(x) & CSR_MHSP_CTL_M_MASK) >> CSR_MHSP_CTL_M_SHIFT)
4161 
4162 /*
4163  * S (RW)
4164  *
4165  * Enables the SP protection and recording mechanism in Supervisor mode
4166  * 0:The mechanism is disabled in Supervisor mode
4167  * 1:The mechanism is enabled in Supervisor mode
4168  */
4169 #define CSR_MHSP_CTL_S_MASK (0x10U)
4170 #define CSR_MHSP_CTL_S_SHIFT (4U)
4171 #define CSR_MHSP_CTL_S_SET(x) (((uint32_t)(x) << CSR_MHSP_CTL_S_SHIFT) & CSR_MHSP_CTL_S_MASK)
4172 #define CSR_MHSP_CTL_S_GET(x) (((uint32_t)(x) & CSR_MHSP_CTL_S_MASK) >> CSR_MHSP_CTL_S_SHIFT)
4173 
4174 /*
4175  * U (RW)
4176  *
4177  * Enables the SP protection and recording mechanism in User mode
4178  * 0:The mechanism is disabled in User mode
4179  * 1:The mechanism is enabled in User mode.
4180  */
4181 #define CSR_MHSP_CTL_U_MASK (0x8U)
4182 #define CSR_MHSP_CTL_U_SHIFT (3U)
4183 #define CSR_MHSP_CTL_U_SET(x) (((uint32_t)(x) << CSR_MHSP_CTL_U_SHIFT) & CSR_MHSP_CTL_U_MASK)
4184 #define CSR_MHSP_CTL_U_GET(x) (((uint32_t)(x) & CSR_MHSP_CTL_U_MASK) >> CSR_MHSP_CTL_U_SHIFT)
4185 
4186 /*
4187  * SCHM (RW)
4188  *
4189  * Selects the operating scheme of the stack protection and recording mechanism
4190  * 0:Stack overflow/underflow detection
4191  * 1:Top-of-stack recording
4192  */
4193 #define CSR_MHSP_CTL_SCHM_MASK (0x4U)
4194 #define CSR_MHSP_CTL_SCHM_SHIFT (2U)
4195 #define CSR_MHSP_CTL_SCHM_SET(x) (((uint32_t)(x) << CSR_MHSP_CTL_SCHM_SHIFT) & CSR_MHSP_CTL_SCHM_MASK)
4196 #define CSR_MHSP_CTL_SCHM_GET(x) (((uint32_t)(x) & CSR_MHSP_CTL_SCHM_MASK) >> CSR_MHSP_CTL_SCHM_SHIFT)
4197 
4198 /*
4199  * UDF_EN (RW)
4200  *
4201  * 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.
4202  * 0:The stack underflow protection is disabled
4203  * 1:The stack underflow protection is enabled.
4204  */
4205 #define CSR_MHSP_CTL_UDF_EN_MASK (0x2U)
4206 #define CSR_MHSP_CTL_UDF_EN_SHIFT (1U)
4207 #define CSR_MHSP_CTL_UDF_EN_SET(x) (((uint32_t)(x) << CSR_MHSP_CTL_UDF_EN_SHIFT) & CSR_MHSP_CTL_UDF_EN_MASK)
4208 #define CSR_MHSP_CTL_UDF_EN_GET(x) (((uint32_t)(x) & CSR_MHSP_CTL_UDF_EN_MASK) >> CSR_MHSP_CTL_UDF_EN_SHIFT)
4209 
4210 /*
4211  * OVF_EN (RW)
4212  *
4213  * 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.
4214  * 0:The stack overflow protection and recording mechanism are disabled.
4215  * 1:The stack overflow protection and recording mechanism are enabled.
4216  */
4217 #define CSR_MHSP_CTL_OVF_EN_MASK (0x1U)
4218 #define CSR_MHSP_CTL_OVF_EN_SHIFT (0U)
4219 #define CSR_MHSP_CTL_OVF_EN_SET(x) (((uint32_t)(x) << CSR_MHSP_CTL_OVF_EN_SHIFT) & CSR_MHSP_CTL_OVF_EN_MASK)
4220 #define CSR_MHSP_CTL_OVF_EN_GET(x) (((uint32_t)(x) & CSR_MHSP_CTL_OVF_EN_MASK) >> CSR_MHSP_CTL_OVF_EN_SHIFT)
4221 
4222 /* Bitfield definition for register: MSP_BOUND */
4223 /*
4224  * MSP_BOUND (RW)
4225  *
4226  * Machine SP Bound
4227  */
4228 #define CSR_MSP_BOUND_MSP_BOUND_MASK (0xFFFFFFFFUL)
4229 #define CSR_MSP_BOUND_MSP_BOUND_SHIFT (0U)
4230 #define CSR_MSP_BOUND_MSP_BOUND_SET(x) (((uint32_t)(x) << CSR_MSP_BOUND_MSP_BOUND_SHIFT) & CSR_MSP_BOUND_MSP_BOUND_MASK)
4231 #define CSR_MSP_BOUND_MSP_BOUND_GET(x) (((uint32_t)(x) & CSR_MSP_BOUND_MSP_BOUND_MASK) >> CSR_MSP_BOUND_MSP_BOUND_SHIFT)
4232 
4233 /* Bitfield definition for register: MSP_BASE */
4234 /*
4235  * SP_BASE (RW)
4236  *
4237  * Machine SP base
4238  */
4239 #define CSR_MSP_BASE_SP_BASE_MASK (0xFFFFFFFFUL)
4240 #define CSR_MSP_BASE_SP_BASE_SHIFT (0U)
4241 #define CSR_MSP_BASE_SP_BASE_SET(x) (((uint32_t)(x) << CSR_MSP_BASE_SP_BASE_SHIFT) & CSR_MSP_BASE_SP_BASE_MASK)
4242 #define CSR_MSP_BASE_SP_BASE_GET(x) (((uint32_t)(x) & CSR_MSP_BASE_SP_BASE_MASK) >> CSR_MSP_BASE_SP_BASE_SHIFT)
4243 
4244 /* Bitfield definition for register: MDCAUSE */
4245 /*
4246  * PM (RW)
4247  *
4248  * 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 is defined as follows:
4249  * 0: User mode
4250  * 1: Supervisor mode
4251  * 2: Reserved
4252  * 3: Machine mode
4253  */
4254 #define CSR_MDCAUSE_PM_MASK (0x60U)
4255 #define CSR_MDCAUSE_PM_SHIFT (5U)
4256 #define CSR_MDCAUSE_PM_SET(x) (((uint32_t)(x) << CSR_MDCAUSE_PM_SHIFT) & CSR_MDCAUSE_PM_MASK)
4257 #define CSR_MDCAUSE_PM_GET(x) (((uint32_t)(x) & CSR_MDCAUSE_PM_MASK) >> CSR_MDCAUSE_PM_SHIFT)
4258 
4259 /*
4260  * MDCAUSE (RW)
4261  *
4262  * This register further disambiguates causes of traps recorded in the mcause register.
4263  * The value of MDCAUSE for precise exception:
4264  * When mcause == 1 (Instruction access fault):
4265  * 0:Reserved; 1:ECC/Parity error; 2:PMP instruction access violation; 3:Bus error; 4:PMA empty hole access
4266  * When mcause == 2 (Illegal instruction):
4267  * 0:Please parse the mtval CSR; 1:FP disabled exception; 2:ACE disabled exception
4268  * When mcause == 5 (Load access fault):
4269  * 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
4270  * When mcause == 7 (Store access fault):
4271  * 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
4272  * The value of MDCAUSE for imprecise exception:
4273  * When mcause == Local Interrupt 16 or Local Interrupt 272 (16 + 256) (ECC error local interrupt)
4274  * 0:Reserved; 1:LM slave port ECC/Parity error; 2:Imprecise store ECC/Parity error; 3:Imprecise load ECC/Parity error
4275  * When mcause == Local Interrupt 17 or Local Interrupt 273 (17 + 256) (Bus read/write transaction error local interrupt)
4276  * 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
4277  */
4278 #define CSR_MDCAUSE_MDCAUSE_MASK (0x7U)
4279 #define CSR_MDCAUSE_MDCAUSE_SHIFT (0U)
4280 #define CSR_MDCAUSE_MDCAUSE_SET(x) (((uint32_t)(x) << CSR_MDCAUSE_MDCAUSE_SHIFT) & CSR_MDCAUSE_MDCAUSE_MASK)
4281 #define CSR_MDCAUSE_MDCAUSE_GET(x) (((uint32_t)(x) & CSR_MDCAUSE_MDCAUSE_MASK) >> CSR_MDCAUSE_MDCAUSE_SHIFT)
4282 
4283 /* Bitfield definition for register: MCACHE_CTL */
4284 /*
4285  * DC_WAROUND (RW)
4286  *
4287  * Cache Write-Around threshold
4288  * 0:Disables streaming. All cacheable write misses allocate a cache line according to PMA settings.
4289  * 1:Stop allocating D-Cache entries regardless of PMA settings after consecutive stores to 4 cache lines.
4290  * 2:Stop allocating D-Cache entries regardless of PMA settings after consecutive stores to 64 cache lines.
4291  * 3:Stop allocating D-Cache entries regardless of PMA settings after consecutive stores to 128 cache lines.
4292  */
4293 #define CSR_MCACHE_CTL_DC_WAROUND_MASK (0x6000U)
4294 #define CSR_MCACHE_CTL_DC_WAROUND_SHIFT (13U)
4295 #define CSR_MCACHE_CTL_DC_WAROUND_SET(x) (((uint32_t)(x) << CSR_MCACHE_CTL_DC_WAROUND_SHIFT) & CSR_MCACHE_CTL_DC_WAROUND_MASK)
4296 #define CSR_MCACHE_CTL_DC_WAROUND_GET(x) (((uint32_t)(x) & CSR_MCACHE_CTL_DC_WAROUND_MASK) >> CSR_MCACHE_CTL_DC_WAROUND_SHIFT)
4297 
4298 /*
4299  * DC_FIRST_WORD (RO)
4300  *
4301  * Cache miss allocation filling policy
4302  * 0:Cache line data is returned critical (double) word first
4303  * 1:Cache line data is returned the lowest address (double) word first
4304  */
4305 #define CSR_MCACHE_CTL_DC_FIRST_WORD_MASK (0x1000U)
4306 #define CSR_MCACHE_CTL_DC_FIRST_WORD_SHIFT (12U)
4307 #define CSR_MCACHE_CTL_DC_FIRST_WORD_GET(x) (((uint32_t)(x) & CSR_MCACHE_CTL_DC_FIRST_WORD_MASK) >> CSR_MCACHE_CTL_DC_FIRST_WORD_SHIFT)
4308 
4309 /*
4310  * IC_FIRST_WORD (RO)
4311  *
4312  * Cache miss allocation filling policy
4313  * 0:Cache line data is returned critical (double) word first
4314  * 1:Cache line data is returned the lowest address (double) word first
4315  */
4316 #define CSR_MCACHE_CTL_IC_FIRST_WORD_MASK (0x800U)
4317 #define CSR_MCACHE_CTL_IC_FIRST_WORD_SHIFT (11U)
4318 #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)
4319 
4320 /*
4321  * DPREF_EN (RW)
4322  *
4323  * This bit controls hardware prefetch for load/store accesses to cacheable memory regions when D-Cache size is not 0
4324  * 0:Disable hardware prefetch on load/store memory accesses
4325  * 1:Enable hardware prefetch on load/store memory accesses
4326  */
4327 #define CSR_MCACHE_CTL_DPREF_EN_MASK (0x400U)
4328 #define CSR_MCACHE_CTL_DPREF_EN_SHIFT (10U)
4329 #define CSR_MCACHE_CTL_DPREF_EN_SET(x) (((uint32_t)(x) << CSR_MCACHE_CTL_DPREF_EN_SHIFT) & CSR_MCACHE_CTL_DPREF_EN_MASK)
4330 #define CSR_MCACHE_CTL_DPREF_EN_GET(x) (((uint32_t)(x) & CSR_MCACHE_CTL_DPREF_EN_MASK) >> CSR_MCACHE_CTL_DPREF_EN_SHIFT)
4331 
4332 /*
4333  * IPREF_EN (RW)
4334  *
4335  * This bit controls hardware prefetch for instruction fetches to cacheable memory regions when Cache size is not 0
4336  * 0:Disable hardware prefetch on instruction fetches
4337  * 1:Enable hardware prefetch on instruction fetches
4338  */
4339 #define CSR_MCACHE_CTL_IPREF_EN_MASK (0x200U)
4340 #define CSR_MCACHE_CTL_IPREF_EN_SHIFT (9U)
4341 #define CSR_MCACHE_CTL_IPREF_EN_SET(x) (((uint32_t)(x) << CSR_MCACHE_CTL_IPREF_EN_SHIFT) & CSR_MCACHE_CTL_IPREF_EN_MASK)
4342 #define CSR_MCACHE_CTL_IPREF_EN_GET(x) (((uint32_t)(x) & CSR_MCACHE_CTL_IPREF_EN_MASK) >> CSR_MCACHE_CTL_IPREF_EN_SHIFT)
4343 
4344 /*
4345  * CCTL_SUEN (RW)
4346  *
4347  * Enable bit for Superuser-mode and User-mode software to access ucctlbeginaddr and ucctlcommand CSRs
4348  * 0:Disable ucctlbeginaddr and ucctlcommand accesses in S/U mode
4349  * 1:Enable ucctlbeginaddr and ucctlcommand accesses in S/U mode
4350  */
4351 #define CSR_MCACHE_CTL_CCTL_SUEN_MASK (0x100U)
4352 #define CSR_MCACHE_CTL_CCTL_SUEN_SHIFT (8U)
4353 #define CSR_MCACHE_CTL_CCTL_SUEN_SET(x) (((uint32_t)(x) << CSR_MCACHE_CTL_CCTL_SUEN_SHIFT) & CSR_MCACHE_CTL_CCTL_SUEN_MASK)
4354 #define CSR_MCACHE_CTL_CCTL_SUEN_GET(x) (((uint32_t)(x) & CSR_MCACHE_CTL_CCTL_SUEN_MASK) >> CSR_MCACHE_CTL_CCTL_SUEN_SHIFT)
4355 
4356 /*
4357  * DC_RWECC (RW)
4358  *
4359  * 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
4360  * 0:Disable diagnostic accesses of ECC codes
4361  * 1:Enable diagnostic accesses of ECC codes
4362  */
4363 #define CSR_MCACHE_CTL_DC_RWECC_MASK (0x80U)
4364 #define CSR_MCACHE_CTL_DC_RWECC_SHIFT (7U)
4365 #define CSR_MCACHE_CTL_DC_RWECC_SET(x) (((uint32_t)(x) << CSR_MCACHE_CTL_DC_RWECC_SHIFT) & CSR_MCACHE_CTL_DC_RWECC_MASK)
4366 #define CSR_MCACHE_CTL_DC_RWECC_GET(x) (((uint32_t)(x) & CSR_MCACHE_CTL_DC_RWECC_MASK) >> CSR_MCACHE_CTL_DC_RWECC_SHIFT)
4367 
4368 /*
4369  * IC_RWECC (RW)
4370  *
4371  * 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.
4372  * 0:Disable diagnostic accesses of ECC codes
4373  * 1:Enable diagnostic accesses of ECC codes
4374  */
4375 #define CSR_MCACHE_CTL_IC_RWECC_MASK (0x40U)
4376 #define CSR_MCACHE_CTL_IC_RWECC_SHIFT (6U)
4377 #define CSR_MCACHE_CTL_IC_RWECC_SET(x) (((uint32_t)(x) << CSR_MCACHE_CTL_IC_RWECC_SHIFT) & CSR_MCACHE_CTL_IC_RWECC_MASK)
4378 #define CSR_MCACHE_CTL_IC_RWECC_GET(x) (((uint32_t)(x) & CSR_MCACHE_CTL_IC_RWECC_MASK) >> CSR_MCACHE_CTL_IC_RWECC_SHIFT)
4379 
4380 /*
4381  * DC_ECCEN (RW)
4382  *
4383  * Parity/ECC error checking enable control for the
4384  * data cache.
4385  * 0:Disable parity/ECC
4386  * 1:Reserved
4387  * 2:Generate exceptions only on uncorrectable parity/ECC errors
4388  * 3:Generate exceptions on any type of parity/ECC errors
4389  */
4390 #define CSR_MCACHE_CTL_DC_ECCEN_MASK (0x30U)
4391 #define CSR_MCACHE_CTL_DC_ECCEN_SHIFT (4U)
4392 #define CSR_MCACHE_CTL_DC_ECCEN_SET(x) (((uint32_t)(x) << CSR_MCACHE_CTL_DC_ECCEN_SHIFT) & CSR_MCACHE_CTL_DC_ECCEN_MASK)
4393 #define CSR_MCACHE_CTL_DC_ECCEN_GET(x) (((uint32_t)(x) & CSR_MCACHE_CTL_DC_ECCEN_MASK) >> CSR_MCACHE_CTL_DC_ECCEN_SHIFT)
4394 
4395 /*
4396  * IC_ECCEN (RW)
4397  *
4398  * Parity/ECC error checking enable control for the
4399  * instruction cache
4400  * 0:Disable parity/ECC
4401  * 1:Reserved
4402  * 2:Generate exceptions only on uncorrectable parity/ECC errors
4403  * 3:Generate exceptions on any type of parity/ECC errors
4404  */
4405 #define CSR_MCACHE_CTL_IC_ECCEN_MASK (0xCU)
4406 #define CSR_MCACHE_CTL_IC_ECCEN_SHIFT (2U)
4407 #define CSR_MCACHE_CTL_IC_ECCEN_SET(x) (((uint32_t)(x) << CSR_MCACHE_CTL_IC_ECCEN_SHIFT) & CSR_MCACHE_CTL_IC_ECCEN_MASK)
4408 #define CSR_MCACHE_CTL_IC_ECCEN_GET(x) (((uint32_t)(x) & CSR_MCACHE_CTL_IC_ECCEN_MASK) >> CSR_MCACHE_CTL_IC_ECCEN_SHIFT)
4409 
4410 /*
4411  * DC_EN (RW)
4412  *
4413  * Controls if the data cache is enabled or not.
4414  * 0:D-Cache is disabled
4415  * 1:D-Cache is enabled
4416  */
4417 #define CSR_MCACHE_CTL_DC_EN_MASK (0x2U)
4418 #define CSR_MCACHE_CTL_DC_EN_SHIFT (1U)
4419 #define CSR_MCACHE_CTL_DC_EN_SET(x) (((uint32_t)(x) << CSR_MCACHE_CTL_DC_EN_SHIFT) & CSR_MCACHE_CTL_DC_EN_MASK)
4420 #define CSR_MCACHE_CTL_DC_EN_GET(x) (((uint32_t)(x) & CSR_MCACHE_CTL_DC_EN_MASK) >> CSR_MCACHE_CTL_DC_EN_SHIFT)
4421 
4422 /*
4423  * IC_EN (RW)
4424  *
4425  * Controls if the instruction cache is enabled or not.
4426  * 0:I-Cache is disabled
4427  * 1:I-Cache is enabled
4428  */
4429 #define CSR_MCACHE_CTL_IC_EN_MASK (0x1U)
4430 #define CSR_MCACHE_CTL_IC_EN_SHIFT (0U)
4431 #define CSR_MCACHE_CTL_IC_EN_SET(x) (((uint32_t)(x) << CSR_MCACHE_CTL_IC_EN_SHIFT) & CSR_MCACHE_CTL_IC_EN_MASK)
4432 #define CSR_MCACHE_CTL_IC_EN_GET(x) (((uint32_t)(x) & CSR_MCACHE_CTL_IC_EN_MASK) >> CSR_MCACHE_CTL_IC_EN_SHIFT)
4433 
4434 /* Bitfield definition for register: MCCTLBEGINADDR */
4435 /*
4436  * VA (RW)
4437  *
4438  * This register holds the address information required by CCTL operations
4439  */
4440 #define CSR_MCCTLBEGINADDR_VA_MASK (0xFFFFFFFFUL)
4441 #define CSR_MCCTLBEGINADDR_VA_SHIFT (0U)
4442 #define CSR_MCCTLBEGINADDR_VA_SET(x) (((uint32_t)(x) << CSR_MCCTLBEGINADDR_VA_SHIFT) & CSR_MCCTLBEGINADDR_VA_MASK)
4443 #define CSR_MCCTLBEGINADDR_VA_GET(x) (((uint32_t)(x) & CSR_MCCTLBEGINADDR_VA_MASK) >> CSR_MCCTLBEGINADDR_VA_SHIFT)
4444 
4445 /* Bitfield definition for register: MCCTLCOMMAND */
4446 /*
4447  * VA (RW)
4448  *
4449  * See CCTL Command Definition Table
4450  */
4451 #define CSR_MCCTLCOMMAND_VA_MASK (0x1FU)
4452 #define CSR_MCCTLCOMMAND_VA_SHIFT (0U)
4453 #define CSR_MCCTLCOMMAND_VA_SET(x) (((uint32_t)(x) << CSR_MCCTLCOMMAND_VA_SHIFT) & CSR_MCCTLCOMMAND_VA_MASK)
4454 #define CSR_MCCTLCOMMAND_VA_GET(x) (((uint32_t)(x) & CSR_MCCTLCOMMAND_VA_MASK) >> CSR_MCCTLCOMMAND_VA_SHIFT)
4455 
4456 /* Bitfield definition for register: MCCTLDATA */
4457 /*
4458  * VA (RW)
4459  *
4460  * See CCTL Commands Which Access mcctldata Table
4461  */
4462 #define CSR_MCCTLDATA_VA_MASK (0x1FU)
4463 #define CSR_MCCTLDATA_VA_SHIFT (0U)
4464 #define CSR_MCCTLDATA_VA_SET(x) (((uint32_t)(x) << CSR_MCCTLDATA_VA_SHIFT) & CSR_MCCTLDATA_VA_MASK)
4465 #define CSR_MCCTLDATA_VA_GET(x) (((uint32_t)(x) & CSR_MCCTLDATA_VA_MASK) >> CSR_MCCTLDATA_VA_SHIFT)
4466 
4467 /* Bitfield definition for register: MCOUNTERWEN */
4468 /*
4469  * HPM6 (RW)
4470  *
4471  * See register description
4472  */
4473 #define CSR_MCOUNTERWEN_HPM6_MASK (0x40U)
4474 #define CSR_MCOUNTERWEN_HPM6_SHIFT (6U)
4475 #define CSR_MCOUNTERWEN_HPM6_SET(x) (((uint32_t)(x) << CSR_MCOUNTERWEN_HPM6_SHIFT) & CSR_MCOUNTERWEN_HPM6_MASK)
4476 #define CSR_MCOUNTERWEN_HPM6_GET(x) (((uint32_t)(x) & CSR_MCOUNTERWEN_HPM6_MASK) >> CSR_MCOUNTERWEN_HPM6_SHIFT)
4477 
4478 /*
4479  * HPM5 (RW)
4480  *
4481  * See register description
4482  */
4483 #define CSR_MCOUNTERWEN_HPM5_MASK (0x20U)
4484 #define CSR_MCOUNTERWEN_HPM5_SHIFT (5U)
4485 #define CSR_MCOUNTERWEN_HPM5_SET(x) (((uint32_t)(x) << CSR_MCOUNTERWEN_HPM5_SHIFT) & CSR_MCOUNTERWEN_HPM5_MASK)
4486 #define CSR_MCOUNTERWEN_HPM5_GET(x) (((uint32_t)(x) & CSR_MCOUNTERWEN_HPM5_MASK) >> CSR_MCOUNTERWEN_HPM5_SHIFT)
4487 
4488 /*
4489  * HPM4 (RW)
4490  *
4491  * See register description
4492  */
4493 #define CSR_MCOUNTERWEN_HPM4_MASK (0x10U)
4494 #define CSR_MCOUNTERWEN_HPM4_SHIFT (4U)
4495 #define CSR_MCOUNTERWEN_HPM4_SET(x) (((uint32_t)(x) << CSR_MCOUNTERWEN_HPM4_SHIFT) & CSR_MCOUNTERWEN_HPM4_MASK)
4496 #define CSR_MCOUNTERWEN_HPM4_GET(x) (((uint32_t)(x) & CSR_MCOUNTERWEN_HPM4_MASK) >> CSR_MCOUNTERWEN_HPM4_SHIFT)
4497 
4498 /*
4499  * HPM3 (RW)
4500  *
4501  * See register description
4502  */
4503 #define CSR_MCOUNTERWEN_HPM3_MASK (0x8U)
4504 #define CSR_MCOUNTERWEN_HPM3_SHIFT (3U)
4505 #define CSR_MCOUNTERWEN_HPM3_SET(x) (((uint32_t)(x) << CSR_MCOUNTERWEN_HPM3_SHIFT) & CSR_MCOUNTERWEN_HPM3_MASK)
4506 #define CSR_MCOUNTERWEN_HPM3_GET(x) (((uint32_t)(x) & CSR_MCOUNTERWEN_HPM3_MASK) >> CSR_MCOUNTERWEN_HPM3_SHIFT)
4507 
4508 /*
4509  * IR (RW)
4510  *
4511  * See register description
4512  */
4513 #define CSR_MCOUNTERWEN_IR_MASK (0x4U)
4514 #define CSR_MCOUNTERWEN_IR_SHIFT (2U)
4515 #define CSR_MCOUNTERWEN_IR_SET(x) (((uint32_t)(x) << CSR_MCOUNTERWEN_IR_SHIFT) & CSR_MCOUNTERWEN_IR_MASK)
4516 #define CSR_MCOUNTERWEN_IR_GET(x) (((uint32_t)(x) & CSR_MCOUNTERWEN_IR_MASK) >> CSR_MCOUNTERWEN_IR_SHIFT)
4517 
4518 /*
4519  * CY (RW)
4520  *
4521  * See register description
4522  */
4523 #define CSR_MCOUNTERWEN_CY_MASK (0x1U)
4524 #define CSR_MCOUNTERWEN_CY_SHIFT (0U)
4525 #define CSR_MCOUNTERWEN_CY_SET(x) (((uint32_t)(x) << CSR_MCOUNTERWEN_CY_SHIFT) & CSR_MCOUNTERWEN_CY_MASK)
4526 #define CSR_MCOUNTERWEN_CY_GET(x) (((uint32_t)(x) & CSR_MCOUNTERWEN_CY_MASK) >> CSR_MCOUNTERWEN_CY_SHIFT)
4527 
4528 /* Bitfield definition for register: MCOUNTERINTEN */
4529 /*
4530  * HPM6 (RW)
4531  *
4532  * See register description
4533  */
4534 #define CSR_MCOUNTERINTEN_HPM6_MASK (0x40U)
4535 #define CSR_MCOUNTERINTEN_HPM6_SHIFT (6U)
4536 #define CSR_MCOUNTERINTEN_HPM6_SET(x) (((uint32_t)(x) << CSR_MCOUNTERINTEN_HPM6_SHIFT) & CSR_MCOUNTERINTEN_HPM6_MASK)
4537 #define CSR_MCOUNTERINTEN_HPM6_GET(x) (((uint32_t)(x) & CSR_MCOUNTERINTEN_HPM6_MASK) >> CSR_MCOUNTERINTEN_HPM6_SHIFT)
4538 
4539 /*
4540  * HPM5 (RW)
4541  *
4542  * See register description
4543  */
4544 #define CSR_MCOUNTERINTEN_HPM5_MASK (0x20U)
4545 #define CSR_MCOUNTERINTEN_HPM5_SHIFT (5U)
4546 #define CSR_MCOUNTERINTEN_HPM5_SET(x) (((uint32_t)(x) << CSR_MCOUNTERINTEN_HPM5_SHIFT) & CSR_MCOUNTERINTEN_HPM5_MASK)
4547 #define CSR_MCOUNTERINTEN_HPM5_GET(x) (((uint32_t)(x) & CSR_MCOUNTERINTEN_HPM5_MASK) >> CSR_MCOUNTERINTEN_HPM5_SHIFT)
4548 
4549 /*
4550  * HPM4 (RW)
4551  *
4552  * See register description
4553  */
4554 #define CSR_MCOUNTERINTEN_HPM4_MASK (0x10U)
4555 #define CSR_MCOUNTERINTEN_HPM4_SHIFT (4U)
4556 #define CSR_MCOUNTERINTEN_HPM4_SET(x) (((uint32_t)(x) << CSR_MCOUNTERINTEN_HPM4_SHIFT) & CSR_MCOUNTERINTEN_HPM4_MASK)
4557 #define CSR_MCOUNTERINTEN_HPM4_GET(x) (((uint32_t)(x) & CSR_MCOUNTERINTEN_HPM4_MASK) >> CSR_MCOUNTERINTEN_HPM4_SHIFT)
4558 
4559 /*
4560  * HPM3 (RW)
4561  *
4562  * See register description
4563  */
4564 #define CSR_MCOUNTERINTEN_HPM3_MASK (0x8U)
4565 #define CSR_MCOUNTERINTEN_HPM3_SHIFT (3U)
4566 #define CSR_MCOUNTERINTEN_HPM3_SET(x) (((uint32_t)(x) << CSR_MCOUNTERINTEN_HPM3_SHIFT) & CSR_MCOUNTERINTEN_HPM3_MASK)
4567 #define CSR_MCOUNTERINTEN_HPM3_GET(x) (((uint32_t)(x) & CSR_MCOUNTERINTEN_HPM3_MASK) >> CSR_MCOUNTERINTEN_HPM3_SHIFT)
4568 
4569 /*
4570  * IR (RW)
4571  *
4572  * See register description
4573  */
4574 #define CSR_MCOUNTERINTEN_IR_MASK (0x4U)
4575 #define CSR_MCOUNTERINTEN_IR_SHIFT (2U)
4576 #define CSR_MCOUNTERINTEN_IR_SET(x) (((uint32_t)(x) << CSR_MCOUNTERINTEN_IR_SHIFT) & CSR_MCOUNTERINTEN_IR_MASK)
4577 #define CSR_MCOUNTERINTEN_IR_GET(x) (((uint32_t)(x) & CSR_MCOUNTERINTEN_IR_MASK) >> CSR_MCOUNTERINTEN_IR_SHIFT)
4578 
4579 /*
4580  * CY (RW)
4581  *
4582  * See register description
4583  */
4584 #define CSR_MCOUNTERINTEN_CY_MASK (0x1U)
4585 #define CSR_MCOUNTERINTEN_CY_SHIFT (0U)
4586 #define CSR_MCOUNTERINTEN_CY_SET(x) (((uint32_t)(x) << CSR_MCOUNTERINTEN_CY_SHIFT) & CSR_MCOUNTERINTEN_CY_MASK)
4587 #define CSR_MCOUNTERINTEN_CY_GET(x) (((uint32_t)(x) & CSR_MCOUNTERINTEN_CY_MASK) >> CSR_MCOUNTERINTEN_CY_SHIFT)
4588 
4589 /* Bitfield definition for register: MMISC_CTL */
4590 /*
4591  * NBLD_EN (RW)
4592  *
4593  * This field controls the blocking behavior of load instructions. When this bit is clear, load instructions accessing non-device regions are blocking. When this bit is set, load instructions will not be blocking on such occasions and bus errors will no longer be reported synchronously.
4594  * 0:Load to memory regions are blocking.
4595  * 1:Load to memory regions are non-blocking.
4596  */
4597 #define CSR_MMISC_CTL_NBLD_EN_MASK (0x100U)
4598 #define CSR_MMISC_CTL_NBLD_EN_SHIFT (8U)
4599 #define CSR_MMISC_CTL_NBLD_EN_SET(x) (((uint32_t)(x) << CSR_MMISC_CTL_NBLD_EN_SHIFT) & CSR_MMISC_CTL_NBLD_EN_MASK)
4600 #define CSR_MMISC_CTL_NBLD_EN_GET(x) (((uint32_t)(x) & CSR_MMISC_CTL_NBLD_EN_MASK) >> CSR_MMISC_CTL_NBLD_EN_SHIFT)
4601 
4602 /*
4603  * MSA_UNA (RW)
4604  *
4605  * This field controls whether the load/store instructions can access misaligned memory locations without generating Address Misaligned exceptions.
4606  * Supported instructions: LW/LH/LHU/SW/SH
4607  * 0:Misaligned accesses generate Address Misaligned exceptions.
4608  * 1:Misaligned accesses generate Address Misaligned exceptions.
4609  */
4610 #define CSR_MMISC_CTL_MSA_UNA_MASK (0x40U)
4611 #define CSR_MMISC_CTL_MSA_UNA_SHIFT (6U)
4612 #define CSR_MMISC_CTL_MSA_UNA_SET(x) (((uint32_t)(x) << CSR_MMISC_CTL_MSA_UNA_SHIFT) & CSR_MMISC_CTL_MSA_UNA_MASK)
4613 #define CSR_MMISC_CTL_MSA_UNA_GET(x) (((uint32_t)(x) & CSR_MMISC_CTL_MSA_UNA_MASK) >> CSR_MMISC_CTL_MSA_UNA_SHIFT)
4614 
4615 /*
4616  * BRPE (RW)
4617  *
4618  * Branch prediction enable bit. This bit controls all branch prediction structures.
4619  * 0:Disabled
4620  * 1:Enabled
4621  * This bit is hardwired to 0 if branch prediction structure is not supported.
4622  */
4623 #define CSR_MMISC_CTL_BRPE_MASK (0x8U)
4624 #define CSR_MMISC_CTL_BRPE_SHIFT (3U)
4625 #define CSR_MMISC_CTL_BRPE_SET(x) (((uint32_t)(x) << CSR_MMISC_CTL_BRPE_SHIFT) & CSR_MMISC_CTL_BRPE_MASK)
4626 #define CSR_MMISC_CTL_BRPE_GET(x) (((uint32_t)(x) & CSR_MMISC_CTL_BRPE_MASK) >> CSR_MMISC_CTL_BRPE_SHIFT)
4627 
4628 /*
4629  * RVCOMPM (RW)
4630  *
4631  * RISC-V compatibility mode enable bit. If the compatibility mode is turned on, all specific instructions become reserved instructions
4632  * 0:Disabled
4633  * 1:Enabled
4634  */
4635 #define CSR_MMISC_CTL_RVCOMPM_MASK (0x4U)
4636 #define CSR_MMISC_CTL_RVCOMPM_SHIFT (2U)
4637 #define CSR_MMISC_CTL_RVCOMPM_SET(x) (((uint32_t)(x) << CSR_MMISC_CTL_RVCOMPM_SHIFT) & CSR_MMISC_CTL_RVCOMPM_MASK)
4638 #define CSR_MMISC_CTL_RVCOMPM_GET(x) (((uint32_t)(x) & CSR_MMISC_CTL_RVCOMPM_MASK) >> CSR_MMISC_CTL_RVCOMPM_SHIFT)
4639 
4640 /*
4641  * VEC_PLIC (RW)
4642  *
4643  * Selects the operation mode of PLIC:
4644  * 0:Regular mode
4645  * 1:Vector mode
4646  * 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.
4647  */
4648 #define CSR_MMISC_CTL_VEC_PLIC_MASK (0x2U)
4649 #define CSR_MMISC_CTL_VEC_PLIC_SHIFT (1U)
4650 #define CSR_MMISC_CTL_VEC_PLIC_SET(x) (((uint32_t)(x) << CSR_MMISC_CTL_VEC_PLIC_SHIFT) & CSR_MMISC_CTL_VEC_PLIC_MASK)
4651 #define CSR_MMISC_CTL_VEC_PLIC_GET(x) (((uint32_t)(x) & CSR_MMISC_CTL_VEC_PLIC_MASK) >> CSR_MMISC_CTL_VEC_PLIC_SHIFT)
4652 
4653 /* Bitfield definition for register: MCOUNTERMASK_M */
4654 /*
4655  * HPM6 (RW)
4656  *
4657  * See register description
4658  */
4659 #define CSR_MCOUNTERMASK_M_HPM6_MASK (0x40U)
4660 #define CSR_MCOUNTERMASK_M_HPM6_SHIFT (6U)
4661 #define CSR_MCOUNTERMASK_M_HPM6_SET(x) (((uint32_t)(x) << CSR_MCOUNTERMASK_M_HPM6_SHIFT) & CSR_MCOUNTERMASK_M_HPM6_MASK)
4662 #define CSR_MCOUNTERMASK_M_HPM6_GET(x) (((uint32_t)(x) & CSR_MCOUNTERMASK_M_HPM6_MASK) >> CSR_MCOUNTERMASK_M_HPM6_SHIFT)
4663 
4664 /*
4665  * HPM5 (RW)
4666  *
4667  * See register description
4668  */
4669 #define CSR_MCOUNTERMASK_M_HPM5_MASK (0x20U)
4670 #define CSR_MCOUNTERMASK_M_HPM5_SHIFT (5U)
4671 #define CSR_MCOUNTERMASK_M_HPM5_SET(x) (((uint32_t)(x) << CSR_MCOUNTERMASK_M_HPM5_SHIFT) & CSR_MCOUNTERMASK_M_HPM5_MASK)
4672 #define CSR_MCOUNTERMASK_M_HPM5_GET(x) (((uint32_t)(x) & CSR_MCOUNTERMASK_M_HPM5_MASK) >> CSR_MCOUNTERMASK_M_HPM5_SHIFT)
4673 
4674 /*
4675  * HPM4 (RW)
4676  *
4677  * See register description
4678  */
4679 #define CSR_MCOUNTERMASK_M_HPM4_MASK (0x10U)
4680 #define CSR_MCOUNTERMASK_M_HPM4_SHIFT (4U)
4681 #define CSR_MCOUNTERMASK_M_HPM4_SET(x) (((uint32_t)(x) << CSR_MCOUNTERMASK_M_HPM4_SHIFT) & CSR_MCOUNTERMASK_M_HPM4_MASK)
4682 #define CSR_MCOUNTERMASK_M_HPM4_GET(x) (((uint32_t)(x) & CSR_MCOUNTERMASK_M_HPM4_MASK) >> CSR_MCOUNTERMASK_M_HPM4_SHIFT)
4683 
4684 /*
4685  * HPM3 (RW)
4686  *
4687  * See register description
4688  */
4689 #define CSR_MCOUNTERMASK_M_HPM3_MASK (0x8U)
4690 #define CSR_MCOUNTERMASK_M_HPM3_SHIFT (3U)
4691 #define CSR_MCOUNTERMASK_M_HPM3_SET(x) (((uint32_t)(x) << CSR_MCOUNTERMASK_M_HPM3_SHIFT) & CSR_MCOUNTERMASK_M_HPM3_MASK)
4692 #define CSR_MCOUNTERMASK_M_HPM3_GET(x) (((uint32_t)(x) & CSR_MCOUNTERMASK_M_HPM3_MASK) >> CSR_MCOUNTERMASK_M_HPM3_SHIFT)
4693 
4694 /*
4695  * IR (RW)
4696  *
4697  * See register description
4698  */
4699 #define CSR_MCOUNTERMASK_M_IR_MASK (0x4U)
4700 #define CSR_MCOUNTERMASK_M_IR_SHIFT (2U)
4701 #define CSR_MCOUNTERMASK_M_IR_SET(x) (((uint32_t)(x) << CSR_MCOUNTERMASK_M_IR_SHIFT) & CSR_MCOUNTERMASK_M_IR_MASK)
4702 #define CSR_MCOUNTERMASK_M_IR_GET(x) (((uint32_t)(x) & CSR_MCOUNTERMASK_M_IR_MASK) >> CSR_MCOUNTERMASK_M_IR_SHIFT)
4703 
4704 /*
4705  * CY (RW)
4706  *
4707  * See register description
4708  */
4709 #define CSR_MCOUNTERMASK_M_CY_MASK (0x1U)
4710 #define CSR_MCOUNTERMASK_M_CY_SHIFT (0U)
4711 #define CSR_MCOUNTERMASK_M_CY_SET(x) (((uint32_t)(x) << CSR_MCOUNTERMASK_M_CY_SHIFT) & CSR_MCOUNTERMASK_M_CY_MASK)
4712 #define CSR_MCOUNTERMASK_M_CY_GET(x) (((uint32_t)(x) & CSR_MCOUNTERMASK_M_CY_MASK) >> CSR_MCOUNTERMASK_M_CY_SHIFT)
4713 
4714 /* Bitfield definition for register: MCOUNTERMASK_S */
4715 /*
4716  * HPM6 (RW)
4717  *
4718  * See register description
4719  */
4720 #define CSR_MCOUNTERMASK_S_HPM6_MASK (0x40U)
4721 #define CSR_MCOUNTERMASK_S_HPM6_SHIFT (6U)
4722 #define CSR_MCOUNTERMASK_S_HPM6_SET(x) (((uint32_t)(x) << CSR_MCOUNTERMASK_S_HPM6_SHIFT) & CSR_MCOUNTERMASK_S_HPM6_MASK)
4723 #define CSR_MCOUNTERMASK_S_HPM6_GET(x) (((uint32_t)(x) & CSR_MCOUNTERMASK_S_HPM6_MASK) >> CSR_MCOUNTERMASK_S_HPM6_SHIFT)
4724 
4725 /*
4726  * HPM5 (RW)
4727  *
4728  * See register description
4729  */
4730 #define CSR_MCOUNTERMASK_S_HPM5_MASK (0x20U)
4731 #define CSR_MCOUNTERMASK_S_HPM5_SHIFT (5U)
4732 #define CSR_MCOUNTERMASK_S_HPM5_SET(x) (((uint32_t)(x) << CSR_MCOUNTERMASK_S_HPM5_SHIFT) & CSR_MCOUNTERMASK_S_HPM5_MASK)
4733 #define CSR_MCOUNTERMASK_S_HPM5_GET(x) (((uint32_t)(x) & CSR_MCOUNTERMASK_S_HPM5_MASK) >> CSR_MCOUNTERMASK_S_HPM5_SHIFT)
4734 
4735 /*
4736  * HPM4 (RW)
4737  *
4738  * See register description
4739  */
4740 #define CSR_MCOUNTERMASK_S_HPM4_MASK (0x10U)
4741 #define CSR_MCOUNTERMASK_S_HPM4_SHIFT (4U)
4742 #define CSR_MCOUNTERMASK_S_HPM4_SET(x) (((uint32_t)(x) << CSR_MCOUNTERMASK_S_HPM4_SHIFT) & CSR_MCOUNTERMASK_S_HPM4_MASK)
4743 #define CSR_MCOUNTERMASK_S_HPM4_GET(x) (((uint32_t)(x) & CSR_MCOUNTERMASK_S_HPM4_MASK) >> CSR_MCOUNTERMASK_S_HPM4_SHIFT)
4744 
4745 /*
4746  * HPM3 (RW)
4747  *
4748  * See register description
4749  */
4750 #define CSR_MCOUNTERMASK_S_HPM3_MASK (0x8U)
4751 #define CSR_MCOUNTERMASK_S_HPM3_SHIFT (3U)
4752 #define CSR_MCOUNTERMASK_S_HPM3_SET(x) (((uint32_t)(x) << CSR_MCOUNTERMASK_S_HPM3_SHIFT) & CSR_MCOUNTERMASK_S_HPM3_MASK)
4753 #define CSR_MCOUNTERMASK_S_HPM3_GET(x) (((uint32_t)(x) & CSR_MCOUNTERMASK_S_HPM3_MASK) >> CSR_MCOUNTERMASK_S_HPM3_SHIFT)
4754 
4755 /*
4756  * IR (RW)
4757  *
4758  * See register description
4759  */
4760 #define CSR_MCOUNTERMASK_S_IR_MASK (0x4U)
4761 #define CSR_MCOUNTERMASK_S_IR_SHIFT (2U)
4762 #define CSR_MCOUNTERMASK_S_IR_SET(x) (((uint32_t)(x) << CSR_MCOUNTERMASK_S_IR_SHIFT) & CSR_MCOUNTERMASK_S_IR_MASK)
4763 #define CSR_MCOUNTERMASK_S_IR_GET(x) (((uint32_t)(x) & CSR_MCOUNTERMASK_S_IR_MASK) >> CSR_MCOUNTERMASK_S_IR_SHIFT)
4764 
4765 /*
4766  * CY (RW)
4767  *
4768  * See register description
4769  */
4770 #define CSR_MCOUNTERMASK_S_CY_MASK (0x1U)
4771 #define CSR_MCOUNTERMASK_S_CY_SHIFT (0U)
4772 #define CSR_MCOUNTERMASK_S_CY_SET(x) (((uint32_t)(x) << CSR_MCOUNTERMASK_S_CY_SHIFT) & CSR_MCOUNTERMASK_S_CY_MASK)
4773 #define CSR_MCOUNTERMASK_S_CY_GET(x) (((uint32_t)(x) & CSR_MCOUNTERMASK_S_CY_MASK) >> CSR_MCOUNTERMASK_S_CY_SHIFT)
4774 
4775 /* Bitfield definition for register: MCOUNTERMASK_U */
4776 /*
4777  * HPM6 (RW)
4778  *
4779  * See register description
4780  */
4781 #define CSR_MCOUNTERMASK_U_HPM6_MASK (0x40U)
4782 #define CSR_MCOUNTERMASK_U_HPM6_SHIFT (6U)
4783 #define CSR_MCOUNTERMASK_U_HPM6_SET(x) (((uint32_t)(x) << CSR_MCOUNTERMASK_U_HPM6_SHIFT) & CSR_MCOUNTERMASK_U_HPM6_MASK)
4784 #define CSR_MCOUNTERMASK_U_HPM6_GET(x) (((uint32_t)(x) & CSR_MCOUNTERMASK_U_HPM6_MASK) >> CSR_MCOUNTERMASK_U_HPM6_SHIFT)
4785 
4786 /*
4787  * HPM5 (RW)
4788  *
4789  * See register description
4790  */
4791 #define CSR_MCOUNTERMASK_U_HPM5_MASK (0x20U)
4792 #define CSR_MCOUNTERMASK_U_HPM5_SHIFT (5U)
4793 #define CSR_MCOUNTERMASK_U_HPM5_SET(x) (((uint32_t)(x) << CSR_MCOUNTERMASK_U_HPM5_SHIFT) & CSR_MCOUNTERMASK_U_HPM5_MASK)
4794 #define CSR_MCOUNTERMASK_U_HPM5_GET(x) (((uint32_t)(x) & CSR_MCOUNTERMASK_U_HPM5_MASK) >> CSR_MCOUNTERMASK_U_HPM5_SHIFT)
4795 
4796 /*
4797  * HPM4 (RW)
4798  *
4799  * See register description
4800  */
4801 #define CSR_MCOUNTERMASK_U_HPM4_MASK (0x10U)
4802 #define CSR_MCOUNTERMASK_U_HPM4_SHIFT (4U)
4803 #define CSR_MCOUNTERMASK_U_HPM4_SET(x) (((uint32_t)(x) << CSR_MCOUNTERMASK_U_HPM4_SHIFT) & CSR_MCOUNTERMASK_U_HPM4_MASK)
4804 #define CSR_MCOUNTERMASK_U_HPM4_GET(x) (((uint32_t)(x) & CSR_MCOUNTERMASK_U_HPM4_MASK) >> CSR_MCOUNTERMASK_U_HPM4_SHIFT)
4805 
4806 /*
4807  * HPM3 (RW)
4808  *
4809  * See register description
4810  */
4811 #define CSR_MCOUNTERMASK_U_HPM3_MASK (0x8U)
4812 #define CSR_MCOUNTERMASK_U_HPM3_SHIFT (3U)
4813 #define CSR_MCOUNTERMASK_U_HPM3_SET(x) (((uint32_t)(x) << CSR_MCOUNTERMASK_U_HPM3_SHIFT) & CSR_MCOUNTERMASK_U_HPM3_MASK)
4814 #define CSR_MCOUNTERMASK_U_HPM3_GET(x) (((uint32_t)(x) & CSR_MCOUNTERMASK_U_HPM3_MASK) >> CSR_MCOUNTERMASK_U_HPM3_SHIFT)
4815 
4816 /*
4817  * IR (RW)
4818  *
4819  * See register description
4820  */
4821 #define CSR_MCOUNTERMASK_U_IR_MASK (0x4U)
4822 #define CSR_MCOUNTERMASK_U_IR_SHIFT (2U)
4823 #define CSR_MCOUNTERMASK_U_IR_SET(x) (((uint32_t)(x) << CSR_MCOUNTERMASK_U_IR_SHIFT) & CSR_MCOUNTERMASK_U_IR_MASK)
4824 #define CSR_MCOUNTERMASK_U_IR_GET(x) (((uint32_t)(x) & CSR_MCOUNTERMASK_U_IR_MASK) >> CSR_MCOUNTERMASK_U_IR_SHIFT)
4825 
4826 /*
4827  * CY (RW)
4828  *
4829  * See register description
4830  */
4831 #define CSR_MCOUNTERMASK_U_CY_MASK (0x1U)
4832 #define CSR_MCOUNTERMASK_U_CY_SHIFT (0U)
4833 #define CSR_MCOUNTERMASK_U_CY_SET(x) (((uint32_t)(x) << CSR_MCOUNTERMASK_U_CY_SHIFT) & CSR_MCOUNTERMASK_U_CY_MASK)
4834 #define CSR_MCOUNTERMASK_U_CY_GET(x) (((uint32_t)(x) & CSR_MCOUNTERMASK_U_CY_MASK) >> CSR_MCOUNTERMASK_U_CY_SHIFT)
4835 
4836 /* Bitfield definition for register: MCOUNTEROVF */
4837 /*
4838  * HPM6 (RW)
4839  *
4840  * See register description
4841  */
4842 #define CSR_MCOUNTEROVF_HPM6_MASK (0x40U)
4843 #define CSR_MCOUNTEROVF_HPM6_SHIFT (6U)
4844 #define CSR_MCOUNTEROVF_HPM6_SET(x) (((uint32_t)(x) << CSR_MCOUNTEROVF_HPM6_SHIFT) & CSR_MCOUNTEROVF_HPM6_MASK)
4845 #define CSR_MCOUNTEROVF_HPM6_GET(x) (((uint32_t)(x) & CSR_MCOUNTEROVF_HPM6_MASK) >> CSR_MCOUNTEROVF_HPM6_SHIFT)
4846 
4847 /*
4848  * HPM5 (RW)
4849  *
4850  * See register description
4851  */
4852 #define CSR_MCOUNTEROVF_HPM5_MASK (0x20U)
4853 #define CSR_MCOUNTEROVF_HPM5_SHIFT (5U)
4854 #define CSR_MCOUNTEROVF_HPM5_SET(x) (((uint32_t)(x) << CSR_MCOUNTEROVF_HPM5_SHIFT) & CSR_MCOUNTEROVF_HPM5_MASK)
4855 #define CSR_MCOUNTEROVF_HPM5_GET(x) (((uint32_t)(x) & CSR_MCOUNTEROVF_HPM5_MASK) >> CSR_MCOUNTEROVF_HPM5_SHIFT)
4856 
4857 /*
4858  * HPM4 (RW)
4859  *
4860  * See register description
4861  */
4862 #define CSR_MCOUNTEROVF_HPM4_MASK (0x10U)
4863 #define CSR_MCOUNTEROVF_HPM4_SHIFT (4U)
4864 #define CSR_MCOUNTEROVF_HPM4_SET(x) (((uint32_t)(x) << CSR_MCOUNTEROVF_HPM4_SHIFT) & CSR_MCOUNTEROVF_HPM4_MASK)
4865 #define CSR_MCOUNTEROVF_HPM4_GET(x) (((uint32_t)(x) & CSR_MCOUNTEROVF_HPM4_MASK) >> CSR_MCOUNTEROVF_HPM4_SHIFT)
4866 
4867 /*
4868  * HPM3 (RW)
4869  *
4870  * See register description
4871  */
4872 #define CSR_MCOUNTEROVF_HPM3_MASK (0x8U)
4873 #define CSR_MCOUNTEROVF_HPM3_SHIFT (3U)
4874 #define CSR_MCOUNTEROVF_HPM3_SET(x) (((uint32_t)(x) << CSR_MCOUNTEROVF_HPM3_SHIFT) & CSR_MCOUNTEROVF_HPM3_MASK)
4875 #define CSR_MCOUNTEROVF_HPM3_GET(x) (((uint32_t)(x) & CSR_MCOUNTEROVF_HPM3_MASK) >> CSR_MCOUNTEROVF_HPM3_SHIFT)
4876 
4877 /*
4878  * IR (RW)
4879  *
4880  * See register description
4881  */
4882 #define CSR_MCOUNTEROVF_IR_MASK (0x4U)
4883 #define CSR_MCOUNTEROVF_IR_SHIFT (2U)
4884 #define CSR_MCOUNTEROVF_IR_SET(x) (((uint32_t)(x) << CSR_MCOUNTEROVF_IR_SHIFT) & CSR_MCOUNTEROVF_IR_MASK)
4885 #define CSR_MCOUNTEROVF_IR_GET(x) (((uint32_t)(x) & CSR_MCOUNTEROVF_IR_MASK) >> CSR_MCOUNTEROVF_IR_SHIFT)
4886 
4887 /*
4888  * CY (RW)
4889  *
4890  * See register description
4891  */
4892 #define CSR_MCOUNTEROVF_CY_MASK (0x1U)
4893 #define CSR_MCOUNTEROVF_CY_SHIFT (0U)
4894 #define CSR_MCOUNTEROVF_CY_SET(x) (((uint32_t)(x) << CSR_MCOUNTEROVF_CY_SHIFT) & CSR_MCOUNTEROVF_CY_MASK)
4895 #define CSR_MCOUNTEROVF_CY_GET(x) (((uint32_t)(x) & CSR_MCOUNTEROVF_CY_MASK) >> CSR_MCOUNTEROVF_CY_SHIFT)
4896 
4897 /* Bitfield definition for register: MSLIDELEG */
4898 /*
4899  * PMOVI (RW)
4900  *
4901  * Delegate S-mode performance monitor overflow local interrupt to S-mode.
4902  * 0:Do not delegate to S-mode.
4903  * 1:Delegate to S-mode.
4904  */
4905 #define CSR_MSLIDELEG_PMOVI_MASK (0x40000UL)
4906 #define CSR_MSLIDELEG_PMOVI_SHIFT (18U)
4907 #define CSR_MSLIDELEG_PMOVI_SET(x) (((uint32_t)(x) << CSR_MSLIDELEG_PMOVI_SHIFT) & CSR_MSLIDELEG_PMOVI_MASK)
4908 #define CSR_MSLIDELEG_PMOVI_GET(x) (((uint32_t)(x) & CSR_MSLIDELEG_PMOVI_MASK) >> CSR_MSLIDELEG_PMOVI_SHIFT)
4909 
4910 /*
4911  * BWEI (RW)
4912  *
4913  * Delegate S-mode bus read/write transaction error local interrupt to S-mode
4914  * 0:Do not delegate to S-mode.
4915  * 1:Delegate to S-mode.
4916  */
4917 #define CSR_MSLIDELEG_BWEI_MASK (0x20000UL)
4918 #define CSR_MSLIDELEG_BWEI_SHIFT (17U)
4919 #define CSR_MSLIDELEG_BWEI_SET(x) (((uint32_t)(x) << CSR_MSLIDELEG_BWEI_SHIFT) & CSR_MSLIDELEG_BWEI_MASK)
4920 #define CSR_MSLIDELEG_BWEI_GET(x) (((uint32_t)(x) & CSR_MSLIDELEG_BWEI_MASK) >> CSR_MSLIDELEG_BWEI_SHIFT)
4921 
4922 /*
4923  * IMECCI (RW)
4924  *
4925  * Delegate S-mode slave-port ECC error local interrupt to S-mode
4926  * 0:Do not delegate to S-mode.
4927  * 1:Delegate to S-mode.
4928  */
4929 #define CSR_MSLIDELEG_IMECCI_MASK (0x10000UL)
4930 #define CSR_MSLIDELEG_IMECCI_SHIFT (16U)
4931 #define CSR_MSLIDELEG_IMECCI_SET(x) (((uint32_t)(x) << CSR_MSLIDELEG_IMECCI_SHIFT) & CSR_MSLIDELEG_IMECCI_MASK)
4932 #define CSR_MSLIDELEG_IMECCI_GET(x) (((uint32_t)(x) & CSR_MSLIDELEG_IMECCI_MASK) >> CSR_MSLIDELEG_IMECCI_SHIFT)
4933 
4934 /* Bitfield definition for register: MCLK_CTL */
4935 /*
4936  * FUNIT (RW)
4937  *
4938  * Level 2 clock gating enable for function units listed in the following table.
4939  * 16:integer arithmetic unit
4940  * 17:integer permutation unit
4941  * 18:integer mask unit
4942  * 19:integer division unit
4943  * 20:integer multiply and add unit
4944  * 21:floating-point multiply and add
4945  * unit
4946  * 22:floating-point miscellaneous unit
4947  * 23:floating-point division unit
4948  * 24:load/store unit
4949  * 31:25:Reserved
4950  */
4951 #define CSR_MCLK_CTL_FUNIT_MASK (0xFFFF0000UL)
4952 #define CSR_MCLK_CTL_FUNIT_SHIFT (16U)
4953 #define CSR_MCLK_CTL_FUNIT_SET(x) (((uint32_t)(x) << CSR_MCLK_CTL_FUNIT_SHIFT) & CSR_MCLK_CTL_FUNIT_MASK)
4954 #define CSR_MCLK_CTL_FUNIT_GET(x) (((uint32_t)(x) & CSR_MCLK_CTL_FUNIT_MASK) >> CSR_MCLK_CTL_FUNIT_SHIFT)
4955 
4956 /*
4957  * VI (RW)
4958  *
4959  * Level 1 clock gating enable for the vector/floating-point issue queues.
4960  */
4961 #define CSR_MCLK_CTL_VI_MASK (0x8000U)
4962 #define CSR_MCLK_CTL_VI_SHIFT (15U)
4963 #define CSR_MCLK_CTL_VI_SET(x) (((uint32_t)(x) << CSR_MCLK_CTL_VI_SHIFT) & CSR_MCLK_CTL_VI_MASK)
4964 #define CSR_MCLK_CTL_VI_GET(x) (((uint32_t)(x) & CSR_MCLK_CTL_VI_MASK) >> CSR_MCLK_CTL_VI_SHIFT)
4965 
4966 /*
4967  * VR (RW)
4968  *
4969  * Level 1 clock gating enable for the vector/floating-point register file.
4970  */
4971 #define CSR_MCLK_CTL_VR_MASK (0x4000U)
4972 #define CSR_MCLK_CTL_VR_SHIFT (14U)
4973 #define CSR_MCLK_CTL_VR_SET(x) (((uint32_t)(x) << CSR_MCLK_CTL_VR_SHIFT) & CSR_MCLK_CTL_VR_MASK)
4974 #define CSR_MCLK_CTL_VR_GET(x) (((uint32_t)(x) & CSR_MCLK_CTL_VR_MASK) >> CSR_MCLK_CTL_VR_SHIFT)
4975 
4976 /*
4977  * AQ (RW)
4978  *
4979  * Level 1 clock gating enable for ACE load/store queues.
4980  */
4981 #define CSR_MCLK_CTL_AQ_MASK (0x2000U)
4982 #define CSR_MCLK_CTL_AQ_SHIFT (13U)
4983 #define CSR_MCLK_CTL_AQ_SET(x) (((uint32_t)(x) << CSR_MCLK_CTL_AQ_SHIFT) & CSR_MCLK_CTL_AQ_MASK)
4984 #define CSR_MCLK_CTL_AQ_GET(x) (((uint32_t)(x) & CSR_MCLK_CTL_AQ_MASK) >> CSR_MCLK_CTL_AQ_SHIFT)
4985 
4986 /*
4987  * DQ (RW)
4988  *
4989  * Level 1 clock gating enable for data cache load/store queues.
4990  */
4991 #define CSR_MCLK_CTL_DQ_MASK (0x1000U)
4992 #define CSR_MCLK_CTL_DQ_SHIFT (12U)
4993 #define CSR_MCLK_CTL_DQ_SET(x) (((uint32_t)(x) << CSR_MCLK_CTL_DQ_SHIFT) & CSR_MCLK_CTL_DQ_MASK)
4994 #define CSR_MCLK_CTL_DQ_GET(x) (((uint32_t)(x) & CSR_MCLK_CTL_DQ_MASK) >> CSR_MCLK_CTL_DQ_SHIFT)
4995 
4996 /*
4997  * UQ (RW)
4998  *
4999  * Level 1 clock gating enable for uncached queues
5000  */
5001 #define CSR_MCLK_CTL_UQ_MASK (0x800U)
5002 #define CSR_MCLK_CTL_UQ_SHIFT (11U)
5003 #define CSR_MCLK_CTL_UQ_SET(x) (((uint32_t)(x) << CSR_MCLK_CTL_UQ_SHIFT) & CSR_MCLK_CTL_UQ_MASK)
5004 #define CSR_MCLK_CTL_UQ_GET(x) (((uint32_t)(x) & CSR_MCLK_CTL_UQ_MASK) >> CSR_MCLK_CTL_UQ_SHIFT)
5005 
5006 /*
5007  * FP (RW)
5008  *
5009  * Level 1 clock gating enable for scalar floating point issue unit and queues.
5010  */
5011 #define CSR_MCLK_CTL_FP_MASK (0x400U)
5012 #define CSR_MCLK_CTL_FP_SHIFT (10U)
5013 #define CSR_MCLK_CTL_FP_SET(x) (((uint32_t)(x) << CSR_MCLK_CTL_FP_SHIFT) & CSR_MCLK_CTL_FP_MASK)
5014 #define CSR_MCLK_CTL_FP_GET(x) (((uint32_t)(x) & CSR_MCLK_CTL_FP_MASK) >> CSR_MCLK_CTL_FP_SHIFT)
5015 
5016 /*
5017  * CLKGATE (RW)
5018  *
5019  * One-hot clock gating levels.
5020  * 0:Level 1 clock gating in module level
5021  * 1:Level 2 clock gating in unit level
5022  * 2:Level 3 clock gating in VPU level
5023  * 7:3:Reserved
5024  */
5025 #define CSR_MCLK_CTL_CLKGATE_MASK (0xFFU)
5026 #define CSR_MCLK_CTL_CLKGATE_SHIFT (0U)
5027 #define CSR_MCLK_CTL_CLKGATE_SET(x) (((uint32_t)(x) << CSR_MCLK_CTL_CLKGATE_SHIFT) & CSR_MCLK_CTL_CLKGATE_MASK)
5028 #define CSR_MCLK_CTL_CLKGATE_GET(x) (((uint32_t)(x) & CSR_MCLK_CTL_CLKGATE_MASK) >> CSR_MCLK_CTL_CLKGATE_SHIFT)
5029 
5030 /* Bitfield definition for register: DEXC2DBG */
5031 /*
5032  * PMOV (RW)
5033  *
5034  * Indicates whether performance counter overflow interrupts are redirected to enter Debug Mode
5035  * 0:Do not redirect
5036  * 1:Redirect
5037  */
5038 #define CSR_DEXC2DBG_PMOV_MASK (0x80000UL)
5039 #define CSR_DEXC2DBG_PMOV_SHIFT (19U)
5040 #define CSR_DEXC2DBG_PMOV_SET(x) (((uint32_t)(x) << CSR_DEXC2DBG_PMOV_SHIFT) & CSR_DEXC2DBG_PMOV_MASK)
5041 #define CSR_DEXC2DBG_PMOV_GET(x) (((uint32_t)(x) & CSR_DEXC2DBG_PMOV_MASK) >> CSR_DEXC2DBG_PMOV_SHIFT)
5042 
5043 /*
5044  * SPF (RW)
5045  *
5046  * Indicates whether store page fault exceptions are redirected to enter Debug Mode.
5047  * 0:Do not redirect
5048  * 1:Redirect
5049  */
5050 #define CSR_DEXC2DBG_SPF_MASK (0x40000UL)
5051 #define CSR_DEXC2DBG_SPF_SHIFT (18U)
5052 #define CSR_DEXC2DBG_SPF_SET(x) (((uint32_t)(x) << CSR_DEXC2DBG_SPF_SHIFT) & CSR_DEXC2DBG_SPF_MASK)
5053 #define CSR_DEXC2DBG_SPF_GET(x) (((uint32_t)(x) & CSR_DEXC2DBG_SPF_MASK) >> CSR_DEXC2DBG_SPF_SHIFT)
5054 
5055 /*
5056  * LPF (RW)
5057  *
5058  * Indicates whether load fault exceptions are redirected to enter Debug Mode
5059  * 0:Do not redirect
5060  * 1:Redirect
5061  */
5062 #define CSR_DEXC2DBG_LPF_MASK (0x20000UL)
5063 #define CSR_DEXC2DBG_LPF_SHIFT (17U)
5064 #define CSR_DEXC2DBG_LPF_SET(x) (((uint32_t)(x) << CSR_DEXC2DBG_LPF_SHIFT) & CSR_DEXC2DBG_LPF_MASK)
5065 #define CSR_DEXC2DBG_LPF_GET(x) (((uint32_t)(x) & CSR_DEXC2DBG_LPF_MASK) >> CSR_DEXC2DBG_LPF_SHIFT)
5066 
5067 /*
5068  * IPF (RW)
5069  *
5070  * Indicates whether instruction page fault exceptions are redirected to enter Debug Mode
5071  * 0:Do not redirect
5072  * 1:Redirect
5073  */
5074 #define CSR_DEXC2DBG_IPF_MASK (0x10000UL)
5075 #define CSR_DEXC2DBG_IPF_SHIFT (16U)
5076 #define CSR_DEXC2DBG_IPF_SET(x) (((uint32_t)(x) << CSR_DEXC2DBG_IPF_SHIFT) & CSR_DEXC2DBG_IPF_MASK)
5077 #define CSR_DEXC2DBG_IPF_GET(x) (((uint32_t)(x) & CSR_DEXC2DBG_IPF_MASK) >> CSR_DEXC2DBG_IPF_SHIFT)
5078 
5079 /*
5080  * BWE (RW)
5081  *
5082  * Indicates whether Bus-write Transaction Error local interrupts are redirected to enter Debug Mode
5083  * 0:Do not redirect
5084  * 1:Redirect
5085  */
5086 #define CSR_DEXC2DBG_BWE_MASK (0x8000U)
5087 #define CSR_DEXC2DBG_BWE_SHIFT (15U)
5088 #define CSR_DEXC2DBG_BWE_SET(x) (((uint32_t)(x) << CSR_DEXC2DBG_BWE_SHIFT) & CSR_DEXC2DBG_BWE_MASK)
5089 #define CSR_DEXC2DBG_BWE_GET(x) (((uint32_t)(x) & CSR_DEXC2DBG_BWE_MASK) >> CSR_DEXC2DBG_BWE_SHIFT)
5090 
5091 /*
5092  * SLPECC (RW)
5093  *
5094  * Indicates whether local memory slave port ECC Error local interrupts are redirected to enter Debug Mode
5095  * 0:Do not redirect
5096  * 1:Redirect
5097  */
5098 #define CSR_DEXC2DBG_SLPECC_MASK (0x4000U)
5099 #define CSR_DEXC2DBG_SLPECC_SHIFT (14U)
5100 #define CSR_DEXC2DBG_SLPECC_SET(x) (((uint32_t)(x) << CSR_DEXC2DBG_SLPECC_SHIFT) & CSR_DEXC2DBG_SLPECC_MASK)
5101 #define CSR_DEXC2DBG_SLPECC_GET(x) (((uint32_t)(x) & CSR_DEXC2DBG_SLPECC_MASK) >> CSR_DEXC2DBG_SLPECC_SHIFT)
5102 
5103 /*
5104  * ACE (RW)
5105  *
5106  * Indicates whether ACE-related exceptions are redirected to enter Debug Mode. This bit is present only when mmsc_cfg.ACE is set
5107  * 0:Do not redirect
5108  * 1:Redirect
5109  */
5110 #define CSR_DEXC2DBG_ACE_MASK (0x2000U)
5111 #define CSR_DEXC2DBG_ACE_SHIFT (13U)
5112 #define CSR_DEXC2DBG_ACE_SET(x) (((uint32_t)(x) << CSR_DEXC2DBG_ACE_SHIFT) & CSR_DEXC2DBG_ACE_MASK)
5113 #define CSR_DEXC2DBG_ACE_GET(x) (((uint32_t)(x) & CSR_DEXC2DBG_ACE_MASK) >> CSR_DEXC2DBG_ACE_SHIFT)
5114 
5115 /*
5116  * HSP (RW)
5117  *
5118  * Indicates whether Stack Protection exceptions are redirected to enter Debug Mode. This bit is present only when mmsc_cfg.HSP is set.
5119  * 0:Do not redirect
5120  * 1:Redirect
5121  */
5122 #define CSR_DEXC2DBG_HSP_MASK (0x1000U)
5123 #define CSR_DEXC2DBG_HSP_SHIFT (12U)
5124 #define CSR_DEXC2DBG_HSP_SET(x) (((uint32_t)(x) << CSR_DEXC2DBG_HSP_SHIFT) & CSR_DEXC2DBG_HSP_MASK)
5125 #define CSR_DEXC2DBG_HSP_GET(x) (((uint32_t)(x) & CSR_DEXC2DBG_HSP_MASK) >> CSR_DEXC2DBG_HSP_SHIFT)
5126 
5127 /*
5128  * MEC (RW)
5129  *
5130  * Indicates whether M-mode Environment Call exceptions are redirected to enter Debug Mode
5131  * 0:Do not redirect
5132  * 1:Redirect
5133  */
5134 #define CSR_DEXC2DBG_MEC_MASK (0x800U)
5135 #define CSR_DEXC2DBG_MEC_SHIFT (11U)
5136 #define CSR_DEXC2DBG_MEC_SET(x) (((uint32_t)(x) << CSR_DEXC2DBG_MEC_SHIFT) & CSR_DEXC2DBG_MEC_MASK)
5137 #define CSR_DEXC2DBG_MEC_GET(x) (((uint32_t)(x) & CSR_DEXC2DBG_MEC_MASK) >> CSR_DEXC2DBG_MEC_SHIFT)
5138 
5139 /*
5140  * SEC (RW)
5141  *
5142  * Indicates whether S-mode Environment Call exceptions are redirected to enter Debug Mode
5143  * 0:Do not redirect
5144  * 1:Redirect
5145  */
5146 #define CSR_DEXC2DBG_SEC_MASK (0x200U)
5147 #define CSR_DEXC2DBG_SEC_SHIFT (9U)
5148 #define CSR_DEXC2DBG_SEC_SET(x) (((uint32_t)(x) << CSR_DEXC2DBG_SEC_SHIFT) & CSR_DEXC2DBG_SEC_MASK)
5149 #define CSR_DEXC2DBG_SEC_GET(x) (((uint32_t)(x) & CSR_DEXC2DBG_SEC_MASK) >> CSR_DEXC2DBG_SEC_SHIFT)
5150 
5151 /*
5152  * UEC (RW)
5153  *
5154  * Indicates whether U-mode Environment Call exceptions are redirected to enter Debug Mode.
5155  * 0:Do not redirect
5156  * 1:Redirect
5157  */
5158 #define CSR_DEXC2DBG_UEC_MASK (0x100U)
5159 #define CSR_DEXC2DBG_UEC_SHIFT (8U)
5160 #define CSR_DEXC2DBG_UEC_SET(x) (((uint32_t)(x) << CSR_DEXC2DBG_UEC_SHIFT) & CSR_DEXC2DBG_UEC_MASK)
5161 #define CSR_DEXC2DBG_UEC_GET(x) (((uint32_t)(x) & CSR_DEXC2DBG_UEC_MASK) >> CSR_DEXC2DBG_UEC_SHIFT)
5162 
5163 /*
5164  * SAF (RW)
5165  *
5166  * Indicates whether Store Access Fault exceptions are redirected to enter Debug Mode.
5167  * 0:Do not redirect
5168  * 1:Redirect
5169  */
5170 #define CSR_DEXC2DBG_SAF_MASK (0x80U)
5171 #define CSR_DEXC2DBG_SAF_SHIFT (7U)
5172 #define CSR_DEXC2DBG_SAF_SET(x) (((uint32_t)(x) << CSR_DEXC2DBG_SAF_SHIFT) & CSR_DEXC2DBG_SAF_MASK)
5173 #define CSR_DEXC2DBG_SAF_GET(x) (((uint32_t)(x) & CSR_DEXC2DBG_SAF_MASK) >> CSR_DEXC2DBG_SAF_SHIFT)
5174 
5175 /*
5176  * SAM (RW)
5177  *
5178  * Indicates whether Store Access Misaligned exceptions are redirected to enter Debug Mode.
5179  * 0:Do not redirect
5180  * 1:Redirect
5181  */
5182 #define CSR_DEXC2DBG_SAM_MASK (0x40U)
5183 #define CSR_DEXC2DBG_SAM_SHIFT (6U)
5184 #define CSR_DEXC2DBG_SAM_SET(x) (((uint32_t)(x) << CSR_DEXC2DBG_SAM_SHIFT) & CSR_DEXC2DBG_SAM_MASK)
5185 #define CSR_DEXC2DBG_SAM_GET(x) (((uint32_t)(x) & CSR_DEXC2DBG_SAM_MASK) >> CSR_DEXC2DBG_SAM_SHIFT)
5186 
5187 /*
5188  * LAF (RW)
5189  *
5190  * Indicates whether Load Access Fault exceptions are redirected to enter Debug Mode.
5191  * 0:Do not redirect
5192  * 1:Redirect
5193  */
5194 #define CSR_DEXC2DBG_LAF_MASK (0x20U)
5195 #define CSR_DEXC2DBG_LAF_SHIFT (5U)
5196 #define CSR_DEXC2DBG_LAF_SET(x) (((uint32_t)(x) << CSR_DEXC2DBG_LAF_SHIFT) & CSR_DEXC2DBG_LAF_MASK)
5197 #define CSR_DEXC2DBG_LAF_GET(x) (((uint32_t)(x) & CSR_DEXC2DBG_LAF_MASK) >> CSR_DEXC2DBG_LAF_SHIFT)
5198 
5199 /*
5200  * LAM (RW)
5201  *
5202  * Indicates whether Load Access Misaligned exceptions are redirected to enter Debug Mode
5203  * 0:Do not redirect
5204  * 1:Redirect
5205  */
5206 #define CSR_DEXC2DBG_LAM_MASK (0x10U)
5207 #define CSR_DEXC2DBG_LAM_SHIFT (4U)
5208 #define CSR_DEXC2DBG_LAM_SET(x) (((uint32_t)(x) << CSR_DEXC2DBG_LAM_SHIFT) & CSR_DEXC2DBG_LAM_MASK)
5209 #define CSR_DEXC2DBG_LAM_GET(x) (((uint32_t)(x) & CSR_DEXC2DBG_LAM_MASK) >> CSR_DEXC2DBG_LAM_SHIFT)
5210 
5211 /*
5212  * NMI (RW)
5213  *
5214  * Indicates whether Non-Maskable Interrupt
5215  * 0:Do not redirect
5216  * 1:Redirect
5217  */
5218 #define CSR_DEXC2DBG_NMI_MASK (0x8U)
5219 #define CSR_DEXC2DBG_NMI_SHIFT (3U)
5220 #define CSR_DEXC2DBG_NMI_SET(x) (((uint32_t)(x) << CSR_DEXC2DBG_NMI_SHIFT) & CSR_DEXC2DBG_NMI_MASK)
5221 #define CSR_DEXC2DBG_NMI_GET(x) (((uint32_t)(x) & CSR_DEXC2DBG_NMI_MASK) >> CSR_DEXC2DBG_NMI_SHIFT)
5222 
5223 /*
5224  * II (RW)
5225  *
5226  * Indicates whether Illegal Instruction exceptions are redirected to enter Debug Mode.
5227  * 0:Do not redirect
5228  * 1:Redirect
5229  */
5230 #define CSR_DEXC2DBG_II_MASK (0x4U)
5231 #define CSR_DEXC2DBG_II_SHIFT (2U)
5232 #define CSR_DEXC2DBG_II_SET(x) (((uint32_t)(x) << CSR_DEXC2DBG_II_SHIFT) & CSR_DEXC2DBG_II_MASK)
5233 #define CSR_DEXC2DBG_II_GET(x) (((uint32_t)(x) & CSR_DEXC2DBG_II_MASK) >> CSR_DEXC2DBG_II_SHIFT)
5234 
5235 /*
5236  * IAF (RW)
5237  *
5238  * Indicates whether Instruction Access Fault exceptions are redirected to enter Debug Mode
5239  * 0:Do not redirect
5240  * 1:Redirect
5241  */
5242 #define CSR_DEXC2DBG_IAF_MASK (0x2U)
5243 #define CSR_DEXC2DBG_IAF_SHIFT (1U)
5244 #define CSR_DEXC2DBG_IAF_SET(x) (((uint32_t)(x) << CSR_DEXC2DBG_IAF_SHIFT) & CSR_DEXC2DBG_IAF_MASK)
5245 #define CSR_DEXC2DBG_IAF_GET(x) (((uint32_t)(x) & CSR_DEXC2DBG_IAF_MASK) >> CSR_DEXC2DBG_IAF_SHIFT)
5246 
5247 /*
5248  * IAM (RW)
5249  *
5250  * Indicates whether Instruction Access Misaligned exceptions are redirected to enter Debug Mode.
5251  * 0:Do not redirect
5252  * 1:Redirect
5253  */
5254 #define CSR_DEXC2DBG_IAM_MASK (0x1U)
5255 #define CSR_DEXC2DBG_IAM_SHIFT (0U)
5256 #define CSR_DEXC2DBG_IAM_SET(x) (((uint32_t)(x) << CSR_DEXC2DBG_IAM_SHIFT) & CSR_DEXC2DBG_IAM_MASK)
5257 #define CSR_DEXC2DBG_IAM_GET(x) (((uint32_t)(x) & CSR_DEXC2DBG_IAM_MASK) >> CSR_DEXC2DBG_IAM_SHIFT)
5258 
5259 /* Bitfield definition for register: DDCAUSE */
5260 /*
5261  * SUBTYPE (RO)
5262  *
5263  * Subtypes for main type.
5264  * The table below lists the subtypes for DCSR.CAUSE==1 and DDCAUSE.MAINTYPE==3.
5265  * 0:Illegal instruction
5266  * 1:Privileged instruction
5267  * 2:Non-existent CSR
5268  * 3:Privilege CSR access
5269  * 4:Read-only CSR update
5270  */
5271 #define CSR_DDCAUSE_SUBTYPE_MASK (0xFF00U)
5272 #define CSR_DDCAUSE_SUBTYPE_SHIFT (8U)
5273 #define CSR_DDCAUSE_SUBTYPE_GET(x) (((uint32_t)(x) & CSR_DDCAUSE_SUBTYPE_MASK) >> CSR_DDCAUSE_SUBTYPE_SHIFT)
5274 
5275 /*
5276  * MAINTYPE (RO)
5277  *
5278  * Cause for redirection to Debug Mode.
5279  * 0:Software Breakpoint (EBREAK)
5280  * 1:Instruction Access Misaligned (IAM)
5281  * 2:Instruction Access Fault (IAF)
5282  * 3:Illegal Instruction (II)
5283  * 4:Non-Maskable Interrupt (NMI)
5284  * 5:Load Access Misaligned (LAM)
5285  * 6:Load Access Fault (LAF)
5286  * 7:Store Access Misaligned (SAM)
5287  * 8:Store Access Fault (SAF)
5288  * 9:U-mode Environment Call (UEC)
5289  * 10:S-mode Environment Call (SEC)
5290  * 11:Instruction page fault
5291  * 12:M-mode Environment Call (MEC)
5292  * 13:Load page fault
5293  * 14:Reserved
5294  * 15:Store/AMO page fault
5295  * 16:Imprecise ECC error
5296  * 17;Bus write transaction error
5297  * 18:Performance Counter overflow
5298  * 19–31:Reserved
5299  * 32:Stack overflow exception
5300  * 33:Stack underflow exception
5301  * 34:ACE disabled exception
5302  * 35–39:Reserved
5303  * 40–47:ACE exception
5304  * ≥48:Reserved
5305  */
5306 #define CSR_DDCAUSE_MAINTYPE_MASK (0xFFU)
5307 #define CSR_DDCAUSE_MAINTYPE_SHIFT (0U)
5308 #define CSR_DDCAUSE_MAINTYPE_GET(x) (((uint32_t)(x) & CSR_DDCAUSE_MAINTYPE_MASK) >> CSR_DDCAUSE_MAINTYPE_SHIFT)
5309 
5310 /* Bitfield definition for register: UITB */
5311 /*
5312  * ADDR (RW)
5313  *
5314  * The base address of the CoDense instruction table. This field is reserved if uitb.HW == 1.
5315  */
5316 #define CSR_UITB_ADDR_MASK (0xFFFFFFFCUL)
5317 #define CSR_UITB_ADDR_SHIFT (2U)
5318 #define CSR_UITB_ADDR_SET(x) (((uint32_t)(x) << CSR_UITB_ADDR_SHIFT) & CSR_UITB_ADDR_MASK)
5319 #define CSR_UITB_ADDR_GET(x) (((uint32_t)(x) & CSR_UITB_ADDR_MASK) >> CSR_UITB_ADDR_SHIFT)
5320 
5321 /*
5322  * HW (RO)
5323  *
5324  * This bit specifies if the CoDense instruction table is hardwired.
5325  * 0:The instruction table is located in memory. uitb.ADDR should be initialized to point to the table before using the CoDense instructions.
5326  * 1:The instruction table is hardwired. Initialization of uitb.ADDR is not needed before using the CoDense instructions.
5327  */
5328 #define CSR_UITB_HW_MASK (0x1U)
5329 #define CSR_UITB_HW_SHIFT (0U)
5330 #define CSR_UITB_HW_GET(x) (((uint32_t)(x) & CSR_UITB_HW_MASK) >> CSR_UITB_HW_SHIFT)
5331 
5332 /* Bitfield definition for register: UCODE */
5333 /*
5334  * OV (RW)
5335  *
5336  * Overflow flag. It will be set by DSP instructions with a saturated result.
5337  * 0:A saturated result is not generated
5338  * 1:A saturated result is generated
5339  */
5340 #define CSR_UCODE_OV_MASK (0x1U)
5341 #define CSR_UCODE_OV_SHIFT (0U)
5342 #define CSR_UCODE_OV_SET(x) (((uint32_t)(x) << CSR_UCODE_OV_SHIFT) & CSR_UCODE_OV_MASK)
5343 #define CSR_UCODE_OV_GET(x) (((uint32_t)(x) & CSR_UCODE_OV_MASK) >> CSR_UCODE_OV_SHIFT)
5344 
5345 /* Bitfield definition for register: UDCAUSE */
5346 /*
5347  * UDCAUSE (RW)
5348  *
5349  * This register further disambiguates causes of traps recorded in the ucause register. See the list below for details.
5350  * The value of UDCAUSE for precise exception:
5351  * When ucause == 1 (Instruction access fault)
5352  * 0:Reserved
5353  * 1:ECC/Parity error
5354  * 2:PMP instruction access violation
5355  * 3:Bus error
5356  * 4:PMA empty hole access
5357  * When ucause == 2 (Illegal instruction)
5358  * 0:Please parse the utval CSR
5359  * 1:FP disabled exception
5360  * 2:ACE disabled exception
5361  * When ucause == 5 (Load access fault)
5362  * 0:Reserved
5363  * 1:ECC/Parity error
5364  * 2:PMP load access violation
5365  * 3:Bus error
5366  * 4:Misaligned address
5367  * 5:PMA empty hole access
5368  * 6:PMA attribute inconsistency
5369  * 7:PMA NAMO exception
5370  * When ucause == 7 (Store access fault)
5371  * 0:Reserved
5372  * 1:ECC/Parity error
5373  * 2:PMP store access violation
5374  * 3:Bus error
5375  * 4:Misaligned address
5376  * 5:PMA empty hole access
5377  * 6:PMA attribute inconsistency
5378  * 7:PMA NAMO exception
5379  */
5380 #define CSR_UDCAUSE_UDCAUSE_MASK (0x7U)
5381 #define CSR_UDCAUSE_UDCAUSE_SHIFT (0U)
5382 #define CSR_UDCAUSE_UDCAUSE_SET(x) (((uint32_t)(x) << CSR_UDCAUSE_UDCAUSE_SHIFT) & CSR_UDCAUSE_UDCAUSE_MASK)
5383 #define CSR_UDCAUSE_UDCAUSE_GET(x) (((uint32_t)(x) & CSR_UDCAUSE_UDCAUSE_MASK) >> CSR_UDCAUSE_UDCAUSE_SHIFT)
5384 
5385 /* Bitfield definition for register: UCCTLBEGINADDR */
5386 /*
5387  * VA (RW)
5388  *
5389  * 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.
5390  */
5391 #define CSR_UCCTLBEGINADDR_VA_MASK (0xFFFFFFFFUL)
5392 #define CSR_UCCTLBEGINADDR_VA_SHIFT (0U)
5393 #define CSR_UCCTLBEGINADDR_VA_SET(x) (((uint32_t)(x) << CSR_UCCTLBEGINADDR_VA_SHIFT) & CSR_UCCTLBEGINADDR_VA_MASK)
5394 #define CSR_UCCTLBEGINADDR_VA_GET(x) (((uint32_t)(x) & CSR_UCCTLBEGINADDR_VA_MASK) >> CSR_UCCTLBEGINADDR_VA_SHIFT)
5395 
5396 /* Bitfield definition for register: UCCTLCOMMAND */
5397 /*
5398  * VA (RW)
5399  *
5400  * See User CCTL Command Definition Table
5401  */
5402 #define CSR_UCCTLCOMMAND_VA_MASK (0x1FU)
5403 #define CSR_UCCTLCOMMAND_VA_SHIFT (0U)
5404 #define CSR_UCCTLCOMMAND_VA_SET(x) (((uint32_t)(x) << CSR_UCCTLCOMMAND_VA_SHIFT) & CSR_UCCTLCOMMAND_VA_MASK)
5405 #define CSR_UCCTLCOMMAND_VA_GET(x) (((uint32_t)(x) & CSR_UCCTLCOMMAND_VA_MASK) >> CSR_UCCTLCOMMAND_VA_SHIFT)
5406 
5407 /* Bitfield definition for register: SLIE */
5408 /*
5409  * PMOVI (RW)
5410  *
5411  * Enable S-mode performance monitor overflow local interrupt.
5412  * 0:Local interrupt is not enabled.
5413  * 1:Local interrupt is enabled
5414  */
5415 #define CSR_SLIE_PMOVI_MASK (0x40000UL)
5416 #define CSR_SLIE_PMOVI_SHIFT (18U)
5417 #define CSR_SLIE_PMOVI_SET(x) (((uint32_t)(x) << CSR_SLIE_PMOVI_SHIFT) & CSR_SLIE_PMOVI_MASK)
5418 #define CSR_SLIE_PMOVI_GET(x) (((uint32_t)(x) & CSR_SLIE_PMOVI_MASK) >> CSR_SLIE_PMOVI_SHIFT)
5419 
5420 /*
5421  * BWEI (RW)
5422  *
5423  * Enable S-mode bus read/write transaction error local interrupt. The processor may receive bus errors on load/store instructions or cache writebacks.
5424  * 0:Local interrupt is not enabled.
5425  * 1:Local interrupt is enabled
5426  */
5427 #define CSR_SLIE_BWEI_MASK (0x20000UL)
5428 #define CSR_SLIE_BWEI_SHIFT (17U)
5429 #define CSR_SLIE_BWEI_SET(x) (((uint32_t)(x) << CSR_SLIE_BWEI_SHIFT) & CSR_SLIE_BWEI_MASK)
5430 #define CSR_SLIE_BWEI_GET(x) (((uint32_t)(x) & CSR_SLIE_BWEI_MASK) >> CSR_SLIE_BWEI_SHIFT)
5431 
5432 /*
5433  * IMECCI (RW)
5434  *
5435  * Enable S-mode slave-port ECC error local interrupt.
5436  * 0:Local interrupt is not enabled.
5437  * 1:Local interrupt is enabled
5438  */
5439 #define CSR_SLIE_IMECCI_MASK (0x10000UL)
5440 #define CSR_SLIE_IMECCI_SHIFT (16U)
5441 #define CSR_SLIE_IMECCI_SET(x) (((uint32_t)(x) << CSR_SLIE_IMECCI_SHIFT) & CSR_SLIE_IMECCI_MASK)
5442 #define CSR_SLIE_IMECCI_GET(x) (((uint32_t)(x) & CSR_SLIE_IMECCI_MASK) >> CSR_SLIE_IMECCI_SHIFT)
5443 
5444 /* Bitfield definition for register: SLIP */
5445 /*
5446  * PMOVI (RW)
5447  *
5448  * Pending control and status of S-mode performance monitor overflow local interrupt.
5449  * 0:Local interrupt is not enabled.
5450  * 1:Local interrupt is enabled
5451  */
5452 #define CSR_SLIP_PMOVI_MASK (0x40000UL)
5453 #define CSR_SLIP_PMOVI_SHIFT (18U)
5454 #define CSR_SLIP_PMOVI_SET(x) (((uint32_t)(x) << CSR_SLIP_PMOVI_SHIFT) & CSR_SLIP_PMOVI_MASK)
5455 #define CSR_SLIP_PMOVI_GET(x) (((uint32_t)(x) & CSR_SLIP_PMOVI_MASK) >> CSR_SLIP_PMOVI_SHIFT)
5456 
5457 /*
5458  * BWEI (RW)
5459  *
5460  * Pending control and status of S-mode bus read/write transaction error local interrupt. The processor may receive bus errors on load/store instructions or cache writebacks.
5461  * 0:Local interrupt is not enabled.
5462  * 1:Local interrupt is enabled
5463  */
5464 #define CSR_SLIP_BWEI_MASK (0x20000UL)
5465 #define CSR_SLIP_BWEI_SHIFT (17U)
5466 #define CSR_SLIP_BWEI_SET(x) (((uint32_t)(x) << CSR_SLIP_BWEI_SHIFT) & CSR_SLIP_BWEI_MASK)
5467 #define CSR_SLIP_BWEI_GET(x) (((uint32_t)(x) & CSR_SLIP_BWEI_MASK) >> CSR_SLIP_BWEI_SHIFT)
5468 
5469 /*
5470  * IMECCI (RW)
5471  *
5472  * Pending control and status of S-mode slave-port ECC error local interrupt..
5473  * 0:Local interrupt is not enabled.
5474  * 1:Local interrupt is enabled
5475  */
5476 #define CSR_SLIP_IMECCI_MASK (0x10000UL)
5477 #define CSR_SLIP_IMECCI_SHIFT (16U)
5478 #define CSR_SLIP_IMECCI_SET(x) (((uint32_t)(x) << CSR_SLIP_IMECCI_SHIFT) & CSR_SLIP_IMECCI_MASK)
5479 #define CSR_SLIP_IMECCI_GET(x) (((uint32_t)(x) & CSR_SLIP_IMECCI_MASK) >> CSR_SLIP_IMECCI_SHIFT)
5480 
5481 /* Bitfield definition for register: SDCAUSE */
5482 /*
5483  * PM (RW)
5484  *
5485  * When scause 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 is defined as follows:
5486  * 0:User mode
5487  * 1:Supervisor mode
5488  * 2:Reserved
5489  * 3:Machine mode
5490  */
5491 #define CSR_SDCAUSE_PM_MASK (0x60U)
5492 #define CSR_SDCAUSE_PM_SHIFT (5U)
5493 #define CSR_SDCAUSE_PM_SET(x) (((uint32_t)(x) << CSR_SDCAUSE_PM_SHIFT) & CSR_SDCAUSE_PM_MASK)
5494 #define CSR_SDCAUSE_PM_GET(x) (((uint32_t)(x) & CSR_SDCAUSE_PM_MASK) >> CSR_SDCAUSE_PM_SHIFT)
5495 
5496 /*
5497  * SDCAUSE (RW)
5498  *
5499  * This register further disambiguates causes of traps recorded in the scause register. See the list below for details.
5500  * The value of SDCAUSE for precise exception:
5501  * When scause == 1 (Instruction access fault):
5502  * 0:Reserved; 1:ECC/Parity error; 2:PMP instruction access violation; 3:Bus error; 4:PMA empty hole access
5503  * When scause == 2 (Illegal instruction):
5504  * 0:Please parse the stval CSR; 1:FP disabled exception; 2:ACE disabled exception
5505  * When scause == 5 (Load access fault):
5506  * 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
5507  * When scause == 7 (Store access fault):
5508  * 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
5509  * The value of SDCAUSE for imprecise exception:
5510  * When scause == Local Interrupt 16 or Local Interrupt 272 (16 + 256) (ECC error local interrupt)
5511  * 0:Reserved; 1:LM slave port ECC/Parity error; 2:Imprecise store ECC/Parity error; 3:Imprecise load ECC/Parity error
5512  * When scause == Local Interrupt 17 or Local Interrupt 273 (17 + 256) (Bus read/write transaction error local interrupt)
5513  * 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
5514  */
5515 #define CSR_SDCAUSE_SDCAUSE_MASK (0x7U)
5516 #define CSR_SDCAUSE_SDCAUSE_SHIFT (0U)
5517 #define CSR_SDCAUSE_SDCAUSE_SET(x) (((uint32_t)(x) << CSR_SDCAUSE_SDCAUSE_SHIFT) & CSR_SDCAUSE_SDCAUSE_MASK)
5518 #define CSR_SDCAUSE_SDCAUSE_GET(x) (((uint32_t)(x) & CSR_SDCAUSE_SDCAUSE_MASK) >> CSR_SDCAUSE_SDCAUSE_SHIFT)
5519 
5520 /* Bitfield definition for register: SCCTLDATA */
5521 /*
5522  * VA (RW)
5523  *
5524  * See CCTL Commands Which Access mcctldata Table
5525  */
5526 #define CSR_SCCTLDATA_VA_MASK (0x1FU)
5527 #define CSR_SCCTLDATA_VA_SHIFT (0U)
5528 #define CSR_SCCTLDATA_VA_SET(x) (((uint32_t)(x) << CSR_SCCTLDATA_VA_SHIFT) & CSR_SCCTLDATA_VA_MASK)
5529 #define CSR_SCCTLDATA_VA_GET(x) (((uint32_t)(x) & CSR_SCCTLDATA_VA_MASK) >> CSR_SCCTLDATA_VA_SHIFT)
5530 
5531 /* Bitfield definition for register: SCOUNTERINTEN */
5532 /*
5533  * HPM6 (RW)
5534  *
5535  * See register description
5536  */
5537 #define CSR_SCOUNTERINTEN_HPM6_MASK (0x40U)
5538 #define CSR_SCOUNTERINTEN_HPM6_SHIFT (6U)
5539 #define CSR_SCOUNTERINTEN_HPM6_SET(x) (((uint32_t)(x) << CSR_SCOUNTERINTEN_HPM6_SHIFT) & CSR_SCOUNTERINTEN_HPM6_MASK)
5540 #define CSR_SCOUNTERINTEN_HPM6_GET(x) (((uint32_t)(x) & CSR_SCOUNTERINTEN_HPM6_MASK) >> CSR_SCOUNTERINTEN_HPM6_SHIFT)
5541 
5542 /*
5543  * HPM5 (RW)
5544  *
5545  * See register description
5546  */
5547 #define CSR_SCOUNTERINTEN_HPM5_MASK (0x20U)
5548 #define CSR_SCOUNTERINTEN_HPM5_SHIFT (5U)
5549 #define CSR_SCOUNTERINTEN_HPM5_SET(x) (((uint32_t)(x) << CSR_SCOUNTERINTEN_HPM5_SHIFT) & CSR_SCOUNTERINTEN_HPM5_MASK)
5550 #define CSR_SCOUNTERINTEN_HPM5_GET(x) (((uint32_t)(x) & CSR_SCOUNTERINTEN_HPM5_MASK) >> CSR_SCOUNTERINTEN_HPM5_SHIFT)
5551 
5552 /*
5553  * HPM4 (RW)
5554  *
5555  * See register description
5556  */
5557 #define CSR_SCOUNTERINTEN_HPM4_MASK (0x10U)
5558 #define CSR_SCOUNTERINTEN_HPM4_SHIFT (4U)
5559 #define CSR_SCOUNTERINTEN_HPM4_SET(x) (((uint32_t)(x) << CSR_SCOUNTERINTEN_HPM4_SHIFT) & CSR_SCOUNTERINTEN_HPM4_MASK)
5560 #define CSR_SCOUNTERINTEN_HPM4_GET(x) (((uint32_t)(x) & CSR_SCOUNTERINTEN_HPM4_MASK) >> CSR_SCOUNTERINTEN_HPM4_SHIFT)
5561 
5562 /*
5563  * HPM3 (RW)
5564  *
5565  * See register description
5566  */
5567 #define CSR_SCOUNTERINTEN_HPM3_MASK (0x8U)
5568 #define CSR_SCOUNTERINTEN_HPM3_SHIFT (3U)
5569 #define CSR_SCOUNTERINTEN_HPM3_SET(x) (((uint32_t)(x) << CSR_SCOUNTERINTEN_HPM3_SHIFT) & CSR_SCOUNTERINTEN_HPM3_MASK)
5570 #define CSR_SCOUNTERINTEN_HPM3_GET(x) (((uint32_t)(x) & CSR_SCOUNTERINTEN_HPM3_MASK) >> CSR_SCOUNTERINTEN_HPM3_SHIFT)
5571 
5572 /*
5573  * IR (RW)
5574  *
5575  * See register description
5576  */
5577 #define CSR_SCOUNTERINTEN_IR_MASK (0x4U)
5578 #define CSR_SCOUNTERINTEN_IR_SHIFT (2U)
5579 #define CSR_SCOUNTERINTEN_IR_SET(x) (((uint32_t)(x) << CSR_SCOUNTERINTEN_IR_SHIFT) & CSR_SCOUNTERINTEN_IR_MASK)
5580 #define CSR_SCOUNTERINTEN_IR_GET(x) (((uint32_t)(x) & CSR_SCOUNTERINTEN_IR_MASK) >> CSR_SCOUNTERINTEN_IR_SHIFT)
5581 
5582 /*
5583  * CY (RW)
5584  *
5585  * See register description
5586  */
5587 #define CSR_SCOUNTERINTEN_CY_MASK (0x1U)
5588 #define CSR_SCOUNTERINTEN_CY_SHIFT (0U)
5589 #define CSR_SCOUNTERINTEN_CY_SET(x) (((uint32_t)(x) << CSR_SCOUNTERINTEN_CY_SHIFT) & CSR_SCOUNTERINTEN_CY_MASK)
5590 #define CSR_SCOUNTERINTEN_CY_GET(x) (((uint32_t)(x) & CSR_SCOUNTERINTEN_CY_MASK) >> CSR_SCOUNTERINTEN_CY_SHIFT)
5591 
5592 /* Bitfield definition for register: SCOUNTERMASK_M */
5593 /*
5594  * HPM6 (RW)
5595  *
5596  * See register description
5597  */
5598 #define CSR_SCOUNTERMASK_M_HPM6_MASK (0x40U)
5599 #define CSR_SCOUNTERMASK_M_HPM6_SHIFT (6U)
5600 #define CSR_SCOUNTERMASK_M_HPM6_SET(x) (((uint32_t)(x) << CSR_SCOUNTERMASK_M_HPM6_SHIFT) & CSR_SCOUNTERMASK_M_HPM6_MASK)
5601 #define CSR_SCOUNTERMASK_M_HPM6_GET(x) (((uint32_t)(x) & CSR_SCOUNTERMASK_M_HPM6_MASK) >> CSR_SCOUNTERMASK_M_HPM6_SHIFT)
5602 
5603 /*
5604  * HPM5 (RW)
5605  *
5606  * See register description
5607  */
5608 #define CSR_SCOUNTERMASK_M_HPM5_MASK (0x20U)
5609 #define CSR_SCOUNTERMASK_M_HPM5_SHIFT (5U)
5610 #define CSR_SCOUNTERMASK_M_HPM5_SET(x) (((uint32_t)(x) << CSR_SCOUNTERMASK_M_HPM5_SHIFT) & CSR_SCOUNTERMASK_M_HPM5_MASK)
5611 #define CSR_SCOUNTERMASK_M_HPM5_GET(x) (((uint32_t)(x) & CSR_SCOUNTERMASK_M_HPM5_MASK) >> CSR_SCOUNTERMASK_M_HPM5_SHIFT)
5612 
5613 /*
5614  * HPM4 (RW)
5615  *
5616  * See register description
5617  */
5618 #define CSR_SCOUNTERMASK_M_HPM4_MASK (0x10U)
5619 #define CSR_SCOUNTERMASK_M_HPM4_SHIFT (4U)
5620 #define CSR_SCOUNTERMASK_M_HPM4_SET(x) (((uint32_t)(x) << CSR_SCOUNTERMASK_M_HPM4_SHIFT) & CSR_SCOUNTERMASK_M_HPM4_MASK)
5621 #define CSR_SCOUNTERMASK_M_HPM4_GET(x) (((uint32_t)(x) & CSR_SCOUNTERMASK_M_HPM4_MASK) >> CSR_SCOUNTERMASK_M_HPM4_SHIFT)
5622 
5623 /*
5624  * HPM3 (RW)
5625  *
5626  * See register description
5627  */
5628 #define CSR_SCOUNTERMASK_M_HPM3_MASK (0x8U)
5629 #define CSR_SCOUNTERMASK_M_HPM3_SHIFT (3U)
5630 #define CSR_SCOUNTERMASK_M_HPM3_SET(x) (((uint32_t)(x) << CSR_SCOUNTERMASK_M_HPM3_SHIFT) & CSR_SCOUNTERMASK_M_HPM3_MASK)
5631 #define CSR_SCOUNTERMASK_M_HPM3_GET(x) (((uint32_t)(x) & CSR_SCOUNTERMASK_M_HPM3_MASK) >> CSR_SCOUNTERMASK_M_HPM3_SHIFT)
5632 
5633 /*
5634  * IR (RW)
5635  *
5636  * See register description
5637  */
5638 #define CSR_SCOUNTERMASK_M_IR_MASK (0x4U)
5639 #define CSR_SCOUNTERMASK_M_IR_SHIFT (2U)
5640 #define CSR_SCOUNTERMASK_M_IR_SET(x) (((uint32_t)(x) << CSR_SCOUNTERMASK_M_IR_SHIFT) & CSR_SCOUNTERMASK_M_IR_MASK)
5641 #define CSR_SCOUNTERMASK_M_IR_GET(x) (((uint32_t)(x) & CSR_SCOUNTERMASK_M_IR_MASK) >> CSR_SCOUNTERMASK_M_IR_SHIFT)
5642 
5643 /*
5644  * CY (RW)
5645  *
5646  * See register description
5647  */
5648 #define CSR_SCOUNTERMASK_M_CY_MASK (0x1U)
5649 #define CSR_SCOUNTERMASK_M_CY_SHIFT (0U)
5650 #define CSR_SCOUNTERMASK_M_CY_SET(x) (((uint32_t)(x) << CSR_SCOUNTERMASK_M_CY_SHIFT) & CSR_SCOUNTERMASK_M_CY_MASK)
5651 #define CSR_SCOUNTERMASK_M_CY_GET(x) (((uint32_t)(x) & CSR_SCOUNTERMASK_M_CY_MASK) >> CSR_SCOUNTERMASK_M_CY_SHIFT)
5652 
5653 /* Bitfield definition for register: SCOUNTERMASK_S */
5654 /*
5655  * HPM6 (RW)
5656  *
5657  * See register description
5658  */
5659 #define CSR_SCOUNTERMASK_S_HPM6_MASK (0x40U)
5660 #define CSR_SCOUNTERMASK_S_HPM6_SHIFT (6U)
5661 #define CSR_SCOUNTERMASK_S_HPM6_SET(x) (((uint32_t)(x) << CSR_SCOUNTERMASK_S_HPM6_SHIFT) & CSR_SCOUNTERMASK_S_HPM6_MASK)
5662 #define CSR_SCOUNTERMASK_S_HPM6_GET(x) (((uint32_t)(x) & CSR_SCOUNTERMASK_S_HPM6_MASK) >> CSR_SCOUNTERMASK_S_HPM6_SHIFT)
5663 
5664 /*
5665  * HPM5 (RW)
5666  *
5667  * See register description
5668  */
5669 #define CSR_SCOUNTERMASK_S_HPM5_MASK (0x20U)
5670 #define CSR_SCOUNTERMASK_S_HPM5_SHIFT (5U)
5671 #define CSR_SCOUNTERMASK_S_HPM5_SET(x) (((uint32_t)(x) << CSR_SCOUNTERMASK_S_HPM5_SHIFT) & CSR_SCOUNTERMASK_S_HPM5_MASK)
5672 #define CSR_SCOUNTERMASK_S_HPM5_GET(x) (((uint32_t)(x) & CSR_SCOUNTERMASK_S_HPM5_MASK) >> CSR_SCOUNTERMASK_S_HPM5_SHIFT)
5673 
5674 /*
5675  * HPM4 (RW)
5676  *
5677  * See register description
5678  */
5679 #define CSR_SCOUNTERMASK_S_HPM4_MASK (0x10U)
5680 #define CSR_SCOUNTERMASK_S_HPM4_SHIFT (4U)
5681 #define CSR_SCOUNTERMASK_S_HPM4_SET(x) (((uint32_t)(x) << CSR_SCOUNTERMASK_S_HPM4_SHIFT) & CSR_SCOUNTERMASK_S_HPM4_MASK)
5682 #define CSR_SCOUNTERMASK_S_HPM4_GET(x) (((uint32_t)(x) & CSR_SCOUNTERMASK_S_HPM4_MASK) >> CSR_SCOUNTERMASK_S_HPM4_SHIFT)
5683 
5684 /*
5685  * HPM3 (RW)
5686  *
5687  * See register description
5688  */
5689 #define CSR_SCOUNTERMASK_S_HPM3_MASK (0x8U)
5690 #define CSR_SCOUNTERMASK_S_HPM3_SHIFT (3U)
5691 #define CSR_SCOUNTERMASK_S_HPM3_SET(x) (((uint32_t)(x) << CSR_SCOUNTERMASK_S_HPM3_SHIFT) & CSR_SCOUNTERMASK_S_HPM3_MASK)
5692 #define CSR_SCOUNTERMASK_S_HPM3_GET(x) (((uint32_t)(x) & CSR_SCOUNTERMASK_S_HPM3_MASK) >> CSR_SCOUNTERMASK_S_HPM3_SHIFT)
5693 
5694 /*
5695  * IR (RW)
5696  *
5697  * See register description
5698  */
5699 #define CSR_SCOUNTERMASK_S_IR_MASK (0x4U)
5700 #define CSR_SCOUNTERMASK_S_IR_SHIFT (2U)
5701 #define CSR_SCOUNTERMASK_S_IR_SET(x) (((uint32_t)(x) << CSR_SCOUNTERMASK_S_IR_SHIFT) & CSR_SCOUNTERMASK_S_IR_MASK)
5702 #define CSR_SCOUNTERMASK_S_IR_GET(x) (((uint32_t)(x) & CSR_SCOUNTERMASK_S_IR_MASK) >> CSR_SCOUNTERMASK_S_IR_SHIFT)
5703 
5704 /*
5705  * CY (RW)
5706  *
5707  * See register description
5708  */
5709 #define CSR_SCOUNTERMASK_S_CY_MASK (0x1U)
5710 #define CSR_SCOUNTERMASK_S_CY_SHIFT (0U)
5711 #define CSR_SCOUNTERMASK_S_CY_SET(x) (((uint32_t)(x) << CSR_SCOUNTERMASK_S_CY_SHIFT) & CSR_SCOUNTERMASK_S_CY_MASK)
5712 #define CSR_SCOUNTERMASK_S_CY_GET(x) (((uint32_t)(x) & CSR_SCOUNTERMASK_S_CY_MASK) >> CSR_SCOUNTERMASK_S_CY_SHIFT)
5713 
5714 /* Bitfield definition for register: SCOUNTERMASK_U */
5715 /*
5716  * HPM6 (RW)
5717  *
5718  * See register description
5719  */
5720 #define CSR_SCOUNTERMASK_U_HPM6_MASK (0x40U)
5721 #define CSR_SCOUNTERMASK_U_HPM6_SHIFT (6U)
5722 #define CSR_SCOUNTERMASK_U_HPM6_SET(x) (((uint32_t)(x) << CSR_SCOUNTERMASK_U_HPM6_SHIFT) & CSR_SCOUNTERMASK_U_HPM6_MASK)
5723 #define CSR_SCOUNTERMASK_U_HPM6_GET(x) (((uint32_t)(x) & CSR_SCOUNTERMASK_U_HPM6_MASK) >> CSR_SCOUNTERMASK_U_HPM6_SHIFT)
5724 
5725 /*
5726  * HPM5 (RW)
5727  *
5728  * See register description
5729  */
5730 #define CSR_SCOUNTERMASK_U_HPM5_MASK (0x20U)
5731 #define CSR_SCOUNTERMASK_U_HPM5_SHIFT (5U)
5732 #define CSR_SCOUNTERMASK_U_HPM5_SET(x) (((uint32_t)(x) << CSR_SCOUNTERMASK_U_HPM5_SHIFT) & CSR_SCOUNTERMASK_U_HPM5_MASK)
5733 #define CSR_SCOUNTERMASK_U_HPM5_GET(x) (((uint32_t)(x) & CSR_SCOUNTERMASK_U_HPM5_MASK) >> CSR_SCOUNTERMASK_U_HPM5_SHIFT)
5734 
5735 /*
5736  * HPM4 (RW)
5737  *
5738  * See register description
5739  */
5740 #define CSR_SCOUNTERMASK_U_HPM4_MASK (0x10U)
5741 #define CSR_SCOUNTERMASK_U_HPM4_SHIFT (4U)
5742 #define CSR_SCOUNTERMASK_U_HPM4_SET(x) (((uint32_t)(x) << CSR_SCOUNTERMASK_U_HPM4_SHIFT) & CSR_SCOUNTERMASK_U_HPM4_MASK)
5743 #define CSR_SCOUNTERMASK_U_HPM4_GET(x) (((uint32_t)(x) & CSR_SCOUNTERMASK_U_HPM4_MASK) >> CSR_SCOUNTERMASK_U_HPM4_SHIFT)
5744 
5745 /*
5746  * HPM3 (RW)
5747  *
5748  * See register description
5749  */
5750 #define CSR_SCOUNTERMASK_U_HPM3_MASK (0x8U)
5751 #define CSR_SCOUNTERMASK_U_HPM3_SHIFT (3U)
5752 #define CSR_SCOUNTERMASK_U_HPM3_SET(x) (((uint32_t)(x) << CSR_SCOUNTERMASK_U_HPM3_SHIFT) & CSR_SCOUNTERMASK_U_HPM3_MASK)
5753 #define CSR_SCOUNTERMASK_U_HPM3_GET(x) (((uint32_t)(x) & CSR_SCOUNTERMASK_U_HPM3_MASK) >> CSR_SCOUNTERMASK_U_HPM3_SHIFT)
5754 
5755 /*
5756  * IR (RW)
5757  *
5758  * See register description
5759  */
5760 #define CSR_SCOUNTERMASK_U_IR_MASK (0x4U)
5761 #define CSR_SCOUNTERMASK_U_IR_SHIFT (2U)
5762 #define CSR_SCOUNTERMASK_U_IR_SET(x) (((uint32_t)(x) << CSR_SCOUNTERMASK_U_IR_SHIFT) & CSR_SCOUNTERMASK_U_IR_MASK)
5763 #define CSR_SCOUNTERMASK_U_IR_GET(x) (((uint32_t)(x) & CSR_SCOUNTERMASK_U_IR_MASK) >> CSR_SCOUNTERMASK_U_IR_SHIFT)
5764 
5765 /*
5766  * CY (RW)
5767  *
5768  * See register description
5769  */
5770 #define CSR_SCOUNTERMASK_U_CY_MASK (0x1U)
5771 #define CSR_SCOUNTERMASK_U_CY_SHIFT (0U)
5772 #define CSR_SCOUNTERMASK_U_CY_SET(x) (((uint32_t)(x) << CSR_SCOUNTERMASK_U_CY_SHIFT) & CSR_SCOUNTERMASK_U_CY_MASK)
5773 #define CSR_SCOUNTERMASK_U_CY_GET(x) (((uint32_t)(x) & CSR_SCOUNTERMASK_U_CY_MASK) >> CSR_SCOUNTERMASK_U_CY_SHIFT)
5774 
5775 /* Bitfield definition for register: SCOUNTEROVF */
5776 /*
5777  * HPM6 (RW)
5778  *
5779  * See register description
5780  */
5781 #define CSR_SCOUNTEROVF_HPM6_MASK (0x40U)
5782 #define CSR_SCOUNTEROVF_HPM6_SHIFT (6U)
5783 #define CSR_SCOUNTEROVF_HPM6_SET(x) (((uint32_t)(x) << CSR_SCOUNTEROVF_HPM6_SHIFT) & CSR_SCOUNTEROVF_HPM6_MASK)
5784 #define CSR_SCOUNTEROVF_HPM6_GET(x) (((uint32_t)(x) & CSR_SCOUNTEROVF_HPM6_MASK) >> CSR_SCOUNTEROVF_HPM6_SHIFT)
5785 
5786 /*
5787  * HPM5 (RW)
5788  *
5789  * See register description
5790  */
5791 #define CSR_SCOUNTEROVF_HPM5_MASK (0x20U)
5792 #define CSR_SCOUNTEROVF_HPM5_SHIFT (5U)
5793 #define CSR_SCOUNTEROVF_HPM5_SET(x) (((uint32_t)(x) << CSR_SCOUNTEROVF_HPM5_SHIFT) & CSR_SCOUNTEROVF_HPM5_MASK)
5794 #define CSR_SCOUNTEROVF_HPM5_GET(x) (((uint32_t)(x) & CSR_SCOUNTEROVF_HPM5_MASK) >> CSR_SCOUNTEROVF_HPM5_SHIFT)
5795 
5796 /*
5797  * HPM4 (RW)
5798  *
5799  * See register description
5800  */
5801 #define CSR_SCOUNTEROVF_HPM4_MASK (0x10U)
5802 #define CSR_SCOUNTEROVF_HPM4_SHIFT (4U)
5803 #define CSR_SCOUNTEROVF_HPM4_SET(x) (((uint32_t)(x) << CSR_SCOUNTEROVF_HPM4_SHIFT) & CSR_SCOUNTEROVF_HPM4_MASK)
5804 #define CSR_SCOUNTEROVF_HPM4_GET(x) (((uint32_t)(x) & CSR_SCOUNTEROVF_HPM4_MASK) >> CSR_SCOUNTEROVF_HPM4_SHIFT)
5805 
5806 /*
5807  * HPM3 (RW)
5808  *
5809  * See register description
5810  */
5811 #define CSR_SCOUNTEROVF_HPM3_MASK (0x8U)
5812 #define CSR_SCOUNTEROVF_HPM3_SHIFT (3U)
5813 #define CSR_SCOUNTEROVF_HPM3_SET(x) (((uint32_t)(x) << CSR_SCOUNTEROVF_HPM3_SHIFT) & CSR_SCOUNTEROVF_HPM3_MASK)
5814 #define CSR_SCOUNTEROVF_HPM3_GET(x) (((uint32_t)(x) & CSR_SCOUNTEROVF_HPM3_MASK) >> CSR_SCOUNTEROVF_HPM3_SHIFT)
5815 
5816 /*
5817  * IR (RW)
5818  *
5819  * See register description
5820  */
5821 #define CSR_SCOUNTEROVF_IR_MASK (0x4U)
5822 #define CSR_SCOUNTEROVF_IR_SHIFT (2U)
5823 #define CSR_SCOUNTEROVF_IR_SET(x) (((uint32_t)(x) << CSR_SCOUNTEROVF_IR_SHIFT) & CSR_SCOUNTEROVF_IR_MASK)
5824 #define CSR_SCOUNTEROVF_IR_GET(x) (((uint32_t)(x) & CSR_SCOUNTEROVF_IR_MASK) >> CSR_SCOUNTEROVF_IR_SHIFT)
5825 
5826 /*
5827  * CY (RW)
5828  *
5829  * See register description
5830  */
5831 #define CSR_SCOUNTEROVF_CY_MASK (0x1U)
5832 #define CSR_SCOUNTEROVF_CY_SHIFT (0U)
5833 #define CSR_SCOUNTEROVF_CY_SET(x) (((uint32_t)(x) << CSR_SCOUNTEROVF_CY_SHIFT) & CSR_SCOUNTEROVF_CY_MASK)
5834 #define CSR_SCOUNTEROVF_CY_GET(x) (((uint32_t)(x) & CSR_SCOUNTEROVF_CY_MASK) >> CSR_SCOUNTEROVF_CY_SHIFT)
5835 
5836 /* Bitfield definition for register: SCOUNTINHIBIT */
5837 /*
5838  * HPM6 (RW)
5839  *
5840  * See register description
5841  */
5842 #define CSR_SCOUNTINHIBIT_HPM6_MASK (0x40U)
5843 #define CSR_SCOUNTINHIBIT_HPM6_SHIFT (6U)
5844 #define CSR_SCOUNTINHIBIT_HPM6_SET(x) (((uint32_t)(x) << CSR_SCOUNTINHIBIT_HPM6_SHIFT) & CSR_SCOUNTINHIBIT_HPM6_MASK)
5845 #define CSR_SCOUNTINHIBIT_HPM6_GET(x) (((uint32_t)(x) & CSR_SCOUNTINHIBIT_HPM6_MASK) >> CSR_SCOUNTINHIBIT_HPM6_SHIFT)
5846 
5847 /*
5848  * HPM5 (RW)
5849  *
5850  * See register description
5851  */
5852 #define CSR_SCOUNTINHIBIT_HPM5_MASK (0x20U)
5853 #define CSR_SCOUNTINHIBIT_HPM5_SHIFT (5U)
5854 #define CSR_SCOUNTINHIBIT_HPM5_SET(x) (((uint32_t)(x) << CSR_SCOUNTINHIBIT_HPM5_SHIFT) & CSR_SCOUNTINHIBIT_HPM5_MASK)
5855 #define CSR_SCOUNTINHIBIT_HPM5_GET(x) (((uint32_t)(x) & CSR_SCOUNTINHIBIT_HPM5_MASK) >> CSR_SCOUNTINHIBIT_HPM5_SHIFT)
5856 
5857 /*
5858  * HPM4 (RW)
5859  *
5860  * See register description
5861  */
5862 #define CSR_SCOUNTINHIBIT_HPM4_MASK (0x10U)
5863 #define CSR_SCOUNTINHIBIT_HPM4_SHIFT (4U)
5864 #define CSR_SCOUNTINHIBIT_HPM4_SET(x) (((uint32_t)(x) << CSR_SCOUNTINHIBIT_HPM4_SHIFT) & CSR_SCOUNTINHIBIT_HPM4_MASK)
5865 #define CSR_SCOUNTINHIBIT_HPM4_GET(x) (((uint32_t)(x) & CSR_SCOUNTINHIBIT_HPM4_MASK) >> CSR_SCOUNTINHIBIT_HPM4_SHIFT)
5866 
5867 /*
5868  * HPM3 (RW)
5869  *
5870  * See register description
5871  */
5872 #define CSR_SCOUNTINHIBIT_HPM3_MASK (0x8U)
5873 #define CSR_SCOUNTINHIBIT_HPM3_SHIFT (3U)
5874 #define CSR_SCOUNTINHIBIT_HPM3_SET(x) (((uint32_t)(x) << CSR_SCOUNTINHIBIT_HPM3_SHIFT) & CSR_SCOUNTINHIBIT_HPM3_MASK)
5875 #define CSR_SCOUNTINHIBIT_HPM3_GET(x) (((uint32_t)(x) & CSR_SCOUNTINHIBIT_HPM3_MASK) >> CSR_SCOUNTINHIBIT_HPM3_SHIFT)
5876 
5877 /*
5878  * IR (RW)
5879  *
5880  * See register description
5881  */
5882 #define CSR_SCOUNTINHIBIT_IR_MASK (0x4U)
5883 #define CSR_SCOUNTINHIBIT_IR_SHIFT (2U)
5884 #define CSR_SCOUNTINHIBIT_IR_SET(x) (((uint32_t)(x) << CSR_SCOUNTINHIBIT_IR_SHIFT) & CSR_SCOUNTINHIBIT_IR_MASK)
5885 #define CSR_SCOUNTINHIBIT_IR_GET(x) (((uint32_t)(x) & CSR_SCOUNTINHIBIT_IR_MASK) >> CSR_SCOUNTINHIBIT_IR_SHIFT)
5886 
5887 /*
5888  * TM (RW)
5889  *
5890  * See register description
5891  */
5892 #define CSR_SCOUNTINHIBIT_TM_MASK (0x2U)
5893 #define CSR_SCOUNTINHIBIT_TM_SHIFT (1U)
5894 #define CSR_SCOUNTINHIBIT_TM_SET(x) (((uint32_t)(x) << CSR_SCOUNTINHIBIT_TM_SHIFT) & CSR_SCOUNTINHIBIT_TM_MASK)
5895 #define CSR_SCOUNTINHIBIT_TM_GET(x) (((uint32_t)(x) & CSR_SCOUNTINHIBIT_TM_MASK) >> CSR_SCOUNTINHIBIT_TM_SHIFT)
5896 
5897 /*
5898  * CY (RW)
5899  *
5900  * See register description
5901  */
5902 #define CSR_SCOUNTINHIBIT_CY_MASK (0x1U)
5903 #define CSR_SCOUNTINHIBIT_CY_SHIFT (0U)
5904 #define CSR_SCOUNTINHIBIT_CY_SET(x) (((uint32_t)(x) << CSR_SCOUNTINHIBIT_CY_SHIFT) & CSR_SCOUNTINHIBIT_CY_MASK)
5905 #define CSR_SCOUNTINHIBIT_CY_GET(x) (((uint32_t)(x) & CSR_SCOUNTINHIBIT_CY_MASK) >> CSR_SCOUNTINHIBIT_CY_SHIFT)
5906 
5907 /* Bitfield definition for register: SHPMEVENT3 */
5908 /*
5909  * SEL (RW)
5910  *
5911  * See Event Selectors table
5912  */
5913 #define CSR_SHPMEVENT3_SEL_MASK (0x1F0U)
5914 #define CSR_SHPMEVENT3_SEL_SHIFT (4U)
5915 #define CSR_SHPMEVENT3_SEL_SET(x) (((uint32_t)(x) << CSR_SHPMEVENT3_SEL_SHIFT) & CSR_SHPMEVENT3_SEL_MASK)
5916 #define CSR_SHPMEVENT3_SEL_GET(x) (((uint32_t)(x) & CSR_SHPMEVENT3_SEL_MASK) >> CSR_SHPMEVENT3_SEL_SHIFT)
5917 
5918 /*
5919  * TYPE (RW)
5920  *
5921  * See Event Selectors table
5922  */
5923 #define CSR_SHPMEVENT3_TYPE_MASK (0xFU)
5924 #define CSR_SHPMEVENT3_TYPE_SHIFT (0U)
5925 #define CSR_SHPMEVENT3_TYPE_SET(x) (((uint32_t)(x) << CSR_SHPMEVENT3_TYPE_SHIFT) & CSR_SHPMEVENT3_TYPE_MASK)
5926 #define CSR_SHPMEVENT3_TYPE_GET(x) (((uint32_t)(x) & CSR_SHPMEVENT3_TYPE_MASK) >> CSR_SHPMEVENT3_TYPE_SHIFT)
5927 
5928 /* Bitfield definition for register: SHPMEVENT4 */
5929 /*
5930  * SEL (RW)
5931  *
5932  * See Event Selectors table
5933  */
5934 #define CSR_SHPMEVENT4_SEL_MASK (0x1F0U)
5935 #define CSR_SHPMEVENT4_SEL_SHIFT (4U)
5936 #define CSR_SHPMEVENT4_SEL_SET(x) (((uint32_t)(x) << CSR_SHPMEVENT4_SEL_SHIFT) & CSR_SHPMEVENT4_SEL_MASK)
5937 #define CSR_SHPMEVENT4_SEL_GET(x) (((uint32_t)(x) & CSR_SHPMEVENT4_SEL_MASK) >> CSR_SHPMEVENT4_SEL_SHIFT)
5938 
5939 /*
5940  * TYPE (RW)
5941  *
5942  * See Event Selectors table
5943  */
5944 #define CSR_SHPMEVENT4_TYPE_MASK (0xFU)
5945 #define CSR_SHPMEVENT4_TYPE_SHIFT (0U)
5946 #define CSR_SHPMEVENT4_TYPE_SET(x) (((uint32_t)(x) << CSR_SHPMEVENT4_TYPE_SHIFT) & CSR_SHPMEVENT4_TYPE_MASK)
5947 #define CSR_SHPMEVENT4_TYPE_GET(x) (((uint32_t)(x) & CSR_SHPMEVENT4_TYPE_MASK) >> CSR_SHPMEVENT4_TYPE_SHIFT)
5948 
5949 /* Bitfield definition for register: SHPMEVENT5 */
5950 /*
5951  * SEL (RW)
5952  *
5953  * See Event Selectors table
5954  */
5955 #define CSR_SHPMEVENT5_SEL_MASK (0x1F0U)
5956 #define CSR_SHPMEVENT5_SEL_SHIFT (4U)
5957 #define CSR_SHPMEVENT5_SEL_SET(x) (((uint32_t)(x) << CSR_SHPMEVENT5_SEL_SHIFT) & CSR_SHPMEVENT5_SEL_MASK)
5958 #define CSR_SHPMEVENT5_SEL_GET(x) (((uint32_t)(x) & CSR_SHPMEVENT5_SEL_MASK) >> CSR_SHPMEVENT5_SEL_SHIFT)
5959 
5960 /*
5961  * TYPE (RW)
5962  *
5963  * See Event Selectors table
5964  */
5965 #define CSR_SHPMEVENT5_TYPE_MASK (0xFU)
5966 #define CSR_SHPMEVENT5_TYPE_SHIFT (0U)
5967 #define CSR_SHPMEVENT5_TYPE_SET(x) (((uint32_t)(x) << CSR_SHPMEVENT5_TYPE_SHIFT) & CSR_SHPMEVENT5_TYPE_MASK)
5968 #define CSR_SHPMEVENT5_TYPE_GET(x) (((uint32_t)(x) & CSR_SHPMEVENT5_TYPE_MASK) >> CSR_SHPMEVENT5_TYPE_SHIFT)
5969 
5970 /* Bitfield definition for register: SHPMEVENT6 */
5971 /*
5972  * SEL (RW)
5973  *
5974  * See Event Selectors table
5975  */
5976 #define CSR_SHPMEVENT6_SEL_MASK (0x1F0U)
5977 #define CSR_SHPMEVENT6_SEL_SHIFT (4U)
5978 #define CSR_SHPMEVENT6_SEL_SET(x) (((uint32_t)(x) << CSR_SHPMEVENT6_SEL_SHIFT) & CSR_SHPMEVENT6_SEL_MASK)
5979 #define CSR_SHPMEVENT6_SEL_GET(x) (((uint32_t)(x) & CSR_SHPMEVENT6_SEL_MASK) >> CSR_SHPMEVENT6_SEL_SHIFT)
5980 
5981 /*
5982  * TYPE (RW)
5983  *
5984  * See Event Selectors table
5985  */
5986 #define CSR_SHPMEVENT6_TYPE_MASK (0xFU)
5987 #define CSR_SHPMEVENT6_TYPE_SHIFT (0U)
5988 #define CSR_SHPMEVENT6_TYPE_SET(x) (((uint32_t)(x) << CSR_SHPMEVENT6_TYPE_SHIFT) & CSR_SHPMEVENT6_TYPE_MASK)
5989 #define CSR_SHPMEVENT6_TYPE_GET(x) (((uint32_t)(x) & CSR_SHPMEVENT6_TYPE_MASK) >> CSR_SHPMEVENT6_TYPE_SHIFT)
5990 
5991 /* Bitfield definition for register: MICM_CFG */
5992 /*
5993  * SETH (RO)
5994  *
5995  * This bit extends the ISET field.
5996  * When instruction cache is not configured, this field should be ignored.
5997  */
5998 #define CSR_MICM_CFG_SETH_MASK (0x1000000UL)
5999 #define CSR_MICM_CFG_SETH_SHIFT (24U)
6000 #define CSR_MICM_CFG_SETH_GET(x) (((uint32_t)(x) & CSR_MICM_CFG_SETH_MASK) >> CSR_MICM_CFG_SETH_SHIFT)
6001 
6002 /*
6003  * ILM_ECC (RO)
6004  *
6005  * ILM soft-error protection scheme
6006  * 0:No parity/ECC
6007  * 1:Parity
6008  * 2:ECC
6009  * 3:Reserved
6010  * ILM is not configured, this field should be ignored.
6011  */
6012 #define CSR_MICM_CFG_ILM_ECC_MASK (0x600000UL)
6013 #define CSR_MICM_CFG_ILM_ECC_SHIFT (21U)
6014 #define CSR_MICM_CFG_ILM_ECC_GET(x) (((uint32_t)(x) & CSR_MICM_CFG_ILM_ECC_MASK) >> CSR_MICM_CFG_ILM_ECC_SHIFT)
6015 
6016 /*
6017  * ILMSZ (RO)
6018  *
6019  * ILM Size
6020  * 0:0 Byte
6021  * 1:1 KiB
6022  * 2:2 KiB
6023  * 3:4 KiB
6024  * 4:8 KiB
6025  * 5:16 KiB
6026  * 6:32 KiB
6027  * 7:64 KiB
6028  * 8:128 KiB
6029  * 9:256 KiB
6030  * 10:512 KiB
6031  * 11:1 MiB
6032  * 12:2 MiB
6033  * 13:4 MiB
6034  * 14:8 MiB
6035  * 15:16 MiB
6036  * 16-31:Reserved
6037  * When ILM is not configured, this field should be ignored.
6038  */
6039 #define CSR_MICM_CFG_ILMSZ_MASK (0xF8000UL)
6040 #define CSR_MICM_CFG_ILMSZ_SHIFT (15U)
6041 #define CSR_MICM_CFG_ILMSZ_GET(x) (((uint32_t)(x) & CSR_MICM_CFG_ILMSZ_MASK) >> CSR_MICM_CFG_ILMSZ_SHIFT)
6042 
6043 /*
6044  * ILMB (RW)
6045  *
6046  * Number of ILM base registers present
6047  * 0:No ILM base register present
6048  * 1:One ILM base register present
6049  * 2-7:Reserved
6050  * When ILM is not configured, this field should be ignored.
6051  */
6052 #define CSR_MICM_CFG_ILMB_MASK (0x7000U)
6053 #define CSR_MICM_CFG_ILMB_SHIFT (12U)
6054 #define CSR_MICM_CFG_ILMB_SET(x) (((uint32_t)(x) << CSR_MICM_CFG_ILMB_SHIFT) & CSR_MICM_CFG_ILMB_MASK)
6055 #define CSR_MICM_CFG_ILMB_GET(x) (((uint32_t)(x) & CSR_MICM_CFG_ILMB_MASK) >> CSR_MICM_CFG_ILMB_SHIFT)
6056 
6057 /*
6058  * IC_ECC (RO)
6059  *
6060  * Cache soft-error protection scheme
6061  * 0:No parity/ECC
6062  * 1:Parity
6063  * 2:ECC
6064  * 3:Reserved
6065  * When instruction cache is not configured, this field should be ignored.
6066  */
6067 #define CSR_MICM_CFG_IC_ECC_MASK (0xC00U)
6068 #define CSR_MICM_CFG_IC_ECC_SHIFT (10U)
6069 #define CSR_MICM_CFG_IC_ECC_GET(x) (((uint32_t)(x) & CSR_MICM_CFG_IC_ECC_MASK) >> CSR_MICM_CFG_IC_ECC_SHIFT)
6070 
6071 /*
6072  * ILCK (RO)
6073  *
6074  * I-Cache locking support
6075  * 0:No locking support
6076  * 1:With locking support
6077  * When instruction cache is not configured, this field should be ignored.
6078  */
6079 #define CSR_MICM_CFG_ILCK_MASK (0x200U)
6080 #define CSR_MICM_CFG_ILCK_SHIFT (9U)
6081 #define CSR_MICM_CFG_ILCK_GET(x) (((uint32_t)(x) & CSR_MICM_CFG_ILCK_MASK) >> CSR_MICM_CFG_ILCK_SHIFT)
6082 
6083 /*
6084  * ISZ (RO)
6085  *
6086  * Cache block (line) size
6087  * 0:No I-Cache
6088  * 1:8 bytes
6089  * 2:16 bytes
6090  * 3:32 bytes
6091  * 4:64 bytes
6092  * 5:128 bytes
6093  * 6-7:Reserved
6094  * When instruction cache is not configured, this field should be ignored.
6095  */
6096 #define CSR_MICM_CFG_ISZ_MASK (0x1C0U)
6097 #define CSR_MICM_CFG_ISZ_SHIFT (6U)
6098 #define CSR_MICM_CFG_ISZ_GET(x) (((uint32_t)(x) & CSR_MICM_CFG_ISZ_MASK) >> CSR_MICM_CFG_ISZ_SHIFT)
6099 
6100 /*
6101  * IWAY (RO)
6102  *
6103  * Associativity of I-Cache
6104  * 0:Direct-mapped
6105  * 1:2-way
6106  * 2:3-way
6107  * 3:4-way
6108  * 4:5-way
6109  * 5:6-way
6110  * 6:7-way
6111  * 7:8-way
6112  * When instruction cache is not configured, this field should be ignored.
6113  */
6114 #define CSR_MICM_CFG_IWAY_MASK (0x38U)
6115 #define CSR_MICM_CFG_IWAY_SHIFT (3U)
6116 #define CSR_MICM_CFG_IWAY_GET(x) (((uint32_t)(x) & CSR_MICM_CFG_IWAY_MASK) >> CSR_MICM_CFG_IWAY_SHIFT)
6117 
6118 /*
6119  * ISET (RO)
6120  *
6121  * I-Cache sets (# of cache lines per way):
6122  * When micm_cfg.SETH==0:
6123  * 0:64
6124  * 1:128
6125  * 2:256
6126  * 3:512
6127  * 4:1024
6128  * 5:2048
6129  * 6:4096
6130  * 7:Reserved
6131  * When micm_cfg.SETH==1:
6132  * 0:32
6133  * 1:16
6134  * 2:8
6135  * 3-7:Reserved
6136  */
6137 #define CSR_MICM_CFG_ISET_MASK (0x7U)
6138 #define CSR_MICM_CFG_ISET_SHIFT (0U)
6139 #define CSR_MICM_CFG_ISET_GET(x) (((uint32_t)(x) & CSR_MICM_CFG_ISET_MASK) >> CSR_MICM_CFG_ISET_SHIFT)
6140 
6141 /* Bitfield definition for register: MDCM_CFG */
6142 /*
6143  * SETH (RO)
6144  *
6145  * This bit extends the DSET field.
6146  * When data cache is not configured, this field should be ignored
6147  */
6148 #define CSR_MDCM_CFG_SETH_MASK (0x1000000UL)
6149 #define CSR_MDCM_CFG_SETH_SHIFT (24U)
6150 #define CSR_MDCM_CFG_SETH_GET(x) (((uint32_t)(x) & CSR_MDCM_CFG_SETH_MASK) >> CSR_MDCM_CFG_SETH_SHIFT)
6151 
6152 /*
6153  * DLM_ECC (RO)
6154  *
6155  * DLM soft-error protection scheme
6156  * 0:No parity/ECC
6157  * 1:Parity
6158  * 2:ECC
6159  * 3:Reserved
6160  * When DLM is not configured, this field should be ignored.
6161  */
6162 #define CSR_MDCM_CFG_DLM_ECC_MASK (0x600000UL)
6163 #define CSR_MDCM_CFG_DLM_ECC_SHIFT (21U)
6164 #define CSR_MDCM_CFG_DLM_ECC_GET(x) (((uint32_t)(x) & CSR_MDCM_CFG_DLM_ECC_MASK) >> CSR_MDCM_CFG_DLM_ECC_SHIFT)
6165 
6166 /*
6167  * DLMSZ (RO)
6168  *
6169  * DLM Size
6170  * 0:0 Byte
6171  * 1:1 KiB
6172  * 2:2 KiB
6173  * 3:4 KiB
6174  * 4:8 KiB
6175  * 5:16 KiB
6176  * 6:32 KiB
6177  * 7:64 KiB
6178  * 8:128 KiB
6179  * 9:256 KiB
6180  * 10:512 KiB
6181  * 11:1 MiB
6182  * 12:2 MiB
6183  * 13:4 MiB
6184  * 14:8 MiB
6185  * 15:16 MiB
6186  * 16-31:Reserved
6187  * When ILM is not configured, this field should be ignored.
6188  */
6189 #define CSR_MDCM_CFG_DLMSZ_MASK (0xF8000UL)
6190 #define CSR_MDCM_CFG_DLMSZ_SHIFT (15U)
6191 #define CSR_MDCM_CFG_DLMSZ_GET(x) (((uint32_t)(x) & CSR_MDCM_CFG_DLMSZ_MASK) >> CSR_MDCM_CFG_DLMSZ_SHIFT)
6192 
6193 /*
6194  * DLMB (RO)
6195  *
6196  * Number of DLM base registers present
6197  * 0:No DLM base register present
6198  * 1:One DLM base register present
6199  * 2-7:Reserved
6200  * When DLM is not configured, this field should be ignored
6201  */
6202 #define CSR_MDCM_CFG_DLMB_MASK (0x7000U)
6203 #define CSR_MDCM_CFG_DLMB_SHIFT (12U)
6204 #define CSR_MDCM_CFG_DLMB_GET(x) (((uint32_t)(x) & CSR_MDCM_CFG_DLMB_MASK) >> CSR_MDCM_CFG_DLMB_SHIFT)
6205 
6206 /*
6207  * DC_ECC (RO)
6208  *
6209  * Cache soft-error protection scheme
6210  * 0:No parity/ECC support
6211  * 1:Has parity support
6212  * 2:Has ECC support
6213  * 3:Reserved
6214  * When data cache is not configured, this field should be ignored.
6215  */
6216 #define CSR_MDCM_CFG_DC_ECC_MASK (0xC00U)
6217 #define CSR_MDCM_CFG_DC_ECC_SHIFT (10U)
6218 #define CSR_MDCM_CFG_DC_ECC_GET(x) (((uint32_t)(x) & CSR_MDCM_CFG_DC_ECC_MASK) >> CSR_MDCM_CFG_DC_ECC_SHIFT)
6219 
6220 /*
6221  * DLCK (RO)
6222  *
6223  * D-Cache locking support
6224  * 0:No locking support
6225  * 1:With locking support
6226  * When data cache is not configured, this field should be ignored.
6227  */
6228 #define CSR_MDCM_CFG_DLCK_MASK (0x200U)
6229 #define CSR_MDCM_CFG_DLCK_SHIFT (9U)
6230 #define CSR_MDCM_CFG_DLCK_GET(x) (((uint32_t)(x) & CSR_MDCM_CFG_DLCK_MASK) >> CSR_MDCM_CFG_DLCK_SHIFT)
6231 
6232 /*
6233  * DSZ (RO)
6234  *
6235  * Cache block (line) size
6236  * 0:No I-Cache
6237  * 1:8 bytes
6238  * 2:16 bytes
6239  * 3:32 bytes
6240  * 4:64 bytes
6241  * 5:128 bytes
6242  * 6-7:Reserved
6243  * When instruction cache is not configured, this field should be ignored.
6244  */
6245 #define CSR_MDCM_CFG_DSZ_MASK (0x1C0U)
6246 #define CSR_MDCM_CFG_DSZ_SHIFT (6U)
6247 #define CSR_MDCM_CFG_DSZ_GET(x) (((uint32_t)(x) & CSR_MDCM_CFG_DSZ_MASK) >> CSR_MDCM_CFG_DSZ_SHIFT)
6248 
6249 /*
6250  * DWAY (RO)
6251  *
6252  * Associativity of D-Cache
6253  * 0:Direct-mapped
6254  * 1:2-way
6255  * 2:3-way
6256  * 3:4-way
6257  * 4:5-way
6258  * 5:6-way
6259  * 6:7-way
6260  * 7:8-way
6261  * When data cache is not configured, this field should be ignored.
6262  */
6263 #define CSR_MDCM_CFG_DWAY_MASK (0x38U)
6264 #define CSR_MDCM_CFG_DWAY_SHIFT (3U)
6265 #define CSR_MDCM_CFG_DWAY_GET(x) (((uint32_t)(x) & CSR_MDCM_CFG_DWAY_MASK) >> CSR_MDCM_CFG_DWAY_SHIFT)
6266 
6267 /*
6268  * DSET (RO)
6269  *
6270  * D-Cache sets (# of cache lines per way):
6271  * When mdcm_cfg.SETH==0:
6272  * 0:64
6273  * 1:128
6274  * 2:256
6275  * 3:512
6276  * 4:1024
6277  * 5:2048
6278  * 6:4096
6279  * 7:Reserved
6280  * When mdcm_cfg.SETH==1:
6281  * 0:32
6282  * 1:16
6283  * 2:8
6284  * 3-7:Reserved
6285  * When data cache is not configured, this field should be ignored
6286  */
6287 #define CSR_MDCM_CFG_DSET_MASK (0x7U)
6288 #define CSR_MDCM_CFG_DSET_SHIFT (0U)
6289 #define CSR_MDCM_CFG_DSET_GET(x) (((uint32_t)(x) & CSR_MDCM_CFG_DSET_MASK) >> CSR_MDCM_CFG_DSET_SHIFT)
6290 
6291 /* Bitfield definition for register: MMSC_CFG */
6292 /*
6293  * MSC_EXT (RO)
6294  *
6295  * Indicates if the mmsc_cfg2 CSR is present or not.
6296  * 0:The mmsc_cfg2 CSR is not present.
6297  * 1:The mmsc_cfg2 CSR is present
6298  */
6299 #define CSR_MMSC_CFG_MSC_EXT_MASK (0x80000000UL)
6300 #define CSR_MMSC_CFG_MSC_EXT_SHIFT (31U)
6301 #define CSR_MMSC_CFG_MSC_EXT_GET(x) (((uint32_t)(x) & CSR_MMSC_CFG_MSC_EXT_MASK) >> CSR_MMSC_CFG_MSC_EXT_SHIFT)
6302 
6303 /*
6304  * PPMA (RO)
6305  *
6306  * Indicates if programmable PMA setup with PMA region CSRs is supported or not
6307  * 0:Programmable PMA setup is not supported.
6308  * 1:Programmable PMA setup is supported.
6309  */
6310 #define CSR_MMSC_CFG_PPMA_MASK (0x40000000UL)
6311 #define CSR_MMSC_CFG_PPMA_SHIFT (30U)
6312 #define CSR_MMSC_CFG_PPMA_GET(x) (((uint32_t)(x) & CSR_MMSC_CFG_PPMA_MASK) >> CSR_MMSC_CFG_PPMA_SHIFT)
6313 
6314 /*
6315  * EDSP (RO)
6316  *
6317  * Indicates if the DSP extension is supported or not
6318  * 0:The DSP extension is not supported.
6319  * 1:The DSP extension is supported.
6320  */
6321 #define CSR_MMSC_CFG_EDSP_MASK (0x20000000UL)
6322 #define CSR_MMSC_CFG_EDSP_SHIFT (29U)
6323 #define CSR_MMSC_CFG_EDSP_GET(x) (((uint32_t)(x) & CSR_MMSC_CFG_EDSP_MASK) >> CSR_MMSC_CFG_EDSP_SHIFT)
6324 
6325 /*
6326  * VCCTL (RO)
6327  *
6328  * Indicates the version number of CCTL command operation scheme supported by an implementation
6329  * 0:instruction cache and data cache are not configured.
6330  * 1:instruction cache or data cache is configured.
6331  */
6332 #define CSR_MMSC_CFG_VCCTL_MASK (0xC0000UL)
6333 #define CSR_MMSC_CFG_VCCTL_SHIFT (18U)
6334 #define CSR_MMSC_CFG_VCCTL_GET(x) (((uint32_t)(x) & CSR_MMSC_CFG_VCCTL_MASK) >> CSR_MMSC_CFG_VCCTL_SHIFT)
6335 
6336 /*
6337  * EFHW (RO)
6338  *
6339  * Indicates the support of FLHW and FSHW instructions
6340  * 0:FLHW and FSHW instructions are not supported
6341  * 1:FLHW and FSHW instructions are supported.
6342  */
6343 #define CSR_MMSC_CFG_EFHW_MASK (0x20000UL)
6344 #define CSR_MMSC_CFG_EFHW_SHIFT (17U)
6345 #define CSR_MMSC_CFG_EFHW_GET(x) (((uint32_t)(x) & CSR_MMSC_CFG_EFHW_MASK) >> CSR_MMSC_CFG_EFHW_SHIFT)
6346 
6347 /*
6348  * CCTLCSR (RO)
6349  *
6350  * Indicates the presence of CSRs for CCTL operations.
6351  * 0:Feature of CSRs for CCTL operations is not supported.
6352  * 1:Feature of CSRs for CCTL operations is supported.
6353  */
6354 #define CSR_MMSC_CFG_CCTLCSR_MASK (0x10000UL)
6355 #define CSR_MMSC_CFG_CCTLCSR_SHIFT (16U)
6356 #define CSR_MMSC_CFG_CCTLCSR_GET(x) (((uint32_t)(x) & CSR_MMSC_CFG_CCTLCSR_MASK) >> CSR_MMSC_CFG_CCTLCSR_SHIFT)
6357 
6358 /*
6359  * PMNDS (RO)
6360  *
6361  * Indicates if Andes-enhanced performance monitoring feature is present or no.
6362  * 0:Andes-enhanced performance monitoring feature is not supported.
6363  * 1:Andes-enhanced performance monitoring feature is supported.
6364  */
6365 #define CSR_MMSC_CFG_PMNDS_MASK (0x8000U)
6366 #define CSR_MMSC_CFG_PMNDS_SHIFT (15U)
6367 #define CSR_MMSC_CFG_PMNDS_GET(x) (((uint32_t)(x) & CSR_MMSC_CFG_PMNDS_MASK) >> CSR_MMSC_CFG_PMNDS_SHIFT)
6368 
6369 /*
6370  * LMSLVP (RO)
6371  *
6372  * Indicates if local memory slave port is present or not.
6373  * 0:Local memory slave port is not present.
6374  * 1:Local memory slave port is implemented.
6375  */
6376 #define CSR_MMSC_CFG_LMSLVP_MASK (0x4000U)
6377 #define CSR_MMSC_CFG_LMSLVP_SHIFT (14U)
6378 #define CSR_MMSC_CFG_LMSLVP_GET(x) (((uint32_t)(x) & CSR_MMSC_CFG_LMSLVP_MASK) >> CSR_MMSC_CFG_LMSLVP_SHIFT)
6379 
6380 /*
6381  * EV5PE (RO)
6382  *
6383  * Indicates whether AndeStar V5 Performance Extension is implemented or not. D45 always implements AndeStar V5 Performance Extension.
6384  * 0:Not implemented.
6385  * 1:Implemented.
6386  */
6387 #define CSR_MMSC_CFG_EV5PE_MASK (0x2000U)
6388 #define CSR_MMSC_CFG_EV5PE_SHIFT (13U)
6389 #define CSR_MMSC_CFG_EV5PE_GET(x) (((uint32_t)(x) & CSR_MMSC_CFG_EV5PE_MASK) >> CSR_MMSC_CFG_EV5PE_SHIFT)
6390 
6391 /*
6392  * VPLIC (RO)
6393  *
6394  * Indicates whether the Andes Vectored PLIC Extension is implemented or not.
6395  * 0:Not implemented.
6396  * 1:Implemented.
6397  */
6398 #define CSR_MMSC_CFG_VPLIC_MASK (0x1000U)
6399 #define CSR_MMSC_CFG_VPLIC_SHIFT (12U)
6400 #define CSR_MMSC_CFG_VPLIC_GET(x) (((uint32_t)(x) & CSR_MMSC_CFG_VPLIC_MASK) >> CSR_MMSC_CFG_VPLIC_SHIFT)
6401 
6402 /*
6403  * ACE (RO)
6404  *
6405  * Indicates whether the Andes StackSafe hardware stack protection extension is implemented or not.
6406  * 0:Not implemented.
6407  * 1:Implemented.
6408  */
6409 #define CSR_MMSC_CFG_ACE_MASK (0x40U)
6410 #define CSR_MMSC_CFG_ACE_SHIFT (6U)
6411 #define CSR_MMSC_CFG_ACE_GET(x) (((uint32_t)(x) & CSR_MMSC_CFG_ACE_MASK) >> CSR_MMSC_CFG_ACE_SHIFT)
6412 
6413 /*
6414  * HSP (RO)
6415  *
6416  * Indicates whether the Andes PowerBrake (Performance Throttling) power/performance scaling extension is implemented or not.
6417  * 0:Not implemented.
6418  * 1:Implemented.
6419  */
6420 #define CSR_MMSC_CFG_HSP_MASK (0x20U)
6421 #define CSR_MMSC_CFG_HSP_SHIFT (5U)
6422 #define CSR_MMSC_CFG_HSP_GET(x) (((uint32_t)(x) & CSR_MMSC_CFG_HSP_MASK) >> CSR_MMSC_CFG_HSP_SHIFT)
6423 
6424 /*
6425  * PFT (RO)
6426  *
6427  * Indicates whether the Andes PowerBrake (Performance Throttling) power/performance scaling extension is implemented or not
6428  * 0:Not implemented.
6429  * 1:Implemented.
6430  */
6431 #define CSR_MMSC_CFG_PFT_MASK (0x10U)
6432 #define CSR_MMSC_CFG_PFT_SHIFT (4U)
6433 #define CSR_MMSC_CFG_PFT_GET(x) (((uint32_t)(x) & CSR_MMSC_CFG_PFT_MASK) >> CSR_MMSC_CFG_PFT_SHIFT)
6434 
6435 /*
6436  * ECD (RO)
6437  *
6438  * Indicates whether the Andes CoDense Extension is implemented or not.
6439  * 0:Not implemented.
6440  * 1:Implemented.
6441  */
6442 #define CSR_MMSC_CFG_ECD_MASK (0x8U)
6443 #define CSR_MMSC_CFG_ECD_SHIFT (3U)
6444 #define CSR_MMSC_CFG_ECD_GET(x) (((uint32_t)(x) & CSR_MMSC_CFG_ECD_MASK) >> CSR_MMSC_CFG_ECD_SHIFT)
6445 
6446 /*
6447  * TLB_ECC (RO)
6448  *
6449  * TLB parity/ECC support configuration.
6450  * 0:No parity/ECC
6451  * 1:Parity
6452  * 2:ECC
6453  * 3:Reserved
6454  */
6455 #define CSR_MMSC_CFG_TLB_ECC_MASK (0x6U)
6456 #define CSR_MMSC_CFG_TLB_ECC_SHIFT (1U)
6457 #define CSR_MMSC_CFG_TLB_ECC_GET(x) (((uint32_t)(x) & CSR_MMSC_CFG_TLB_ECC_MASK) >> CSR_MMSC_CFG_TLB_ECC_SHIFT)
6458 
6459 /*
6460  * ECC (RO)
6461  *
6462  * Indicates whether the parity/ECC soft-error protection is implemented or not.
6463  * 0:Not implemented.
6464  * 1:Implemented.
6465  * The specific parity/ECC scheme used for each protected RAM is specified by the control bits in the following list.
6466  * micm_cfg.IC_ECC
6467  * micm_cfg.ILM_ECC
6468  * mdcm_cfg.DC_ECC
6469  * mdcm_cfg.DLM_ECC
6470  * mmsc_cfg.TLB_ECC
6471  */
6472 #define CSR_MMSC_CFG_ECC_MASK (0x1U)
6473 #define CSR_MMSC_CFG_ECC_SHIFT (0U)
6474 #define CSR_MMSC_CFG_ECC_GET(x) (((uint32_t)(x) & CSR_MMSC_CFG_ECC_MASK) >> CSR_MMSC_CFG_ECC_SHIFT)
6475 
6476 /* Bitfield definition for register: MMSC_CFG2 */
6477 /*
6478  * FINV (RO)
6479  *
6480  * Indicates if scalar FPU is implemented in VPU
6481  * 0:Scalar FPU is not implemented in VPU
6482  * 1:Scalar FPU is implemented in VPU
6483  */
6484 #define CSR_MMSC_CFG2_FINV_MASK (0x20U)
6485 #define CSR_MMSC_CFG2_FINV_SHIFT (5U)
6486 #define CSR_MMSC_CFG2_FINV_GET(x) (((uint32_t)(x) & CSR_MMSC_CFG2_FINV_MASK) >> CSR_MMSC_CFG2_FINV_SHIFT)
6487 
6488 /*
6489  * ZFH (RO)
6490  *
6491  * Indicates if the FP16 half-precision floating-point extension (Zfh) is supported or not.
6492  * 0:The FP16 extension is not supported.
6493  * 1:The FP16 extension is supported
6494  */
6495 #define CSR_MMSC_CFG2_ZFH_MASK (0x2U)
6496 #define CSR_MMSC_CFG2_ZFH_SHIFT (1U)
6497 #define CSR_MMSC_CFG2_ZFH_GET(x) (((uint32_t)(x) & CSR_MMSC_CFG2_ZFH_MASK) >> CSR_MMSC_CFG2_ZFH_SHIFT)
6498 
6499 /*
6500  * BF16CVT (RO)
6501  *
6502  * Indicates if the BFLOAT16 conversion extension
6503  * is supported or not.
6504  * 0:The BFLOAT16 conversion extension is not supported
6505  * 1:The BFLOAT16 conversion extension is supported
6506  */
6507 #define CSR_MMSC_CFG2_BF16CVT_MASK (0x1U)
6508 #define CSR_MMSC_CFG2_BF16CVT_SHIFT (0U)
6509 #define CSR_MMSC_CFG2_BF16CVT_GET(x) (((uint32_t)(x) & CSR_MMSC_CFG2_BF16CVT_MASK) >> CSR_MMSC_CFG2_BF16CVT_SHIFT)
6510 
6511 
6512 #endif /* HPM_CSR_H */