From 6944cd10e6bdc450d66ab245bf0620979fba8f71 Mon Sep 17 00:00:00 2001 From: Sebastian Huber Date: Thu, 17 Dec 2020 15:26:57 +0100 Subject: arm: Add header file for AArch32 System Registers Update #4202. --- .../include/rtems/score/aarch32-system-registers.h | 14657 +++++++++++++++++++ 1 file changed, 14657 insertions(+) create mode 100644 cpukit/score/cpu/arm/include/rtems/score/aarch32-system-registers.h (limited to 'cpukit/score/cpu') diff --git a/cpukit/score/cpu/arm/include/rtems/score/aarch32-system-registers.h b/cpukit/score/cpu/arm/include/rtems/score/aarch32-system-registers.h new file mode 100644 index 0000000000..2c532ca669 --- /dev/null +++ b/cpukit/score/cpu/arm/include/rtems/score/aarch32-system-registers.h @@ -0,0 +1,14657 @@ +/* SPDX-License-Identifier: BSD-2-Clause */ + +/** + * @file + * + * @ingroup RTEMSScoreCPUARMSysReg + * + * @brief This header file provides the API to read and write the AArch32 + * system registers. + */ + +/* + * Copyright (C) 2020 embedded brains GmbH (http://www.embedded-brains.de) + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef _RTEMS_SCORE_AARCH32_SYSTEM_REGISTERS_H +#define _RTEMS_SCORE_AARCH32_SYSTEM_REGISTERS_H + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * @defgroup RTEMSScoreCPUARMSysReg AArch32 System Registers + * + * @ingroup RTEMSScoreCPUARM + * + * @brief This group provides functions to read and write the AArch32 system + * registers. + * + * The ordering of the registers is according to the document + * "Arm Architecture Reference Manual, Armv8, for Armv8-A architecture profile, + * Issue F.c" followed by the additional registers defined by the document + * "Arm Architecture Reference Manual, Armv8, for the Armv8-R AArch32 + * architecture profile, Issue A.c". + * + * @{ + */ + +/* ACTLR, Auxiliary Control Register */ + +static inline uint32_t _AArch32_Read_actlr( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c1, c0, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_actlr( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c1, c0, 1" : : "r" ( value ) : "memory" + ); +} + +/* ACTLR2, Auxiliary Control Register 2 */ + +static inline uint32_t _AArch32_Read_actlr2( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c1, c0, 3" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_actlr2( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c1, c0, 3" : : "r" ( value ) : "memory" + ); +} + +/* ADFSR, Auxiliary Data Fault Status Register */ + +static inline uint32_t _AArch32_Read_adfsr( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c5, c1, 0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_adfsr( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c5, c1, 0" : : "r" ( value ) : "memory" + ); +} + +/* AIDR, Auxiliary ID Register */ + +static inline uint32_t _AArch32_Read_aidr( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 1, %0, c0, c0, 7" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +/* AIFSR, Auxiliary Instruction Fault Status Register */ + +static inline uint32_t _AArch32_Read_aifsr( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c5, c1, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_aifsr( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c5, c1, 1" : : "r" ( value ) : "memory" + ); +} + +/* AMAIR0, Auxiliary Memory Attribute Indirection Register 0 */ + +static inline uint32_t _AArch32_Read_amair0( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c10, c3, 0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_amair0( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c10, c3, 0" : : "r" ( value ) : "memory" + ); +} + +/* AMAIR1, Auxiliary Memory Attribute Indirection Register 1 */ + +static inline uint32_t _AArch32_Read_amair1( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c10, c3, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_amair1( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c10, c3, 1" : : "r" ( value ) : "memory" + ); +} + +/* APSR, Application Program Status Register */ + +#define AARCH32_APSR_GE( _val ) ( ( _val ) << 16 ) +#define AARCH32_APSR_GE_SHIFT 16 +#define AARCH32_APSR_GE_MASK 0xf0000U +#define AARCH32_APSR_GE_GET( _reg ) \ + ( ( ( _reg ) >> 16 ) & 0xfU ) + +#define AARCH32_APSR_Q 0x8000000U + +#define AARCH32_APSR_V 0x10000000U + +#define AARCH32_APSR_C 0x20000000U + +#define AARCH32_APSR_Z 0x40000000U + +#define AARCH32_APSR_N 0x80000000U + +/* ATS12NSOPR, Address Translate Stages 1 and 2 Non-secure Only PL1 Read */ + +static inline void _AArch32_Write_ats12nsopr( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c7, c8, 4" : : "r" ( value ) : "memory" + ); +} + +/* ATS12NSOPW, Address Translate Stages 1 and 2 Non-secure Only PL1 Write */ + +static inline void _AArch32_Write_ats12nsopw( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c7, c8, 5" : : "r" ( value ) : "memory" + ); +} + +/* ATS12NSOUR, Address Translate Stages 1 and 2 Non-secure Only Unprivileged Read */ + +static inline void _AArch32_Write_ats12nsour( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c7, c8, 6" : : "r" ( value ) : "memory" + ); +} + +/* ATS12NSOUW, Address Translate Stages 1 and 2 Non-secure Only Unprivileged Write */ + +static inline void _AArch32_Write_ats12nsouw( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c7, c8, 7" : : "r" ( value ) : "memory" + ); +} + +/* ATS1CPR, Address Translate Stage 1 Current state PL1 Read */ + +static inline void _AArch32_Write_ats1cpr( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c7, c8, 0" : : "r" ( value ) : "memory" + ); +} + +/* ATS1CPRP, Address Translate Stage 1 Current state PL1 Read PAN */ + +static inline void _AArch32_Write_ats1cprp( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c7, c9, 0" : : "r" ( value ) : "memory" + ); +} + +/* ATS1CPW, Address Translate Stage 1 Current state PL1 Write */ + +static inline void _AArch32_Write_ats1cpw( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c7, c8, 1" : : "r" ( value ) : "memory" + ); +} + +/* ATS1CPWP, Address Translate Stage 1 Current state PL1 Write PAN */ + +static inline void _AArch32_Write_ats1cpwp( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c7, c9, 1" : : "r" ( value ) : "memory" + ); +} + +/* ATS1CUR, Address Translate Stage 1 Current state Unprivileged Read */ + +static inline void _AArch32_Write_ats1cur( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c7, c8, 2" : : "r" ( value ) : "memory" + ); +} + +/* ATS1CUW, Address Translate Stage 1 Current state Unprivileged Write */ + +static inline void _AArch32_Write_ats1cuw( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c7, c8, 3" : : "r" ( value ) : "memory" + ); +} + +/* ATS1HR, Address Translate Stage 1 Hyp mode Read */ + +static inline void _AArch32_Write_ats1hr( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 4, %0, c7, c8, 0" : : "r" ( value ) : "memory" + ); +} + +/* ATS1HW, Address Translate Stage 1 Hyp mode Write */ + +static inline void _AArch32_Write_ats1hw( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 4, %0, c7, c8, 1" : : "r" ( value ) : "memory" + ); +} + +/* BPIALL, Branch Predictor Invalidate All */ + +static inline void _AArch32_Write_bpiall( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c7, c5, 6" : : "r" ( value ) : "memory" + ); +} + +/* BPIALLIS, Branch Predictor Invalidate All, Inner Shareable */ + +static inline void _AArch32_Write_bpiallis( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c7, c1, 6" : : "r" ( value ) : "memory" + ); +} + +/* BPIMVA, Branch Predictor Invalidate by VA */ + +static inline void _AArch32_Write_bpimva( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c7, c5, 7" : : "r" ( value ) : "memory" + ); +} + +/* CCSIDR, Current Cache Size ID Register */ + +#define AARCH32_CCSIDR_LINESIZE( _val ) ( ( _val ) << 0 ) +#define AARCH32_CCSIDR_LINESIZE_SHIFT 0 +#define AARCH32_CCSIDR_LINESIZE_MASK 0x7U +#define AARCH32_CCSIDR_LINESIZE_GET( _reg ) \ + ( ( ( _reg ) >> 0 ) & 0x7U ) + +#define AARCH32_CCSIDR_ASSOCIATIVITY_0( _val ) ( ( _val ) << 3 ) +#define AARCH32_CCSIDR_ASSOCIATIVITY_SHIFT_0 3 +#define AARCH32_CCSIDR_ASSOCIATIVITY_MASK_0 0x1ff8U +#define AARCH32_CCSIDR_ASSOCIATIVITY_GET_0( _reg ) \ + ( ( ( _reg ) >> 3 ) & 0x3ffU ) + +#define AARCH32_CCSIDR_ASSOCIATIVITY_1( _val ) ( ( _val ) << 3 ) +#define AARCH32_CCSIDR_ASSOCIATIVITY_SHIFT_1 3 +#define AARCH32_CCSIDR_ASSOCIATIVITY_MASK_1 0xfffff8U +#define AARCH32_CCSIDR_ASSOCIATIVITY_GET_1( _reg ) \ + ( ( ( _reg ) >> 3 ) & 0x1fffffU ) + +#define AARCH32_CCSIDR_NUMSETS( _val ) ( ( _val ) << 13 ) +#define AARCH32_CCSIDR_NUMSETS_SHIFT 13 +#define AARCH32_CCSIDR_NUMSETS_MASK 0xfffe000U +#define AARCH32_CCSIDR_NUMSETS_GET( _reg ) \ + ( ( ( _reg ) >> 13 ) & 0x7fffU ) + +static inline uint32_t _AArch32_Read_ccsidr( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 1, %0, c0, c0, 0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +/* CCSIDR2, Current Cache Size ID Register 2 */ + +#define AARCH32_CCSIDR2_NUMSETS( _val ) ( ( _val ) << 0 ) +#define AARCH32_CCSIDR2_NUMSETS_SHIFT 0 +#define AARCH32_CCSIDR2_NUMSETS_MASK 0xffffffU +#define AARCH32_CCSIDR2_NUMSETS_GET( _reg ) \ + ( ( ( _reg ) >> 0 ) & 0xffffffU ) + +static inline uint32_t _AArch32_Read_ccsidr2( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 1, %0, c0, c0, 2" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +/* CFPRCTX, Control Flow Prediction Restriction by Context */ + +#define AARCH32_CFPRCTX_ASID( _val ) ( ( _val ) << 0 ) +#define AARCH32_CFPRCTX_ASID_SHIFT 0 +#define AARCH32_CFPRCTX_ASID_MASK 0xffU +#define AARCH32_CFPRCTX_ASID_GET( _reg ) \ + ( ( ( _reg ) >> 0 ) & 0xffU ) + +#define AARCH32_CFPRCTX_GASID 0x100U + +#define AARCH32_CFPRCTX_VMID( _val ) ( ( _val ) << 16 ) +#define AARCH32_CFPRCTX_VMID_SHIFT 16 +#define AARCH32_CFPRCTX_VMID_MASK 0xff0000U +#define AARCH32_CFPRCTX_VMID_GET( _reg ) \ + ( ( ( _reg ) >> 16 ) & 0xffU ) + +#define AARCH32_CFPRCTX_EL( _val ) ( ( _val ) << 24 ) +#define AARCH32_CFPRCTX_EL_SHIFT 24 +#define AARCH32_CFPRCTX_EL_MASK 0x3000000U +#define AARCH32_CFPRCTX_EL_GET( _reg ) \ + ( ( ( _reg ) >> 24 ) & 0x3U ) + +#define AARCH32_CFPRCTX_NS 0x4000000U + +#define AARCH32_CFPRCTX_GVMID 0x8000000U + +static inline void _AArch32_Write_cfprctx( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c7, c3, 4" : : "r" ( value ) : "memory" + ); +} + +/* CLIDR, Cache Level ID Register */ + +#define AARCH32_CLIDR_LOUIS( _val ) ( ( _val ) << 21 ) +#define AARCH32_CLIDR_LOUIS_SHIFT 21 +#define AARCH32_CLIDR_LOUIS_MASK 0xe00000U +#define AARCH32_CLIDR_LOUIS_GET( _reg ) \ + ( ( ( _reg ) >> 21 ) & 0x7U ) + +#define AARCH32_CLIDR_LOC( _val ) ( ( _val ) << 24 ) +#define AARCH32_CLIDR_LOC_SHIFT 24 +#define AARCH32_CLIDR_LOC_MASK 0x7000000U +#define AARCH32_CLIDR_LOC_GET( _reg ) \ + ( ( ( _reg ) >> 24 ) & 0x7U ) + +#define AARCH32_CLIDR_LOUU( _val ) ( ( _val ) << 27 ) +#define AARCH32_CLIDR_LOUU_SHIFT 27 +#define AARCH32_CLIDR_LOUU_MASK 0x38000000U +#define AARCH32_CLIDR_LOUU_GET( _reg ) \ + ( ( ( _reg ) >> 27 ) & 0x7U ) + +#define AARCH32_CLIDR_ICB( _val ) ( ( _val ) << 30 ) +#define AARCH32_CLIDR_ICB_SHIFT 30 +#define AARCH32_CLIDR_ICB_MASK 0xc0000000U +#define AARCH32_CLIDR_ICB_GET( _reg ) \ + ( ( ( _reg ) >> 30 ) & 0x3U ) + +static inline uint32_t _AArch32_Read_clidr( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 1, %0, c0, c0, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +/* CONTEXTIDR, Context ID Register */ + +#define AARCH32_CONTEXTIDR_ASID( _val ) ( ( _val ) << 0 ) +#define AARCH32_CONTEXTIDR_ASID_SHIFT 0 +#define AARCH32_CONTEXTIDR_ASID_MASK 0xffU +#define AARCH32_CONTEXTIDR_ASID_GET( _reg ) \ + ( ( ( _reg ) >> 0 ) & 0xffU ) + +#define AARCH32_CONTEXTIDR_PROCID( _val ) ( ( _val ) << 8 ) +#define AARCH32_CONTEXTIDR_PROCID_SHIFT 8 +#define AARCH32_CONTEXTIDR_PROCID_MASK 0xffffff00U +#define AARCH32_CONTEXTIDR_PROCID_GET( _reg ) \ + ( ( ( _reg ) >> 8 ) & 0xffffffU ) + +static inline uint32_t _AArch32_Read_contextidr( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c13, c0, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_contextidr( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c13, c0, 1" : : "r" ( value ) : "memory" + ); +} + +/* CP15DMB, Data Memory Barrier System instruction */ + +static inline void _AArch32_Write_cp15dmb( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c7, c10, 5" : : "r" ( value ) : "memory" + ); +} + +/* CP15DSB, Data Synchronization Barrier System instruction */ + +static inline void _AArch32_Write_cp15dsb( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c7, c10, 4" : : "r" ( value ) : "memory" + ); +} + +/* CP15ISB, Instruction Synchronization Barrier System instruction */ + +static inline void _AArch32_Write_cp15isb( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c7, c5, 4" : : "r" ( value ) : "memory" + ); +} + +/* CPACR, Architectural Feature Access Control Register */ + +#define AARCH32_CPACR_CP10( _val ) ( ( _val ) << 20 ) +#define AARCH32_CPACR_CP10_SHIFT 20 +#define AARCH32_CPACR_CP10_MASK 0x300000U +#define AARCH32_CPACR_CP10_GET( _reg ) \ + ( ( ( _reg ) >> 20 ) & 0x3U ) + +#define AARCH32_CPACR_CP11( _val ) ( ( _val ) << 22 ) +#define AARCH32_CPACR_CP11_SHIFT 22 +#define AARCH32_CPACR_CP11_MASK 0xc00000U +#define AARCH32_CPACR_CP11_GET( _reg ) \ + ( ( ( _reg ) >> 22 ) & 0x3U ) + +#define AARCH32_CPACR_TRCDIS 0x10000000U + +#define AARCH32_CPACR_ASEDIS 0x80000000U + +static inline uint32_t _AArch32_Read_cpacr( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c1, c0, 2" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_cpacr( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c1, c0, 2" : : "r" ( value ) : "memory" + ); +} + +/* CPSR, Current Program Status Register */ + +#define AARCH32_CPSR_M( _val ) ( ( _val ) << 0 ) +#define AARCH32_CPSR_M_SHIFT 0 +#define AARCH32_CPSR_M_MASK 0xfU +#define AARCH32_CPSR_M_GET( _reg ) \ + ( ( ( _reg ) >> 0 ) & 0xfU ) + +#define AARCH32_CPSR_F 0x40U + +#define AARCH32_CPSR_I 0x80U + +#define AARCH32_CPSR_A 0x100U + +#define AARCH32_CPSR_E 0x200U + +#define AARCH32_CPSR_GE( _val ) ( ( _val ) << 16 ) +#define AARCH32_CPSR_GE_SHIFT 16 +#define AARCH32_CPSR_GE_MASK 0xf0000U +#define AARCH32_CPSR_GE_GET( _reg ) \ + ( ( ( _reg ) >> 16 ) & 0xfU ) + +#define AARCH32_CPSR_DIT 0x200000U + +#define AARCH32_CPSR_PAN 0x400000U + +#define AARCH32_CPSR_SSBS 0x800000U + +#define AARCH32_CPSR_Q 0x8000000U + +#define AARCH32_CPSR_V 0x10000000U + +#define AARCH32_CPSR_C 0x20000000U + +#define AARCH32_CPSR_Z 0x40000000U + +#define AARCH32_CPSR_N 0x80000000U + +/* CPPRCTX, Cache Prefetch Prediction Restriction by Context */ + +#define AARCH32_CPPRCTX_ASID( _val ) ( ( _val ) << 0 ) +#define AARCH32_CPPRCTX_ASID_SHIFT 0 +#define AARCH32_CPPRCTX_ASID_MASK 0xffU +#define AARCH32_CPPRCTX_ASID_GET( _reg ) \ + ( ( ( _reg ) >> 0 ) & 0xffU ) + +#define AARCH32_CPPRCTX_GASID 0x100U + +#define AARCH32_CPPRCTX_VMID( _val ) ( ( _val ) << 16 ) +#define AARCH32_CPPRCTX_VMID_SHIFT 16 +#define AARCH32_CPPRCTX_VMID_MASK 0xff0000U +#define AARCH32_CPPRCTX_VMID_GET( _reg ) \ + ( ( ( _reg ) >> 16 ) & 0xffU ) + +#define AARCH32_CPPRCTX_EL( _val ) ( ( _val ) << 24 ) +#define AARCH32_CPPRCTX_EL_SHIFT 24 +#define AARCH32_CPPRCTX_EL_MASK 0x3000000U +#define AARCH32_CPPRCTX_EL_GET( _reg ) \ + ( ( ( _reg ) >> 24 ) & 0x3U ) + +#define AARCH32_CPPRCTX_NS 0x4000000U + +#define AARCH32_CPPRCTX_GVMID 0x8000000U + +static inline void _AArch32_Write_cpprctx( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c7, c3, 7" : : "r" ( value ) : "memory" + ); +} + +/* CSSELR, Cache Size Selection Register */ + +#define AARCH32_CSSELR_IND 0x1U + +#define AARCH32_CSSELR_LEVEL( _val ) ( ( _val ) << 1 ) +#define AARCH32_CSSELR_LEVEL_SHIFT 1 +#define AARCH32_CSSELR_LEVEL_MASK 0xeU +#define AARCH32_CSSELR_LEVEL_GET( _reg ) \ + ( ( ( _reg ) >> 1 ) & 0x7U ) + +static inline uint32_t _AArch32_Read_csselr( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 2, %0, c0, c0, 0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_csselr( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 2, %0, c0, c0, 0" : : "r" ( value ) : "memory" + ); +} + +/* CTR, Cache Type Register */ + +#define AARCH32_CTR_IMINLINE( _val ) ( ( _val ) << 0 ) +#define AARCH32_CTR_IMINLINE_SHIFT 0 +#define AARCH32_CTR_IMINLINE_MASK 0xfU +#define AARCH32_CTR_IMINLINE_GET( _reg ) \ + ( ( ( _reg ) >> 0 ) & 0xfU ) + +#define AARCH32_CTR_L1IP( _val ) ( ( _val ) << 14 ) +#define AARCH32_CTR_L1IP_SHIFT 14 +#define AARCH32_CTR_L1IP_MASK 0xc000U +#define AARCH32_CTR_L1IP_GET( _reg ) \ + ( ( ( _reg ) >> 14 ) & 0x3U ) + +#define AARCH32_CTR_DMINLINE( _val ) ( ( _val ) << 16 ) +#define AARCH32_CTR_DMINLINE_SHIFT 16 +#define AARCH32_CTR_DMINLINE_MASK 0xf0000U +#define AARCH32_CTR_DMINLINE_GET( _reg ) \ + ( ( ( _reg ) >> 16 ) & 0xfU ) + +#define AARCH32_CTR_ERG( _val ) ( ( _val ) << 20 ) +#define AARCH32_CTR_ERG_SHIFT 20 +#define AARCH32_CTR_ERG_MASK 0xf00000U +#define AARCH32_CTR_ERG_GET( _reg ) \ + ( ( ( _reg ) >> 20 ) & 0xfU ) + +#define AARCH32_CTR_CWG( _val ) ( ( _val ) << 24 ) +#define AARCH32_CTR_CWG_SHIFT 24 +#define AARCH32_CTR_CWG_MASK 0xf000000U +#define AARCH32_CTR_CWG_GET( _reg ) \ + ( ( ( _reg ) >> 24 ) & 0xfU ) + +#define AARCH32_CTR_IDC 0x10000000U + +#define AARCH32_CTR_DIC 0x20000000U + +static inline uint32_t _AArch32_Read_ctr( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c0, c0, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +/* DACR, Domain Access Control Register */ + +static inline uint32_t _AArch32_Read_dacr( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c3, c0, 0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_dacr( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c3, c0, 0" : : "r" ( value ) : "memory" + ); +} + +/* DCCIMVAC, Data Cache line Clean and Invalidate by VA to PoC */ + +static inline void _AArch32_Write_dccimvac( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c7, c14, 1" : : "r" ( value ) : "memory" + ); +} + +/* DCCISW, Data Cache line Clean and Invalidate by Set/Way */ + +#define AARCH32_DCCISW_LEVEL( _val ) ( ( _val ) << 1 ) +#define AARCH32_DCCISW_LEVEL_SHIFT 1 +#define AARCH32_DCCISW_LEVEL_MASK 0xeU +#define AARCH32_DCCISW_LEVEL_GET( _reg ) \ + ( ( ( _reg ) >> 1 ) & 0x7U ) + +#define AARCH32_DCCISW_SETWAY( _val ) ( ( _val ) << 4 ) +#define AARCH32_DCCISW_SETWAY_SHIFT 4 +#define AARCH32_DCCISW_SETWAY_MASK 0xfffffff0U +#define AARCH32_DCCISW_SETWAY_GET( _reg ) \ + ( ( ( _reg ) >> 4 ) & 0xfffffffU ) + +static inline void _AArch32_Write_dccisw( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c7, c14, 2" : : "r" ( value ) : "memory" + ); +} + +/* DCCMVAC, Data Cache line Clean by VA to PoC */ + +static inline void _AArch32_Write_dccmvac( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c7, c10, 1" : : "r" ( value ) : "memory" + ); +} + +/* DCCMVAU, Data Cache line Clean by VA to PoU */ + +static inline void _AArch32_Write_dccmvau( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c7, c11, 1" : : "r" ( value ) : "memory" + ); +} + +/* DCCSW, Data Cache line Clean by Set/Way */ + +#define AARCH32_DCCSW_LEVEL( _val ) ( ( _val ) << 1 ) +#define AARCH32_DCCSW_LEVEL_SHIFT 1 +#define AARCH32_DCCSW_LEVEL_MASK 0xeU +#define AARCH32_DCCSW_LEVEL_GET( _reg ) \ + ( ( ( _reg ) >> 1 ) & 0x7U ) + +#define AARCH32_DCCSW_SETWAY( _val ) ( ( _val ) << 4 ) +#define AARCH32_DCCSW_SETWAY_SHIFT 4 +#define AARCH32_DCCSW_SETWAY_MASK 0xfffffff0U +#define AARCH32_DCCSW_SETWAY_GET( _reg ) \ + ( ( ( _reg ) >> 4 ) & 0xfffffffU ) + +static inline void _AArch32_Write_dccsw( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c7, c10, 2" : : "r" ( value ) : "memory" + ); +} + +/* DCIMVAC, Data Cache line Invalidate by VA to PoC */ + +static inline void _AArch32_Write_dcimvac( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c7, c6, 1" : : "r" ( value ) : "memory" + ); +} + +/* DCISW, Data Cache line Invalidate by Set/Way */ + +#define AARCH32_DCISW_LEVEL( _val ) ( ( _val ) << 1 ) +#define AARCH32_DCISW_LEVEL_SHIFT 1 +#define AARCH32_DCISW_LEVEL_MASK 0xeU +#define AARCH32_DCISW_LEVEL_GET( _reg ) \ + ( ( ( _reg ) >> 1 ) & 0x7U ) + +#define AARCH32_DCISW_SETWAY( _val ) ( ( _val ) << 4 ) +#define AARCH32_DCISW_SETWAY_SHIFT 4 +#define AARCH32_DCISW_SETWAY_MASK 0xfffffff0U +#define AARCH32_DCISW_SETWAY_GET( _reg ) \ + ( ( ( _reg ) >> 4 ) & 0xfffffffU ) + +static inline void _AArch32_Write_dcisw( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c7, c6, 2" : : "r" ( value ) : "memory" + ); +} + +/* DFAR, Data Fault Address Register */ + +static inline uint32_t _AArch32_Read_dfar( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c6, c0, 0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_dfar( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c6, c0, 0" : : "r" ( value ) : "memory" + ); +} + +/* DFSR, Data Fault Status Register */ + +#define AARCH32_DFSR_FS_3_0( _val ) ( ( _val ) << 0 ) +#define AARCH32_DFSR_FS_3_0_SHIFT 0 +#define AARCH32_DFSR_FS_3_0_MASK 0xfU +#define AARCH32_DFSR_FS_3_0_GET( _reg ) \ + ( ( ( _reg ) >> 0 ) & 0xfU ) + +#define AARCH32_DFSR_STATUS( _val ) ( ( _val ) << 0 ) +#define AARCH32_DFSR_STATUS_SHIFT 0 +#define AARCH32_DFSR_STATUS_MASK 0x3fU +#define AARCH32_DFSR_STATUS_GET( _reg ) \ + ( ( ( _reg ) >> 0 ) & 0x3fU ) + +#define AARCH32_DFSR_DOMAIN( _val ) ( ( _val ) << 4 ) +#define AARCH32_DFSR_DOMAIN_SHIFT 4 +#define AARCH32_DFSR_DOMAIN_MASK 0xf0U +#define AARCH32_DFSR_DOMAIN_GET( _reg ) \ + ( ( ( _reg ) >> 4 ) & 0xfU ) + +#define AARCH32_DFSR_LPAE 0x200U + +#define AARCH32_DFSR_FS_4 0x400U + +#define AARCH32_DFSR_WNR 0x800U + +#define AARCH32_DFSR_EXT 0x1000U + +#define AARCH32_DFSR_CM 0x2000U + +#define AARCH32_DFSR_AET( _val ) ( ( _val ) << 14 ) +#define AARCH32_DFSR_AET_SHIFT 14 +#define AARCH32_DFSR_AET_MASK 0xc000U +#define AARCH32_DFSR_AET_GET( _reg ) \ + ( ( ( _reg ) >> 14 ) & 0x3U ) + +#define AARCH32_DFSR_FNV 0x10000U + +static inline uint32_t _AArch32_Read_dfsr( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c5, c0, 0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_dfsr( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c5, c0, 0" : : "r" ( value ) : "memory" + ); +} + +/* DTLBIALL, Data TLB Invalidate All */ + +static inline void _AArch32_Write_dtlbiall( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c8, c6, 0" : : "r" ( value ) : "memory" + ); +} + +/* DTLBIASID, Data TLB Invalidate by ASID match */ + +#define AARCH32_DTLBIASID_ASID( _val ) ( ( _val ) << 0 ) +#define AARCH32_DTLBIASID_ASID_SHIFT 0 +#define AARCH32_DTLBIASID_ASID_MASK 0xffU +#define AARCH32_DTLBIASID_ASID_GET( _reg ) \ + ( ( ( _reg ) >> 0 ) & 0xffU ) + +static inline void _AArch32_Write_dtlbiasid( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c8, c6, 2" : : "r" ( value ) : "memory" + ); +} + +/* DTLBIMVA, Data TLB Invalidate by VA */ + +#define AARCH32_DTLBIMVA_ASID( _val ) ( ( _val ) << 0 ) +#define AARCH32_DTLBIMVA_ASID_SHIFT 0 +#define AARCH32_DTLBIMVA_ASID_MASK 0xffU +#define AARCH32_DTLBIMVA_ASID_GET( _reg ) \ + ( ( ( _reg ) >> 0 ) & 0xffU ) + +#define AARCH32_DTLBIMVA_VA( _val ) ( ( _val ) << 12 ) +#define AARCH32_DTLBIMVA_VA_SHIFT 12 +#define AARCH32_DTLBIMVA_VA_MASK 0xfffff000U +#define AARCH32_DTLBIMVA_VA_GET( _reg ) \ + ( ( ( _reg ) >> 12 ) & 0xfffffU ) + +static inline void _AArch32_Write_dtlbimva( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c8, c6, 1" : : "r" ( value ) : "memory" + ); +} + +/* DVPRCTX, Data Value Prediction Restriction by Context */ + +#define AARCH32_DVPRCTX_ASID( _val ) ( ( _val ) << 0 ) +#define AARCH32_DVPRCTX_ASID_SHIFT 0 +#define AARCH32_DVPRCTX_ASID_MASK 0xffU +#define AARCH32_DVPRCTX_ASID_GET( _reg ) \ + ( ( ( _reg ) >> 0 ) & 0xffU ) + +#define AARCH32_DVPRCTX_GASID 0x100U + +#define AARCH32_DVPRCTX_VMID( _val ) ( ( _val ) << 16 ) +#define AARCH32_DVPRCTX_VMID_SHIFT 16 +#define AARCH32_DVPRCTX_VMID_MASK 0xff0000U +#define AARCH32_DVPRCTX_VMID_GET( _reg ) \ + ( ( ( _reg ) >> 16 ) & 0xffU ) + +#define AARCH32_DVPRCTX_EL( _val ) ( ( _val ) << 24 ) +#define AARCH32_DVPRCTX_EL_SHIFT 24 +#define AARCH32_DVPRCTX_EL_MASK 0x3000000U +#define AARCH32_DVPRCTX_EL_GET( _reg ) \ + ( ( ( _reg ) >> 24 ) & 0x3U ) + +#define AARCH32_DVPRCTX_NS 0x4000000U + +#define AARCH32_DVPRCTX_GVMID 0x8000000U + +static inline void _AArch32_Write_dvprctx( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c7, c3, 5" : : "r" ( value ) : "memory" + ); +} + +/* FCSEIDR, FCSE Process ID Register */ + +static inline uint32_t _AArch32_Read_fcseidr( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c13, c0, 0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_fcseidr( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c13, c0, 0" : : "r" ( value ) : "memory" + ); +} + +/* FPEXC, Floating-Point Exception Control Register */ + +#define AARCH32_FPEXC_IOF 0x1U + +#define AARCH32_FPEXC_DZF 0x2U + +#define AARCH32_FPEXC_OFF 0x4U + +#define AARCH32_FPEXC_UFF 0x8U + +#define AARCH32_FPEXC_IXF 0x10U + +#define AARCH32_FPEXC_IDF 0x80U + +#define AARCH32_FPEXC_VECITR( _val ) ( ( _val ) << 8 ) +#define AARCH32_FPEXC_VECITR_SHIFT 8 +#define AARCH32_FPEXC_VECITR_MASK 0x700U +#define AARCH32_FPEXC_VECITR_GET( _reg ) \ + ( ( ( _reg ) >> 8 ) & 0x7U ) + +#define AARCH32_FPEXC_TFV 0x4000000U + +#define AARCH32_FPEXC_VV 0x8000000U + +#define AARCH32_FPEXC_FP2V 0x10000000U + +#define AARCH32_FPEXC_DEX 0x20000000U + +#define AARCH32_FPEXC_EN 0x40000000U + +#define AARCH32_FPEXC_EX 0x80000000U + +/* FPSCR, Floating-Point Status and Control Register */ + +#define AARCH32_FPSCR_IOC 0x1U + +#define AARCH32_FPSCR_DZC 0x2U + +#define AARCH32_FPSCR_OFC 0x4U + +#define AARCH32_FPSCR_UFC 0x8U + +#define AARCH32_FPSCR_IXC 0x10U + +#define AARCH32_FPSCR_IDC 0x80U + +#define AARCH32_FPSCR_IOE 0x100U + +#define AARCH32_FPSCR_DZE 0x200U + +#define AARCH32_FPSCR_OFE 0x400U + +#define AARCH32_FPSCR_UFE 0x800U + +#define AARCH32_FPSCR_IXE 0x1000U + +#define AARCH32_FPSCR_IDE 0x8000U + +#define AARCH32_FPSCR_LEN( _val ) ( ( _val ) << 16 ) +#define AARCH32_FPSCR_LEN_SHIFT 16 +#define AARCH32_FPSCR_LEN_MASK 0x70000U +#define AARCH32_FPSCR_LEN_GET( _reg ) \ + ( ( ( _reg ) >> 16 ) & 0x7U ) + +#define AARCH32_FPSCR_FZ16 0x80000U + +#define AARCH32_FPSCR_STRIDE( _val ) ( ( _val ) << 20 ) +#define AARCH32_FPSCR_STRIDE_SHIFT 20 +#define AARCH32_FPSCR_STRIDE_MASK 0x300000U +#define AARCH32_FPSCR_STRIDE_GET( _reg ) \ + ( ( ( _reg ) >> 20 ) & 0x3U ) + +#define AARCH32_FPSCR_RMODE( _val ) ( ( _val ) << 22 ) +#define AARCH32_FPSCR_RMODE_SHIFT 22 +#define AARCH32_FPSCR_RMODE_MASK 0xc00000U +#define AARCH32_FPSCR_RMODE_GET( _reg ) \ + ( ( ( _reg ) >> 22 ) & 0x3U ) + +#define AARCH32_FPSCR_FZ 0x1000000U + +#define AARCH32_FPSCR_DN 0x2000000U + +#define AARCH32_FPSCR_AHP 0x4000000U + +#define AARCH32_FPSCR_QC 0x8000000U + +#define AARCH32_FPSCR_V 0x10000000U + +#define AARCH32_FPSCR_C 0x20000000U + +#define AARCH32_FPSCR_Z 0x40000000U + +#define AARCH32_FPSCR_N 0x80000000U + +/* FPSID, Floating-Point System ID Register */ + +#define AARCH32_FPSID_REVISION( _val ) ( ( _val ) << 0 ) +#define AARCH32_FPSID_REVISION_SHIFT 0 +#define AARCH32_FPSID_REVISION_MASK 0xfU +#define AARCH32_FPSID_REVISION_GET( _reg ) \ + ( ( ( _reg ) >> 0 ) & 0xfU ) + +#define AARCH32_FPSID_VARIANT( _val ) ( ( _val ) << 4 ) +#define AARCH32_FPSID_VARIANT_SHIFT 4 +#define AARCH32_FPSID_VARIANT_MASK 0xf0U +#define AARCH32_FPSID_VARIANT_GET( _reg ) \ + ( ( ( _reg ) >> 4 ) & 0xfU ) + +#define AARCH32_FPSID_PARTNUM( _val ) ( ( _val ) << 8 ) +#define AARCH32_FPSID_PARTNUM_SHIFT 8 +#define AARCH32_FPSID_PARTNUM_MASK 0xff00U +#define AARCH32_FPSID_PARTNUM_GET( _reg ) \ + ( ( ( _reg ) >> 8 ) & 0xffU ) + +#define AARCH32_FPSID_SUBARCHITECTURE( _val ) ( ( _val ) << 16 ) +#define AARCH32_FPSID_SUBARCHITECTURE_SHIFT 16 +#define AARCH32_FPSID_SUBARCHITECTURE_MASK 0x7f0000U +#define AARCH32_FPSID_SUBARCHITECTURE_GET( _reg ) \ + ( ( ( _reg ) >> 16 ) & 0x7fU ) + +#define AARCH32_FPSID_SW 0x800000U + +#define AARCH32_FPSID_IMPLEMENTER( _val ) ( ( _val ) << 24 ) +#define AARCH32_FPSID_IMPLEMENTER_SHIFT 24 +#define AARCH32_FPSID_IMPLEMENTER_MASK 0xff000000U +#define AARCH32_FPSID_IMPLEMENTER_GET( _reg ) \ + ( ( ( _reg ) >> 24 ) & 0xffU ) + +/* HACR, Hyp Auxiliary Configuration Register */ + +static inline uint32_t _AArch32_Read_hacr( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 4, %0, c1, c1, 7" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_hacr( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 4, %0, c1, c1, 7" : : "r" ( value ) : "memory" + ); +} + +/* HACTLR, Hyp Auxiliary Control Register */ + +static inline uint32_t _AArch32_Read_hactlr( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 4, %0, c1, c0, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_hactlr( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 4, %0, c1, c0, 1" : : "r" ( value ) : "memory" + ); +} + +/* HACTLR2, Hyp Auxiliary Control Register 2 */ + +static inline uint32_t _AArch32_Read_hactlr2( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 4, %0, c1, c0, 3" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_hactlr2( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 4, %0, c1, c0, 3" : : "r" ( value ) : "memory" + ); +} + +/* HADFSR, Hyp Auxiliary Data Fault Status Register */ + +static inline uint32_t _AArch32_Read_hadfsr( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 4, %0, c5, c1, 0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_hadfsr( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 4, %0, c5, c1, 0" : : "r" ( value ) : "memory" + ); +} + +/* HAIFSR, Hyp Auxiliary Instruction Fault Status Register */ + +static inline uint32_t _AArch32_Read_haifsr( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 4, %0, c5, c1, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_haifsr( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 4, %0, c5, c1, 1" : : "r" ( value ) : "memory" + ); +} + +/* HAMAIR0, Hyp Auxiliary Memory Attribute Indirection Register 0 */ + +static inline uint32_t _AArch32_Read_hamair0( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 4, %0, c10, c3, 0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_hamair0( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 4, %0, c10, c3, 0" : : "r" ( value ) : "memory" + ); +} + +/* HAMAIR1, Hyp Auxiliary Memory Attribute Indirection Register 1 */ + +static inline uint32_t _AArch32_Read_hamair1( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 4, %0, c10, c3, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_hamair1( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 4, %0, c10, c3, 1" : : "r" ( value ) : "memory" + ); +} + +/* HCPTR, Hyp Architectural Feature Trap Register */ + +#define AARCH32_HCPTR_TCP10 0x400U + +#define AARCH32_HCPTR_TCP11 0x800U + +#define AARCH32_HCPTR_TASE 0x8000U + +#define AARCH32_HCPTR_TTA 0x100000U + +#define AARCH32_HCPTR_TAM 0x40000000U + +#define AARCH32_HCPTR_TCPAC 0x80000000U + +static inline uint32_t _AArch32_Read_hcptr( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 4, %0, c1, c1, 2" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_hcptr( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 4, %0, c1, c1, 2" : : "r" ( value ) : "memory" + ); +} + +/* HCR, Hyp Configuration Register */ + +#define AARCH32_HCR_VM 0x1U + +#define AARCH32_HCR_SWIO 0x2U + +#define AARCH32_HCR_PTW 0x4U + +#define AARCH32_HCR_FMO 0x8U + +#define AARCH32_HCR_IMO 0x10U + +#define AARCH32_HCR_AMO 0x20U + +#define AARCH32_HCR_VF 0x40U + +#define AARCH32_HCR_VI 0x80U + +#define AARCH32_HCR_VA 0x100U + +#define AARCH32_HCR_FB 0x200U + +#define AARCH32_HCR_BSU( _val ) ( ( _val ) << 10 ) +#define AARCH32_HCR_BSU_SHIFT 10 +#define AARCH32_HCR_BSU_MASK 0xc00U +#define AARCH32_HCR_BSU_GET( _reg ) \ + ( ( ( _reg ) >> 10 ) & 0x3U ) + +#define AARCH32_HCR_DC 0x1000U + +#define AARCH32_HCR_TWI 0x2000U + +#define AARCH32_HCR_TWE 0x4000U + +#define AARCH32_HCR_TID0 0x8000U + +#define AARCH32_HCR_TID1 0x10000U + +#define AARCH32_HCR_TID2 0x20000U + +#define AARCH32_HCR_TID3 0x40000U + +#define AARCH32_HCR_TSC 0x80000U + +#define AARCH32_HCR_TIDCP 0x100000U + +#define AARCH32_HCR_TAC 0x200000U + +#define AARCH32_HCR_TSW 0x400000U + +#define AARCH32_HCR_TPC 0x800000U + +#define AARCH32_HCR_TPU 0x1000000U + +#define AARCH32_HCR_TTLB 0x2000000U + +#define AARCH32_HCR_TVM 0x4000000U + +#define AARCH32_HCR_TGE 0x8000000U + +#define AARCH32_HCR_HCD 0x20000000U + +#define AARCH32_HCR_TRVM 0x40000000U + +static inline uint32_t _AArch32_Read_hcr( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 4, %0, c1, c1, 0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_hcr( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 4, %0, c1, c1, 0" : : "r" ( value ) : "memory" + ); +} + +/* HCR2, Hyp Configuration Register 2 */ + +#define AARCH32_HCR2_CD 0x1U + +#define AARCH32_HCR2_ID 0x2U + +#define AARCH32_HCR2_TERR 0x10U + +#define AARCH32_HCR2_TEA 0x20U + +#define AARCH32_HCR2_MIOCNCE 0x40U + +#define AARCH32_HCR2_TID4 0x20000U + +#define AARCH32_HCR2_TICAB 0x40000U + +#define AARCH32_HCR2_TOCU 0x100000U + +#define AARCH32_HCR2_TTLBIS 0x400000U + +static inline uint32_t _AArch32_Read_hcr2( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 4, %0, c1, c1, 4" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_hcr2( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 4, %0, c1, c1, 4" : : "r" ( value ) : "memory" + ); +} + +/* HDFAR, Hyp Data Fault Address Register */ + +static inline uint32_t _AArch32_Read_hdfar( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 4, %0, c6, c0, 0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_hdfar( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 4, %0, c6, c0, 0" : : "r" ( value ) : "memory" + ); +} + +/* HIFAR, Hyp Instruction Fault Address Register */ + +static inline uint32_t _AArch32_Read_hifar( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 4, %0, c6, c0, 2" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_hifar( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 4, %0, c6, c0, 2" : : "r" ( value ) : "memory" + ); +} + +/* HMAIR0, Hyp Memory Attribute Indirection Register 0 */ + +static inline uint32_t _AArch32_Read_hmair0( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 4, %0, c10, c2, 0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_hmair0( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 4, %0, c10, c2, 0" : : "r" ( value ) : "memory" + ); +} + +/* HMAIR1, Hyp Memory Attribute Indirection Register 1 */ + +static inline uint32_t _AArch32_Read_hmair1( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 4, %0, c10, c2, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_hmair1( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 4, %0, c10, c2, 1" : : "r" ( value ) : "memory" + ); +} + +/* HPFAR, Hyp IPA Fault Address Register */ + +#define AARCH32_HPFAR_FIPA_39_12( _val ) ( ( _val ) << 4 ) +#define AARCH32_HPFAR_FIPA_39_12_SHIFT 4 +#define AARCH32_HPFAR_FIPA_39_12_MASK 0xfffffff0U +#define AARCH32_HPFAR_FIPA_39_12_GET( _reg ) \ + ( ( ( _reg ) >> 4 ) & 0xfffffffU ) + +static inline uint32_t _AArch32_Read_hpfar( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 4, %0, c6, c0, 4" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_hpfar( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 4, %0, c6, c0, 4" : : "r" ( value ) : "memory" + ); +} + +/* HRMR, Hyp Reset Management Register */ + +#define AARCH32_HRMR_AA64 0x1U + +#define AARCH32_HRMR_RR 0x2U + +static inline uint32_t _AArch32_Read_hrmr( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 4, %0, c12, c0, 2" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_hrmr( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 4, %0, c12, c0, 2" : : "r" ( value ) : "memory" + ); +} + +/* HSCTLR, Hyp System Control Register */ + +#define AARCH32_HSCTLR_M 0x1U + +#define AARCH32_HSCTLR_A 0x2U + +#define AARCH32_HSCTLR_C 0x4U + +#define AARCH32_HSCTLR_NTLSMD 0x8U + +#define AARCH32_HSCTLR_LSMAOE 0x10U + +#define AARCH32_HSCTLR_CP15BEN 0x20U + +#define AARCH32_HSCTLR_ITD 0x80U + +#define AARCH32_HSCTLR_SED 0x100U + +#define AARCH32_HSCTLR_I 0x1000U + +#define AARCH32_HSCTLR_BR 0x20000U + +#define AARCH32_HSCTLR_WXN 0x80000U + +#define AARCH32_HSCTLR_FI 0x200000U + +#define AARCH32_HSCTLR_EE 0x2000000U + +#define AARCH32_HSCTLR_TE 0x40000000U + +#define AARCH32_HSCTLR_DSSBS 0x80000000U + +static inline uint32_t _AArch32_Read_hsctlr( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 4, %0, c1, c0, 0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_hsctlr( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 4, %0, c1, c0, 0" : : "r" ( value ) : "memory" + ); +} + +/* HSR, Hyp Syndrome Register */ + +#define AARCH32_HSR_DIRECTION 0x1U + +#define AARCH32_HSR_TI 0x1U + +#define AARCH32_HSR_COPROC( _val ) ( ( _val ) << 0 ) +#define AARCH32_HSR_COPROC_SHIFT 0 +#define AARCH32_HSR_COPROC_MASK 0xfU +#define AARCH32_HSR_COPROC_GET( _reg ) \ + ( ( ( _reg ) >> 0 ) & 0xfU ) + +#define AARCH32_HSR_DFSC( _val ) ( ( _val ) << 0 ) +#define AARCH32_HSR_DFSC_SHIFT 0 +#define AARCH32_HSR_DFSC_MASK 0x3fU +#define AARCH32_HSR_DFSC_GET( _reg ) \ + ( ( ( _reg ) >> 0 ) & 0x3fU ) + +#define AARCH32_HSR_IFSC( _val ) ( ( _val ) << 0 ) +#define AARCH32_HSR_IFSC_SHIFT 0 +#define AARCH32_HSR_IFSC_MASK 0x3fU +#define AARCH32_HSR_IFSC_GET( _reg ) \ + ( ( ( _reg ) >> 0 ) & 0x3fU ) + +#define AARCH32_HSR_IMM16( _val ) ( ( _val ) << 0 ) +#define AARCH32_HSR_IMM16_SHIFT 0 +#define AARCH32_HSR_IMM16_MASK 0xffffU +#define AARCH32_HSR_IMM16_GET( _reg ) \ + ( ( ( _reg ) >> 0 ) & 0xffffU ) + +#define AARCH32_HSR_ISS( _val ) ( ( _val ) << 0 ) +#define AARCH32_HSR_ISS_SHIFT 0 +#define AARCH32_HSR_ISS_MASK 0x1ffffffU +#define AARCH32_HSR_ISS_GET( _reg ) \ + ( ( ( _reg ) >> 0 ) & 0x1ffffffU ) + +#define AARCH32_HSR_AM( _val ) ( ( _val ) << 1 ) +#define AARCH32_HSR_AM_SHIFT 1 +#define AARCH32_HSR_AM_MASK 0xeU +#define AARCH32_HSR_AM_GET( _reg ) \ + ( ( ( _reg ) >> 1 ) & 0x7U ) + +#define AARCH32_HSR_CRM( _val ) ( ( _val ) << 1 ) +#define AARCH32_HSR_CRM_SHIFT 1 +#define AARCH32_HSR_CRM_MASK 0x1eU +#define AARCH32_HSR_CRM_GET( _reg ) \ + ( ( ( _reg ) >> 1 ) & 0xfU ) + +#define AARCH32_HSR_OFFSET 0x10U + +#define AARCH32_HSR_TA 0x20U + +#define AARCH32_HSR_RN( _val ) ( ( _val ) << 5 ) +#define AARCH32_HSR_RN_SHIFT 5 +#define AARCH32_HSR_RN_MASK 0x1e0U +#define AARCH32_HSR_RN_GET( _reg ) \ + ( ( ( _reg ) >> 5 ) & 0xfU ) + +#define AARCH32_HSR_RT( _val ) ( ( _val ) << 5 ) +#define AARCH32_HSR_RT_SHIFT 5 +#define AARCH32_HSR_RT_MASK 0x1e0U +#define AARCH32_HSR_RT_GET( _reg ) \ + ( ( ( _reg ) >> 5 ) & 0xfU ) + +#define AARCH32_HSR_WNR 0x40U + +#define AARCH32_HSR_S1PTW 0x80U + +#define AARCH32_HSR_CM 0x100U + +#define AARCH32_HSR_EA 0x200U + +#define AARCH32_HSR_FNV 0x400U + +#define AARCH32_HSR_AET( _val ) ( ( _val ) << 10 ) +#define AARCH32_HSR_AET_SHIFT 10 +#define AARCH32_HSR_AET_MASK 0xc00U +#define AARCH32_HSR_AET_GET( _reg ) \ + ( ( ( _reg ) >> 10 ) & 0x3U ) + +#define AARCH32_HSR_CRN( _val ) ( ( _val ) << 10 ) +#define AARCH32_HSR_CRN_SHIFT 10 +#define AARCH32_HSR_CRN_MASK 0x3c00U +#define AARCH32_HSR_CRN_GET( _reg ) \ + ( ( ( _reg ) >> 10 ) & 0xfU ) + +#define AARCH32_HSR_RT2( _val ) ( ( _val ) << 10 ) +#define AARCH32_HSR_RT2_SHIFT 10 +#define AARCH32_HSR_RT2_MASK 0x3c00U +#define AARCH32_HSR_RT2_GET( _reg ) \ + ( ( ( _reg ) >> 10 ) & 0xfU ) + +#define AARCH32_HSR_IMM8( _val ) ( ( _val ) << 12 ) +#define AARCH32_HSR_IMM8_SHIFT 12 +#define AARCH32_HSR_IMM8_MASK 0xff000U +#define AARCH32_HSR_IMM8_GET( _reg ) \ + ( ( ( _reg ) >> 12 ) & 0xffU ) + +#define AARCH32_HSR_AR 0x4000U + +#define AARCH32_HSR_OPC1_0( _val ) ( ( _val ) << 14 ) +#define AARCH32_HSR_OPC1_SHIFT_0 14 +#define AARCH32_HSR_OPC1_MASK_0 0x1c000U +#define AARCH32_HSR_OPC1_GET_0( _reg ) \ + ( ( ( _reg ) >> 14 ) & 0x7U ) + +#define AARCH32_HSR_OPC1_1( _val ) ( ( _val ) << 16 ) +#define AARCH32_HSR_OPC1_SHIFT_1 16 +#define AARCH32_HSR_OPC1_MASK_1 0xf0000U +#define AARCH32_HSR_OPC1_GET_1( _reg ) \ + ( ( ( _reg ) >> 16 ) & 0xfU ) + +#define AARCH32_HSR_SRT( _val ) ( ( _val ) << 16 ) +#define AARCH32_HSR_SRT_SHIFT 16 +#define AARCH32_HSR_SRT_MASK 0xf0000U +#define AARCH32_HSR_SRT_GET( _reg ) \ + ( ( ( _reg ) >> 16 ) & 0xfU ) + +#define AARCH32_HSR_OPC2( _val ) ( ( _val ) << 17 ) +#define AARCH32_HSR_OPC2_SHIFT 17 +#define AARCH32_HSR_OPC2_MASK 0xe0000U +#define AARCH32_HSR_OPC2_GET( _reg ) \ + ( ( ( _reg ) >> 17 ) & 0x7U ) + +#define AARCH32_HSR_CCKNOWNPASS 0x80000U + +#define AARCH32_HSR_COND( _val ) ( ( _val ) << 20 ) +#define AARCH32_HSR_COND_SHIFT 20 +#define AARCH32_HSR_COND_MASK 0xf00000U +#define AARCH32_HSR_COND_GET( _reg ) \ + ( ( ( _reg ) >> 20 ) & 0xfU ) + +#define AARCH32_HSR_SSE 0x200000U + +#define AARCH32_HSR_SAS( _val ) ( ( _val ) << 22 ) +#define AARCH32_HSR_SAS_SHIFT 22 +#define AARCH32_HSR_SAS_MASK 0xc00000U +#define AARCH32_HSR_SAS_GET( _reg ) \ + ( ( ( _reg ) >> 22 ) & 0x3U ) + +#define AARCH32_HSR_CV 0x1000000U + +#define AARCH32_HSR_ISV 0x1000000U + +#define AARCH32_HSR_IL 0x2000000U + +#define AARCH32_HSR_EC( _val ) ( ( _val ) << 26 ) +#define AARCH32_HSR_EC_SHIFT 26 +#define AARCH32_HSR_EC_MASK 0xfc000000U +#define AARCH32_HSR_EC_GET( _reg ) \ + ( ( ( _reg ) >> 26 ) & 0x3fU ) + +static inline uint32_t _AArch32_Read_hsr( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 4, %0, c5, c2, 0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_hsr( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 4, %0, c5, c2, 0" : : "r" ( value ) : "memory" + ); +} + +/* HSTR, Hyp System Trap Register */ + +static inline uint32_t _AArch32_Read_hstr( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 4, %0, c1, c1, 3" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_hstr( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 4, %0, c1, c1, 3" : : "r" ( value ) : "memory" + ); +} + +/* HTCR, Hyp Translation Control Register */ + +#define AARCH32_HTCR_T0SZ( _val ) ( ( _val ) << 0 ) +#define AARCH32_HTCR_T0SZ_SHIFT 0 +#define AARCH32_HTCR_T0SZ_MASK 0x7U +#define AARCH32_HTCR_T0SZ_GET( _reg ) \ + ( ( ( _reg ) >> 0 ) & 0x7U ) + +#define AARCH32_HTCR_IRGN0( _val ) ( ( _val ) << 8 ) +#define AARCH32_HTCR_IRGN0_SHIFT 8 +#define AARCH32_HTCR_IRGN0_MASK 0x300U +#define AARCH32_HTCR_IRGN0_GET( _reg ) \ + ( ( ( _reg ) >> 8 ) & 0x3U ) + +#define AARCH32_HTCR_ORGN0( _val ) ( ( _val ) << 10 ) +#define AARCH32_HTCR_ORGN0_SHIFT 10 +#define AARCH32_HTCR_ORGN0_MASK 0xc00U +#define AARCH32_HTCR_ORGN0_GET( _reg ) \ + ( ( ( _reg ) >> 10 ) & 0x3U ) + +#define AARCH32_HTCR_SH0( _val ) ( ( _val ) << 12 ) +#define AARCH32_HTCR_SH0_SHIFT 12 +#define AARCH32_HTCR_SH0_MASK 0x3000U +#define AARCH32_HTCR_SH0_GET( _reg ) \ + ( ( ( _reg ) >> 12 ) & 0x3U ) + +#define AARCH32_HTCR_HPD 0x1000000U + +#define AARCH32_HTCR_HWU59 0x2000000U + +#define AARCH32_HTCR_HWU60 0x4000000U + +#define AARCH32_HTCR_HWU61 0x8000000U + +#define AARCH32_HTCR_HWU62 0x10000000U + +static inline uint32_t _AArch32_Read_htcr( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 4, %0, c2, c0, 2" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_htcr( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 4, %0, c2, c0, 2" : : "r" ( value ) : "memory" + ); +} + +/* HTPIDR, Hyp Software Thread ID Register */ + +static inline uint32_t _AArch32_Read_htpidr( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 4, %0, c13, c0, 2" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_htpidr( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 4, %0, c13, c0, 2" : : "r" ( value ) : "memory" + ); +} + +/* HTTBR, Hyp Translation Table Base Register */ + +#define AARCH32_HTTBR_CNP 0x1U + +#define AARCH32_HTTBR_BADDR( _val ) ( ( _val ) << 1 ) +#define AARCH32_HTTBR_BADDR_SHIFT 1 +#define AARCH32_HTTBR_BADDR_MASK 0xfffffffffffeULL +#define AARCH32_HTTBR_BADDR_GET( _reg ) \ + ( ( ( _reg ) >> 1 ) & 0x7fffffffffffULL ) + +static inline uint64_t _AArch32_Read_httbr( void ) +{ + uint64_t value; + + __asm__ volatile ( + "mrrc p15, 4, %Q0, %R0, c2" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_httbr( uint64_t value ) +{ + __asm__ volatile ( + "mcrr p15, 4, %Q0, %R0, c2" : : "r" ( value ) : "memory" + ); +} + +/* HVBAR, Hyp Vector Base Address Register */ + +static inline uint32_t _AArch32_Read_hvbar( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 4, %0, c12, c0, 0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_hvbar( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 4, %0, c12, c0, 0" : : "r" ( value ) : "memory" + ); +} + +/* ICIALLU, Instruction Cache Invalidate All to PoU */ + +static inline void _AArch32_Write_iciallu( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c7, c5, 0" : : "r" ( value ) : "memory" + ); +} + +/* ICIALLUIS, Instruction Cache Invalidate All to PoU, Inner Shareable */ + +static inline void _AArch32_Write_icialluis( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c7, c1, 0" : : "r" ( value ) : "memory" + ); +} + +/* ICIMVAU, Instruction Cache line Invalidate by VA to PoU */ + +static inline void _AArch32_Write_icimvau( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c7, c5, 1" : : "r" ( value ) : "memory" + ); +} + +/* ID_AFR0, Auxiliary Feature Register 0 */ + +static inline uint32_t _AArch32_Read_id_afr0( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c0, c1, 3" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +/* ID_DFR0, Debug Feature Register 0 */ + +#define AARCH32_ID_DFR0_COPDBG( _val ) ( ( _val ) << 0 ) +#define AARCH32_ID_DFR0_COPDBG_SHIFT 0 +#define AARCH32_ID_DFR0_COPDBG_MASK 0xfU +#define AARCH32_ID_DFR0_COPDBG_GET( _reg ) \ + ( ( ( _reg ) >> 0 ) & 0xfU ) + +#define AARCH32_ID_DFR0_COPSDBG( _val ) ( ( _val ) << 4 ) +#define AARCH32_ID_DFR0_COPSDBG_SHIFT 4 +#define AARCH32_ID_DFR0_COPSDBG_MASK 0xf0U +#define AARCH32_ID_DFR0_COPSDBG_GET( _reg ) \ + ( ( ( _reg ) >> 4 ) & 0xfU ) + +#define AARCH32_ID_DFR0_MMAPDBG( _val ) ( ( _val ) << 8 ) +#define AARCH32_ID_DFR0_MMAPDBG_SHIFT 8 +#define AARCH32_ID_DFR0_MMAPDBG_MASK 0xf00U +#define AARCH32_ID_DFR0_MMAPDBG_GET( _reg ) \ + ( ( ( _reg ) >> 8 ) & 0xfU ) + +#define AARCH32_ID_DFR0_COPTRC( _val ) ( ( _val ) << 12 ) +#define AARCH32_ID_DFR0_COPTRC_SHIFT 12 +#define AARCH32_ID_DFR0_COPTRC_MASK 0xf000U +#define AARCH32_ID_DFR0_COPTRC_GET( _reg ) \ + ( ( ( _reg ) >> 12 ) & 0xfU ) + +#define AARCH32_ID_DFR0_MMAPTRC( _val ) ( ( _val ) << 16 ) +#define AARCH32_ID_DFR0_MMAPTRC_SHIFT 16 +#define AARCH32_ID_DFR0_MMAPTRC_MASK 0xf0000U +#define AARCH32_ID_DFR0_MMAPTRC_GET( _reg ) \ + ( ( ( _reg ) >> 16 ) & 0xfU ) + +#define AARCH32_ID_DFR0_MPROFDBG( _val ) ( ( _val ) << 20 ) +#define AARCH32_ID_DFR0_MPROFDBG_SHIFT 20 +#define AARCH32_ID_DFR0_MPROFDBG_MASK 0xf00000U +#define AARCH32_ID_DFR0_MPROFDBG_GET( _reg ) \ + ( ( ( _reg ) >> 20 ) & 0xfU ) + +#define AARCH32_ID_DFR0_PERFMON( _val ) ( ( _val ) << 24 ) +#define AARCH32_ID_DFR0_PERFMON_SHIFT 24 +#define AARCH32_ID_DFR0_PERFMON_MASK 0xf000000U +#define AARCH32_ID_DFR0_PERFMON_GET( _reg ) \ + ( ( ( _reg ) >> 24 ) & 0xfU ) + +#define AARCH32_ID_DFR0_TRACEFILT( _val ) ( ( _val ) << 28 ) +#define AARCH32_ID_DFR0_TRACEFILT_SHIFT 28 +#define AARCH32_ID_DFR0_TRACEFILT_MASK 0xf0000000U +#define AARCH32_ID_DFR0_TRACEFILT_GET( _reg ) \ + ( ( ( _reg ) >> 28 ) & 0xfU ) + +static inline uint32_t _AArch32_Read_id_dfr0( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c0, c1, 2" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +/* ID_DFR1, Debug Feature Register 1 */ + +#define AARCH32_ID_DFR1_MTPMU( _val ) ( ( _val ) << 0 ) +#define AARCH32_ID_DFR1_MTPMU_SHIFT 0 +#define AARCH32_ID_DFR1_MTPMU_MASK 0xfU +#define AARCH32_ID_DFR1_MTPMU_GET( _reg ) \ + ( ( ( _reg ) >> 0 ) & 0xfU ) + +static inline uint32_t _AArch32_Read_id_dfr1( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c0, c3, 5" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +/* ID_ISAR0, Instruction Set Attribute Register 0 */ + +#define AARCH32_ID_ISAR0_SWAP( _val ) ( ( _val ) << 0 ) +#define AARCH32_ID_ISAR0_SWAP_SHIFT 0 +#define AARCH32_ID_ISAR0_SWAP_MASK 0xfU +#define AARCH32_ID_ISAR0_SWAP_GET( _reg ) \ + ( ( ( _reg ) >> 0 ) & 0xfU ) + +#define AARCH32_ID_ISAR0_BITCOUNT( _val ) ( ( _val ) << 4 ) +#define AARCH32_ID_ISAR0_BITCOUNT_SHIFT 4 +#define AARCH32_ID_ISAR0_BITCOUNT_MASK 0xf0U +#define AARCH32_ID_ISAR0_BITCOUNT_GET( _reg ) \ + ( ( ( _reg ) >> 4 ) & 0xfU ) + +#define AARCH32_ID_ISAR0_BITFIELD( _val ) ( ( _val ) << 8 ) +#define AARCH32_ID_ISAR0_BITFIELD_SHIFT 8 +#define AARCH32_ID_ISAR0_BITFIELD_MASK 0xf00U +#define AARCH32_ID_ISAR0_BITFIELD_GET( _reg ) \ + ( ( ( _reg ) >> 8 ) & 0xfU ) + +#define AARCH32_ID_ISAR0_CMPBRANCH( _val ) ( ( _val ) << 12 ) +#define AARCH32_ID_ISAR0_CMPBRANCH_SHIFT 12 +#define AARCH32_ID_ISAR0_CMPBRANCH_MASK 0xf000U +#define AARCH32_ID_ISAR0_CMPBRANCH_GET( _reg ) \ + ( ( ( _reg ) >> 12 ) & 0xfU ) + +#define AARCH32_ID_ISAR0_COPROC( _val ) ( ( _val ) << 16 ) +#define AARCH32_ID_ISAR0_COPROC_SHIFT 16 +#define AARCH32_ID_ISAR0_COPROC_MASK 0xf0000U +#define AARCH32_ID_ISAR0_COPROC_GET( _reg ) \ + ( ( ( _reg ) >> 16 ) & 0xfU ) + +#define AARCH32_ID_ISAR0_DEBUG( _val ) ( ( _val ) << 20 ) +#define AARCH32_ID_ISAR0_DEBUG_SHIFT 20 +#define AARCH32_ID_ISAR0_DEBUG_MASK 0xf00000U +#define AARCH32_ID_ISAR0_DEBUG_GET( _reg ) \ + ( ( ( _reg ) >> 20 ) & 0xfU ) + +#define AARCH32_ID_ISAR0_DIVIDE( _val ) ( ( _val ) << 24 ) +#define AARCH32_ID_ISAR0_DIVIDE_SHIFT 24 +#define AARCH32_ID_ISAR0_DIVIDE_MASK 0xf000000U +#define AARCH32_ID_ISAR0_DIVIDE_GET( _reg ) \ + ( ( ( _reg ) >> 24 ) & 0xfU ) + +static inline uint32_t _AArch32_Read_id_isar0( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c0, c2, 0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +/* ID_ISAR1, Instruction Set Attribute Register 1 */ + +#define AARCH32_ID_ISAR1_ENDIAN( _val ) ( ( _val ) << 0 ) +#define AARCH32_ID_ISAR1_ENDIAN_SHIFT 0 +#define AARCH32_ID_ISAR1_ENDIAN_MASK 0xfU +#define AARCH32_ID_ISAR1_ENDIAN_GET( _reg ) \ + ( ( ( _reg ) >> 0 ) & 0xfU ) + +#define AARCH32_ID_ISAR1_EXCEPT( _val ) ( ( _val ) << 4 ) +#define AARCH32_ID_ISAR1_EXCEPT_SHIFT 4 +#define AARCH32_ID_ISAR1_EXCEPT_MASK 0xf0U +#define AARCH32_ID_ISAR1_EXCEPT_GET( _reg ) \ + ( ( ( _reg ) >> 4 ) & 0xfU ) + +#define AARCH32_ID_ISAR1_EXCEPT_AR( _val ) ( ( _val ) << 8 ) +#define AARCH32_ID_ISAR1_EXCEPT_AR_SHIFT 8 +#define AARCH32_ID_ISAR1_EXCEPT_AR_MASK 0xf00U +#define AARCH32_ID_ISAR1_EXCEPT_AR_GET( _reg ) \ + ( ( ( _reg ) >> 8 ) & 0xfU ) + +#define AARCH32_ID_ISAR1_EXTEND( _val ) ( ( _val ) << 12 ) +#define AARCH32_ID_ISAR1_EXTEND_SHIFT 12 +#define AARCH32_ID_ISAR1_EXTEND_MASK 0xf000U +#define AARCH32_ID_ISAR1_EXTEND_GET( _reg ) \ + ( ( ( _reg ) >> 12 ) & 0xfU ) + +#define AARCH32_ID_ISAR1_IFTHEN( _val ) ( ( _val ) << 16 ) +#define AARCH32_ID_ISAR1_IFTHEN_SHIFT 16 +#define AARCH32_ID_ISAR1_IFTHEN_MASK 0xf0000U +#define AARCH32_ID_ISAR1_IFTHEN_GET( _reg ) \ + ( ( ( _reg ) >> 16 ) & 0xfU ) + +#define AARCH32_ID_ISAR1_IMMEDIATE( _val ) ( ( _val ) << 20 ) +#define AARCH32_ID_ISAR1_IMMEDIATE_SHIFT 20 +#define AARCH32_ID_ISAR1_IMMEDIATE_MASK 0xf00000U +#define AARCH32_ID_ISAR1_IMMEDIATE_GET( _reg ) \ + ( ( ( _reg ) >> 20 ) & 0xfU ) + +#define AARCH32_ID_ISAR1_INTERWORK( _val ) ( ( _val ) << 24 ) +#define AARCH32_ID_ISAR1_INTERWORK_SHIFT 24 +#define AARCH32_ID_ISAR1_INTERWORK_MASK 0xf000000U +#define AARCH32_ID_ISAR1_INTERWORK_GET( _reg ) \ + ( ( ( _reg ) >> 24 ) & 0xfU ) + +#define AARCH32_ID_ISAR1_JAZELLE( _val ) ( ( _val ) << 28 ) +#define AARCH32_ID_ISAR1_JAZELLE_SHIFT 28 +#define AARCH32_ID_ISAR1_JAZELLE_MASK 0xf0000000U +#define AARCH32_ID_ISAR1_JAZELLE_GET( _reg ) \ + ( ( ( _reg ) >> 28 ) & 0xfU ) + +static inline uint32_t _AArch32_Read_id_isar1( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c0, c2, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +/* ID_ISAR2, Instruction Set Attribute Register 2 */ + +#define AARCH32_ID_ISAR2_LOADSTORE( _val ) ( ( _val ) << 0 ) +#define AARCH32_ID_ISAR2_LOADSTORE_SHIFT 0 +#define AARCH32_ID_ISAR2_LOADSTORE_MASK 0xfU +#define AARCH32_ID_ISAR2_LOADSTORE_GET( _reg ) \ + ( ( ( _reg ) >> 0 ) & 0xfU ) + +#define AARCH32_ID_ISAR2_MEMHINT( _val ) ( ( _val ) << 4 ) +#define AARCH32_ID_ISAR2_MEMHINT_SHIFT 4 +#define AARCH32_ID_ISAR2_MEMHINT_MASK 0xf0U +#define AARCH32_ID_ISAR2_MEMHINT_GET( _reg ) \ + ( ( ( _reg ) >> 4 ) & 0xfU ) + +#define AARCH32_ID_ISAR2_MULTIACCESSINT( _val ) ( ( _val ) << 8 ) +#define AARCH32_ID_ISAR2_MULTIACCESSINT_SHIFT 8 +#define AARCH32_ID_ISAR2_MULTIACCESSINT_MASK 0xf00U +#define AARCH32_ID_ISAR2_MULTIACCESSINT_GET( _reg ) \ + ( ( ( _reg ) >> 8 ) & 0xfU ) + +#define AARCH32_ID_ISAR2_MULT( _val ) ( ( _val ) << 12 ) +#define AARCH32_ID_ISAR2_MULT_SHIFT 12 +#define AARCH32_ID_ISAR2_MULT_MASK 0xf000U +#define AARCH32_ID_ISAR2_MULT_GET( _reg ) \ + ( ( ( _reg ) >> 12 ) & 0xfU ) + +#define AARCH32_ID_ISAR2_MULTS( _val ) ( ( _val ) << 16 ) +#define AARCH32_ID_ISAR2_MULTS_SHIFT 16 +#define AARCH32_ID_ISAR2_MULTS_MASK 0xf0000U +#define AARCH32_ID_ISAR2_MULTS_GET( _reg ) \ + ( ( ( _reg ) >> 16 ) & 0xfU ) + +#define AARCH32_ID_ISAR2_MULTU( _val ) ( ( _val ) << 20 ) +#define AARCH32_ID_ISAR2_MULTU_SHIFT 20 +#define AARCH32_ID_ISAR2_MULTU_MASK 0xf00000U +#define AARCH32_ID_ISAR2_MULTU_GET( _reg ) \ + ( ( ( _reg ) >> 20 ) & 0xfU ) + +#define AARCH32_ID_ISAR2_PSR_AR( _val ) ( ( _val ) << 24 ) +#define AARCH32_ID_ISAR2_PSR_AR_SHIFT 24 +#define AARCH32_ID_ISAR2_PSR_AR_MASK 0xf000000U +#define AARCH32_ID_ISAR2_PSR_AR_GET( _reg ) \ + ( ( ( _reg ) >> 24 ) & 0xfU ) + +#define AARCH32_ID_ISAR2_REVERSAL( _val ) ( ( _val ) << 28 ) +#define AARCH32_ID_ISAR2_REVERSAL_SHIFT 28 +#define AARCH32_ID_ISAR2_REVERSAL_MASK 0xf0000000U +#define AARCH32_ID_ISAR2_REVERSAL_GET( _reg ) \ + ( ( ( _reg ) >> 28 ) & 0xfU ) + +static inline uint32_t _AArch32_Read_id_isar2( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c0, c2, 2" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +/* ID_ISAR3, Instruction Set Attribute Register 3 */ + +#define AARCH32_ID_ISAR3_SATURATE( _val ) ( ( _val ) << 0 ) +#define AARCH32_ID_ISAR3_SATURATE_SHIFT 0 +#define AARCH32_ID_ISAR3_SATURATE_MASK 0xfU +#define AARCH32_ID_ISAR3_SATURATE_GET( _reg ) \ + ( ( ( _reg ) >> 0 ) & 0xfU ) + +#define AARCH32_ID_ISAR3_SIMD( _val ) ( ( _val ) << 4 ) +#define AARCH32_ID_ISAR3_SIMD_SHIFT 4 +#define AARCH32_ID_ISAR3_SIMD_MASK 0xf0U +#define AARCH32_ID_ISAR3_SIMD_GET( _reg ) \ + ( ( ( _reg ) >> 4 ) & 0xfU ) + +#define AARCH32_ID_ISAR3_SVC( _val ) ( ( _val ) << 8 ) +#define AARCH32_ID_ISAR3_SVC_SHIFT 8 +#define AARCH32_ID_ISAR3_SVC_MASK 0xf00U +#define AARCH32_ID_ISAR3_SVC_GET( _reg ) \ + ( ( ( _reg ) >> 8 ) & 0xfU ) + +#define AARCH32_ID_ISAR3_SYNCHPRIM( _val ) ( ( _val ) << 12 ) +#define AARCH32_ID_ISAR3_SYNCHPRIM_SHIFT 12 +#define AARCH32_ID_ISAR3_SYNCHPRIM_MASK 0xf000U +#define AARCH32_ID_ISAR3_SYNCHPRIM_GET( _reg ) \ + ( ( ( _reg ) >> 12 ) & 0xfU ) + +#define AARCH32_ID_ISAR3_TABBRANCH( _val ) ( ( _val ) << 16 ) +#define AARCH32_ID_ISAR3_TABBRANCH_SHIFT 16 +#define AARCH32_ID_ISAR3_TABBRANCH_MASK 0xf0000U +#define AARCH32_ID_ISAR3_TABBRANCH_GET( _reg ) \ + ( ( ( _reg ) >> 16 ) & 0xfU ) + +#define AARCH32_ID_ISAR3_T32COPY( _val ) ( ( _val ) << 20 ) +#define AARCH32_ID_ISAR3_T32COPY_SHIFT 20 +#define AARCH32_ID_ISAR3_T32COPY_MASK 0xf00000U +#define AARCH32_ID_ISAR3_T32COPY_GET( _reg ) \ + ( ( ( _reg ) >> 20 ) & 0xfU ) + +#define AARCH32_ID_ISAR3_TRUENOP( _val ) ( ( _val ) << 24 ) +#define AARCH32_ID_ISAR3_TRUENOP_SHIFT 24 +#define AARCH32_ID_ISAR3_TRUENOP_MASK 0xf000000U +#define AARCH32_ID_ISAR3_TRUENOP_GET( _reg ) \ + ( ( ( _reg ) >> 24 ) & 0xfU ) + +#define AARCH32_ID_ISAR3_T32EE( _val ) ( ( _val ) << 28 ) +#define AARCH32_ID_ISAR3_T32EE_SHIFT 28 +#define AARCH32_ID_ISAR3_T32EE_MASK 0xf0000000U +#define AARCH32_ID_ISAR3_T32EE_GET( _reg ) \ + ( ( ( _reg ) >> 28 ) & 0xfU ) + +static inline uint32_t _AArch32_Read_id_isar3( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c0, c2, 3" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +/* ID_ISAR4, Instruction Set Attribute Register 4 */ + +#define AARCH32_ID_ISAR4_UNPRIV( _val ) ( ( _val ) << 0 ) +#define AARCH32_ID_ISAR4_UNPRIV_SHIFT 0 +#define AARCH32_ID_ISAR4_UNPRIV_MASK 0xfU +#define AARCH32_ID_ISAR4_UNPRIV_GET( _reg ) \ + ( ( ( _reg ) >> 0 ) & 0xfU ) + +#define AARCH32_ID_ISAR4_WITHSHIFTS( _val ) ( ( _val ) << 4 ) +#define AARCH32_ID_ISAR4_WITHSHIFTS_SHIFT 4 +#define AARCH32_ID_ISAR4_WITHSHIFTS_MASK 0xf0U +#define AARCH32_ID_ISAR4_WITHSHIFTS_GET( _reg ) \ + ( ( ( _reg ) >> 4 ) & 0xfU ) + +#define AARCH32_ID_ISAR4_WRITEBACK( _val ) ( ( _val ) << 8 ) +#define AARCH32_ID_ISAR4_WRITEBACK_SHIFT 8 +#define AARCH32_ID_ISAR4_WRITEBACK_MASK 0xf00U +#define AARCH32_ID_ISAR4_WRITEBACK_GET( _reg ) \ + ( ( ( _reg ) >> 8 ) & 0xfU ) + +#define AARCH32_ID_ISAR4_SMC( _val ) ( ( _val ) << 12 ) +#define AARCH32_ID_ISAR4_SMC_SHIFT 12 +#define AARCH32_ID_ISAR4_SMC_MASK 0xf000U +#define AARCH32_ID_ISAR4_SMC_GET( _reg ) \ + ( ( ( _reg ) >> 12 ) & 0xfU ) + +#define AARCH32_ID_ISAR4_BARRIER( _val ) ( ( _val ) << 16 ) +#define AARCH32_ID_ISAR4_BARRIER_SHIFT 16 +#define AARCH32_ID_ISAR4_BARRIER_MASK 0xf0000U +#define AARCH32_ID_ISAR4_BARRIER_GET( _reg ) \ + ( ( ( _reg ) >> 16 ) & 0xfU ) + +#define AARCH32_ID_ISAR4_SYNCHPRIM_FRAC( _val ) ( ( _val ) << 20 ) +#define AARCH32_ID_ISAR4_SYNCHPRIM_FRAC_SHIFT 20 +#define AARCH32_ID_ISAR4_SYNCHPRIM_FRAC_MASK 0xf00000U +#define AARCH32_ID_ISAR4_SYNCHPRIM_FRAC_GET( _reg ) \ + ( ( ( _reg ) >> 20 ) & 0xfU ) + +#define AARCH32_ID_ISAR4_PSR_M( _val ) ( ( _val ) << 24 ) +#define AARCH32_ID_ISAR4_PSR_M_SHIFT 24 +#define AARCH32_ID_ISAR4_PSR_M_MASK 0xf000000U +#define AARCH32_ID_ISAR4_PSR_M_GET( _reg ) \ + ( ( ( _reg ) >> 24 ) & 0xfU ) + +#define AARCH32_ID_ISAR4_SWP_FRAC( _val ) ( ( _val ) << 28 ) +#define AARCH32_ID_ISAR4_SWP_FRAC_SHIFT 28 +#define AARCH32_ID_ISAR4_SWP_FRAC_MASK 0xf0000000U +#define AARCH32_ID_ISAR4_SWP_FRAC_GET( _reg ) \ + ( ( ( _reg ) >> 28 ) & 0xfU ) + +static inline uint32_t _AArch32_Read_id_isar4( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c0, c2, 4" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +/* ID_ISAR5, Instruction Set Attribute Register 5 */ + +#define AARCH32_ID_ISAR5_SEVL( _val ) ( ( _val ) << 0 ) +#define AARCH32_ID_ISAR5_SEVL_SHIFT 0 +#define AARCH32_ID_ISAR5_SEVL_MASK 0xfU +#define AARCH32_ID_ISAR5_SEVL_GET( _reg ) \ + ( ( ( _reg ) >> 0 ) & 0xfU ) + +#define AARCH32_ID_ISAR5_AES( _val ) ( ( _val ) << 4 ) +#define AARCH32_ID_ISAR5_AES_SHIFT 4 +#define AARCH32_ID_ISAR5_AES_MASK 0xf0U +#define AARCH32_ID_ISAR5_AES_GET( _reg ) \ + ( ( ( _reg ) >> 4 ) & 0xfU ) + +#define AARCH32_ID_ISAR5_SHA1( _val ) ( ( _val ) << 8 ) +#define AARCH32_ID_ISAR5_SHA1_SHIFT 8 +#define AARCH32_ID_ISAR5_SHA1_MASK 0xf00U +#define AARCH32_ID_ISAR5_SHA1_GET( _reg ) \ + ( ( ( _reg ) >> 8 ) & 0xfU ) + +#define AARCH32_ID_ISAR5_SHA2( _val ) ( ( _val ) << 12 ) +#define AARCH32_ID_ISAR5_SHA2_SHIFT 12 +#define AARCH32_ID_ISAR5_SHA2_MASK 0xf000U +#define AARCH32_ID_ISAR5_SHA2_GET( _reg ) \ + ( ( ( _reg ) >> 12 ) & 0xfU ) + +#define AARCH32_ID_ISAR5_CRC32( _val ) ( ( _val ) << 16 ) +#define AARCH32_ID_ISAR5_CRC32_SHIFT 16 +#define AARCH32_ID_ISAR5_CRC32_MASK 0xf0000U +#define AARCH32_ID_ISAR5_CRC32_GET( _reg ) \ + ( ( ( _reg ) >> 16 ) & 0xfU ) + +#define AARCH32_ID_ISAR5_RDM( _val ) ( ( _val ) << 24 ) +#define AARCH32_ID_ISAR5_RDM_SHIFT 24 +#define AARCH32_ID_ISAR5_RDM_MASK 0xf000000U +#define AARCH32_ID_ISAR5_RDM_GET( _reg ) \ + ( ( ( _reg ) >> 24 ) & 0xfU ) + +#define AARCH32_ID_ISAR5_VCMA( _val ) ( ( _val ) << 28 ) +#define AARCH32_ID_ISAR5_VCMA_SHIFT 28 +#define AARCH32_ID_ISAR5_VCMA_MASK 0xf0000000U +#define AARCH32_ID_ISAR5_VCMA_GET( _reg ) \ + ( ( ( _reg ) >> 28 ) & 0xfU ) + +static inline uint32_t _AArch32_Read_id_isar5( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c0, c2, 5" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +/* ID_ISAR6, Instruction Set Attribute Register 6 */ + +#define AARCH32_ID_ISAR6_JSCVT( _val ) ( ( _val ) << 0 ) +#define AARCH32_ID_ISAR6_JSCVT_SHIFT 0 +#define AARCH32_ID_ISAR6_JSCVT_MASK 0xfU +#define AARCH32_ID_ISAR6_JSCVT_GET( _reg ) \ + ( ( ( _reg ) >> 0 ) & 0xfU ) + +#define AARCH32_ID_ISAR6_DP( _val ) ( ( _val ) << 4 ) +#define AARCH32_ID_ISAR6_DP_SHIFT 4 +#define AARCH32_ID_ISAR6_DP_MASK 0xf0U +#define AARCH32_ID_ISAR6_DP_GET( _reg ) \ + ( ( ( _reg ) >> 4 ) & 0xfU ) + +#define AARCH32_ID_ISAR6_FHM( _val ) ( ( _val ) << 8 ) +#define AARCH32_ID_ISAR6_FHM_SHIFT 8 +#define AARCH32_ID_ISAR6_FHM_MASK 0xf00U +#define AARCH32_ID_ISAR6_FHM_GET( _reg ) \ + ( ( ( _reg ) >> 8 ) & 0xfU ) + +#define AARCH32_ID_ISAR6_SB( _val ) ( ( _val ) << 12 ) +#define AARCH32_ID_ISAR6_SB_SHIFT 12 +#define AARCH32_ID_ISAR6_SB_MASK 0xf000U +#define AARCH32_ID_ISAR6_SB_GET( _reg ) \ + ( ( ( _reg ) >> 12 ) & 0xfU ) + +#define AARCH32_ID_ISAR6_SPECRES( _val ) ( ( _val ) << 16 ) +#define AARCH32_ID_ISAR6_SPECRES_SHIFT 16 +#define AARCH32_ID_ISAR6_SPECRES_MASK 0xf0000U +#define AARCH32_ID_ISAR6_SPECRES_GET( _reg ) \ + ( ( ( _reg ) >> 16 ) & 0xfU ) + +#define AARCH32_ID_ISAR6_BF16( _val ) ( ( _val ) << 20 ) +#define AARCH32_ID_ISAR6_BF16_SHIFT 20 +#define AARCH32_ID_ISAR6_BF16_MASK 0xf00000U +#define AARCH32_ID_ISAR6_BF16_GET( _reg ) \ + ( ( ( _reg ) >> 20 ) & 0xfU ) + +#define AARCH32_ID_ISAR6_I8MM( _val ) ( ( _val ) << 24 ) +#define AARCH32_ID_ISAR6_I8MM_SHIFT 24 +#define AARCH32_ID_ISAR6_I8MM_MASK 0xf000000U +#define AARCH32_ID_ISAR6_I8MM_GET( _reg ) \ + ( ( ( _reg ) >> 24 ) & 0xfU ) + +static inline uint32_t _AArch32_Read_id_isar6( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c0, c2, 7" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +/* ID_MMFR0, Memory Model Feature Register 0 */ + +#define AARCH32_ID_MMFR0_VMSA( _val ) ( ( _val ) << 0 ) +#define AARCH32_ID_MMFR0_VMSA_SHIFT 0 +#define AARCH32_ID_MMFR0_VMSA_MASK 0xfU +#define AARCH32_ID_MMFR0_VMSA_GET( _reg ) \ + ( ( ( _reg ) >> 0 ) & 0xfU ) + +#define AARCH32_ID_MMFR0_PMSA( _val ) ( ( _val ) << 4 ) +#define AARCH32_ID_MMFR0_PMSA_SHIFT 4 +#define AARCH32_ID_MMFR0_PMSA_MASK 0xf0U +#define AARCH32_ID_MMFR0_PMSA_GET( _reg ) \ + ( ( ( _reg ) >> 4 ) & 0xfU ) + +#define AARCH32_ID_MMFR0_OUTERSHR( _val ) ( ( _val ) << 8 ) +#define AARCH32_ID_MMFR0_OUTERSHR_SHIFT 8 +#define AARCH32_ID_MMFR0_OUTERSHR_MASK 0xf00U +#define AARCH32_ID_MMFR0_OUTERSHR_GET( _reg ) \ + ( ( ( _reg ) >> 8 ) & 0xfU ) + +#define AARCH32_ID_MMFR0_SHARELVL( _val ) ( ( _val ) << 12 ) +#define AARCH32_ID_MMFR0_SHARELVL_SHIFT 12 +#define AARCH32_ID_MMFR0_SHARELVL_MASK 0xf000U +#define AARCH32_ID_MMFR0_SHARELVL_GET( _reg ) \ + ( ( ( _reg ) >> 12 ) & 0xfU ) + +#define AARCH32_ID_MMFR0_TCM( _val ) ( ( _val ) << 16 ) +#define AARCH32_ID_MMFR0_TCM_SHIFT 16 +#define AARCH32_ID_MMFR0_TCM_MASK 0xf0000U +#define AARCH32_ID_MMFR0_TCM_GET( _reg ) \ + ( ( ( _reg ) >> 16 ) & 0xfU ) + +#define AARCH32_ID_MMFR0_AUXREG( _val ) ( ( _val ) << 20 ) +#define AARCH32_ID_MMFR0_AUXREG_SHIFT 20 +#define AARCH32_ID_MMFR0_AUXREG_MASK 0xf00000U +#define AARCH32_ID_MMFR0_AUXREG_GET( _reg ) \ + ( ( ( _reg ) >> 20 ) & 0xfU ) + +#define AARCH32_ID_MMFR0_FCSE( _val ) ( ( _val ) << 24 ) +#define AARCH32_ID_MMFR0_FCSE_SHIFT 24 +#define AARCH32_ID_MMFR0_FCSE_MASK 0xf000000U +#define AARCH32_ID_MMFR0_FCSE_GET( _reg ) \ + ( ( ( _reg ) >> 24 ) & 0xfU ) + +#define AARCH32_ID_MMFR0_INNERSHR( _val ) ( ( _val ) << 28 ) +#define AARCH32_ID_MMFR0_INNERSHR_SHIFT 28 +#define AARCH32_ID_MMFR0_INNERSHR_MASK 0xf0000000U +#define AARCH32_ID_MMFR0_INNERSHR_GET( _reg ) \ + ( ( ( _reg ) >> 28 ) & 0xfU ) + +static inline uint32_t _AArch32_Read_id_mmfr0( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c0, c1, 4" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +/* ID_MMFR1, Memory Model Feature Register 1 */ + +#define AARCH32_ID_MMFR1_L1HVDVA( _val ) ( ( _val ) << 0 ) +#define AARCH32_ID_MMFR1_L1HVDVA_SHIFT 0 +#define AARCH32_ID_MMFR1_L1HVDVA_MASK 0xfU +#define AARCH32_ID_MMFR1_L1HVDVA_GET( _reg ) \ + ( ( ( _reg ) >> 0 ) & 0xfU ) + +#define AARCH32_ID_MMFR1_L1UNIVA( _val ) ( ( _val ) << 4 ) +#define AARCH32_ID_MMFR1_L1UNIVA_SHIFT 4 +#define AARCH32_ID_MMFR1_L1UNIVA_MASK 0xf0U +#define AARCH32_ID_MMFR1_L1UNIVA_GET( _reg ) \ + ( ( ( _reg ) >> 4 ) & 0xfU ) + +#define AARCH32_ID_MMFR1_L1HVDSW( _val ) ( ( _val ) << 8 ) +#define AARCH32_ID_MMFR1_L1HVDSW_SHIFT 8 +#define AARCH32_ID_MMFR1_L1HVDSW_MASK 0xf00U +#define AARCH32_ID_MMFR1_L1HVDSW_GET( _reg ) \ + ( ( ( _reg ) >> 8 ) & 0xfU ) + +#define AARCH32_ID_MMFR1_L1UNISW( _val ) ( ( _val ) << 12 ) +#define AARCH32_ID_MMFR1_L1UNISW_SHIFT 12 +#define AARCH32_ID_MMFR1_L1UNISW_MASK 0xf000U +#define AARCH32_ID_MMFR1_L1UNISW_GET( _reg ) \ + ( ( ( _reg ) >> 12 ) & 0xfU ) + +#define AARCH32_ID_MMFR1_L1HVD( _val ) ( ( _val ) << 16 ) +#define AARCH32_ID_MMFR1_L1HVD_SHIFT 16 +#define AARCH32_ID_MMFR1_L1HVD_MASK 0xf0000U +#define AARCH32_ID_MMFR1_L1HVD_GET( _reg ) \ + ( ( ( _reg ) >> 16 ) & 0xfU ) + +#define AARCH32_ID_MMFR1_L1UNI( _val ) ( ( _val ) << 20 ) +#define AARCH32_ID_MMFR1_L1UNI_SHIFT 20 +#define AARCH32_ID_MMFR1_L1UNI_MASK 0xf00000U +#define AARCH32_ID_MMFR1_L1UNI_GET( _reg ) \ + ( ( ( _reg ) >> 20 ) & 0xfU ) + +#define AARCH32_ID_MMFR1_L1TSTCLN( _val ) ( ( _val ) << 24 ) +#define AARCH32_ID_MMFR1_L1TSTCLN_SHIFT 24 +#define AARCH32_ID_MMFR1_L1TSTCLN_MASK 0xf000000U +#define AARCH32_ID_MMFR1_L1TSTCLN_GET( _reg ) \ + ( ( ( _reg ) >> 24 ) & 0xfU ) + +#define AARCH32_ID_MMFR1_BPRED( _val ) ( ( _val ) << 28 ) +#define AARCH32_ID_MMFR1_BPRED_SHIFT 28 +#define AARCH32_ID_MMFR1_BPRED_MASK 0xf0000000U +#define AARCH32_ID_MMFR1_BPRED_GET( _reg ) \ + ( ( ( _reg ) >> 28 ) & 0xfU ) + +static inline uint32_t _AArch32_Read_id_mmfr1( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c0, c1, 5" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +/* ID_MMFR2, Memory Model Feature Register 2 */ + +#define AARCH32_ID_MMFR2_L1HVDFG( _val ) ( ( _val ) << 0 ) +#define AARCH32_ID_MMFR2_L1HVDFG_SHIFT 0 +#define AARCH32_ID_MMFR2_L1HVDFG_MASK 0xfU +#define AARCH32_ID_MMFR2_L1HVDFG_GET( _reg ) \ + ( ( ( _reg ) >> 0 ) & 0xfU ) + +#define AARCH32_ID_MMFR2_L1HVDBG( _val ) ( ( _val ) << 4 ) +#define AARCH32_ID_MMFR2_L1HVDBG_SHIFT 4 +#define AARCH32_ID_MMFR2_L1HVDBG_MASK 0xf0U +#define AARCH32_ID_MMFR2_L1HVDBG_GET( _reg ) \ + ( ( ( _reg ) >> 4 ) & 0xfU ) + +#define AARCH32_ID_MMFR2_L1HVDRNG( _val ) ( ( _val ) << 8 ) +#define AARCH32_ID_MMFR2_L1HVDRNG_SHIFT 8 +#define AARCH32_ID_MMFR2_L1HVDRNG_MASK 0xf00U +#define AARCH32_ID_MMFR2_L1HVDRNG_GET( _reg ) \ + ( ( ( _reg ) >> 8 ) & 0xfU ) + +#define AARCH32_ID_MMFR2_HVDTLB( _val ) ( ( _val ) << 12 ) +#define AARCH32_ID_MMFR2_HVDTLB_SHIFT 12 +#define AARCH32_ID_MMFR2_HVDTLB_MASK 0xf000U +#define AARCH32_ID_MMFR2_HVDTLB_GET( _reg ) \ + ( ( ( _reg ) >> 12 ) & 0xfU ) + +#define AARCH32_ID_MMFR2_UNITLB( _val ) ( ( _val ) << 16 ) +#define AARCH32_ID_MMFR2_UNITLB_SHIFT 16 +#define AARCH32_ID_MMFR2_UNITLB_MASK 0xf0000U +#define AARCH32_ID_MMFR2_UNITLB_GET( _reg ) \ + ( ( ( _reg ) >> 16 ) & 0xfU ) + +#define AARCH32_ID_MMFR2_MEMBARR( _val ) ( ( _val ) << 20 ) +#define AARCH32_ID_MMFR2_MEMBARR_SHIFT 20 +#define AARCH32_ID_MMFR2_MEMBARR_MASK 0xf00000U +#define AARCH32_ID_MMFR2_MEMBARR_GET( _reg ) \ + ( ( ( _reg ) >> 20 ) & 0xfU ) + +#define AARCH32_ID_MMFR2_WFISTALL( _val ) ( ( _val ) << 24 ) +#define AARCH32_ID_MMFR2_WFISTALL_SHIFT 24 +#define AARCH32_ID_MMFR2_WFISTALL_MASK 0xf000000U +#define AARCH32_ID_MMFR2_WFISTALL_GET( _reg ) \ + ( ( ( _reg ) >> 24 ) & 0xfU ) + +#define AARCH32_ID_MMFR2_HWACCFLG( _val ) ( ( _val ) << 28 ) +#define AARCH32_ID_MMFR2_HWACCFLG_SHIFT 28 +#define AARCH32_ID_MMFR2_HWACCFLG_MASK 0xf0000000U +#define AARCH32_ID_MMFR2_HWACCFLG_GET( _reg ) \ + ( ( ( _reg ) >> 28 ) & 0xfU ) + +static inline uint32_t _AArch32_Read_id_mmfr2( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c0, c1, 6" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +/* ID_MMFR3, Memory Model Feature Register 3 */ + +#define AARCH32_ID_MMFR3_CMAINTVA( _val ) ( ( _val ) << 0 ) +#define AARCH32_ID_MMFR3_CMAINTVA_SHIFT 0 +#define AARCH32_ID_MMFR3_CMAINTVA_MASK 0xfU +#define AARCH32_ID_MMFR3_CMAINTVA_GET( _reg ) \ + ( ( ( _reg ) >> 0 ) & 0xfU ) + +#define AARCH32_ID_MMFR3_CMAINTSW( _val ) ( ( _val ) << 4 ) +#define AARCH32_ID_MMFR3_CMAINTSW_SHIFT 4 +#define AARCH32_ID_MMFR3_CMAINTSW_MASK 0xf0U +#define AARCH32_ID_MMFR3_CMAINTSW_GET( _reg ) \ + ( ( ( _reg ) >> 4 ) & 0xfU ) + +#define AARCH32_ID_MMFR3_BPMAINT( _val ) ( ( _val ) << 8 ) +#define AARCH32_ID_MMFR3_BPMAINT_SHIFT 8 +#define AARCH32_ID_MMFR3_BPMAINT_MASK 0xf00U +#define AARCH32_ID_MMFR3_BPMAINT_GET( _reg ) \ + ( ( ( _reg ) >> 8 ) & 0xfU ) + +#define AARCH32_ID_MMFR3_MAINTBCST( _val ) ( ( _val ) << 12 ) +#define AARCH32_ID_MMFR3_MAINTBCST_SHIFT 12 +#define AARCH32_ID_MMFR3_MAINTBCST_MASK 0xf000U +#define AARCH32_ID_MMFR3_MAINTBCST_GET( _reg ) \ + ( ( ( _reg ) >> 12 ) & 0xfU ) + +#define AARCH32_ID_MMFR3_PAN( _val ) ( ( _val ) << 16 ) +#define AARCH32_ID_MMFR3_PAN_SHIFT 16 +#define AARCH32_ID_MMFR3_PAN_MASK 0xf0000U +#define AARCH32_ID_MMFR3_PAN_GET( _reg ) \ + ( ( ( _reg ) >> 16 ) & 0xfU ) + +#define AARCH32_ID_MMFR3_COHWALK( _val ) ( ( _val ) << 20 ) +#define AARCH32_ID_MMFR3_COHWALK_SHIFT 20 +#define AARCH32_ID_MMFR3_COHWALK_MASK 0xf00000U +#define AARCH32_ID_MMFR3_COHWALK_GET( _reg ) \ + ( ( ( _reg ) >> 20 ) & 0xfU ) + +#define AARCH32_ID_MMFR3_CMEMSZ( _val ) ( ( _val ) << 24 ) +#define AARCH32_ID_MMFR3_CMEMSZ_SHIFT 24 +#define AARCH32_ID_MMFR3_CMEMSZ_MASK 0xf000000U +#define AARCH32_ID_MMFR3_CMEMSZ_GET( _reg ) \ + ( ( ( _reg ) >> 24 ) & 0xfU ) + +#define AARCH32_ID_MMFR3_SUPERSEC( _val ) ( ( _val ) << 28 ) +#define AARCH32_ID_MMFR3_SUPERSEC_SHIFT 28 +#define AARCH32_ID_MMFR3_SUPERSEC_MASK 0xf0000000U +#define AARCH32_ID_MMFR3_SUPERSEC_GET( _reg ) \ + ( ( ( _reg ) >> 28 ) & 0xfU ) + +static inline uint32_t _AArch32_Read_id_mmfr3( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c0, c1, 7" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +/* ID_MMFR4, Memory Model Feature Register 4 */ + +#define AARCH32_ID_MMFR4_SPECSEI( _val ) ( ( _val ) << 0 ) +#define AARCH32_ID_MMFR4_SPECSEI_SHIFT 0 +#define AARCH32_ID_MMFR4_SPECSEI_MASK 0xfU +#define AARCH32_ID_MMFR4_SPECSEI_GET( _reg ) \ + ( ( ( _reg ) >> 0 ) & 0xfU ) + +#define AARCH32_ID_MMFR4_AC2( _val ) ( ( _val ) << 4 ) +#define AARCH32_ID_MMFR4_AC2_SHIFT 4 +#define AARCH32_ID_MMFR4_AC2_MASK 0xf0U +#define AARCH32_ID_MMFR4_AC2_GET( _reg ) \ + ( ( ( _reg ) >> 4 ) & 0xfU ) + +#define AARCH32_ID_MMFR4_XNX( _val ) ( ( _val ) << 8 ) +#define AARCH32_ID_MMFR4_XNX_SHIFT 8 +#define AARCH32_ID_MMFR4_XNX_MASK 0xf00U +#define AARCH32_ID_MMFR4_XNX_GET( _reg ) \ + ( ( ( _reg ) >> 8 ) & 0xfU ) + +#define AARCH32_ID_MMFR4_CNP( _val ) ( ( _val ) << 12 ) +#define AARCH32_ID_MMFR4_CNP_SHIFT 12 +#define AARCH32_ID_MMFR4_CNP_MASK 0xf000U +#define AARCH32_ID_MMFR4_CNP_GET( _reg ) \ + ( ( ( _reg ) >> 12 ) & 0xfU ) + +#define AARCH32_ID_MMFR4_HPDS( _val ) ( ( _val ) << 16 ) +#define AARCH32_ID_MMFR4_HPDS_SHIFT 16 +#define AARCH32_ID_MMFR4_HPDS_MASK 0xf0000U +#define AARCH32_ID_MMFR4_HPDS_GET( _reg ) \ + ( ( ( _reg ) >> 16 ) & 0xfU ) + +#define AARCH32_ID_MMFR4_LSM( _val ) ( ( _val ) << 20 ) +#define AARCH32_ID_MMFR4_LSM_SHIFT 20 +#define AARCH32_ID_MMFR4_LSM_MASK 0xf00000U +#define AARCH32_ID_MMFR4_LSM_GET( _reg ) \ + ( ( ( _reg ) >> 20 ) & 0xfU ) + +#define AARCH32_ID_MMFR4_CCIDX( _val ) ( ( _val ) << 24 ) +#define AARCH32_ID_MMFR4_CCIDX_SHIFT 24 +#define AARCH32_ID_MMFR4_CCIDX_MASK 0xf000000U +#define AARCH32_ID_MMFR4_CCIDX_GET( _reg ) \ + ( ( ( _reg ) >> 24 ) & 0xfU ) + +#define AARCH32_ID_MMFR4_EVT( _val ) ( ( _val ) << 28 ) +#define AARCH32_ID_MMFR4_EVT_SHIFT 28 +#define AARCH32_ID_MMFR4_EVT_MASK 0xf0000000U +#define AARCH32_ID_MMFR4_EVT_GET( _reg ) \ + ( ( ( _reg ) >> 28 ) & 0xfU ) + +static inline uint32_t _AArch32_Read_id_mmfr4( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c0, c2, 6" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +/* ID_MMFR5, Memory Model Feature Register 5 */ + +#define AARCH32_ID_MMFR5_ETS( _val ) ( ( _val ) << 0 ) +#define AARCH32_ID_MMFR5_ETS_SHIFT 0 +#define AARCH32_ID_MMFR5_ETS_MASK 0xfU +#define AARCH32_ID_MMFR5_ETS_GET( _reg ) \ + ( ( ( _reg ) >> 0 ) & 0xfU ) + +static inline uint32_t _AArch32_Read_id_mmfr5( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c0, c3, 6" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +/* ID_PFR0, Processor Feature Register 0 */ + +#define AARCH32_ID_PFR0_STATE0( _val ) ( ( _val ) << 0 ) +#define AARCH32_ID_PFR0_STATE0_SHIFT 0 +#define AARCH32_ID_PFR0_STATE0_MASK 0xfU +#define AARCH32_ID_PFR0_STATE0_GET( _reg ) \ + ( ( ( _reg ) >> 0 ) & 0xfU ) + +#define AARCH32_ID_PFR0_STATE1( _val ) ( ( _val ) << 4 ) +#define AARCH32_ID_PFR0_STATE1_SHIFT 4 +#define AARCH32_ID_PFR0_STATE1_MASK 0xf0U +#define AARCH32_ID_PFR0_STATE1_GET( _reg ) \ + ( ( ( _reg ) >> 4 ) & 0xfU ) + +#define AARCH32_ID_PFR0_STATE2( _val ) ( ( _val ) << 8 ) +#define AARCH32_ID_PFR0_STATE2_SHIFT 8 +#define AARCH32_ID_PFR0_STATE2_MASK 0xf00U +#define AARCH32_ID_PFR0_STATE2_GET( _reg ) \ + ( ( ( _reg ) >> 8 ) & 0xfU ) + +#define AARCH32_ID_PFR0_STATE3( _val ) ( ( _val ) << 12 ) +#define AARCH32_ID_PFR0_STATE3_SHIFT 12 +#define AARCH32_ID_PFR0_STATE3_MASK 0xf000U +#define AARCH32_ID_PFR0_STATE3_GET( _reg ) \ + ( ( ( _reg ) >> 12 ) & 0xfU ) + +#define AARCH32_ID_PFR0_CSV2( _val ) ( ( _val ) << 16 ) +#define AARCH32_ID_PFR0_CSV2_SHIFT 16 +#define AARCH32_ID_PFR0_CSV2_MASK 0xf0000U +#define AARCH32_ID_PFR0_CSV2_GET( _reg ) \ + ( ( ( _reg ) >> 16 ) & 0xfU ) + +#define AARCH32_ID_PFR0_AMU( _val ) ( ( _val ) << 20 ) +#define AARCH32_ID_PFR0_AMU_SHIFT 20 +#define AARCH32_ID_PFR0_AMU_MASK 0xf00000U +#define AARCH32_ID_PFR0_AMU_GET( _reg ) \ + ( ( ( _reg ) >> 20 ) & 0xfU ) + +#define AARCH32_ID_PFR0_DIT( _val ) ( ( _val ) << 24 ) +#define AARCH32_ID_PFR0_DIT_SHIFT 24 +#define AARCH32_ID_PFR0_DIT_MASK 0xf000000U +#define AARCH32_ID_PFR0_DIT_GET( _reg ) \ + ( ( ( _reg ) >> 24 ) & 0xfU ) + +#define AARCH32_ID_PFR0_RAS( _val ) ( ( _val ) << 28 ) +#define AARCH32_ID_PFR0_RAS_SHIFT 28 +#define AARCH32_ID_PFR0_RAS_MASK 0xf0000000U +#define AARCH32_ID_PFR0_RAS_GET( _reg ) \ + ( ( ( _reg ) >> 28 ) & 0xfU ) + +static inline uint32_t _AArch32_Read_id_pfr0( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c0, c1, 0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +/* ID_PFR1, Processor Feature Register 1 */ + +#define AARCH32_ID_PFR1_PROGMOD( _val ) ( ( _val ) << 0 ) +#define AARCH32_ID_PFR1_PROGMOD_SHIFT 0 +#define AARCH32_ID_PFR1_PROGMOD_MASK 0xfU +#define AARCH32_ID_PFR1_PROGMOD_GET( _reg ) \ + ( ( ( _reg ) >> 0 ) & 0xfU ) + +#define AARCH32_ID_PFR1_SECURITY( _val ) ( ( _val ) << 4 ) +#define AARCH32_ID_PFR1_SECURITY_SHIFT 4 +#define AARCH32_ID_PFR1_SECURITY_MASK 0xf0U +#define AARCH32_ID_PFR1_SECURITY_GET( _reg ) \ + ( ( ( _reg ) >> 4 ) & 0xfU ) + +#define AARCH32_ID_PFR1_MPROGMOD( _val ) ( ( _val ) << 8 ) +#define AARCH32_ID_PFR1_MPROGMOD_SHIFT 8 +#define AARCH32_ID_PFR1_MPROGMOD_MASK 0xf00U +#define AARCH32_ID_PFR1_MPROGMOD_GET( _reg ) \ + ( ( ( _reg ) >> 8 ) & 0xfU ) + +#define AARCH32_ID_PFR1_VIRTUALIZATION( _val ) ( ( _val ) << 12 ) +#define AARCH32_ID_PFR1_VIRTUALIZATION_SHIFT 12 +#define AARCH32_ID_PFR1_VIRTUALIZATION_MASK 0xf000U +#define AARCH32_ID_PFR1_VIRTUALIZATION_GET( _reg ) \ + ( ( ( _reg ) >> 12 ) & 0xfU ) + +#define AARCH32_ID_PFR1_GENTIMER( _val ) ( ( _val ) << 16 ) +#define AARCH32_ID_PFR1_GENTIMER_SHIFT 16 +#define AARCH32_ID_PFR1_GENTIMER_MASK 0xf0000U +#define AARCH32_ID_PFR1_GENTIMER_GET( _reg ) \ + ( ( ( _reg ) >> 16 ) & 0xfU ) + +#define AARCH32_ID_PFR1_SEC_FRAC( _val ) ( ( _val ) << 20 ) +#define AARCH32_ID_PFR1_SEC_FRAC_SHIFT 20 +#define AARCH32_ID_PFR1_SEC_FRAC_MASK 0xf00000U +#define AARCH32_ID_PFR1_SEC_FRAC_GET( _reg ) \ + ( ( ( _reg ) >> 20 ) & 0xfU ) + +#define AARCH32_ID_PFR1_VIRT_FRAC( _val ) ( ( _val ) << 24 ) +#define AARCH32_ID_PFR1_VIRT_FRAC_SHIFT 24 +#define AARCH32_ID_PFR1_VIRT_FRAC_MASK 0xf000000U +#define AARCH32_ID_PFR1_VIRT_FRAC_GET( _reg ) \ + ( ( ( _reg ) >> 24 ) & 0xfU ) + +#define AARCH32_ID_PFR1_GIC( _val ) ( ( _val ) << 28 ) +#define AARCH32_ID_PFR1_GIC_SHIFT 28 +#define AARCH32_ID_PFR1_GIC_MASK 0xf0000000U +#define AARCH32_ID_PFR1_GIC_GET( _reg ) \ + ( ( ( _reg ) >> 28 ) & 0xfU ) + +static inline uint32_t _AArch32_Read_id_pfr1( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c0, c1, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +/* ID_PFR2, Processor Feature Register 2 */ + +#define AARCH32_ID_PFR2_CSV3( _val ) ( ( _val ) << 0 ) +#define AARCH32_ID_PFR2_CSV3_SHIFT 0 +#define AARCH32_ID_PFR2_CSV3_MASK 0xfU +#define AARCH32_ID_PFR2_CSV3_GET( _reg ) \ + ( ( ( _reg ) >> 0 ) & 0xfU ) + +#define AARCH32_ID_PFR2_SSBS( _val ) ( ( _val ) << 4 ) +#define AARCH32_ID_PFR2_SSBS_SHIFT 4 +#define AARCH32_ID_PFR2_SSBS_MASK 0xf0U +#define AARCH32_ID_PFR2_SSBS_GET( _reg ) \ + ( ( ( _reg ) >> 4 ) & 0xfU ) + +#define AARCH32_ID_PFR2_RAS_FRAC( _val ) ( ( _val ) << 8 ) +#define AARCH32_ID_PFR2_RAS_FRAC_SHIFT 8 +#define AARCH32_ID_PFR2_RAS_FRAC_MASK 0xf00U +#define AARCH32_ID_PFR2_RAS_FRAC_GET( _reg ) \ + ( ( ( _reg ) >> 8 ) & 0xfU ) + +static inline uint32_t _AArch32_Read_id_pfr2( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c0, c3, 4" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +/* IFAR, Instruction Fault Address Register */ + +static inline uint32_t _AArch32_Read_ifar( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c6, c0, 2" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_ifar( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c6, c0, 2" : : "r" ( value ) : "memory" + ); +} + +/* IFSR, Instruction Fault Status Register */ + +#define AARCH32_IFSR_FS_3_0( _val ) ( ( _val ) << 0 ) +#define AARCH32_IFSR_FS_3_0_SHIFT 0 +#define AARCH32_IFSR_FS_3_0_MASK 0xfU +#define AARCH32_IFSR_FS_3_0_GET( _reg ) \ + ( ( ( _reg ) >> 0 ) & 0xfU ) + +#define AARCH32_IFSR_STATUS( _val ) ( ( _val ) << 0 ) +#define AARCH32_IFSR_STATUS_SHIFT 0 +#define AARCH32_IFSR_STATUS_MASK 0x3fU +#define AARCH32_IFSR_STATUS_GET( _reg ) \ + ( ( ( _reg ) >> 0 ) & 0x3fU ) + +#define AARCH32_IFSR_LPAE 0x200U + +#define AARCH32_IFSR_FS_4 0x400U + +#define AARCH32_IFSR_EXT 0x1000U + +#define AARCH32_IFSR_FNV 0x10000U + +static inline uint32_t _AArch32_Read_ifsr( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c5, c0, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_ifsr( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c5, c0, 1" : : "r" ( value ) : "memory" + ); +} + +/* ISR, Interrupt Status Register */ + +#define AARCH32_ISR_F 0x40U + +#define AARCH32_ISR_I 0x80U + +#define AARCH32_ISR_A 0x100U + +static inline uint32_t _AArch32_Read_isr( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c12, c1, 0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +/* ITLBIALL, Instruction TLB Invalidate All */ + +static inline void _AArch32_Write_itlbiall( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c8, c5, 0" : : "r" ( value ) : "memory" + ); +} + +/* ITLBIASID, Instruction TLB Invalidate by ASID match */ + +#define AARCH32_ITLBIASID_ASID( _val ) ( ( _val ) << 0 ) +#define AARCH32_ITLBIASID_ASID_SHIFT 0 +#define AARCH32_ITLBIASID_ASID_MASK 0xffU +#define AARCH32_ITLBIASID_ASID_GET( _reg ) \ + ( ( ( _reg ) >> 0 ) & 0xffU ) + +static inline void _AArch32_Write_itlbiasid( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c8, c5, 2" : : "r" ( value ) : "memory" + ); +} + +/* ITLBIMVA, Instruction TLB Invalidate by VA */ + +#define AARCH32_ITLBIMVA_ASID( _val ) ( ( _val ) << 0 ) +#define AARCH32_ITLBIMVA_ASID_SHIFT 0 +#define AARCH32_ITLBIMVA_ASID_MASK 0xffU +#define AARCH32_ITLBIMVA_ASID_GET( _reg ) \ + ( ( ( _reg ) >> 0 ) & 0xffU ) + +#define AARCH32_ITLBIMVA_VA( _val ) ( ( _val ) << 12 ) +#define AARCH32_ITLBIMVA_VA_SHIFT 12 +#define AARCH32_ITLBIMVA_VA_MASK 0xfffff000U +#define AARCH32_ITLBIMVA_VA_GET( _reg ) \ + ( ( ( _reg ) >> 12 ) & 0xfffffU ) + +static inline void _AArch32_Write_itlbimva( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c8, c5, 1" : : "r" ( value ) : "memory" + ); +} + +/* JIDR, Jazelle ID Register */ + +static inline uint32_t _AArch32_Read_jidr( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p14, 7, %0, c0, c0, 0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +/* JMCR, Jazelle Main Configuration Register */ + +static inline uint32_t _AArch32_Read_jmcr( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p14, 7, %0, c2, c0, 0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_jmcr( uint32_t value ) +{ + __asm__ volatile ( + "mcr p14, 7, %0, c2, c0, 0" : : "r" ( value ) : "memory" + ); +} + +/* JOSCR, Jazelle OS Control Register */ + +static inline uint32_t _AArch32_Read_joscr( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p14, 7, %0, c1, c0, 0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_joscr( uint32_t value ) +{ + __asm__ volatile ( + "mcr p14, 7, %0, c1, c0, 0" : : "r" ( value ) : "memory" + ); +} + +/* MAIR0, Memory Attribute Indirection Register 0 */ + +static inline uint32_t _AArch32_Read_mair0( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c10, c2, 0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_mair0( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c10, c2, 0" : : "r" ( value ) : "memory" + ); +} + +/* MAIR1, Memory Attribute Indirection Register 1 */ + +static inline uint32_t _AArch32_Read_mair1( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c10, c2, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_mair1( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c10, c2, 1" : : "r" ( value ) : "memory" + ); +} + +/* MIDR, Main ID Register */ + +#define AARCH32_MIDR_REVISION( _val ) ( ( _val ) << 0 ) +#define AARCH32_MIDR_REVISION_SHIFT 0 +#define AARCH32_MIDR_REVISION_MASK 0xfU +#define AARCH32_MIDR_REVISION_GET( _reg ) \ + ( ( ( _reg ) >> 0 ) & 0xfU ) + +#define AARCH32_MIDR_PARTNUM( _val ) ( ( _val ) << 4 ) +#define AARCH32_MIDR_PARTNUM_SHIFT 4 +#define AARCH32_MIDR_PARTNUM_MASK 0xfff0U +#define AARCH32_MIDR_PARTNUM_GET( _reg ) \ + ( ( ( _reg ) >> 4 ) & 0xfffU ) + +#define AARCH32_MIDR_ARCHITECTURE( _val ) ( ( _val ) << 16 ) +#define AARCH32_MIDR_ARCHITECTURE_SHIFT 16 +#define AARCH32_MIDR_ARCHITECTURE_MASK 0xf0000U +#define AARCH32_MIDR_ARCHITECTURE_GET( _reg ) \ + ( ( ( _reg ) >> 16 ) & 0xfU ) + +#define AARCH32_MIDR_VARIANT( _val ) ( ( _val ) << 20 ) +#define AARCH32_MIDR_VARIANT_SHIFT 20 +#define AARCH32_MIDR_VARIANT_MASK 0xf00000U +#define AARCH32_MIDR_VARIANT_GET( _reg ) \ + ( ( ( _reg ) >> 20 ) & 0xfU ) + +#define AARCH32_MIDR_IMPLEMENTER( _val ) ( ( _val ) << 24 ) +#define AARCH32_MIDR_IMPLEMENTER_SHIFT 24 +#define AARCH32_MIDR_IMPLEMENTER_MASK 0xff000000U +#define AARCH32_MIDR_IMPLEMENTER_GET( _reg ) \ + ( ( ( _reg ) >> 24 ) & 0xffU ) + +static inline uint32_t _AArch32_Read_midr( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c0, c0, 0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +/* MPIDR, Multiprocessor Affinity Register */ + +#define AARCH32_MPIDR_AFF0( _val ) ( ( _val ) << 0 ) +#define AARCH32_MPIDR_AFF0_SHIFT 0 +#define AARCH32_MPIDR_AFF0_MASK 0xffU +#define AARCH32_MPIDR_AFF0_GET( _reg ) \ + ( ( ( _reg ) >> 0 ) & 0xffU ) + +#define AARCH32_MPIDR_AFF1( _val ) ( ( _val ) << 8 ) +#define AARCH32_MPIDR_AFF1_SHIFT 8 +#define AARCH32_MPIDR_AFF1_MASK 0xff00U +#define AARCH32_MPIDR_AFF1_GET( _reg ) \ + ( ( ( _reg ) >> 8 ) & 0xffU ) + +#define AARCH32_MPIDR_AFF2( _val ) ( ( _val ) << 16 ) +#define AARCH32_MPIDR_AFF2_SHIFT 16 +#define AARCH32_MPIDR_AFF2_MASK 0xff0000U +#define AARCH32_MPIDR_AFF2_GET( _reg ) \ + ( ( ( _reg ) >> 16 ) & 0xffU ) + +#define AARCH32_MPIDR_MT 0x1000000U + +#define AARCH32_MPIDR_U 0x40000000U + +#define AARCH32_MPIDR_M 0x80000000U + +static inline uint32_t _AArch32_Read_mpidr( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c0, c0, 5" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +/* MVBAR, Monitor Vector Base Address Register */ + +#define AARCH32_MVBAR_RESERVED( _val ) ( ( _val ) << 0 ) +#define AARCH32_MVBAR_RESERVED_SHIFT 0 +#define AARCH32_MVBAR_RESERVED_MASK 0x1fU +#define AARCH32_MVBAR_RESERVED_GET( _reg ) \ + ( ( ( _reg ) >> 0 ) & 0x1fU ) + +static inline uint32_t _AArch32_Read_mvbar( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c12, c0, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_mvbar( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c12, c0, 1" : : "r" ( value ) : "memory" + ); +} + +/* MVFR0, Media and VFP Feature Register 0 */ + +#define AARCH32_MVFR0_SIMDREG( _val ) ( ( _val ) << 0 ) +#define AARCH32_MVFR0_SIMDREG_SHIFT 0 +#define AARCH32_MVFR0_SIMDREG_MASK 0xfU +#define AARCH32_MVFR0_SIMDREG_GET( _reg ) \ + ( ( ( _reg ) >> 0 ) & 0xfU ) + +#define AARCH32_MVFR0_FPSP( _val ) ( ( _val ) << 4 ) +#define AARCH32_MVFR0_FPSP_SHIFT 4 +#define AARCH32_MVFR0_FPSP_MASK 0xf0U +#define AARCH32_MVFR0_FPSP_GET( _reg ) \ + ( ( ( _reg ) >> 4 ) & 0xfU ) + +#define AARCH32_MVFR0_FPDP( _val ) ( ( _val ) << 8 ) +#define AARCH32_MVFR0_FPDP_SHIFT 8 +#define AARCH32_MVFR0_FPDP_MASK 0xf00U +#define AARCH32_MVFR0_FPDP_GET( _reg ) \ + ( ( ( _reg ) >> 8 ) & 0xfU ) + +#define AARCH32_MVFR0_FPTRAP( _val ) ( ( _val ) << 12 ) +#define AARCH32_MVFR0_FPTRAP_SHIFT 12 +#define AARCH32_MVFR0_FPTRAP_MASK 0xf000U +#define AARCH32_MVFR0_FPTRAP_GET( _reg ) \ + ( ( ( _reg ) >> 12 ) & 0xfU ) + +#define AARCH32_MVFR0_FPDIVIDE( _val ) ( ( _val ) << 16 ) +#define AARCH32_MVFR0_FPDIVIDE_SHIFT 16 +#define AARCH32_MVFR0_FPDIVIDE_MASK 0xf0000U +#define AARCH32_MVFR0_FPDIVIDE_GET( _reg ) \ + ( ( ( _reg ) >> 16 ) & 0xfU ) + +#define AARCH32_MVFR0_FPSQRT( _val ) ( ( _val ) << 20 ) +#define AARCH32_MVFR0_FPSQRT_SHIFT 20 +#define AARCH32_MVFR0_FPSQRT_MASK 0xf00000U +#define AARCH32_MVFR0_FPSQRT_GET( _reg ) \ + ( ( ( _reg ) >> 20 ) & 0xfU ) + +#define AARCH32_MVFR0_FPSHVEC( _val ) ( ( _val ) << 24 ) +#define AARCH32_MVFR0_FPSHVEC_SHIFT 24 +#define AARCH32_MVFR0_FPSHVEC_MASK 0xf000000U +#define AARCH32_MVFR0_FPSHVEC_GET( _reg ) \ + ( ( ( _reg ) >> 24 ) & 0xfU ) + +#define AARCH32_MVFR0_FPROUND( _val ) ( ( _val ) << 28 ) +#define AARCH32_MVFR0_FPROUND_SHIFT 28 +#define AARCH32_MVFR0_FPROUND_MASK 0xf0000000U +#define AARCH32_MVFR0_FPROUND_GET( _reg ) \ + ( ( ( _reg ) >> 28 ) & 0xfU ) + +/* MVFR1, Media and VFP Feature Register 1 */ + +#define AARCH32_MVFR1_FPFTZ( _val ) ( ( _val ) << 0 ) +#define AARCH32_MVFR1_FPFTZ_SHIFT 0 +#define AARCH32_MVFR1_FPFTZ_MASK 0xfU +#define AARCH32_MVFR1_FPFTZ_GET( _reg ) \ + ( ( ( _reg ) >> 0 ) & 0xfU ) + +#define AARCH32_MVFR1_FPDNAN( _val ) ( ( _val ) << 4 ) +#define AARCH32_MVFR1_FPDNAN_SHIFT 4 +#define AARCH32_MVFR1_FPDNAN_MASK 0xf0U +#define AARCH32_MVFR1_FPDNAN_GET( _reg ) \ + ( ( ( _reg ) >> 4 ) & 0xfU ) + +#define AARCH32_MVFR1_SIMDLS( _val ) ( ( _val ) << 8 ) +#define AARCH32_MVFR1_SIMDLS_SHIFT 8 +#define AARCH32_MVFR1_SIMDLS_MASK 0xf00U +#define AARCH32_MVFR1_SIMDLS_GET( _reg ) \ + ( ( ( _reg ) >> 8 ) & 0xfU ) + +#define AARCH32_MVFR1_SIMDINT( _val ) ( ( _val ) << 12 ) +#define AARCH32_MVFR1_SIMDINT_SHIFT 12 +#define AARCH32_MVFR1_SIMDINT_MASK 0xf000U +#define AARCH32_MVFR1_SIMDINT_GET( _reg ) \ + ( ( ( _reg ) >> 12 ) & 0xfU ) + +#define AARCH32_MVFR1_SIMDSP( _val ) ( ( _val ) << 16 ) +#define AARCH32_MVFR1_SIMDSP_SHIFT 16 +#define AARCH32_MVFR1_SIMDSP_MASK 0xf0000U +#define AARCH32_MVFR1_SIMDSP_GET( _reg ) \ + ( ( ( _reg ) >> 16 ) & 0xfU ) + +#define AARCH32_MVFR1_SIMDHP( _val ) ( ( _val ) << 20 ) +#define AARCH32_MVFR1_SIMDHP_SHIFT 20 +#define AARCH32_MVFR1_SIMDHP_MASK 0xf00000U +#define AARCH32_MVFR1_SIMDHP_GET( _reg ) \ + ( ( ( _reg ) >> 20 ) & 0xfU ) + +#define AARCH32_MVFR1_FPHP( _val ) ( ( _val ) << 24 ) +#define AARCH32_MVFR1_FPHP_SHIFT 24 +#define AARCH32_MVFR1_FPHP_MASK 0xf000000U +#define AARCH32_MVFR1_FPHP_GET( _reg ) \ + ( ( ( _reg ) >> 24 ) & 0xfU ) + +#define AARCH32_MVFR1_SIMDFMAC( _val ) ( ( _val ) << 28 ) +#define AARCH32_MVFR1_SIMDFMAC_SHIFT 28 +#define AARCH32_MVFR1_SIMDFMAC_MASK 0xf0000000U +#define AARCH32_MVFR1_SIMDFMAC_GET( _reg ) \ + ( ( ( _reg ) >> 28 ) & 0xfU ) + +/* MVFR2, Media and VFP Feature Register 2 */ + +#define AARCH32_MVFR2_SIMDMISC( _val ) ( ( _val ) << 0 ) +#define AARCH32_MVFR2_SIMDMISC_SHIFT 0 +#define AARCH32_MVFR2_SIMDMISC_MASK 0xfU +#define AARCH32_MVFR2_SIMDMISC_GET( _reg ) \ + ( ( ( _reg ) >> 0 ) & 0xfU ) + +#define AARCH32_MVFR2_FPMISC( _val ) ( ( _val ) << 4 ) +#define AARCH32_MVFR2_FPMISC_SHIFT 4 +#define AARCH32_MVFR2_FPMISC_MASK 0xf0U +#define AARCH32_MVFR2_FPMISC_GET( _reg ) \ + ( ( ( _reg ) >> 4 ) & 0xfU ) + +/* NMRR, Normal Memory Remap Register */ + +static inline uint32_t _AArch32_Read_nmrr( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c10, c2, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_nmrr( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c10, c2, 1" : : "r" ( value ) : "memory" + ); +} + +/* NSACR, Non-Secure Access Control Register */ + +#define AARCH32_NSACR_CP10 0x400U + +#define AARCH32_NSACR_CP11 0x800U + +#define AARCH32_NSACR_NSASEDIS 0x8000U + +#define AARCH32_NSACR_NSTRCDIS 0x100000U + +static inline uint32_t _AArch32_Read_nsacr( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c1, c1, 2" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_nsacr( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c1, c1, 2" : : "r" ( value ) : "memory" + ); +} + +/* PAR, Physical Address Register */ + +#define AARCH32_PAR_F 0x1U + +#define AARCH32_PAR_SS 0x2U + +#define AARCH32_PAR_FS_4_0( _val ) ( ( _val ) << 1 ) +#define AARCH32_PAR_FS_4_0_SHIFT 1 +#define AARCH32_PAR_FS_4_0_MASK 0x3eU +#define AARCH32_PAR_FS_4_0_GET( _reg ) \ + ( ( ( _reg ) >> 1 ) & 0x1fU ) + +#define AARCH32_PAR_FST( _val ) ( ( _val ) << 1 ) +#define AARCH32_PAR_FST_SHIFT 1 +#define AARCH32_PAR_FST_MASK 0x7eU +#define AARCH32_PAR_FST_GET( _reg ) \ + ( ( ( _reg ) >> 1 ) & 0x3fU ) + +#define AARCH32_PAR_OUTER_1_0( _val ) ( ( _val ) << 2 ) +#define AARCH32_PAR_OUTER_1_0_SHIFT 2 +#define AARCH32_PAR_OUTER_1_0_MASK 0xcU +#define AARCH32_PAR_OUTER_1_0_GET( _reg ) \ + ( ( ( _reg ) >> 2 ) & 0x3U ) + +#define AARCH32_PAR_INNER_2_0( _val ) ( ( _val ) << 4 ) +#define AARCH32_PAR_INNER_2_0_SHIFT 4 +#define AARCH32_PAR_INNER_2_0_MASK 0x70U +#define AARCH32_PAR_INNER_2_0_GET( _reg ) \ + ( ( ( _reg ) >> 4 ) & 0x7U ) + +#define AARCH32_PAR_FS_5 0x40U + +#define AARCH32_PAR_SH_0 0x80U + +#define AARCH32_PAR_SH_1( _val ) ( ( _val ) << 7 ) +#define AARCH32_PAR_SH_SHIFT_1 7 +#define AARCH32_PAR_SH_MASK_1 0x180U +#define AARCH32_PAR_SH_GET_1( _reg ) \ + ( ( ( _reg ) >> 7 ) & 0x3U ) + +#define AARCH32_PAR_S2WLK 0x100U + +#define AARCH32_PAR_FSTAGE 0x200U + +#define AARCH32_PAR_NS 0x200U + +#define AARCH32_PAR_NOS 0x400U + +#define AARCH32_PAR_LPAE 0x800U + +#define AARCH32_PAR_PA_0( _val ) ( ( _val ) << 12 ) +#define AARCH32_PAR_PA_SHIFT_0 12 +#define AARCH32_PAR_PA_MASK_0 0xfffff000U +#define AARCH32_PAR_PA_GET_0( _reg ) \ + ( ( ( _reg ) >> 12 ) & 0xfffffU ) + +#define AARCH32_PAR_PA_1( _val ) ( ( _val ) << 12 ) +#define AARCH32_PAR_PA_SHIFT_1 12 +#define AARCH32_PAR_PA_MASK_1 0xfffffff000ULL +#define AARCH32_PAR_PA_GET_1( _reg ) \ + ( ( ( _reg ) >> 12 ) & 0xfffffffULL ) + +#define AARCH32_PAR_ATTR( _val ) ( ( _val ) << 56 ) +#define AARCH32_PAR_ATTR_SHIFT 56 +#define AARCH32_PAR_ATTR_MASK 0xff00000000000000ULL +#define AARCH32_PAR_ATTR_GET( _reg ) \ + ( ( ( _reg ) >> 56 ) & 0xffULL ) + +static inline uint32_t _AArch32_Read_32_par( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c7, c4, 0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_32_par( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c7, c4, 0" : : "r" ( value ) : "memory" + ); +} + +/* PAR, Physical Address Register */ + +static inline uint64_t _AArch32_Read_64_par( void ) +{ + uint64_t value; + + __asm__ volatile ( + "mrrc p15, 0, %Q0, %R0, c7" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_64_par( uint64_t value ) +{ + __asm__ volatile ( + "mcrr p15, 0, %Q0, %R0, c7" : : "r" ( value ) : "memory" + ); +} + +/* PRRR, Primary Region Remap Register */ + +#define AARCH32_PRRR_DS0 0x10000U + +#define AARCH32_PRRR_DS1 0x20000U + +#define AARCH32_PRRR_NS0 0x40000U + +#define AARCH32_PRRR_NS1 0x80000U + +static inline uint32_t _AArch32_Read_prrr( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c10, c2, 0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_prrr( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c10, c2, 0" : : "r" ( value ) : "memory" + ); +} + +/* REVIDR, Revision ID Register */ + +static inline uint32_t _AArch32_Read_revidr( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c0, c0, 6" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +/* RMR, Reset Management Register */ + +#define AARCH32_RMR_AA64 0x1U + +#define AARCH32_RMR_RR 0x2U + +static inline uint32_t _AArch32_Read_rmr( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c12, c0, 2" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_rmr( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c12, c0, 2" : : "r" ( value ) : "memory" + ); +} + +/* RVBAR, Reset Vector Base Address Register */ + +static inline uint32_t _AArch32_Read_rvbar( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c12, c0, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +/* SCR, Secure Configuration Register */ + +#define AARCH32_SCR_NS 0x1U + +#define AARCH32_SCR_IRQ 0x2U + +#define AARCH32_SCR_FIQ 0x4U + +#define AARCH32_SCR_EA 0x8U + +#define AARCH32_SCR_FW 0x10U + +#define AARCH32_SCR_AW 0x20U + +#define AARCH32_SCR_NET 0x40U + +#define AARCH32_SCR_SCD 0x80U + +#define AARCH32_SCR_HCE 0x100U + +#define AARCH32_SCR_SIF 0x200U + +#define AARCH32_SCR_TWI 0x1000U + +#define AARCH32_SCR_TWE 0x2000U + +#define AARCH32_SCR_TERR 0x8000U + +static inline uint32_t _AArch32_Read_scr( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c1, c1, 0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_scr( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c1, c1, 0" : : "r" ( value ) : "memory" + ); +} + +/* SCTLR, System Control Register */ + +#define AARCH32_SCTLR_M 0x1U + +#define AARCH32_SCTLR_A 0x2U + +#define AARCH32_SCTLR_C 0x4U + +#define AARCH32_SCTLR_NTLSMD 0x8U + +#define AARCH32_SCTLR_LSMAOE 0x10U + +#define AARCH32_SCTLR_CP15BEN 0x20U + +#define AARCH32_SCTLR_UNK 0x40U + +#define AARCH32_SCTLR_ITD 0x80U + +#define AARCH32_SCTLR_SED 0x100U + +#define AARCH32_SCTLR_ENRCTX 0x400U + +#define AARCH32_SCTLR_I 0x1000U + +#define AARCH32_SCTLR_V 0x2000U + +#define AARCH32_SCTLR_NTWI 0x10000U + +#define AARCH32_SCTLR_BR 0x20000U + +#define AARCH32_SCTLR_NTWE 0x40000U + +#define AARCH32_SCTLR_WXN 0x80000U + +#define AARCH32_SCTLR_UWXN 0x100000U + +#define AARCH32_SCTLR_FI 0x200000U + +#define AARCH32_SCTLR_SPAN 0x800000U + +#define AARCH32_SCTLR_EE 0x2000000U + +#define AARCH32_SCTLR_TRE 0x10000000U + +#define AARCH32_SCTLR_AFE 0x20000000U + +#define AARCH32_SCTLR_TE 0x40000000U + +#define AARCH32_SCTLR_DSSBS 0x80000000U + +static inline uint32_t _AArch32_Read_sctlr( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c1, c0, 0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_sctlr( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c1, c0, 0" : : "r" ( value ) : "memory" + ); +} + +/* SPSR, Saved Program Status Register */ + +#define AARCH32_SPSR_M_4_0( _val ) ( ( _val ) << 0 ) +#define AARCH32_SPSR_M_4_0_SHIFT 0 +#define AARCH32_SPSR_M_4_0_MASK 0x1fU +#define AARCH32_SPSR_M_4_0_GET( _reg ) \ + ( ( ( _reg ) >> 0 ) & 0x1fU ) + +#define AARCH32_SPSR_T 0x20U + +#define AARCH32_SPSR_F 0x40U + +#define AARCH32_SPSR_I 0x80U + +#define AARCH32_SPSR_A 0x100U + +#define AARCH32_SPSR_E 0x200U + +#define AARCH32_SPSR_IT_7_2( _val ) ( ( _val ) << 10 ) +#define AARCH32_SPSR_IT_7_2_SHIFT 10 +#define AARCH32_SPSR_IT_7_2_MASK 0xfc00U +#define AARCH32_SPSR_IT_7_2_GET( _reg ) \ + ( ( ( _reg ) >> 10 ) & 0x3fU ) + +#define AARCH32_SPSR_GE( _val ) ( ( _val ) << 16 ) +#define AARCH32_SPSR_GE_SHIFT 16 +#define AARCH32_SPSR_GE_MASK 0xf0000U +#define AARCH32_SPSR_GE_GET( _reg ) \ + ( ( ( _reg ) >> 16 ) & 0xfU ) + +#define AARCH32_SPSR_IL 0x100000U + +#define AARCH32_SPSR_DIT 0x200000U + +#define AARCH32_SPSR_PAN 0x400000U + +#define AARCH32_SPSR_SSBS 0x800000U + +#define AARCH32_SPSR_J 0x1000000U + +#define AARCH32_SPSR_IT_1_0( _val ) ( ( _val ) << 25 ) +#define AARCH32_SPSR_IT_1_0_SHIFT 25 +#define AARCH32_SPSR_IT_1_0_MASK 0x6000000U +#define AARCH32_SPSR_IT_1_0_GET( _reg ) \ + ( ( ( _reg ) >> 25 ) & 0x3U ) + +#define AARCH32_SPSR_Q 0x8000000U + +#define AARCH32_SPSR_V 0x10000000U + +#define AARCH32_SPSR_C 0x20000000U + +#define AARCH32_SPSR_Z 0x40000000U + +#define AARCH32_SPSR_N 0x80000000U + +/* SPSR_ABT, Saved Program Status Register (Abort mode) */ + +#define AARCH32_SPSR_ABT_M_4_0( _val ) ( ( _val ) << 0 ) +#define AARCH32_SPSR_ABT_M_4_0_SHIFT 0 +#define AARCH32_SPSR_ABT_M_4_0_MASK 0x1fU +#define AARCH32_SPSR_ABT_M_4_0_GET( _reg ) \ + ( ( ( _reg ) >> 0 ) & 0x1fU ) + +#define AARCH32_SPSR_ABT_T 0x20U + +#define AARCH32_SPSR_ABT_F 0x40U + +#define AARCH32_SPSR_ABT_I 0x80U + +#define AARCH32_SPSR_ABT_A 0x100U + +#define AARCH32_SPSR_ABT_E 0x200U + +#define AARCH32_SPSR_ABT_IT_7_2( _val ) ( ( _val ) << 10 ) +#define AARCH32_SPSR_ABT_IT_7_2_SHIFT 10 +#define AARCH32_SPSR_ABT_IT_7_2_MASK 0xfc00U +#define AARCH32_SPSR_ABT_IT_7_2_GET( _reg ) \ + ( ( ( _reg ) >> 10 ) & 0x3fU ) + +#define AARCH32_SPSR_ABT_GE( _val ) ( ( _val ) << 16 ) +#define AARCH32_SPSR_ABT_GE_SHIFT 16 +#define AARCH32_SPSR_ABT_GE_MASK 0xf0000U +#define AARCH32_SPSR_ABT_GE_GET( _reg ) \ + ( ( ( _reg ) >> 16 ) & 0xfU ) + +#define AARCH32_SPSR_ABT_IL 0x100000U + +#define AARCH32_SPSR_ABT_DIT 0x200000U + +#define AARCH32_SPSR_ABT_PAN 0x400000U + +#define AARCH32_SPSR_ABT_SSBS 0x800000U + +#define AARCH32_SPSR_ABT_J 0x1000000U + +#define AARCH32_SPSR_ABT_IT_1_0( _val ) ( ( _val ) << 25 ) +#define AARCH32_SPSR_ABT_IT_1_0_SHIFT 25 +#define AARCH32_SPSR_ABT_IT_1_0_MASK 0x6000000U +#define AARCH32_SPSR_ABT_IT_1_0_GET( _reg ) \ + ( ( ( _reg ) >> 25 ) & 0x3U ) + +#define AARCH32_SPSR_ABT_Q 0x8000000U + +#define AARCH32_SPSR_ABT_V 0x10000000U + +#define AARCH32_SPSR_ABT_C 0x20000000U + +#define AARCH32_SPSR_ABT_Z 0x40000000U + +#define AARCH32_SPSR_ABT_N 0x80000000U + +/* SPSR_FIQ, Saved Program Status Register (FIQ mode) */ + +#define AARCH32_SPSR_FIQ_M_4_0( _val ) ( ( _val ) << 0 ) +#define AARCH32_SPSR_FIQ_M_4_0_SHIFT 0 +#define AARCH32_SPSR_FIQ_M_4_0_MASK 0x1fU +#define AARCH32_SPSR_FIQ_M_4_0_GET( _reg ) \ + ( ( ( _reg ) >> 0 ) & 0x1fU ) + +#define AARCH32_SPSR_FIQ_T 0x20U + +#define AARCH32_SPSR_FIQ_F 0x40U + +#define AARCH32_SPSR_FIQ_I 0x80U + +#define AARCH32_SPSR_FIQ_A 0x100U + +#define AARCH32_SPSR_FIQ_E 0x200U + +#define AARCH32_SPSR_FIQ_IT_7_2( _val ) ( ( _val ) << 10 ) +#define AARCH32_SPSR_FIQ_IT_7_2_SHIFT 10 +#define AARCH32_SPSR_FIQ_IT_7_2_MASK 0xfc00U +#define AARCH32_SPSR_FIQ_IT_7_2_GET( _reg ) \ + ( ( ( _reg ) >> 10 ) & 0x3fU ) + +#define AARCH32_SPSR_FIQ_GE( _val ) ( ( _val ) << 16 ) +#define AARCH32_SPSR_FIQ_GE_SHIFT 16 +#define AARCH32_SPSR_FIQ_GE_MASK 0xf0000U +#define AARCH32_SPSR_FIQ_GE_GET( _reg ) \ + ( ( ( _reg ) >> 16 ) & 0xfU ) + +#define AARCH32_SPSR_FIQ_IL 0x100000U + +#define AARCH32_SPSR_FIQ_DIT 0x200000U + +#define AARCH32_SPSR_FIQ_PAN 0x400000U + +#define AARCH32_SPSR_FIQ_SSBS 0x800000U + +#define AARCH32_SPSR_FIQ_J 0x1000000U + +#define AARCH32_SPSR_FIQ_IT_1_0( _val ) ( ( _val ) << 25 ) +#define AARCH32_SPSR_FIQ_IT_1_0_SHIFT 25 +#define AARCH32_SPSR_FIQ_IT_1_0_MASK 0x6000000U +#define AARCH32_SPSR_FIQ_IT_1_0_GET( _reg ) \ + ( ( ( _reg ) >> 25 ) & 0x3U ) + +#define AARCH32_SPSR_FIQ_Q 0x8000000U + +#define AARCH32_SPSR_FIQ_V 0x10000000U + +#define AARCH32_SPSR_FIQ_C 0x20000000U + +#define AARCH32_SPSR_FIQ_Z 0x40000000U + +#define AARCH32_SPSR_FIQ_N 0x80000000U + +/* SPSR_HYP, Saved Program Status Register (Hyp mode) */ + +#define AARCH32_SPSR_HYP_M_4_0( _val ) ( ( _val ) << 0 ) +#define AARCH32_SPSR_HYP_M_4_0_SHIFT 0 +#define AARCH32_SPSR_HYP_M_4_0_MASK 0x1fU +#define AARCH32_SPSR_HYP_M_4_0_GET( _reg ) \ + ( ( ( _reg ) >> 0 ) & 0x1fU ) + +#define AARCH32_SPSR_HYP_T 0x20U + +#define AARCH32_SPSR_HYP_F 0x40U + +#define AARCH32_SPSR_HYP_I 0x80U + +#define AARCH32_SPSR_HYP_A 0x100U + +#define AARCH32_SPSR_HYP_E 0x200U + +#define AARCH32_SPSR_HYP_IT_7_2( _val ) ( ( _val ) << 10 ) +#define AARCH32_SPSR_HYP_IT_7_2_SHIFT 10 +#define AARCH32_SPSR_HYP_IT_7_2_MASK 0xfc00U +#define AARCH32_SPSR_HYP_IT_7_2_GET( _reg ) \ + ( ( ( _reg ) >> 10 ) & 0x3fU ) + +#define AARCH32_SPSR_HYP_GE( _val ) ( ( _val ) << 16 ) +#define AARCH32_SPSR_HYP_GE_SHIFT 16 +#define AARCH32_SPSR_HYP_GE_MASK 0xf0000U +#define AARCH32_SPSR_HYP_GE_GET( _reg ) \ + ( ( ( _reg ) >> 16 ) & 0xfU ) + +#define AARCH32_SPSR_HYP_IL 0x100000U + +#define AARCH32_SPSR_HYP_DIT 0x200000U + +#define AARCH32_SPSR_HYP_PAN 0x400000U + +#define AARCH32_SPSR_HYP_SSBS 0x800000U + +#define AARCH32_SPSR_HYP_J 0x1000000U + +#define AARCH32_SPSR_HYP_IT_1_0( _val ) ( ( _val ) << 25 ) +#define AARCH32_SPSR_HYP_IT_1_0_SHIFT 25 +#define AARCH32_SPSR_HYP_IT_1_0_MASK 0x6000000U +#define AARCH32_SPSR_HYP_IT_1_0_GET( _reg ) \ + ( ( ( _reg ) >> 25 ) & 0x3U ) + +#define AARCH32_SPSR_HYP_Q 0x8000000U + +#define AARCH32_SPSR_HYP_V 0x10000000U + +#define AARCH32_SPSR_HYP_C 0x20000000U + +#define AARCH32_SPSR_HYP_Z 0x40000000U + +#define AARCH32_SPSR_HYP_N 0x80000000U + +/* SPSR_IRQ, Saved Program Status Register (IRQ mode) */ + +#define AARCH32_SPSR_IRQ_M_4_0( _val ) ( ( _val ) << 0 ) +#define AARCH32_SPSR_IRQ_M_4_0_SHIFT 0 +#define AARCH32_SPSR_IRQ_M_4_0_MASK 0x1fU +#define AARCH32_SPSR_IRQ_M_4_0_GET( _reg ) \ + ( ( ( _reg ) >> 0 ) & 0x1fU ) + +#define AARCH32_SPSR_IRQ_T 0x20U + +#define AARCH32_SPSR_IRQ_F 0x40U + +#define AARCH32_SPSR_IRQ_I 0x80U + +#define AARCH32_SPSR_IRQ_A 0x100U + +#define AARCH32_SPSR_IRQ_E 0x200U + +#define AARCH32_SPSR_IRQ_IT_7_2( _val ) ( ( _val ) << 10 ) +#define AARCH32_SPSR_IRQ_IT_7_2_SHIFT 10 +#define AARCH32_SPSR_IRQ_IT_7_2_MASK 0xfc00U +#define AARCH32_SPSR_IRQ_IT_7_2_GET( _reg ) \ + ( ( ( _reg ) >> 10 ) & 0x3fU ) + +#define AARCH32_SPSR_IRQ_GE( _val ) ( ( _val ) << 16 ) +#define AARCH32_SPSR_IRQ_GE_SHIFT 16 +#define AARCH32_SPSR_IRQ_GE_MASK 0xf0000U +#define AARCH32_SPSR_IRQ_GE_GET( _reg ) \ + ( ( ( _reg ) >> 16 ) & 0xfU ) + +#define AARCH32_SPSR_IRQ_IL 0x100000U + +#define AARCH32_SPSR_IRQ_DIT 0x200000U + +#define AARCH32_SPSR_IRQ_PAN 0x400000U + +#define AARCH32_SPSR_IRQ_SSBS 0x800000U + +#define AARCH32_SPSR_IRQ_J 0x1000000U + +#define AARCH32_SPSR_IRQ_IT_1_0( _val ) ( ( _val ) << 25 ) +#define AARCH32_SPSR_IRQ_IT_1_0_SHIFT 25 +#define AARCH32_SPSR_IRQ_IT_1_0_MASK 0x6000000U +#define AARCH32_SPSR_IRQ_IT_1_0_GET( _reg ) \ + ( ( ( _reg ) >> 25 ) & 0x3U ) + +#define AARCH32_SPSR_IRQ_Q 0x8000000U + +#define AARCH32_SPSR_IRQ_V 0x10000000U + +#define AARCH32_SPSR_IRQ_C 0x20000000U + +#define AARCH32_SPSR_IRQ_Z 0x40000000U + +#define AARCH32_SPSR_IRQ_N 0x80000000U + +/* SPSR_MON, Saved Program Status Register (Monitor mode) */ + +#define AARCH32_SPSR_MON_M_4_0( _val ) ( ( _val ) << 0 ) +#define AARCH32_SPSR_MON_M_4_0_SHIFT 0 +#define AARCH32_SPSR_MON_M_4_0_MASK 0x1fU +#define AARCH32_SPSR_MON_M_4_0_GET( _reg ) \ + ( ( ( _reg ) >> 0 ) & 0x1fU ) + +#define AARCH32_SPSR_MON_T 0x20U + +#define AARCH32_SPSR_MON_F 0x40U + +#define AARCH32_SPSR_MON_I 0x80U + +#define AARCH32_SPSR_MON_A 0x100U + +#define AARCH32_SPSR_MON_E 0x200U + +#define AARCH32_SPSR_MON_IT_7_2( _val ) ( ( _val ) << 10 ) +#define AARCH32_SPSR_MON_IT_7_2_SHIFT 10 +#define AARCH32_SPSR_MON_IT_7_2_MASK 0xfc00U +#define AARCH32_SPSR_MON_IT_7_2_GET( _reg ) \ + ( ( ( _reg ) >> 10 ) & 0x3fU ) + +#define AARCH32_SPSR_MON_GE( _val ) ( ( _val ) << 16 ) +#define AARCH32_SPSR_MON_GE_SHIFT 16 +#define AARCH32_SPSR_MON_GE_MASK 0xf0000U +#define AARCH32_SPSR_MON_GE_GET( _reg ) \ + ( ( ( _reg ) >> 16 ) & 0xfU ) + +#define AARCH32_SPSR_MON_IL 0x100000U + +#define AARCH32_SPSR_MON_DIT 0x200000U + +#define AARCH32_SPSR_MON_PAN 0x400000U + +#define AARCH32_SPSR_MON_SSBS 0x800000U + +#define AARCH32_SPSR_MON_J 0x1000000U + +#define AARCH32_SPSR_MON_IT_1_0( _val ) ( ( _val ) << 25 ) +#define AARCH32_SPSR_MON_IT_1_0_SHIFT 25 +#define AARCH32_SPSR_MON_IT_1_0_MASK 0x6000000U +#define AARCH32_SPSR_MON_IT_1_0_GET( _reg ) \ + ( ( ( _reg ) >> 25 ) & 0x3U ) + +#define AARCH32_SPSR_MON_Q 0x8000000U + +#define AARCH32_SPSR_MON_V 0x10000000U + +#define AARCH32_SPSR_MON_C 0x20000000U + +#define AARCH32_SPSR_MON_Z 0x40000000U + +#define AARCH32_SPSR_MON_N 0x80000000U + +/* SPSR_SVC, Saved Program Status Register (Supervisor mode) */ + +#define AARCH32_SPSR_SVC_M_4_0( _val ) ( ( _val ) << 0 ) +#define AARCH32_SPSR_SVC_M_4_0_SHIFT 0 +#define AARCH32_SPSR_SVC_M_4_0_MASK 0x1fU +#define AARCH32_SPSR_SVC_M_4_0_GET( _reg ) \ + ( ( ( _reg ) >> 0 ) & 0x1fU ) + +#define AARCH32_SPSR_SVC_T 0x20U + +#define AARCH32_SPSR_SVC_F 0x40U + +#define AARCH32_SPSR_SVC_I 0x80U + +#define AARCH32_SPSR_SVC_A 0x100U + +#define AARCH32_SPSR_SVC_E 0x200U + +#define AARCH32_SPSR_SVC_IT_7_2( _val ) ( ( _val ) << 10 ) +#define AARCH32_SPSR_SVC_IT_7_2_SHIFT 10 +#define AARCH32_SPSR_SVC_IT_7_2_MASK 0xfc00U +#define AARCH32_SPSR_SVC_IT_7_2_GET( _reg ) \ + ( ( ( _reg ) >> 10 ) & 0x3fU ) + +#define AARCH32_SPSR_SVC_GE( _val ) ( ( _val ) << 16 ) +#define AARCH32_SPSR_SVC_GE_SHIFT 16 +#define AARCH32_SPSR_SVC_GE_MASK 0xf0000U +#define AARCH32_SPSR_SVC_GE_GET( _reg ) \ + ( ( ( _reg ) >> 16 ) & 0xfU ) + +#define AARCH32_SPSR_SVC_IL 0x100000U + +#define AARCH32_SPSR_SVC_DIT 0x200000U + +#define AARCH32_SPSR_SVC_PAN 0x400000U + +#define AARCH32_SPSR_SVC_SSBS 0x800000U + +#define AARCH32_SPSR_SVC_J 0x1000000U + +#define AARCH32_SPSR_SVC_IT_1_0( _val ) ( ( _val ) << 25 ) +#define AARCH32_SPSR_SVC_IT_1_0_SHIFT 25 +#define AARCH32_SPSR_SVC_IT_1_0_MASK 0x6000000U +#define AARCH32_SPSR_SVC_IT_1_0_GET( _reg ) \ + ( ( ( _reg ) >> 25 ) & 0x3U ) + +#define AARCH32_SPSR_SVC_Q 0x8000000U + +#define AARCH32_SPSR_SVC_V 0x10000000U + +#define AARCH32_SPSR_SVC_C 0x20000000U + +#define AARCH32_SPSR_SVC_Z 0x40000000U + +#define AARCH32_SPSR_SVC_N 0x80000000U + +/* SPSR_UND, Saved Program Status Register (Undefined mode) */ + +#define AARCH32_SPSR_UND_M_4_0( _val ) ( ( _val ) << 0 ) +#define AARCH32_SPSR_UND_M_4_0_SHIFT 0 +#define AARCH32_SPSR_UND_M_4_0_MASK 0x1fU +#define AARCH32_SPSR_UND_M_4_0_GET( _reg ) \ + ( ( ( _reg ) >> 0 ) & 0x1fU ) + +#define AARCH32_SPSR_UND_T 0x20U + +#define AARCH32_SPSR_UND_F 0x40U + +#define AARCH32_SPSR_UND_I 0x80U + +#define AARCH32_SPSR_UND_A 0x100U + +#define AARCH32_SPSR_UND_E 0x200U + +#define AARCH32_SPSR_UND_IT_7_2( _val ) ( ( _val ) << 10 ) +#define AARCH32_SPSR_UND_IT_7_2_SHIFT 10 +#define AARCH32_SPSR_UND_IT_7_2_MASK 0xfc00U +#define AARCH32_SPSR_UND_IT_7_2_GET( _reg ) \ + ( ( ( _reg ) >> 10 ) & 0x3fU ) + +#define AARCH32_SPSR_UND_GE( _val ) ( ( _val ) << 16 ) +#define AARCH32_SPSR_UND_GE_SHIFT 16 +#define AARCH32_SPSR_UND_GE_MASK 0xf0000U +#define AARCH32_SPSR_UND_GE_GET( _reg ) \ + ( ( ( _reg ) >> 16 ) & 0xfU ) + +#define AARCH32_SPSR_UND_IL 0x100000U + +#define AARCH32_SPSR_UND_DIT 0x200000U + +#define AARCH32_SPSR_UND_PAN 0x400000U + +#define AARCH32_SPSR_UND_SSBS 0x800000U + +#define AARCH32_SPSR_UND_J 0x1000000U + +#define AARCH32_SPSR_UND_IT_1_0( _val ) ( ( _val ) << 25 ) +#define AARCH32_SPSR_UND_IT_1_0_SHIFT 25 +#define AARCH32_SPSR_UND_IT_1_0_MASK 0x6000000U +#define AARCH32_SPSR_UND_IT_1_0_GET( _reg ) \ + ( ( ( _reg ) >> 25 ) & 0x3U ) + +#define AARCH32_SPSR_UND_Q 0x8000000U + +#define AARCH32_SPSR_UND_V 0x10000000U + +#define AARCH32_SPSR_UND_C 0x20000000U + +#define AARCH32_SPSR_UND_Z 0x40000000U + +#define AARCH32_SPSR_UND_N 0x80000000U + +/* TCMTR, TCM Type Register */ + +static inline uint32_t _AArch32_Read_tcmtr( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c0, c0, 2" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +/* TLBIALL, TLB Invalidate All */ + +static inline void _AArch32_Write_tlbiall( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c8, c7, 0" : : "r" ( value ) : "memory" + ); +} + +/* TLBIALLH, TLB Invalidate All, Hyp mode */ + +static inline void _AArch32_Write_tlbiallh( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 4, %0, c8, c7, 0" : : "r" ( value ) : "memory" + ); +} + +/* TLBIALLHIS, TLB Invalidate All, Hyp mode, Inner Shareable */ + +static inline void _AArch32_Write_tlbiallhis( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 4, %0, c8, c3, 0" : : "r" ( value ) : "memory" + ); +} + +/* TLBIALLIS, TLB Invalidate All, Inner Shareable */ + +static inline void _AArch32_Write_tlbiallis( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c8, c3, 0" : : "r" ( value ) : "memory" + ); +} + +/* TLBIALLNSNH, TLB Invalidate All, Non-Secure Non-Hyp */ + +static inline void _AArch32_Write_tlbiallnsnh( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 4, %0, c8, c7, 4" : : "r" ( value ) : "memory" + ); +} + +/* TLBIALLNSNHIS, TLB Invalidate All, Non-Secure Non-Hyp, Inner Shareable */ + +static inline void _AArch32_Write_tlbiallnsnhis( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 4, %0, c8, c3, 4" : : "r" ( value ) : "memory" + ); +} + +/* TLBIASID, TLB Invalidate by ASID match */ + +#define AARCH32_TLBIASID_ASID( _val ) ( ( _val ) << 0 ) +#define AARCH32_TLBIASID_ASID_SHIFT 0 +#define AARCH32_TLBIASID_ASID_MASK 0xffU +#define AARCH32_TLBIASID_ASID_GET( _reg ) \ + ( ( ( _reg ) >> 0 ) & 0xffU ) + +static inline void _AArch32_Write_tlbiasid( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c8, c7, 2" : : "r" ( value ) : "memory" + ); +} + +/* TLBIASIDIS, TLB Invalidate by ASID match, Inner Shareable */ + +#define AARCH32_TLBIASIDIS_ASID( _val ) ( ( _val ) << 0 ) +#define AARCH32_TLBIASIDIS_ASID_SHIFT 0 +#define AARCH32_TLBIASIDIS_ASID_MASK 0xffU +#define AARCH32_TLBIASIDIS_ASID_GET( _reg ) \ + ( ( ( _reg ) >> 0 ) & 0xffU ) + +static inline void _AArch32_Write_tlbiasidis( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c8, c3, 2" : : "r" ( value ) : "memory" + ); +} + +/* TLBIIPAS2, TLB Invalidate by Intermediate Physical Address, Stage 2 */ + +#define AARCH32_TLBIIPAS2_IPA_39_12( _val ) ( ( _val ) << 0 ) +#define AARCH32_TLBIIPAS2_IPA_39_12_SHIFT 0 +#define AARCH32_TLBIIPAS2_IPA_39_12_MASK 0xfffffffU +#define AARCH32_TLBIIPAS2_IPA_39_12_GET( _reg ) \ + ( ( ( _reg ) >> 0 ) & 0xfffffffU ) + +static inline void _AArch32_Write_tlbiipas2( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 4, %0, c8, c4, 1" : : "r" ( value ) : "memory" + ); +} + +/* TLBIIPAS2IS, TLB Invalidate by Intermediate Physical Address, Stage 2, Inner Shareable */ + +#define AARCH32_TLBIIPAS2IS_IPA_39_12( _val ) ( ( _val ) << 0 ) +#define AARCH32_TLBIIPAS2IS_IPA_39_12_SHIFT 0 +#define AARCH32_TLBIIPAS2IS_IPA_39_12_MASK 0xfffffffU +#define AARCH32_TLBIIPAS2IS_IPA_39_12_GET( _reg ) \ + ( ( ( _reg ) >> 0 ) & 0xfffffffU ) + +static inline void _AArch32_Write_tlbiipas2is( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 4, %0, c8, c0, 1" : : "r" ( value ) : "memory" + ); +} + +/* TLBIIPAS2L, TLB Invalidate by Intermediate Physical Address, Stage 2, Last level */ + +#define AARCH32_TLBIIPAS2L_IPA_39_12( _val ) ( ( _val ) << 0 ) +#define AARCH32_TLBIIPAS2L_IPA_39_12_SHIFT 0 +#define AARCH32_TLBIIPAS2L_IPA_39_12_MASK 0xfffffffU +#define AARCH32_TLBIIPAS2L_IPA_39_12_GET( _reg ) \ + ( ( ( _reg ) >> 0 ) & 0xfffffffU ) + +static inline void _AArch32_Write_tlbiipas2l( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 4, %0, c8, c4, 5" : : "r" ( value ) : "memory" + ); +} + +/* TLBIIPAS2LIS, TLB Invalidate by Intermediate Physical Address, Stage 2, Last level, Inner */ + +#define AARCH32_TLBIIPAS2LIS_IPA_39_12( _val ) ( ( _val ) << 0 ) +#define AARCH32_TLBIIPAS2LIS_IPA_39_12_SHIFT 0 +#define AARCH32_TLBIIPAS2LIS_IPA_39_12_MASK 0xfffffffU +#define AARCH32_TLBIIPAS2LIS_IPA_39_12_GET( _reg ) \ + ( ( ( _reg ) >> 0 ) & 0xfffffffU ) + +static inline void _AArch32_Write_tlbiipas2lis( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 4, %0, c8, c0, 5" : : "r" ( value ) : "memory" + ); +} + +/* TLBIMVA, TLB Invalidate by VA */ + +#define AARCH32_TLBIMVA_ASID( _val ) ( ( _val ) << 0 ) +#define AARCH32_TLBIMVA_ASID_SHIFT 0 +#define AARCH32_TLBIMVA_ASID_MASK 0xffU +#define AARCH32_TLBIMVA_ASID_GET( _reg ) \ + ( ( ( _reg ) >> 0 ) & 0xffU ) + +#define AARCH32_TLBIMVA_VA( _val ) ( ( _val ) << 12 ) +#define AARCH32_TLBIMVA_VA_SHIFT 12 +#define AARCH32_TLBIMVA_VA_MASK 0xfffff000U +#define AARCH32_TLBIMVA_VA_GET( _reg ) \ + ( ( ( _reg ) >> 12 ) & 0xfffffU ) + +static inline void _AArch32_Write_tlbimva( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c8, c7, 1" : : "r" ( value ) : "memory" + ); +} + +/* TLBIMVAA, TLB Invalidate by VA, All ASID */ + +#define AARCH32_TLBIMVAA_VA( _val ) ( ( _val ) << 12 ) +#define AARCH32_TLBIMVAA_VA_SHIFT 12 +#define AARCH32_TLBIMVAA_VA_MASK 0xfffff000U +#define AARCH32_TLBIMVAA_VA_GET( _reg ) \ + ( ( ( _reg ) >> 12 ) & 0xfffffU ) + +static inline void _AArch32_Write_tlbimvaa( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c8, c7, 3" : : "r" ( value ) : "memory" + ); +} + +/* TLBIMVAAIS, TLB Invalidate by VA, All ASID, Inner Shareable */ + +#define AARCH32_TLBIMVAAIS_VA( _val ) ( ( _val ) << 12 ) +#define AARCH32_TLBIMVAAIS_VA_SHIFT 12 +#define AARCH32_TLBIMVAAIS_VA_MASK 0xfffff000U +#define AARCH32_TLBIMVAAIS_VA_GET( _reg ) \ + ( ( ( _reg ) >> 12 ) & 0xfffffU ) + +static inline void _AArch32_Write_tlbimvaais( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c8, c3, 3" : : "r" ( value ) : "memory" + ); +} + +/* TLBIMVAAL, TLB Invalidate by VA, All ASID, Last level */ + +#define AARCH32_TLBIMVAAL_VA( _val ) ( ( _val ) << 12 ) +#define AARCH32_TLBIMVAAL_VA_SHIFT 12 +#define AARCH32_TLBIMVAAL_VA_MASK 0xfffff000U +#define AARCH32_TLBIMVAAL_VA_GET( _reg ) \ + ( ( ( _reg ) >> 12 ) & 0xfffffU ) + +static inline void _AArch32_Write_tlbimvaal( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c8, c7, 7" : : "r" ( value ) : "memory" + ); +} + +/* TLBIMVAALIS, TLB Invalidate by VA, All ASID, Last level, Inner Shareable */ + +#define AARCH32_TLBIMVAALIS_VA( _val ) ( ( _val ) << 12 ) +#define AARCH32_TLBIMVAALIS_VA_SHIFT 12 +#define AARCH32_TLBIMVAALIS_VA_MASK 0xfffff000U +#define AARCH32_TLBIMVAALIS_VA_GET( _reg ) \ + ( ( ( _reg ) >> 12 ) & 0xfffffU ) + +static inline void _AArch32_Write_tlbimvaalis( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c8, c3, 7" : : "r" ( value ) : "memory" + ); +} + +/* TLBIMVAH, TLB Invalidate by VA, Hyp mode */ + +#define AARCH32_TLBIMVAH_VA( _val ) ( ( _val ) << 12 ) +#define AARCH32_TLBIMVAH_VA_SHIFT 12 +#define AARCH32_TLBIMVAH_VA_MASK 0xfffff000U +#define AARCH32_TLBIMVAH_VA_GET( _reg ) \ + ( ( ( _reg ) >> 12 ) & 0xfffffU ) + +static inline void _AArch32_Write_tlbimvah( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 4, %0, c8, c7, 1" : : "r" ( value ) : "memory" + ); +} + +/* TLBIMVAHIS, TLB Invalidate by VA, Hyp mode, Inner Shareable */ + +#define AARCH32_TLBIMVAHIS_VA( _val ) ( ( _val ) << 12 ) +#define AARCH32_TLBIMVAHIS_VA_SHIFT 12 +#define AARCH32_TLBIMVAHIS_VA_MASK 0xfffff000U +#define AARCH32_TLBIMVAHIS_VA_GET( _reg ) \ + ( ( ( _reg ) >> 12 ) & 0xfffffU ) + +static inline void _AArch32_Write_tlbimvahis( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 4, %0, c8, c3, 1" : : "r" ( value ) : "memory" + ); +} + +/* TLBIMVAIS, TLB Invalidate by VA, Inner Shareable */ + +#define AARCH32_TLBIMVAIS_ASID( _val ) ( ( _val ) << 0 ) +#define AARCH32_TLBIMVAIS_ASID_SHIFT 0 +#define AARCH32_TLBIMVAIS_ASID_MASK 0xffU +#define AARCH32_TLBIMVAIS_ASID_GET( _reg ) \ + ( ( ( _reg ) >> 0 ) & 0xffU ) + +#define AARCH32_TLBIMVAIS_VA( _val ) ( ( _val ) << 12 ) +#define AARCH32_TLBIMVAIS_VA_SHIFT 12 +#define AARCH32_TLBIMVAIS_VA_MASK 0xfffff000U +#define AARCH32_TLBIMVAIS_VA_GET( _reg ) \ + ( ( ( _reg ) >> 12 ) & 0xfffffU ) + +static inline void _AArch32_Write_tlbimvais( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c8, c3, 1" : : "r" ( value ) : "memory" + ); +} + +/* TLBIMVAL, TLB Invalidate by VA, Last level */ + +#define AARCH32_TLBIMVAL_ASID( _val ) ( ( _val ) << 0 ) +#define AARCH32_TLBIMVAL_ASID_SHIFT 0 +#define AARCH32_TLBIMVAL_ASID_MASK 0xffU +#define AARCH32_TLBIMVAL_ASID_GET( _reg ) \ + ( ( ( _reg ) >> 0 ) & 0xffU ) + +#define AARCH32_TLBIMVAL_VA( _val ) ( ( _val ) << 12 ) +#define AARCH32_TLBIMVAL_VA_SHIFT 12 +#define AARCH32_TLBIMVAL_VA_MASK 0xfffff000U +#define AARCH32_TLBIMVAL_VA_GET( _reg ) \ + ( ( ( _reg ) >> 12 ) & 0xfffffU ) + +static inline void _AArch32_Write_tlbimval( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c8, c7, 5" : : "r" ( value ) : "memory" + ); +} + +/* TLBIMVALH, TLB Invalidate by VA, Last level, Hyp mode */ + +#define AARCH32_TLBIMVALH_VA( _val ) ( ( _val ) << 12 ) +#define AARCH32_TLBIMVALH_VA_SHIFT 12 +#define AARCH32_TLBIMVALH_VA_MASK 0xfffff000U +#define AARCH32_TLBIMVALH_VA_GET( _reg ) \ + ( ( ( _reg ) >> 12 ) & 0xfffffU ) + +static inline void _AArch32_Write_tlbimvalh( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 4, %0, c8, c7, 5" : : "r" ( value ) : "memory" + ); +} + +/* TLBIMVALHIS, TLB Invalidate by VA, Last level, Hyp mode, Inner Shareable */ + +#define AARCH32_TLBIMVALHIS_VA( _val ) ( ( _val ) << 12 ) +#define AARCH32_TLBIMVALHIS_VA_SHIFT 12 +#define AARCH32_TLBIMVALHIS_VA_MASK 0xfffff000U +#define AARCH32_TLBIMVALHIS_VA_GET( _reg ) \ + ( ( ( _reg ) >> 12 ) & 0xfffffU ) + +static inline void _AArch32_Write_tlbimvalhis( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 4, %0, c8, c3, 5" : : "r" ( value ) : "memory" + ); +} + +/* TLBIMVALIS, TLB Invalidate by VA, Last level, Inner Shareable */ + +#define AARCH32_TLBIMVALIS_ASID( _val ) ( ( _val ) << 0 ) +#define AARCH32_TLBIMVALIS_ASID_SHIFT 0 +#define AARCH32_TLBIMVALIS_ASID_MASK 0xffU +#define AARCH32_TLBIMVALIS_ASID_GET( _reg ) \ + ( ( ( _reg ) >> 0 ) & 0xffU ) + +#define AARCH32_TLBIMVALIS_VA( _val ) ( ( _val ) << 12 ) +#define AARCH32_TLBIMVALIS_VA_SHIFT 12 +#define AARCH32_TLBIMVALIS_VA_MASK 0xfffff000U +#define AARCH32_TLBIMVALIS_VA_GET( _reg ) \ + ( ( ( _reg ) >> 12 ) & 0xfffffU ) + +static inline void _AArch32_Write_tlbimvalis( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c8, c3, 5" : : "r" ( value ) : "memory" + ); +} + +/* TLBTR, TLB Type Register */ + +#define AARCH32_TLBTR_NU 0x1U + +static inline uint32_t _AArch32_Read_tlbtr( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c0, c0, 3" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +/* TPIDRPRW, PL1 Software Thread ID Register */ + +static inline uint32_t _AArch32_Read_tpidrprw( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c13, c0, 4" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_tpidrprw( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c13, c0, 4" : : "r" ( value ) : "memory" + ); +} + +/* TPIDRURO, PL0 Read-Only Software Thread ID Register */ + +static inline uint32_t _AArch32_Read_tpidruro( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c13, c0, 3" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_tpidruro( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c13, c0, 3" : : "r" ( value ) : "memory" + ); +} + +/* TPIDRURW, PL0 Read/Write Software Thread ID Register */ + +static inline uint32_t _AArch32_Read_tpidrurw( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c13, c0, 2" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_tpidrurw( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c13, c0, 2" : : "r" ( value ) : "memory" + ); +} + +/* TTBCR, Translation Table Base Control Register */ + +#define AARCH32_TTBCR_N( _val ) ( ( _val ) << 0 ) +#define AARCH32_TTBCR_N_SHIFT 0 +#define AARCH32_TTBCR_N_MASK 0x7U +#define AARCH32_TTBCR_N_GET( _reg ) \ + ( ( ( _reg ) >> 0 ) & 0x7U ) + +#define AARCH32_TTBCR_T0SZ( _val ) ( ( _val ) << 0 ) +#define AARCH32_TTBCR_T0SZ_SHIFT 0 +#define AARCH32_TTBCR_T0SZ_MASK 0x7U +#define AARCH32_TTBCR_T0SZ_GET( _reg ) \ + ( ( ( _reg ) >> 0 ) & 0x7U ) + +#define AARCH32_TTBCR_PD0 0x10U + +#define AARCH32_TTBCR_PD1 0x20U + +#define AARCH32_TTBCR_T2E 0x40U + +#define AARCH32_TTBCR_EPD0 0x80U + +#define AARCH32_TTBCR_IRGN0( _val ) ( ( _val ) << 8 ) +#define AARCH32_TTBCR_IRGN0_SHIFT 8 +#define AARCH32_TTBCR_IRGN0_MASK 0x300U +#define AARCH32_TTBCR_IRGN0_GET( _reg ) \ + ( ( ( _reg ) >> 8 ) & 0x3U ) + +#define AARCH32_TTBCR_ORGN0( _val ) ( ( _val ) << 10 ) +#define AARCH32_TTBCR_ORGN0_SHIFT 10 +#define AARCH32_TTBCR_ORGN0_MASK 0xc00U +#define AARCH32_TTBCR_ORGN0_GET( _reg ) \ + ( ( ( _reg ) >> 10 ) & 0x3U ) + +#define AARCH32_TTBCR_SH0( _val ) ( ( _val ) << 12 ) +#define AARCH32_TTBCR_SH0_SHIFT 12 +#define AARCH32_TTBCR_SH0_MASK 0x3000U +#define AARCH32_TTBCR_SH0_GET( _reg ) \ + ( ( ( _reg ) >> 12 ) & 0x3U ) + +#define AARCH32_TTBCR_T1SZ( _val ) ( ( _val ) << 16 ) +#define AARCH32_TTBCR_T1SZ_SHIFT 16 +#define AARCH32_TTBCR_T1SZ_MASK 0x70000U +#define AARCH32_TTBCR_T1SZ_GET( _reg ) \ + ( ( ( _reg ) >> 16 ) & 0x7U ) + +#define AARCH32_TTBCR_A1 0x400000U + +#define AARCH32_TTBCR_EPD1 0x800000U + +#define AARCH32_TTBCR_IRGN1( _val ) ( ( _val ) << 24 ) +#define AARCH32_TTBCR_IRGN1_SHIFT 24 +#define AARCH32_TTBCR_IRGN1_MASK 0x3000000U +#define AARCH32_TTBCR_IRGN1_GET( _reg ) \ + ( ( ( _reg ) >> 24 ) & 0x3U ) + +#define AARCH32_TTBCR_ORGN1( _val ) ( ( _val ) << 26 ) +#define AARCH32_TTBCR_ORGN1_SHIFT 26 +#define AARCH32_TTBCR_ORGN1_MASK 0xc000000U +#define AARCH32_TTBCR_ORGN1_GET( _reg ) \ + ( ( ( _reg ) >> 26 ) & 0x3U ) + +#define AARCH32_TTBCR_SH1( _val ) ( ( _val ) << 28 ) +#define AARCH32_TTBCR_SH1_SHIFT 28 +#define AARCH32_TTBCR_SH1_MASK 0x30000000U +#define AARCH32_TTBCR_SH1_GET( _reg ) \ + ( ( ( _reg ) >> 28 ) & 0x3U ) + +#define AARCH32_TTBCR_EAE 0x80000000U + +static inline uint32_t _AArch32_Read_ttbcr( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c2, c0, 2" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_ttbcr( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c2, c0, 2" : : "r" ( value ) : "memory" + ); +} + +/* TTBCR2, Translation Table Base Control Register 2 */ + +#define AARCH32_TTBCR2_HPD0 0x200U + +#define AARCH32_TTBCR2_HPD1 0x400U + +#define AARCH32_TTBCR2_HWU059 0x800U + +#define AARCH32_TTBCR2_HWU060 0x1000U + +#define AARCH32_TTBCR2_HWU061 0x2000U + +#define AARCH32_TTBCR2_HWU062 0x4000U + +#define AARCH32_TTBCR2_HWU159 0x8000U + +#define AARCH32_TTBCR2_HWU160 0x10000U + +#define AARCH32_TTBCR2_HWU161 0x20000U + +#define AARCH32_TTBCR2_HWU162 0x40000U + +static inline uint32_t _AArch32_Read_ttbcr2( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c2, c0, 3" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_ttbcr2( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c2, c0, 3" : : "r" ( value ) : "memory" + ); +} + +/* TTBR0, Translation Table Base Register 0 */ + +#define AARCH32_TTBR0_CNP 0x1U + +#define AARCH32_TTBR0_IRGN_1 0x1U + +#define AARCH32_TTBR0_S 0x2U + +#define AARCH32_TTBR0_BADDR( _val ) ( ( _val ) << 1 ) +#define AARCH32_TTBR0_BADDR_SHIFT 1 +#define AARCH32_TTBR0_BADDR_MASK 0xfffffffffffeULL +#define AARCH32_TTBR0_BADDR_GET( _reg ) \ + ( ( ( _reg ) >> 1 ) & 0x7fffffffffffULL ) + +#define AARCH32_TTBR0_IMP 0x4U + +#define AARCH32_TTBR0_RGN( _val ) ( ( _val ) << 3 ) +#define AARCH32_TTBR0_RGN_SHIFT 3 +#define AARCH32_TTBR0_RGN_MASK 0x18U +#define AARCH32_TTBR0_RGN_GET( _reg ) \ + ( ( ( _reg ) >> 3 ) & 0x3U ) + +#define AARCH32_TTBR0_NOS 0x20U + +#define AARCH32_TTBR0_IRGN_0 0x40U + +#define AARCH32_TTBR0_TTB0( _val ) ( ( _val ) << 7 ) +#define AARCH32_TTBR0_TTB0_SHIFT 7 +#define AARCH32_TTBR0_TTB0_MASK 0xffffff80U +#define AARCH32_TTBR0_TTB0_GET( _reg ) \ + ( ( ( _reg ) >> 7 ) & 0x1ffffffU ) + +#define AARCH32_TTBR0_ASID( _val ) ( ( _val ) << 48 ) +#define AARCH32_TTBR0_ASID_SHIFT 48 +#define AARCH32_TTBR0_ASID_MASK 0xff000000000000ULL +#define AARCH32_TTBR0_ASID_GET( _reg ) \ + ( ( ( _reg ) >> 48 ) & 0xffULL ) + +static inline uint32_t _AArch32_Read_32_ttbr0( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c2, c0, 0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_32_ttbr0( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c2, c0, 0" : : "r" ( value ) : "memory" + ); +} + +/* TTBR0, Translation Table Base Register 0 */ + +static inline uint64_t _AArch32_Read_64_ttbr0( void ) +{ + uint64_t value; + + __asm__ volatile ( + "mrrc p15, 0, %Q0, %R0, c2" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_64_ttbr0( uint64_t value ) +{ + __asm__ volatile ( + "mcrr p15, 0, %Q0, %R0, c2" : : "r" ( value ) : "memory" + ); +} + +/* TTBR1, Translation Table Base Register 1 */ + +#define AARCH32_TTBR1_CNP 0x1U + +#define AARCH32_TTBR1_IRGN_0 0x1U + +#define AARCH32_TTBR1_S 0x2U + +#define AARCH32_TTBR1_BADDR( _val ) ( ( _val ) << 1 ) +#define AARCH32_TTBR1_BADDR_SHIFT 1 +#define AARCH32_TTBR1_BADDR_MASK 0xfffffffffffeULL +#define AARCH32_TTBR1_BADDR_GET( _reg ) \ + ( ( ( _reg ) >> 1 ) & 0x7fffffffffffULL ) + +#define AARCH32_TTBR1_IMP 0x4U + +#define AARCH32_TTBR1_RGN( _val ) ( ( _val ) << 3 ) +#define AARCH32_TTBR1_RGN_SHIFT 3 +#define AARCH32_TTBR1_RGN_MASK 0x18U +#define AARCH32_TTBR1_RGN_GET( _reg ) \ + ( ( ( _reg ) >> 3 ) & 0x3U ) + +#define AARCH32_TTBR1_NOS 0x20U + +#define AARCH32_TTBR1_IRGN_1 0x40U + +#define AARCH32_TTBR1_TTB1( _val ) ( ( _val ) << 7 ) +#define AARCH32_TTBR1_TTB1_SHIFT 7 +#define AARCH32_TTBR1_TTB1_MASK 0xffffff80U +#define AARCH32_TTBR1_TTB1_GET( _reg ) \ + ( ( ( _reg ) >> 7 ) & 0x1ffffffU ) + +#define AARCH32_TTBR1_ASID( _val ) ( ( _val ) << 48 ) +#define AARCH32_TTBR1_ASID_SHIFT 48 +#define AARCH32_TTBR1_ASID_MASK 0xff000000000000ULL +#define AARCH32_TTBR1_ASID_GET( _reg ) \ + ( ( ( _reg ) >> 48 ) & 0xffULL ) + +static inline uint32_t _AArch32_Read_32_ttbr1( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c2, c0, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_32_ttbr1( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c2, c0, 1" : : "r" ( value ) : "memory" + ); +} + +/* TTBR1, Translation Table Base Register 1 */ + +static inline uint64_t _AArch32_Read_64_ttbr1( void ) +{ + uint64_t value; + + __asm__ volatile ( + "mrrc p15, 1, %Q0, %R0, c2" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_64_ttbr1( uint64_t value ) +{ + __asm__ volatile ( + "mcrr p15, 1, %Q0, %R0, c2" : : "r" ( value ) : "memory" + ); +} + +/* VBAR, Vector Base Address Register */ + +static inline uint32_t _AArch32_Read_vbar( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c12, c0, 0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_vbar( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c12, c0, 0" : : "r" ( value ) : "memory" + ); +} + +/* VMPIDR, Virtualization Multiprocessor ID Register */ + +#define AARCH32_VMPIDR_AFF0( _val ) ( ( _val ) << 0 ) +#define AARCH32_VMPIDR_AFF0_SHIFT 0 +#define AARCH32_VMPIDR_AFF0_MASK 0xffU +#define AARCH32_VMPIDR_AFF0_GET( _reg ) \ + ( ( ( _reg ) >> 0 ) & 0xffU ) + +#define AARCH32_VMPIDR_AFF1( _val ) ( ( _val ) << 8 ) +#define AARCH32_VMPIDR_AFF1_SHIFT 8 +#define AARCH32_VMPIDR_AFF1_MASK 0xff00U +#define AARCH32_VMPIDR_AFF1_GET( _reg ) \ + ( ( ( _reg ) >> 8 ) & 0xffU ) + +#define AARCH32_VMPIDR_AFF2( _val ) ( ( _val ) << 16 ) +#define AARCH32_VMPIDR_AFF2_SHIFT 16 +#define AARCH32_VMPIDR_AFF2_MASK 0xff0000U +#define AARCH32_VMPIDR_AFF2_GET( _reg ) \ + ( ( ( _reg ) >> 16 ) & 0xffU ) + +#define AARCH32_VMPIDR_MT 0x1000000U + +#define AARCH32_VMPIDR_U 0x40000000U + +#define AARCH32_VMPIDR_M 0x80000000U + +static inline uint32_t _AArch32_Read_vmpidr( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 4, %0, c0, c0, 5" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_vmpidr( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 4, %0, c0, c0, 5" : : "r" ( value ) : "memory" + ); +} + +/* VPIDR, Virtualization Processor ID Register */ + +#define AARCH32_VPIDR_REVISION( _val ) ( ( _val ) << 0 ) +#define AARCH32_VPIDR_REVISION_SHIFT 0 +#define AARCH32_VPIDR_REVISION_MASK 0xfU +#define AARCH32_VPIDR_REVISION_GET( _reg ) \ + ( ( ( _reg ) >> 0 ) & 0xfU ) + +#define AARCH32_VPIDR_PARTNUM( _val ) ( ( _val ) << 4 ) +#define AARCH32_VPIDR_PARTNUM_SHIFT 4 +#define AARCH32_VPIDR_PARTNUM_MASK 0xfff0U +#define AARCH32_VPIDR_PARTNUM_GET( _reg ) \ + ( ( ( _reg ) >> 4 ) & 0xfffU ) + +#define AARCH32_VPIDR_ARCHITECTURE( _val ) ( ( _val ) << 16 ) +#define AARCH32_VPIDR_ARCHITECTURE_SHIFT 16 +#define AARCH32_VPIDR_ARCHITECTURE_MASK 0xf0000U +#define AARCH32_VPIDR_ARCHITECTURE_GET( _reg ) \ + ( ( ( _reg ) >> 16 ) & 0xfU ) + +#define AARCH32_VPIDR_VARIANT( _val ) ( ( _val ) << 20 ) +#define AARCH32_VPIDR_VARIANT_SHIFT 20 +#define AARCH32_VPIDR_VARIANT_MASK 0xf00000U +#define AARCH32_VPIDR_VARIANT_GET( _reg ) \ + ( ( ( _reg ) >> 20 ) & 0xfU ) + +#define AARCH32_VPIDR_IMPLEMENTER( _val ) ( ( _val ) << 24 ) +#define AARCH32_VPIDR_IMPLEMENTER_SHIFT 24 +#define AARCH32_VPIDR_IMPLEMENTER_MASK 0xff000000U +#define AARCH32_VPIDR_IMPLEMENTER_GET( _reg ) \ + ( ( ( _reg ) >> 24 ) & 0xffU ) + +static inline uint32_t _AArch32_Read_vpidr( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 4, %0, c0, c0, 0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_vpidr( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 4, %0, c0, c0, 0" : : "r" ( value ) : "memory" + ); +} + +/* VTCR, Virtualization Translation Control Register */ + +#define AARCH32_VTCR_T0SZ( _val ) ( ( _val ) << 0 ) +#define AARCH32_VTCR_T0SZ_SHIFT 0 +#define AARCH32_VTCR_T0SZ_MASK 0xfU +#define AARCH32_VTCR_T0SZ_GET( _reg ) \ + ( ( ( _reg ) >> 0 ) & 0xfU ) + +#define AARCH32_VTCR_S 0x10U + +#define AARCH32_VTCR_SL0( _val ) ( ( _val ) << 6 ) +#define AARCH32_VTCR_SL0_SHIFT 6 +#define AARCH32_VTCR_SL0_MASK 0xc0U +#define AARCH32_VTCR_SL0_GET( _reg ) \ + ( ( ( _reg ) >> 6 ) & 0x3U ) + +#define AARCH32_VTCR_IRGN0( _val ) ( ( _val ) << 8 ) +#define AARCH32_VTCR_IRGN0_SHIFT 8 +#define AARCH32_VTCR_IRGN0_MASK 0x300U +#define AARCH32_VTCR_IRGN0_GET( _reg ) \ + ( ( ( _reg ) >> 8 ) & 0x3U ) + +#define AARCH32_VTCR_ORGN0( _val ) ( ( _val ) << 10 ) +#define AARCH32_VTCR_ORGN0_SHIFT 10 +#define AARCH32_VTCR_ORGN0_MASK 0xc00U +#define AARCH32_VTCR_ORGN0_GET( _reg ) \ + ( ( ( _reg ) >> 10 ) & 0x3U ) + +#define AARCH32_VTCR_SH0( _val ) ( ( _val ) << 12 ) +#define AARCH32_VTCR_SH0_SHIFT 12 +#define AARCH32_VTCR_SH0_MASK 0x3000U +#define AARCH32_VTCR_SH0_GET( _reg ) \ + ( ( ( _reg ) >> 12 ) & 0x3U ) + +#define AARCH32_VTCR_HWU59 0x2000000U + +#define AARCH32_VTCR_HWU60 0x4000000U + +#define AARCH32_VTCR_HWU61 0x8000000U + +#define AARCH32_VTCR_HWU62 0x10000000U + +static inline uint32_t _AArch32_Read_vtcr( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 4, %0, c2, c1, 2" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_vtcr( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 4, %0, c2, c1, 2" : : "r" ( value ) : "memory" + ); +} + +/* VTTBR, Virtualization Translation Table Base Register */ + +#define AARCH32_VTTBR_CNP 0x1U + +#define AARCH32_VTTBR_BADDR( _val ) ( ( _val ) << 1 ) +#define AARCH32_VTTBR_BADDR_SHIFT 1 +#define AARCH32_VTTBR_BADDR_MASK 0xfffffffffffeULL +#define AARCH32_VTTBR_BADDR_GET( _reg ) \ + ( ( ( _reg ) >> 1 ) & 0x7fffffffffffULL ) + +#define AARCH32_VTTBR_VMID( _val ) ( ( _val ) << 48 ) +#define AARCH32_VTTBR_VMID_SHIFT 48 +#define AARCH32_VTTBR_VMID_MASK 0xff000000000000ULL +#define AARCH32_VTTBR_VMID_GET( _reg ) \ + ( ( ( _reg ) >> 48 ) & 0xffULL ) + +static inline uint64_t _AArch32_Read_vttbr( void ) +{ + uint64_t value; + + __asm__ volatile ( + "mrrc p15, 6, %Q0, %R0, c2" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_vttbr( uint64_t value ) +{ + __asm__ volatile ( + "mcrr p15, 6, %Q0, %R0, c2" : : "r" ( value ) : "memory" + ); +} + +/* DBGAUTHSTATUS, Debug Authentication Status Register */ + +#define AARCH32_DBGAUTHSTATUS_NSID( _val ) ( ( _val ) << 0 ) +#define AARCH32_DBGAUTHSTATUS_NSID_SHIFT 0 +#define AARCH32_DBGAUTHSTATUS_NSID_MASK 0x3U +#define AARCH32_DBGAUTHSTATUS_NSID_GET( _reg ) \ + ( ( ( _reg ) >> 0 ) & 0x3U ) + +#define AARCH32_DBGAUTHSTATUS_NSNID( _val ) ( ( _val ) << 2 ) +#define AARCH32_DBGAUTHSTATUS_NSNID_SHIFT 2 +#define AARCH32_DBGAUTHSTATUS_NSNID_MASK 0xcU +#define AARCH32_DBGAUTHSTATUS_NSNID_GET( _reg ) \ + ( ( ( _reg ) >> 2 ) & 0x3U ) + +#define AARCH32_DBGAUTHSTATUS_SID( _val ) ( ( _val ) << 4 ) +#define AARCH32_DBGAUTHSTATUS_SID_SHIFT 4 +#define AARCH32_DBGAUTHSTATUS_SID_MASK 0x30U +#define AARCH32_DBGAUTHSTATUS_SID_GET( _reg ) \ + ( ( ( _reg ) >> 4 ) & 0x3U ) + +#define AARCH32_DBGAUTHSTATUS_SNID( _val ) ( ( _val ) << 6 ) +#define AARCH32_DBGAUTHSTATUS_SNID_SHIFT 6 +#define AARCH32_DBGAUTHSTATUS_SNID_MASK 0xc0U +#define AARCH32_DBGAUTHSTATUS_SNID_GET( _reg ) \ + ( ( ( _reg ) >> 6 ) & 0x3U ) + +static inline uint32_t _AArch32_Read_dbgauthstatus( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p14, 0, %0, c7, c14, 6" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +/* DBGBCR, Debug Breakpoint Control Registers */ + +#define AARCH32_DBGBCR_E 0x1U + +#define AARCH32_DBGBCR_PMC( _val ) ( ( _val ) << 1 ) +#define AARCH32_DBGBCR_PMC_SHIFT 1 +#define AARCH32_DBGBCR_PMC_MASK 0x6U +#define AARCH32_DBGBCR_PMC_GET( _reg ) \ + ( ( ( _reg ) >> 1 ) & 0x3U ) + +#define AARCH32_DBGBCR_BAS( _val ) ( ( _val ) << 5 ) +#define AARCH32_DBGBCR_BAS_SHIFT 5 +#define AARCH32_DBGBCR_BAS_MASK 0x1e0U +#define AARCH32_DBGBCR_BAS_GET( _reg ) \ + ( ( ( _reg ) >> 5 ) & 0xfU ) + +#define AARCH32_DBGBCR_HMC 0x2000U + +#define AARCH32_DBGBCR_SSC( _val ) ( ( _val ) << 14 ) +#define AARCH32_DBGBCR_SSC_SHIFT 14 +#define AARCH32_DBGBCR_SSC_MASK 0xc000U +#define AARCH32_DBGBCR_SSC_GET( _reg ) \ + ( ( ( _reg ) >> 14 ) & 0x3U ) + +#define AARCH32_DBGBCR_LBN( _val ) ( ( _val ) << 16 ) +#define AARCH32_DBGBCR_LBN_SHIFT 16 +#define AARCH32_DBGBCR_LBN_MASK 0xf0000U +#define AARCH32_DBGBCR_LBN_GET( _reg ) \ + ( ( ( _reg ) >> 16 ) & 0xfU ) + +#define AARCH32_DBGBCR_BT( _val ) ( ( _val ) << 20 ) +#define AARCH32_DBGBCR_BT_SHIFT 20 +#define AARCH32_DBGBCR_BT_MASK 0xf00000U +#define AARCH32_DBGBCR_BT_GET( _reg ) \ + ( ( ( _reg ) >> 20 ) & 0xfU ) + +/* DBGBCR_0, Debug Breakpoint Control Registers */ + +static inline uint32_t _AArch32_Read_dbgbcr_0( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p14, 0, %0, c0, c0, 5" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_dbgbcr_0( uint32_t value ) +{ + __asm__ volatile ( + "mcr p14, 0, %0, c0, c0, 5" : : "r" ( value ) : "memory" + ); +} + +/* DBGBCR_1, Debug Breakpoint Control Registers */ + +static inline uint32_t _AArch32_Read_dbgbcr_1( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p14, 0, %0, c0, c1, 5" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_dbgbcr_1( uint32_t value ) +{ + __asm__ volatile ( + "mcr p14, 0, %0, c0, c1, 5" : : "r" ( value ) : "memory" + ); +} + +/* DBGBCR_2, Debug Breakpoint Control Registers */ + +static inline uint32_t _AArch32_Read_dbgbcr_2( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p14, 0, %0, c0, c2, 5" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_dbgbcr_2( uint32_t value ) +{ + __asm__ volatile ( + "mcr p14, 0, %0, c0, c2, 5" : : "r" ( value ) : "memory" + ); +} + +/* DBGBCR_3, Debug Breakpoint Control Registers */ + +static inline uint32_t _AArch32_Read_dbgbcr_3( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p14, 0, %0, c0, c3, 5" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_dbgbcr_3( uint32_t value ) +{ + __asm__ volatile ( + "mcr p14, 0, %0, c0, c3, 5" : : "r" ( value ) : "memory" + ); +} + +/* DBGBCR_4, Debug Breakpoint Control Registers */ + +static inline uint32_t _AArch32_Read_dbgbcr_4( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p14, 0, %0, c0, c4, 5" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_dbgbcr_4( uint32_t value ) +{ + __asm__ volatile ( + "mcr p14, 0, %0, c0, c4, 5" : : "r" ( value ) : "memory" + ); +} + +/* DBGBCR_5, Debug Breakpoint Control Registers */ + +static inline uint32_t _AArch32_Read_dbgbcr_5( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p14, 0, %0, c0, c5, 5" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_dbgbcr_5( uint32_t value ) +{ + __asm__ volatile ( + "mcr p14, 0, %0, c0, c5, 5" : : "r" ( value ) : "memory" + ); +} + +/* DBGBCR_6, Debug Breakpoint Control Registers */ + +static inline uint32_t _AArch32_Read_dbgbcr_6( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p14, 0, %0, c0, c6, 5" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_dbgbcr_6( uint32_t value ) +{ + __asm__ volatile ( + "mcr p14, 0, %0, c0, c6, 5" : : "r" ( value ) : "memory" + ); +} + +/* DBGBCR_7, Debug Breakpoint Control Registers */ + +static inline uint32_t _AArch32_Read_dbgbcr_7( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p14, 0, %0, c0, c7, 5" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_dbgbcr_7( uint32_t value ) +{ + __asm__ volatile ( + "mcr p14, 0, %0, c0, c7, 5" : : "r" ( value ) : "memory" + ); +} + +/* DBGBCR_8, Debug Breakpoint Control Registers */ + +static inline uint32_t _AArch32_Read_dbgbcr_8( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p14, 0, %0, c0, c8, 5" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_dbgbcr_8( uint32_t value ) +{ + __asm__ volatile ( + "mcr p14, 0, %0, c0, c8, 5" : : "r" ( value ) : "memory" + ); +} + +/* DBGBCR_9, Debug Breakpoint Control Registers */ + +static inline uint32_t _AArch32_Read_dbgbcr_9( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p14, 0, %0, c0, c9, 5" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_dbgbcr_9( uint32_t value ) +{ + __asm__ volatile ( + "mcr p14, 0, %0, c0, c9, 5" : : "r" ( value ) : "memory" + ); +} + +/* DBGBCR_10, Debug Breakpoint Control Registers */ + +static inline uint32_t _AArch32_Read_dbgbcr_10( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p14, 0, %0, c0, c10, 5" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_dbgbcr_10( uint32_t value ) +{ + __asm__ volatile ( + "mcr p14, 0, %0, c0, c10, 5" : : "r" ( value ) : "memory" + ); +} + +/* DBGBCR_11, Debug Breakpoint Control Registers */ + +static inline uint32_t _AArch32_Read_dbgbcr_11( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p14, 0, %0, c0, c11, 5" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_dbgbcr_11( uint32_t value ) +{ + __asm__ volatile ( + "mcr p14, 0, %0, c0, c11, 5" : : "r" ( value ) : "memory" + ); +} + +/* DBGBCR_12, Debug Breakpoint Control Registers */ + +static inline uint32_t _AArch32_Read_dbgbcr_12( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p14, 0, %0, c0, c12, 5" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_dbgbcr_12( uint32_t value ) +{ + __asm__ volatile ( + "mcr p14, 0, %0, c0, c12, 5" : : "r" ( value ) : "memory" + ); +} + +/* DBGBCR_13, Debug Breakpoint Control Registers */ + +static inline uint32_t _AArch32_Read_dbgbcr_13( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p14, 0, %0, c0, c13, 5" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_dbgbcr_13( uint32_t value ) +{ + __asm__ volatile ( + "mcr p14, 0, %0, c0, c13, 5" : : "r" ( value ) : "memory" + ); +} + +/* DBGBCR_14, Debug Breakpoint Control Registers */ + +static inline uint32_t _AArch32_Read_dbgbcr_14( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p14, 0, %0, c0, c14, 5" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_dbgbcr_14( uint32_t value ) +{ + __asm__ volatile ( + "mcr p14, 0, %0, c0, c14, 5" : : "r" ( value ) : "memory" + ); +} + +/* DBGBCR_15, Debug Breakpoint Control Registers */ + +static inline uint32_t _AArch32_Read_dbgbcr_15( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p14, 0, %0, c0, c15, 5" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_dbgbcr_15( uint32_t value ) +{ + __asm__ volatile ( + "mcr p14, 0, %0, c0, c15, 5" : : "r" ( value ) : "memory" + ); +} + +/* DBGBVR, Debug Breakpoint Value Registers */ + +#define AARCH32_DBGBVR_CONTEXTID( _val ) ( ( _val ) << 0 ) +#define AARCH32_DBGBVR_CONTEXTID_SHIFT 0 +#define AARCH32_DBGBVR_CONTEXTID_MASK 0xffffffffU +#define AARCH32_DBGBVR_CONTEXTID_GET( _reg ) \ + ( ( ( _reg ) >> 0 ) & 0xffffffffU ) + +#define AARCH32_DBGBVR_VA_31_2( _val ) ( ( _val ) << 2 ) +#define AARCH32_DBGBVR_VA_31_2_SHIFT 2 +#define AARCH32_DBGBVR_VA_31_2_MASK 0xfffffffcU +#define AARCH32_DBGBVR_VA_31_2_GET( _reg ) \ + ( ( ( _reg ) >> 2 ) & 0x3fffffffU ) + +/* DBGBVR_0, Debug Breakpoint Value Registers */ + +static inline uint32_t _AArch32_Read_dbgbvr_0( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p14, 0, %0, c0, c0, 4" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_dbgbvr_0( uint32_t value ) +{ + __asm__ volatile ( + "mcr p14, 0, %0, c0, c0, 4" : : "r" ( value ) : "memory" + ); +} + +/* DBGBVR_1, Debug Breakpoint Value Registers */ + +static inline uint32_t _AArch32_Read_dbgbvr_1( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p14, 0, %0, c0, c1, 4" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_dbgbvr_1( uint32_t value ) +{ + __asm__ volatile ( + "mcr p14, 0, %0, c0, c1, 4" : : "r" ( value ) : "memory" + ); +} + +/* DBGBVR_2, Debug Breakpoint Value Registers */ + +static inline uint32_t _AArch32_Read_dbgbvr_2( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p14, 0, %0, c0, c2, 4" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_dbgbvr_2( uint32_t value ) +{ + __asm__ volatile ( + "mcr p14, 0, %0, c0, c2, 4" : : "r" ( value ) : "memory" + ); +} + +/* DBGBVR_3, Debug Breakpoint Value Registers */ + +static inline uint32_t _AArch32_Read_dbgbvr_3( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p14, 0, %0, c0, c3, 4" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_dbgbvr_3( uint32_t value ) +{ + __asm__ volatile ( + "mcr p14, 0, %0, c0, c3, 4" : : "r" ( value ) : "memory" + ); +} + +/* DBGBVR_4, Debug Breakpoint Value Registers */ + +static inline uint32_t _AArch32_Read_dbgbvr_4( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p14, 0, %0, c0, c4, 4" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_dbgbvr_4( uint32_t value ) +{ + __asm__ volatile ( + "mcr p14, 0, %0, c0, c4, 4" : : "r" ( value ) : "memory" + ); +} + +/* DBGBVR_5, Debug Breakpoint Value Registers */ + +static inline uint32_t _AArch32_Read_dbgbvr_5( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p14, 0, %0, c0, c5, 4" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_dbgbvr_5( uint32_t value ) +{ + __asm__ volatile ( + "mcr p14, 0, %0, c0, c5, 4" : : "r" ( value ) : "memory" + ); +} + +/* DBGBVR_6, Debug Breakpoint Value Registers */ + +static inline uint32_t _AArch32_Read_dbgbvr_6( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p14, 0, %0, c0, c6, 4" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_dbgbvr_6( uint32_t value ) +{ + __asm__ volatile ( + "mcr p14, 0, %0, c0, c6, 4" : : "r" ( value ) : "memory" + ); +} + +/* DBGBVR_7, Debug Breakpoint Value Registers */ + +static inline uint32_t _AArch32_Read_dbgbvr_7( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p14, 0, %0, c0, c7, 4" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_dbgbvr_7( uint32_t value ) +{ + __asm__ volatile ( + "mcr p14, 0, %0, c0, c7, 4" : : "r" ( value ) : "memory" + ); +} + +/* DBGBVR_8, Debug Breakpoint Value Registers */ + +static inline uint32_t _AArch32_Read_dbgbvr_8( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p14, 0, %0, c0, c8, 4" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_dbgbvr_8( uint32_t value ) +{ + __asm__ volatile ( + "mcr p14, 0, %0, c0, c8, 4" : : "r" ( value ) : "memory" + ); +} + +/* DBGBVR_9, Debug Breakpoint Value Registers */ + +static inline uint32_t _AArch32_Read_dbgbvr_9( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p14, 0, %0, c0, c9, 4" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_dbgbvr_9( uint32_t value ) +{ + __asm__ volatile ( + "mcr p14, 0, %0, c0, c9, 4" : : "r" ( value ) : "memory" + ); +} + +/* DBGBVR_10, Debug Breakpoint Value Registers */ + +static inline uint32_t _AArch32_Read_dbgbvr_10( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p14, 0, %0, c0, c10, 4" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_dbgbvr_10( uint32_t value ) +{ + __asm__ volatile ( + "mcr p14, 0, %0, c0, c10, 4" : : "r" ( value ) : "memory" + ); +} + +/* DBGBVR_11, Debug Breakpoint Value Registers */ + +static inline uint32_t _AArch32_Read_dbgbvr_11( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p14, 0, %0, c0, c11, 4" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_dbgbvr_11( uint32_t value ) +{ + __asm__ volatile ( + "mcr p14, 0, %0, c0, c11, 4" : : "r" ( value ) : "memory" + ); +} + +/* DBGBVR_12, Debug Breakpoint Value Registers */ + +static inline uint32_t _AArch32_Read_dbgbvr_12( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p14, 0, %0, c0, c12, 4" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_dbgbvr_12( uint32_t value ) +{ + __asm__ volatile ( + "mcr p14, 0, %0, c0, c12, 4" : : "r" ( value ) : "memory" + ); +} + +/* DBGBVR_13, Debug Breakpoint Value Registers */ + +static inline uint32_t _AArch32_Read_dbgbvr_13( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p14, 0, %0, c0, c13, 4" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_dbgbvr_13( uint32_t value ) +{ + __asm__ volatile ( + "mcr p14, 0, %0, c0, c13, 4" : : "r" ( value ) : "memory" + ); +} + +/* DBGBVR_14, Debug Breakpoint Value Registers */ + +static inline uint32_t _AArch32_Read_dbgbvr_14( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p14, 0, %0, c0, c14, 4" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_dbgbvr_14( uint32_t value ) +{ + __asm__ volatile ( + "mcr p14, 0, %0, c0, c14, 4" : : "r" ( value ) : "memory" + ); +} + +/* DBGBVR_15, Debug Breakpoint Value Registers */ + +static inline uint32_t _AArch32_Read_dbgbvr_15( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p14, 0, %0, c0, c15, 4" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_dbgbvr_15( uint32_t value ) +{ + __asm__ volatile ( + "mcr p14, 0, %0, c0, c15, 4" : : "r" ( value ) : "memory" + ); +} + +/* DBGBXVR, Debug Breakpoint Extended Value Registers */ + +#define AARCH32_DBGBXVR_VMID_7_0( _val ) ( ( _val ) << 0 ) +#define AARCH32_DBGBXVR_VMID_7_0_SHIFT 0 +#define AARCH32_DBGBXVR_VMID_7_0_MASK 0xffU +#define AARCH32_DBGBXVR_VMID_7_0_GET( _reg ) \ + ( ( ( _reg ) >> 0 ) & 0xffU ) + +#define AARCH32_DBGBXVR_CONTEXTID2( _val ) ( ( _val ) << 0 ) +#define AARCH32_DBGBXVR_CONTEXTID2_SHIFT 0 +#define AARCH32_DBGBXVR_CONTEXTID2_MASK 0xffffffffU +#define AARCH32_DBGBXVR_CONTEXTID2_GET( _reg ) \ + ( ( ( _reg ) >> 0 ) & 0xffffffffU ) + +#define AARCH32_DBGBXVR_VMID_15_8( _val ) ( ( _val ) << 8 ) +#define AARCH32_DBGBXVR_VMID_15_8_SHIFT 8 +#define AARCH32_DBGBXVR_VMID_15_8_MASK 0xff00U +#define AARCH32_DBGBXVR_VMID_15_8_GET( _reg ) \ + ( ( ( _reg ) >> 8 ) & 0xffU ) + +/* DBGBXVR_0, Debug Breakpoint Extended Value Registers */ + +static inline uint32_t _AArch32_Read_dbgbxvr_0( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p14, 0, %0, c1, c0, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_dbgbxvr_0( uint32_t value ) +{ + __asm__ volatile ( + "mcr p14, 0, %0, c1, c0, 1" : : "r" ( value ) : "memory" + ); +} + +/* DBGBXVR_1, Debug Breakpoint Extended Value Registers */ + +static inline uint32_t _AArch32_Read_dbgbxvr_1( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p14, 0, %0, c1, c1, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_dbgbxvr_1( uint32_t value ) +{ + __asm__ volatile ( + "mcr p14, 0, %0, c1, c1, 1" : : "r" ( value ) : "memory" + ); +} + +/* DBGBXVR_2, Debug Breakpoint Extended Value Registers */ + +static inline uint32_t _AArch32_Read_dbgbxvr_2( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p14, 0, %0, c1, c2, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_dbgbxvr_2( uint32_t value ) +{ + __asm__ volatile ( + "mcr p14, 0, %0, c1, c2, 1" : : "r" ( value ) : "memory" + ); +} + +/* DBGBXVR_3, Debug Breakpoint Extended Value Registers */ + +static inline uint32_t _AArch32_Read_dbgbxvr_3( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p14, 0, %0, c1, c3, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_dbgbxvr_3( uint32_t value ) +{ + __asm__ volatile ( + "mcr p14, 0, %0, c1, c3, 1" : : "r" ( value ) : "memory" + ); +} + +/* DBGBXVR_4, Debug Breakpoint Extended Value Registers */ + +static inline uint32_t _AArch32_Read_dbgbxvr_4( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p14, 0, %0, c1, c4, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_dbgbxvr_4( uint32_t value ) +{ + __asm__ volatile ( + "mcr p14, 0, %0, c1, c4, 1" : : "r" ( value ) : "memory" + ); +} + +/* DBGBXVR_5, Debug Breakpoint Extended Value Registers */ + +static inline uint32_t _AArch32_Read_dbgbxvr_5( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p14, 0, %0, c1, c5, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_dbgbxvr_5( uint32_t value ) +{ + __asm__ volatile ( + "mcr p14, 0, %0, c1, c5, 1" : : "r" ( value ) : "memory" + ); +} + +/* DBGBXVR_6, Debug Breakpoint Extended Value Registers */ + +static inline uint32_t _AArch32_Read_dbgbxvr_6( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p14, 0, %0, c1, c6, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_dbgbxvr_6( uint32_t value ) +{ + __asm__ volatile ( + "mcr p14, 0, %0, c1, c6, 1" : : "r" ( value ) : "memory" + ); +} + +/* DBGBXVR_7, Debug Breakpoint Extended Value Registers */ + +static inline uint32_t _AArch32_Read_dbgbxvr_7( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p14, 0, %0, c1, c7, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_dbgbxvr_7( uint32_t value ) +{ + __asm__ volatile ( + "mcr p14, 0, %0, c1, c7, 1" : : "r" ( value ) : "memory" + ); +} + +/* DBGBXVR_8, Debug Breakpoint Extended Value Registers */ + +static inline uint32_t _AArch32_Read_dbgbxvr_8( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p14, 0, %0, c1, c8, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_dbgbxvr_8( uint32_t value ) +{ + __asm__ volatile ( + "mcr p14, 0, %0, c1, c8, 1" : : "r" ( value ) : "memory" + ); +} + +/* DBGBXVR_9, Debug Breakpoint Extended Value Registers */ + +static inline uint32_t _AArch32_Read_dbgbxvr_9( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p14, 0, %0, c1, c9, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_dbgbxvr_9( uint32_t value ) +{ + __asm__ volatile ( + "mcr p14, 0, %0, c1, c9, 1" : : "r" ( value ) : "memory" + ); +} + +/* DBGBXVR_10, Debug Breakpoint Extended Value Registers */ + +static inline uint32_t _AArch32_Read_dbgbxvr_10( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p14, 0, %0, c1, c10, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_dbgbxvr_10( uint32_t value ) +{ + __asm__ volatile ( + "mcr p14, 0, %0, c1, c10, 1" : : "r" ( value ) : "memory" + ); +} + +/* DBGBXVR_11, Debug Breakpoint Extended Value Registers */ + +static inline uint32_t _AArch32_Read_dbgbxvr_11( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p14, 0, %0, c1, c11, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_dbgbxvr_11( uint32_t value ) +{ + __asm__ volatile ( + "mcr p14, 0, %0, c1, c11, 1" : : "r" ( value ) : "memory" + ); +} + +/* DBGBXVR_12, Debug Breakpoint Extended Value Registers */ + +static inline uint32_t _AArch32_Read_dbgbxvr_12( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p14, 0, %0, c1, c12, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_dbgbxvr_12( uint32_t value ) +{ + __asm__ volatile ( + "mcr p14, 0, %0, c1, c12, 1" : : "r" ( value ) : "memory" + ); +} + +/* DBGBXVR_13, Debug Breakpoint Extended Value Registers */ + +static inline uint32_t _AArch32_Read_dbgbxvr_13( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p14, 0, %0, c1, c13, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_dbgbxvr_13( uint32_t value ) +{ + __asm__ volatile ( + "mcr p14, 0, %0, c1, c13, 1" : : "r" ( value ) : "memory" + ); +} + +/* DBGBXVR_14, Debug Breakpoint Extended Value Registers */ + +static inline uint32_t _AArch32_Read_dbgbxvr_14( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p14, 0, %0, c1, c14, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_dbgbxvr_14( uint32_t value ) +{ + __asm__ volatile ( + "mcr p14, 0, %0, c1, c14, 1" : : "r" ( value ) : "memory" + ); +} + +/* DBGBXVR_15, Debug Breakpoint Extended Value Registers */ + +static inline uint32_t _AArch32_Read_dbgbxvr_15( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p14, 0, %0, c1, c15, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_dbgbxvr_15( uint32_t value ) +{ + __asm__ volatile ( + "mcr p14, 0, %0, c1, c15, 1" : : "r" ( value ) : "memory" + ); +} + +/* DBGCLAIMCLR, Debug CLAIM Tag Clear Register */ + +#define AARCH32_DBGCLAIMCLR_CLAIM( _val ) ( ( _val ) << 0 ) +#define AARCH32_DBGCLAIMCLR_CLAIM_SHIFT 0 +#define AARCH32_DBGCLAIMCLR_CLAIM_MASK 0xffU +#define AARCH32_DBGCLAIMCLR_CLAIM_GET( _reg ) \ + ( ( ( _reg ) >> 0 ) & 0xffU ) + +static inline uint32_t _AArch32_Read_dbgclaimclr( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p14, 0, %0, c7, c9, 6" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_dbgclaimclr( uint32_t value ) +{ + __asm__ volatile ( + "mcr p14, 0, %0, c7, c9, 6" : : "r" ( value ) : "memory" + ); +} + +/* DBGCLAIMSET, Debug CLAIM Tag Set Register */ + +#define AARCH32_DBGCLAIMSET_CLAIM( _val ) ( ( _val ) << 0 ) +#define AARCH32_DBGCLAIMSET_CLAIM_SHIFT 0 +#define AARCH32_DBGCLAIMSET_CLAIM_MASK 0xffU +#define AARCH32_DBGCLAIMSET_CLAIM_GET( _reg ) \ + ( ( ( _reg ) >> 0 ) & 0xffU ) + +static inline uint32_t _AArch32_Read_dbgclaimset( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p14, 0, %0, c7, c8, 6" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_dbgclaimset( uint32_t value ) +{ + __asm__ volatile ( + "mcr p14, 0, %0, c7, c8, 6" : : "r" ( value ) : "memory" + ); +} + +/* DBGDCCINT, DCC Interrupt Enable Register */ + +#define AARCH32_DBGDCCINT_TX 0x20000000U + +#define AARCH32_DBGDCCINT_RX 0x40000000U + +static inline uint32_t _AArch32_Read_dbgdccint( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p14, 0, %0, c0, c2, 0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_dbgdccint( uint32_t value ) +{ + __asm__ volatile ( + "mcr p14, 0, %0, c0, c2, 0" : : "r" ( value ) : "memory" + ); +} + +/* DBGDEVID, Debug Device ID Register 0 */ + +#define AARCH32_DBGDEVID_PCSAMPLE( _val ) ( ( _val ) << 0 ) +#define AARCH32_DBGDEVID_PCSAMPLE_SHIFT 0 +#define AARCH32_DBGDEVID_PCSAMPLE_MASK 0xfU +#define AARCH32_DBGDEVID_PCSAMPLE_GET( _reg ) \ + ( ( ( _reg ) >> 0 ) & 0xfU ) + +#define AARCH32_DBGDEVID_WPADDRMASK( _val ) ( ( _val ) << 4 ) +#define AARCH32_DBGDEVID_WPADDRMASK_SHIFT 4 +#define AARCH32_DBGDEVID_WPADDRMASK_MASK 0xf0U +#define AARCH32_DBGDEVID_WPADDRMASK_GET( _reg ) \ + ( ( ( _reg ) >> 4 ) & 0xfU ) + +#define AARCH32_DBGDEVID_BPADDRMASK( _val ) ( ( _val ) << 8 ) +#define AARCH32_DBGDEVID_BPADDRMASK_SHIFT 8 +#define AARCH32_DBGDEVID_BPADDRMASK_MASK 0xf00U +#define AARCH32_DBGDEVID_BPADDRMASK_GET( _reg ) \ + ( ( ( _reg ) >> 8 ) & 0xfU ) + +#define AARCH32_DBGDEVID_VECTORCATCH( _val ) ( ( _val ) << 12 ) +#define AARCH32_DBGDEVID_VECTORCATCH_SHIFT 12 +#define AARCH32_DBGDEVID_VECTORCATCH_MASK 0xf000U +#define AARCH32_DBGDEVID_VECTORCATCH_GET( _reg ) \ + ( ( ( _reg ) >> 12 ) & 0xfU ) + +#define AARCH32_DBGDEVID_VIRTEXTNS( _val ) ( ( _val ) << 16 ) +#define AARCH32_DBGDEVID_VIRTEXTNS_SHIFT 16 +#define AARCH32_DBGDEVID_VIRTEXTNS_MASK 0xf0000U +#define AARCH32_DBGDEVID_VIRTEXTNS_GET( _reg ) \ + ( ( ( _reg ) >> 16 ) & 0xfU ) + +#define AARCH32_DBGDEVID_DOUBLELOCK( _val ) ( ( _val ) << 20 ) +#define AARCH32_DBGDEVID_DOUBLELOCK_SHIFT 20 +#define AARCH32_DBGDEVID_DOUBLELOCK_MASK 0xf00000U +#define AARCH32_DBGDEVID_DOUBLELOCK_GET( _reg ) \ + ( ( ( _reg ) >> 20 ) & 0xfU ) + +#define AARCH32_DBGDEVID_AUXREGS( _val ) ( ( _val ) << 24 ) +#define AARCH32_DBGDEVID_AUXREGS_SHIFT 24 +#define AARCH32_DBGDEVID_AUXREGS_MASK 0xf000000U +#define AARCH32_DBGDEVID_AUXREGS_GET( _reg ) \ + ( ( ( _reg ) >> 24 ) & 0xfU ) + +#define AARCH32_DBGDEVID_CIDMASK( _val ) ( ( _val ) << 28 ) +#define AARCH32_DBGDEVID_CIDMASK_SHIFT 28 +#define AARCH32_DBGDEVID_CIDMASK_MASK 0xf0000000U +#define AARCH32_DBGDEVID_CIDMASK_GET( _reg ) \ + ( ( ( _reg ) >> 28 ) & 0xfU ) + +static inline uint32_t _AArch32_Read_dbgdevid( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p14, 0, %0, c7, c2, 7" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +/* DBGDEVID1, Debug Device ID Register 1 */ + +#define AARCH32_DBGDEVID1_PCSROFFSET( _val ) ( ( _val ) << 0 ) +#define AARCH32_DBGDEVID1_PCSROFFSET_SHIFT 0 +#define AARCH32_DBGDEVID1_PCSROFFSET_MASK 0xfU +#define AARCH32_DBGDEVID1_PCSROFFSET_GET( _reg ) \ + ( ( ( _reg ) >> 0 ) & 0xfU ) + +static inline uint32_t _AArch32_Read_dbgdevid1( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p14, 0, %0, c7, c1, 7" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +/* DBGDEVID2, Debug Device ID Register 2 */ + +static inline uint32_t _AArch32_Read_dbgdevid2( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p14, 0, %0, c7, c0, 7" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +/* DBGDIDR, Debug ID Register */ + +#define AARCH32_DBGDIDR_SE_IMP 0x1000U + +#define AARCH32_DBGDIDR_NSUHD_IMP 0x4000U + +#define AARCH32_DBGDIDR_VERSION( _val ) ( ( _val ) << 16 ) +#define AARCH32_DBGDIDR_VERSION_SHIFT 16 +#define AARCH32_DBGDIDR_VERSION_MASK 0xf0000U +#define AARCH32_DBGDIDR_VERSION_GET( _reg ) \ + ( ( ( _reg ) >> 16 ) & 0xfU ) + +#define AARCH32_DBGDIDR_CTX_CMPS( _val ) ( ( _val ) << 20 ) +#define AARCH32_DBGDIDR_CTX_CMPS_SHIFT 20 +#define AARCH32_DBGDIDR_CTX_CMPS_MASK 0xf00000U +#define AARCH32_DBGDIDR_CTX_CMPS_GET( _reg ) \ + ( ( ( _reg ) >> 20 ) & 0xfU ) + +#define AARCH32_DBGDIDR_BRPS( _val ) ( ( _val ) << 24 ) +#define AARCH32_DBGDIDR_BRPS_SHIFT 24 +#define AARCH32_DBGDIDR_BRPS_MASK 0xf000000U +#define AARCH32_DBGDIDR_BRPS_GET( _reg ) \ + ( ( ( _reg ) >> 24 ) & 0xfU ) + +#define AARCH32_DBGDIDR_WRPS( _val ) ( ( _val ) << 28 ) +#define AARCH32_DBGDIDR_WRPS_SHIFT 28 +#define AARCH32_DBGDIDR_WRPS_MASK 0xf0000000U +#define AARCH32_DBGDIDR_WRPS_GET( _reg ) \ + ( ( ( _reg ) >> 28 ) & 0xfU ) + +static inline uint32_t _AArch32_Read_dbgdidr( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p14, 0, %0, c0, c0, 0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +/* DBGDRAR, Debug ROM Address Register */ + +#define AARCH32_DBGDRAR_VALID( _val ) ( ( _val ) << 0 ) +#define AARCH32_DBGDRAR_VALID_SHIFT 0 +#define AARCH32_DBGDRAR_VALID_MASK 0x3U +#define AARCH32_DBGDRAR_VALID_GET( _reg ) \ + ( ( ( _reg ) >> 0 ) & 0x3U ) + +#define AARCH32_DBGDRAR_ROMADDR_47_12( _val ) ( ( _val ) << 12 ) +#define AARCH32_DBGDRAR_ROMADDR_47_12_SHIFT 12 +#define AARCH32_DBGDRAR_ROMADDR_47_12_MASK 0xfffffffff000ULL +#define AARCH32_DBGDRAR_ROMADDR_47_12_GET( _reg ) \ + ( ( ( _reg ) >> 12 ) & 0xfffffffffULL ) + +static inline uint32_t _AArch32_Read_32_dbgdrar( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p14, 0, %0, c1, c0, 0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +/* DBGDRAR, Debug ROM Address Register */ + +static inline uint64_t _AArch32_Read_64_dbgdrar( void ) +{ + uint64_t value; + + __asm__ volatile ( + "mrrc p14, 0, %Q0, %R0, c1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +/* DBGDSAR, Debug Self Address Register */ + +static inline uint32_t _AArch32_Read_32_dbgdsar( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p14, 0, %0, c2, c0, 0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +/* DBGDSAR, Debug Self Address Register */ + +static inline uint64_t _AArch32_Read_64_dbgdsar( void ) +{ + uint64_t value; + + __asm__ volatile ( + "mrrc p14, 0, %Q0, %R0, c2" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +/* DBGDSCREXT, Debug Status and Control Register, External View */ + +#define AARCH32_DBGDSCREXT_MOE( _val ) ( ( _val ) << 2 ) +#define AARCH32_DBGDSCREXT_MOE_SHIFT 2 +#define AARCH32_DBGDSCREXT_MOE_MASK 0x3cU +#define AARCH32_DBGDSCREXT_MOE_GET( _reg ) \ + ( ( ( _reg ) >> 2 ) & 0xfU ) + +#define AARCH32_DBGDSCREXT_ERR 0x40U + +#define AARCH32_DBGDSCREXT_UDCCDIS 0x1000U + +#define AARCH32_DBGDSCREXT_HDE 0x4000U + +#define AARCH32_DBGDSCREXT_MDBGEN 0x8000U + +#define AARCH32_DBGDSCREXT_SPIDDIS 0x10000U + +#define AARCH32_DBGDSCREXT_SPNIDDIS 0x20000U + +#define AARCH32_DBGDSCREXT_NS 0x40000U + +#define AARCH32_DBGDSCREXT_SC2 0x80000U + +#define AARCH32_DBGDSCREXT_TDA 0x200000U + +#define AARCH32_DBGDSCREXT_INTDIS( _val ) ( ( _val ) << 22 ) +#define AARCH32_DBGDSCREXT_INTDIS_SHIFT 22 +#define AARCH32_DBGDSCREXT_INTDIS_MASK 0xc00000U +#define AARCH32_DBGDSCREXT_INTDIS_GET( _reg ) \ + ( ( ( _reg ) >> 22 ) & 0x3U ) + +#define AARCH32_DBGDSCREXT_TXU 0x4000000U + +#define AARCH32_DBGDSCREXT_RXO 0x8000000U + +#define AARCH32_DBGDSCREXT_TXFULL 0x20000000U + +#define AARCH32_DBGDSCREXT_RXFULL 0x40000000U + +#define AARCH32_DBGDSCREXT_TFO 0x80000000U + +static inline uint32_t _AArch32_Read_dbgdscrext( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p14, 0, %0, c0, c2, 2" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_dbgdscrext( uint32_t value ) +{ + __asm__ volatile ( + "mcr p14, 0, %0, c0, c2, 2" : : "r" ( value ) : "memory" + ); +} + +/* DBGDSCRINT, Debug Status and Control Register, Internal View */ + +#define AARCH32_DBGDSCRINT_MOE( _val ) ( ( _val ) << 2 ) +#define AARCH32_DBGDSCRINT_MOE_SHIFT 2 +#define AARCH32_DBGDSCRINT_MOE_MASK 0x3cU +#define AARCH32_DBGDSCRINT_MOE_GET( _reg ) \ + ( ( ( _reg ) >> 2 ) & 0xfU ) + +#define AARCH32_DBGDSCRINT_UDCCDIS 0x1000U + +#define AARCH32_DBGDSCRINT_MDBGEN 0x8000U + +#define AARCH32_DBGDSCRINT_SPIDDIS 0x10000U + +#define AARCH32_DBGDSCRINT_SPNIDDIS 0x20000U + +#define AARCH32_DBGDSCRINT_NS 0x40000U + +#define AARCH32_DBGDSCRINT_TXFULL 0x20000000U + +#define AARCH32_DBGDSCRINT_RXFULL 0x40000000U + +static inline uint32_t _AArch32_Read_dbgdscrint( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p14, 0, %0, c0, c1, 0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +/* DBGDTRRXEXT, Debug OS Lock Data Transfer Register, Receive, External View */ + +static inline uint32_t _AArch32_Read_dbgdtrrxext( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p14, 0, %0, c0, c0, 2" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_dbgdtrrxext( uint32_t value ) +{ + __asm__ volatile ( + "mcr p14, 0, %0, c0, c0, 2" : : "r" ( value ) : "memory" + ); +} + +/* DBGDTRRXINT, Debug Data Transfer Register, Receive */ + +static inline uint32_t _AArch32_Read_dbgdtrrxint( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p14, 0, %0, c0, c5, 0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +/* DBGDTRTXEXT, Debug OS Lock Data Transfer Register, Transmit */ + +static inline uint32_t _AArch32_Read_dbgdtrtxext( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p14, 0, %0, c0, c3, 2" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_dbgdtrtxext( uint32_t value ) +{ + __asm__ volatile ( + "mcr p14, 0, %0, c0, c3, 2" : : "r" ( value ) : "memory" + ); +} + +/* DBGDTRTXINT, Debug Data Transfer Register, Transmit */ + +static inline void _AArch32_Write_dbgdtrtxint( uint32_t value ) +{ + __asm__ volatile ( + "mcr p14, 0, %0, c0, c5, 0" : : "r" ( value ) : "memory" + ); +} + +/* DBGOSDLR, Debug OS Double Lock Register */ + +#define AARCH32_DBGOSDLR_DLK 0x1U + +static inline uint32_t _AArch32_Read_dbgosdlr( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p14, 0, %0, c1, c3, 4" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_dbgosdlr( uint32_t value ) +{ + __asm__ volatile ( + "mcr p14, 0, %0, c1, c3, 4" : : "r" ( value ) : "memory" + ); +} + +/* DBGOSECCR, Debug OS Lock Exception Catch Control Register */ + +static inline uint32_t _AArch32_Read_dbgoseccr( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p14, 0, %0, c0, c6, 2" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_dbgoseccr( uint32_t value ) +{ + __asm__ volatile ( + "mcr p14, 0, %0, c0, c6, 2" : : "r" ( value ) : "memory" + ); +} + +/* DBGOSLAR, Debug OS Lock Access Register */ + +static inline void _AArch32_Write_dbgoslar( uint32_t value ) +{ + __asm__ volatile ( + "mcr p14, 0, %0, c1, c0, 4" : : "r" ( value ) : "memory" + ); +} + +/* DBGOSLSR, Debug OS Lock Status Register */ + +#define AARCH32_DBGOSLSR_OSLM_0 0x1U + +#define AARCH32_DBGOSLSR_OSLK 0x2U + +#define AARCH32_DBGOSLSR_NTT 0x4U + +#define AARCH32_DBGOSLSR_OSLM_1 0x8U + +static inline uint32_t _AArch32_Read_dbgoslsr( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p14, 0, %0, c1, c1, 4" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +/* DBGPRCR, Debug Power Control Register */ + +#define AARCH32_DBGPRCR_CORENPDRQ 0x1U + +static inline uint32_t _AArch32_Read_dbgprcr( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p14, 0, %0, c1, c4, 4" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_dbgprcr( uint32_t value ) +{ + __asm__ volatile ( + "mcr p14, 0, %0, c1, c4, 4" : : "r" ( value ) : "memory" + ); +} + +/* DBGVCR, Debug Vector Catch Register */ + +#define AARCH32_DBGVCR_SU 0x2U + +#define AARCH32_DBGVCR_U 0x2U + +#define AARCH32_DBGVCR_S 0x4U + +#define AARCH32_DBGVCR_SS 0x4U + +#define AARCH32_DBGVCR_P 0x8U + +#define AARCH32_DBGVCR_SP 0x8U + +#define AARCH32_DBGVCR_D 0x10U + +#define AARCH32_DBGVCR_SD 0x10U + +#define AARCH32_DBGVCR_I 0x40U + +#define AARCH32_DBGVCR_SI 0x40U + +#define AARCH32_DBGVCR_F 0x80U + +#define AARCH32_DBGVCR_SF 0x80U + +#define AARCH32_DBGVCR_MS 0x400U + +#define AARCH32_DBGVCR_MP 0x800U + +#define AARCH32_DBGVCR_MD 0x1000U + +#define AARCH32_DBGVCR_MI 0x4000U + +#define AARCH32_DBGVCR_MF 0x8000U + +#define AARCH32_DBGVCR_NSU 0x2000000U + +#define AARCH32_DBGVCR_NSS 0x4000000U + +#define AARCH32_DBGVCR_NSP 0x8000000U + +#define AARCH32_DBGVCR_NSD 0x10000000U + +#define AARCH32_DBGVCR_NSI 0x40000000U + +#define AARCH32_DBGVCR_NSF 0x80000000U + +static inline uint32_t _AArch32_Read_dbgvcr( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p14, 0, %0, c0, c7, 0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_dbgvcr( uint32_t value ) +{ + __asm__ volatile ( + "mcr p14, 0, %0, c0, c7, 0" : : "r" ( value ) : "memory" + ); +} + +/* DBGWCR, Debug Watchpoint Control Registers */ + +#define AARCH32_DBGWCR_E 0x1U + +#define AARCH32_DBGWCR_PAC( _val ) ( ( _val ) << 1 ) +#define AARCH32_DBGWCR_PAC_SHIFT 1 +#define AARCH32_DBGWCR_PAC_MASK 0x6U +#define AARCH32_DBGWCR_PAC_GET( _reg ) \ + ( ( ( _reg ) >> 1 ) & 0x3U ) + +#define AARCH32_DBGWCR_LSC( _val ) ( ( _val ) << 3 ) +#define AARCH32_DBGWCR_LSC_SHIFT 3 +#define AARCH32_DBGWCR_LSC_MASK 0x18U +#define AARCH32_DBGWCR_LSC_GET( _reg ) \ + ( ( ( _reg ) >> 3 ) & 0x3U ) + +#define AARCH32_DBGWCR_BAS( _val ) ( ( _val ) << 5 ) +#define AARCH32_DBGWCR_BAS_SHIFT 5 +#define AARCH32_DBGWCR_BAS_MASK 0x1fe0U +#define AARCH32_DBGWCR_BAS_GET( _reg ) \ + ( ( ( _reg ) >> 5 ) & 0xffU ) + +#define AARCH32_DBGWCR_HMC 0x2000U + +#define AARCH32_DBGWCR_SSC( _val ) ( ( _val ) << 14 ) +#define AARCH32_DBGWCR_SSC_SHIFT 14 +#define AARCH32_DBGWCR_SSC_MASK 0xc000U +#define AARCH32_DBGWCR_SSC_GET( _reg ) \ + ( ( ( _reg ) >> 14 ) & 0x3U ) + +#define AARCH32_DBGWCR_LBN( _val ) ( ( _val ) << 16 ) +#define AARCH32_DBGWCR_LBN_SHIFT 16 +#define AARCH32_DBGWCR_LBN_MASK 0xf0000U +#define AARCH32_DBGWCR_LBN_GET( _reg ) \ + ( ( ( _reg ) >> 16 ) & 0xfU ) + +#define AARCH32_DBGWCR_WT 0x100000U + +#define AARCH32_DBGWCR_MASK( _val ) ( ( _val ) << 24 ) +#define AARCH32_DBGWCR_MASK_SHIFT 24 +#define AARCH32_DBGWCR_MASK_MASK 0x1f000000U +#define AARCH32_DBGWCR_MASK_GET( _reg ) \ + ( ( ( _reg ) >> 24 ) & 0x1fU ) + +/* DBGWCR_0, Debug Watchpoint Control Registers */ + +static inline uint32_t _AArch32_Read_dbgwcr_0( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p14, 0, %0, c0, c0, 7" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_dbgwcr_0( uint32_t value ) +{ + __asm__ volatile ( + "mcr p14, 0, %0, c0, c0, 7" : : "r" ( value ) : "memory" + ); +} + +/* DBGWCR_1, Debug Watchpoint Control Registers */ + +static inline uint32_t _AArch32_Read_dbgwcr_1( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p14, 0, %0, c0, c1, 7" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_dbgwcr_1( uint32_t value ) +{ + __asm__ volatile ( + "mcr p14, 0, %0, c0, c1, 7" : : "r" ( value ) : "memory" + ); +} + +/* DBGWCR_2, Debug Watchpoint Control Registers */ + +static inline uint32_t _AArch32_Read_dbgwcr_2( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p14, 0, %0, c0, c2, 7" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_dbgwcr_2( uint32_t value ) +{ + __asm__ volatile ( + "mcr p14, 0, %0, c0, c2, 7" : : "r" ( value ) : "memory" + ); +} + +/* DBGWCR_3, Debug Watchpoint Control Registers */ + +static inline uint32_t _AArch32_Read_dbgwcr_3( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p14, 0, %0, c0, c3, 7" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_dbgwcr_3( uint32_t value ) +{ + __asm__ volatile ( + "mcr p14, 0, %0, c0, c3, 7" : : "r" ( value ) : "memory" + ); +} + +/* DBGWCR_4, Debug Watchpoint Control Registers */ + +static inline uint32_t _AArch32_Read_dbgwcr_4( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p14, 0, %0, c0, c4, 7" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_dbgwcr_4( uint32_t value ) +{ + __asm__ volatile ( + "mcr p14, 0, %0, c0, c4, 7" : : "r" ( value ) : "memory" + ); +} + +/* DBGWCR_5, Debug Watchpoint Control Registers */ + +static inline uint32_t _AArch32_Read_dbgwcr_5( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p14, 0, %0, c0, c5, 7" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_dbgwcr_5( uint32_t value ) +{ + __asm__ volatile ( + "mcr p14, 0, %0, c0, c5, 7" : : "r" ( value ) : "memory" + ); +} + +/* DBGWCR_6, Debug Watchpoint Control Registers */ + +static inline uint32_t _AArch32_Read_dbgwcr_6( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p14, 0, %0, c0, c6, 7" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_dbgwcr_6( uint32_t value ) +{ + __asm__ volatile ( + "mcr p14, 0, %0, c0, c6, 7" : : "r" ( value ) : "memory" + ); +} + +/* DBGWCR_7, Debug Watchpoint Control Registers */ + +static inline uint32_t _AArch32_Read_dbgwcr_7( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p14, 0, %0, c0, c7, 7" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_dbgwcr_7( uint32_t value ) +{ + __asm__ volatile ( + "mcr p14, 0, %0, c0, c7, 7" : : "r" ( value ) : "memory" + ); +} + +/* DBGWCR_8, Debug Watchpoint Control Registers */ + +static inline uint32_t _AArch32_Read_dbgwcr_8( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p14, 0, %0, c0, c8, 7" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_dbgwcr_8( uint32_t value ) +{ + __asm__ volatile ( + "mcr p14, 0, %0, c0, c8, 7" : : "r" ( value ) : "memory" + ); +} + +/* DBGWCR_9, Debug Watchpoint Control Registers */ + +static inline uint32_t _AArch32_Read_dbgwcr_9( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p14, 0, %0, c0, c9, 7" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_dbgwcr_9( uint32_t value ) +{ + __asm__ volatile ( + "mcr p14, 0, %0, c0, c9, 7" : : "r" ( value ) : "memory" + ); +} + +/* DBGWCR_10, Debug Watchpoint Control Registers */ + +static inline uint32_t _AArch32_Read_dbgwcr_10( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p14, 0, %0, c0, c10, 7" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_dbgwcr_10( uint32_t value ) +{ + __asm__ volatile ( + "mcr p14, 0, %0, c0, c10, 7" : : "r" ( value ) : "memory" + ); +} + +/* DBGWCR_11, Debug Watchpoint Control Registers */ + +static inline uint32_t _AArch32_Read_dbgwcr_11( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p14, 0, %0, c0, c11, 7" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_dbgwcr_11( uint32_t value ) +{ + __asm__ volatile ( + "mcr p14, 0, %0, c0, c11, 7" : : "r" ( value ) : "memory" + ); +} + +/* DBGWCR_12, Debug Watchpoint Control Registers */ + +static inline uint32_t _AArch32_Read_dbgwcr_12( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p14, 0, %0, c0, c12, 7" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_dbgwcr_12( uint32_t value ) +{ + __asm__ volatile ( + "mcr p14, 0, %0, c0, c12, 7" : : "r" ( value ) : "memory" + ); +} + +/* DBGWCR_13, Debug Watchpoint Control Registers */ + +static inline uint32_t _AArch32_Read_dbgwcr_13( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p14, 0, %0, c0, c13, 7" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_dbgwcr_13( uint32_t value ) +{ + __asm__ volatile ( + "mcr p14, 0, %0, c0, c13, 7" : : "r" ( value ) : "memory" + ); +} + +/* DBGWCR_14, Debug Watchpoint Control Registers */ + +static inline uint32_t _AArch32_Read_dbgwcr_14( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p14, 0, %0, c0, c14, 7" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_dbgwcr_14( uint32_t value ) +{ + __asm__ volatile ( + "mcr p14, 0, %0, c0, c14, 7" : : "r" ( value ) : "memory" + ); +} + +/* DBGWCR_15, Debug Watchpoint Control Registers */ + +static inline uint32_t _AArch32_Read_dbgwcr_15( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p14, 0, %0, c0, c15, 7" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_dbgwcr_15( uint32_t value ) +{ + __asm__ volatile ( + "mcr p14, 0, %0, c0, c15, 7" : : "r" ( value ) : "memory" + ); +} + +/* DBGWFAR, Debug Watchpoint Fault Address Register */ + +static inline uint32_t _AArch32_Read_dbgwfar( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p14, 0, %0, c0, c6, 0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_dbgwfar( uint32_t value ) +{ + __asm__ volatile ( + "mcr p14, 0, %0, c0, c6, 0" : : "r" ( value ) : "memory" + ); +} + +/* DBGWVR, Debug Watchpoint Value Registers */ + +#define AARCH32_DBGWVR_VA( _val ) ( ( _val ) << 2 ) +#define AARCH32_DBGWVR_VA_SHIFT 2 +#define AARCH32_DBGWVR_VA_MASK 0xfffffffcU +#define AARCH32_DBGWVR_VA_GET( _reg ) \ + ( ( ( _reg ) >> 2 ) & 0x3fffffffU ) + +/* DBGWVR_0, Debug Watchpoint Value Registers */ + +static inline uint32_t _AArch32_Read_dbgwvr_0( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p14, 0, %0, c0, c0, 6" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_dbgwvr_0( uint32_t value ) +{ + __asm__ volatile ( + "mcr p14, 0, %0, c0, c0, 6" : : "r" ( value ) : "memory" + ); +} + +/* DBGWVR_1, Debug Watchpoint Value Registers */ + +static inline uint32_t _AArch32_Read_dbgwvr_1( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p14, 0, %0, c0, c1, 6" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_dbgwvr_1( uint32_t value ) +{ + __asm__ volatile ( + "mcr p14, 0, %0, c0, c1, 6" : : "r" ( value ) : "memory" + ); +} + +/* DBGWVR_2, Debug Watchpoint Value Registers */ + +static inline uint32_t _AArch32_Read_dbgwvr_2( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p14, 0, %0, c0, c2, 6" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_dbgwvr_2( uint32_t value ) +{ + __asm__ volatile ( + "mcr p14, 0, %0, c0, c2, 6" : : "r" ( value ) : "memory" + ); +} + +/* DBGWVR_3, Debug Watchpoint Value Registers */ + +static inline uint32_t _AArch32_Read_dbgwvr_3( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p14, 0, %0, c0, c3, 6" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_dbgwvr_3( uint32_t value ) +{ + __asm__ volatile ( + "mcr p14, 0, %0, c0, c3, 6" : : "r" ( value ) : "memory" + ); +} + +/* DBGWVR_4, Debug Watchpoint Value Registers */ + +static inline uint32_t _AArch32_Read_dbgwvr_4( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p14, 0, %0, c0, c4, 6" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_dbgwvr_4( uint32_t value ) +{ + __asm__ volatile ( + "mcr p14, 0, %0, c0, c4, 6" : : "r" ( value ) : "memory" + ); +} + +/* DBGWVR_5, Debug Watchpoint Value Registers */ + +static inline uint32_t _AArch32_Read_dbgwvr_5( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p14, 0, %0, c0, c5, 6" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_dbgwvr_5( uint32_t value ) +{ + __asm__ volatile ( + "mcr p14, 0, %0, c0, c5, 6" : : "r" ( value ) : "memory" + ); +} + +/* DBGWVR_6, Debug Watchpoint Value Registers */ + +static inline uint32_t _AArch32_Read_dbgwvr_6( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p14, 0, %0, c0, c6, 6" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_dbgwvr_6( uint32_t value ) +{ + __asm__ volatile ( + "mcr p14, 0, %0, c0, c6, 6" : : "r" ( value ) : "memory" + ); +} + +/* DBGWVR_7, Debug Watchpoint Value Registers */ + +static inline uint32_t _AArch32_Read_dbgwvr_7( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p14, 0, %0, c0, c7, 6" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_dbgwvr_7( uint32_t value ) +{ + __asm__ volatile ( + "mcr p14, 0, %0, c0, c7, 6" : : "r" ( value ) : "memory" + ); +} + +/* DBGWVR_8, Debug Watchpoint Value Registers */ + +static inline uint32_t _AArch32_Read_dbgwvr_8( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p14, 0, %0, c0, c8, 6" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_dbgwvr_8( uint32_t value ) +{ + __asm__ volatile ( + "mcr p14, 0, %0, c0, c8, 6" : : "r" ( value ) : "memory" + ); +} + +/* DBGWVR_9, Debug Watchpoint Value Registers */ + +static inline uint32_t _AArch32_Read_dbgwvr_9( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p14, 0, %0, c0, c9, 6" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_dbgwvr_9( uint32_t value ) +{ + __asm__ volatile ( + "mcr p14, 0, %0, c0, c9, 6" : : "r" ( value ) : "memory" + ); +} + +/* DBGWVR_10, Debug Watchpoint Value Registers */ + +static inline uint32_t _AArch32_Read_dbgwvr_10( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p14, 0, %0, c0, c10, 6" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_dbgwvr_10( uint32_t value ) +{ + __asm__ volatile ( + "mcr p14, 0, %0, c0, c10, 6" : : "r" ( value ) : "memory" + ); +} + +/* DBGWVR_11, Debug Watchpoint Value Registers */ + +static inline uint32_t _AArch32_Read_dbgwvr_11( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p14, 0, %0, c0, c11, 6" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_dbgwvr_11( uint32_t value ) +{ + __asm__ volatile ( + "mcr p14, 0, %0, c0, c11, 6" : : "r" ( value ) : "memory" + ); +} + +/* DBGWVR_12, Debug Watchpoint Value Registers */ + +static inline uint32_t _AArch32_Read_dbgwvr_12( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p14, 0, %0, c0, c12, 6" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_dbgwvr_12( uint32_t value ) +{ + __asm__ volatile ( + "mcr p14, 0, %0, c0, c12, 6" : : "r" ( value ) : "memory" + ); +} + +/* DBGWVR_13, Debug Watchpoint Value Registers */ + +static inline uint32_t _AArch32_Read_dbgwvr_13( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p14, 0, %0, c0, c13, 6" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_dbgwvr_13( uint32_t value ) +{ + __asm__ volatile ( + "mcr p14, 0, %0, c0, c13, 6" : : "r" ( value ) : "memory" + ); +} + +/* DBGWVR_14, Debug Watchpoint Value Registers */ + +static inline uint32_t _AArch32_Read_dbgwvr_14( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p14, 0, %0, c0, c14, 6" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_dbgwvr_14( uint32_t value ) +{ + __asm__ volatile ( + "mcr p14, 0, %0, c0, c14, 6" : : "r" ( value ) : "memory" + ); +} + +/* DBGWVR_15, Debug Watchpoint Value Registers */ + +static inline uint32_t _AArch32_Read_dbgwvr_15( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p14, 0, %0, c0, c15, 6" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_dbgwvr_15( uint32_t value ) +{ + __asm__ volatile ( + "mcr p14, 0, %0, c0, c15, 6" : : "r" ( value ) : "memory" + ); +} + +/* DLR, Debug Link Register */ + +static inline uint32_t _AArch32_Read_dlr( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 3, %0, c4, c5, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_dlr( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 3, %0, c4, c5, 1" : : "r" ( value ) : "memory" + ); +} + +/* DSPSR, Debug Saved Program Status Register */ + +#define AARCH32_DSPSR_M_4_0( _val ) ( ( _val ) << 0 ) +#define AARCH32_DSPSR_M_4_0_SHIFT 0 +#define AARCH32_DSPSR_M_4_0_MASK 0x1fU +#define AARCH32_DSPSR_M_4_0_GET( _reg ) \ + ( ( ( _reg ) >> 0 ) & 0x1fU ) + +#define AARCH32_DSPSR_T 0x20U + +#define AARCH32_DSPSR_F 0x40U + +#define AARCH32_DSPSR_I 0x80U + +#define AARCH32_DSPSR_A 0x100U + +#define AARCH32_DSPSR_E 0x200U + +#define AARCH32_DSPSR_IT_7_2( _val ) ( ( _val ) << 10 ) +#define AARCH32_DSPSR_IT_7_2_SHIFT 10 +#define AARCH32_DSPSR_IT_7_2_MASK 0xfc00U +#define AARCH32_DSPSR_IT_7_2_GET( _reg ) \ + ( ( ( _reg ) >> 10 ) & 0x3fU ) + +#define AARCH32_DSPSR_GE( _val ) ( ( _val ) << 16 ) +#define AARCH32_DSPSR_GE_SHIFT 16 +#define AARCH32_DSPSR_GE_MASK 0xf0000U +#define AARCH32_DSPSR_GE_GET( _reg ) \ + ( ( ( _reg ) >> 16 ) & 0xfU ) + +#define AARCH32_DSPSR_IL 0x100000U + +#define AARCH32_DSPSR_SS 0x200000U + +#define AARCH32_DSPSR_PAN 0x400000U + +#define AARCH32_DSPSR_SSBS 0x800000U + +#define AARCH32_DSPSR_DIT 0x1000000U + +#define AARCH32_DSPSR_IT_1_0( _val ) ( ( _val ) << 25 ) +#define AARCH32_DSPSR_IT_1_0_SHIFT 25 +#define AARCH32_DSPSR_IT_1_0_MASK 0x6000000U +#define AARCH32_DSPSR_IT_1_0_GET( _reg ) \ + ( ( ( _reg ) >> 25 ) & 0x3U ) + +#define AARCH32_DSPSR_Q 0x8000000U + +#define AARCH32_DSPSR_V 0x10000000U + +#define AARCH32_DSPSR_C 0x20000000U + +#define AARCH32_DSPSR_Z 0x40000000U + +#define AARCH32_DSPSR_N 0x80000000U + +static inline uint32_t _AArch32_Read_dspsr( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 3, %0, c4, c5, 0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_dspsr( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 3, %0, c4, c5, 0" : : "r" ( value ) : "memory" + ); +} + +/* HDCR, Hyp Debug Control Register */ + +#define AARCH32_HDCR_HPMN( _val ) ( ( _val ) << 0 ) +#define AARCH32_HDCR_HPMN_SHIFT 0 +#define AARCH32_HDCR_HPMN_MASK 0x1fU +#define AARCH32_HDCR_HPMN_GET( _reg ) \ + ( ( ( _reg ) >> 0 ) & 0x1fU ) + +#define AARCH32_HDCR_TPMCR 0x20U + +#define AARCH32_HDCR_TPM 0x40U + +#define AARCH32_HDCR_HPME 0x80U + +#define AARCH32_HDCR_TDE 0x100U + +#define AARCH32_HDCR_TDA 0x200U + +#define AARCH32_HDCR_TDOSA 0x400U + +#define AARCH32_HDCR_TDRA 0x800U + +#define AARCH32_HDCR_HPMD 0x20000U + +#define AARCH32_HDCR_TTRF 0x80000U + +#define AARCH32_HDCR_HCCD 0x800000U + +#define AARCH32_HDCR_HLP 0x4000000U + +#define AARCH32_HDCR_TDCC 0x8000000U + +#define AARCH32_HDCR_MTPME 0x10000000U + +static inline uint32_t _AArch32_Read_hdcr( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 4, %0, c1, c1, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_hdcr( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 4, %0, c1, c1, 1" : : "r" ( value ) : "memory" + ); +} + +/* HTRFCR, Hyp Trace Filter Control Register */ + +#define AARCH32_HTRFCR_E0HTRE 0x1U + +#define AARCH32_HTRFCR_E2TRE 0x2U + +#define AARCH32_HTRFCR_CX 0x8U + +#define AARCH32_HTRFCR_TS( _val ) ( ( _val ) << 5 ) +#define AARCH32_HTRFCR_TS_SHIFT 5 +#define AARCH32_HTRFCR_TS_MASK 0x60U +#define AARCH32_HTRFCR_TS_GET( _reg ) \ + ( ( ( _reg ) >> 5 ) & 0x3U ) + +static inline uint32_t _AArch32_Read_htrfcr( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 4, %0, c1, c2, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_htrfcr( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 4, %0, c1, c2, 1" : : "r" ( value ) : "memory" + ); +} + +/* PMMIR, Performance Monitors Machine Identification Register */ + +#define AARCH32_PMMIR_SLOTS( _val ) ( ( _val ) << 0 ) +#define AARCH32_PMMIR_SLOTS_SHIFT 0 +#define AARCH32_PMMIR_SLOTS_MASK 0xffU +#define AARCH32_PMMIR_SLOTS_GET( _reg ) \ + ( ( ( _reg ) >> 0 ) & 0xffU ) + +static inline uint32_t _AArch32_Read_pmmir( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c9, c14, 6" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +/* SDCR, Secure Debug Control Register */ + +#define AARCH32_SDCR_SPD( _val ) ( ( _val ) << 14 ) +#define AARCH32_SDCR_SPD_SHIFT 14 +#define AARCH32_SDCR_SPD_MASK 0xc000U +#define AARCH32_SDCR_SPD_GET( _reg ) \ + ( ( ( _reg ) >> 14 ) & 0x3U ) + +#define AARCH32_SDCR_SPME 0x20000U + +#define AARCH32_SDCR_STE 0x40000U + +#define AARCH32_SDCR_TTRF 0x80000U + +#define AARCH32_SDCR_EDAD 0x100000U + +#define AARCH32_SDCR_EPMAD 0x200000U + +#define AARCH32_SDCR_SCCD 0x800000U + +#define AARCH32_SDCR_TDCC 0x8000000U + +#define AARCH32_SDCR_MTPME 0x10000000U + +static inline uint32_t _AArch32_Read_sdcr( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c1, c3, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_sdcr( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c1, c3, 1" : : "r" ( value ) : "memory" + ); +} + +/* SDER, Secure Debug Enable Register */ + +#define AARCH32_SDER_SUIDEN 0x1U + +#define AARCH32_SDER_SUNIDEN 0x2U + +static inline uint32_t _AArch32_Read_sder( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c1, c1, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_sder( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c1, c1, 1" : : "r" ( value ) : "memory" + ); +} + +/* TRFCR, Trace Filter Control Register */ + +#define AARCH32_TRFCR_E0TRE 0x1U + +#define AARCH32_TRFCR_E1TRE 0x2U + +#define AARCH32_TRFCR_TS( _val ) ( ( _val ) << 5 ) +#define AARCH32_TRFCR_TS_SHIFT 5 +#define AARCH32_TRFCR_TS_MASK 0x60U +#define AARCH32_TRFCR_TS_GET( _reg ) \ + ( ( ( _reg ) >> 5 ) & 0x3U ) + +static inline uint32_t _AArch32_Read_trfcr( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c1, c2, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_trfcr( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c1, c2, 1" : : "r" ( value ) : "memory" + ); +} + +/* PMCCFILTR, Performance Monitors Cycle Count Filter Register */ + +#define AARCH32_PMCCFILTR_NSH 0x8000000U + +#define AARCH32_PMCCFILTR_NSU 0x10000000U + +#define AARCH32_PMCCFILTR_NSK 0x20000000U + +#define AARCH32_PMCCFILTR_U 0x40000000U + +#define AARCH32_PMCCFILTR_P 0x80000000U + +static inline uint32_t _AArch32_Read_pmccfiltr( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c14, c15, 7" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_pmccfiltr( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c14, c15, 7" : : "r" ( value ) : "memory" + ); +} + +/* PMCCNTR, Performance Monitors Cycle Count Register */ + +#define AARCH32_PMCCNTR_CCNT( _val ) ( ( _val ) << 0 ) +#define AARCH32_PMCCNTR_CCNT_SHIFT 0 +#define AARCH32_PMCCNTR_CCNT_MASK 0xffffffffffffffffULL +#define AARCH32_PMCCNTR_CCNT_GET( _reg ) \ + ( ( ( _reg ) >> 0 ) & 0xffffffffffffffffULL ) + +static inline uint32_t _AArch32_Read_32_pmccntr( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c9, c13, 0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_32_pmccntr( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c9, c13, 0" : : "r" ( value ) : "memory" + ); +} + +/* PMCCNTR, Performance Monitors Cycle Count Register */ + +static inline uint64_t _AArch32_Read_64_pmccntr( void ) +{ + uint64_t value; + + __asm__ volatile ( + "mrrc p15, 0, %Q0, %R0, c9" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_64_pmccntr( uint64_t value ) +{ + __asm__ volatile ( + "mcrr p15, 0, %Q0, %R0, c9" : : "r" ( value ) : "memory" + ); +} + +/* PMCEID0, Performance Monitors Common Event Identification Register 0 */ + +static inline uint32_t _AArch32_Read_pmceid0( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c9, c12, 6" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +/* PMCEID1, Performance Monitors Common Event Identification Register 1 */ + +static inline uint32_t _AArch32_Read_pmceid1( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c9, c12, 7" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +/* PMCEID2, Performance Monitors Common Event Identification Register 2 */ + +static inline uint32_t _AArch32_Read_pmceid2( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c9, c14, 4" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +/* PMCEID3, Performance Monitors Common Event Identification Register 3 */ + +static inline uint32_t _AArch32_Read_pmceid3( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c9, c14, 5" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +/* PMCNTENCLR, Performance Monitors Count Enable Clear Register */ + +#define AARCH32_PMCNTENCLR_C 0x80000000U + +static inline uint32_t _AArch32_Read_pmcntenclr( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c9, c12, 2" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_pmcntenclr( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c9, c12, 2" : : "r" ( value ) : "memory" + ); +} + +/* PMCNTENSET, Performance Monitors Count Enable Set Register */ + +#define AARCH32_PMCNTENSET_C 0x80000000U + +static inline uint32_t _AArch32_Read_pmcntenset( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c9, c12, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_pmcntenset( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c9, c12, 1" : : "r" ( value ) : "memory" + ); +} + +/* PMCR, Performance Monitors Control Register */ + +#define AARCH32_PMCR_E 0x1U + +#define AARCH32_PMCR_P 0x2U + +#define AARCH32_PMCR_C 0x4U + +#define AARCH32_PMCR_D 0x8U + +#define AARCH32_PMCR_X 0x10U + +#define AARCH32_PMCR_DP 0x20U + +#define AARCH32_PMCR_LC 0x40U + +#define AARCH32_PMCR_LP 0x80U + +#define AARCH32_PMCR_N( _val ) ( ( _val ) << 11 ) +#define AARCH32_PMCR_N_SHIFT 11 +#define AARCH32_PMCR_N_MASK 0xf800U +#define AARCH32_PMCR_N_GET( _reg ) \ + ( ( ( _reg ) >> 11 ) & 0x1fU ) + +#define AARCH32_PMCR_IDCODE( _val ) ( ( _val ) << 16 ) +#define AARCH32_PMCR_IDCODE_SHIFT 16 +#define AARCH32_PMCR_IDCODE_MASK 0xff0000U +#define AARCH32_PMCR_IDCODE_GET( _reg ) \ + ( ( ( _reg ) >> 16 ) & 0xffU ) + +#define AARCH32_PMCR_IMP( _val ) ( ( _val ) << 24 ) +#define AARCH32_PMCR_IMP_SHIFT 24 +#define AARCH32_PMCR_IMP_MASK 0xff000000U +#define AARCH32_PMCR_IMP_GET( _reg ) \ + ( ( ( _reg ) >> 24 ) & 0xffU ) + +static inline uint32_t _AArch32_Read_pmcr( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c9, c12, 0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_pmcr( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c9, c12, 0" : : "r" ( value ) : "memory" + ); +} + +/* PMEVCNTR_0, Performance Monitors Event Count Registers */ + +static inline uint32_t _AArch32_Read_pmevcntr_0( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c14, c8, 0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_pmevcntr_0( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c14, c8, 0" : : "r" ( value ) : "memory" + ); +} + +/* PMEVCNTR_1, Performance Monitors Event Count Registers */ + +static inline uint32_t _AArch32_Read_pmevcntr_1( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c14, c8, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_pmevcntr_1( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c14, c8, 1" : : "r" ( value ) : "memory" + ); +} + +/* PMEVCNTR_2, Performance Monitors Event Count Registers */ + +static inline uint32_t _AArch32_Read_pmevcntr_2( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c14, c8, 2" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_pmevcntr_2( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c14, c8, 2" : : "r" ( value ) : "memory" + ); +} + +/* PMEVCNTR_3, Performance Monitors Event Count Registers */ + +static inline uint32_t _AArch32_Read_pmevcntr_3( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c14, c8, 3" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_pmevcntr_3( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c14, c8, 3" : : "r" ( value ) : "memory" + ); +} + +/* PMEVCNTR_4, Performance Monitors Event Count Registers */ + +static inline uint32_t _AArch32_Read_pmevcntr_4( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c14, c8, 4" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_pmevcntr_4( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c14, c8, 4" : : "r" ( value ) : "memory" + ); +} + +/* PMEVCNTR_5, Performance Monitors Event Count Registers */ + +static inline uint32_t _AArch32_Read_pmevcntr_5( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c14, c8, 5" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_pmevcntr_5( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c14, c8, 5" : : "r" ( value ) : "memory" + ); +} + +/* PMEVCNTR_6, Performance Monitors Event Count Registers */ + +static inline uint32_t _AArch32_Read_pmevcntr_6( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c14, c8, 6" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_pmevcntr_6( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c14, c8, 6" : : "r" ( value ) : "memory" + ); +} + +/* PMEVCNTR_7, Performance Monitors Event Count Registers */ + +static inline uint32_t _AArch32_Read_pmevcntr_7( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c14, c8, 7" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_pmevcntr_7( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c14, c8, 7" : : "r" ( value ) : "memory" + ); +} + +/* PMEVCNTR_8, Performance Monitors Event Count Registers */ + +static inline uint32_t _AArch32_Read_pmevcntr_8( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c14, c9, 0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_pmevcntr_8( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c14, c9, 0" : : "r" ( value ) : "memory" + ); +} + +/* PMEVCNTR_9, Performance Monitors Event Count Registers */ + +static inline uint32_t _AArch32_Read_pmevcntr_9( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c14, c9, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_pmevcntr_9( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c14, c9, 1" : : "r" ( value ) : "memory" + ); +} + +/* PMEVCNTR_10, Performance Monitors Event Count Registers */ + +static inline uint32_t _AArch32_Read_pmevcntr_10( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c14, c9, 2" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_pmevcntr_10( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c14, c9, 2" : : "r" ( value ) : "memory" + ); +} + +/* PMEVCNTR_11, Performance Monitors Event Count Registers */ + +static inline uint32_t _AArch32_Read_pmevcntr_11( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c14, c9, 3" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_pmevcntr_11( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c14, c9, 3" : : "r" ( value ) : "memory" + ); +} + +/* PMEVCNTR_12, Performance Monitors Event Count Registers */ + +static inline uint32_t _AArch32_Read_pmevcntr_12( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c14, c9, 4" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_pmevcntr_12( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c14, c9, 4" : : "r" ( value ) : "memory" + ); +} + +/* PMEVCNTR_13, Performance Monitors Event Count Registers */ + +static inline uint32_t _AArch32_Read_pmevcntr_13( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c14, c9, 5" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_pmevcntr_13( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c14, c9, 5" : : "r" ( value ) : "memory" + ); +} + +/* PMEVCNTR_14, Performance Monitors Event Count Registers */ + +static inline uint32_t _AArch32_Read_pmevcntr_14( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c14, c9, 6" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_pmevcntr_14( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c14, c9, 6" : : "r" ( value ) : "memory" + ); +} + +/* PMEVCNTR_15, Performance Monitors Event Count Registers */ + +static inline uint32_t _AArch32_Read_pmevcntr_15( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c14, c9, 7" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_pmevcntr_15( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c14, c9, 7" : : "r" ( value ) : "memory" + ); +} + +/* PMEVCNTR_16, Performance Monitors Event Count Registers */ + +static inline uint32_t _AArch32_Read_pmevcntr_16( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c14, c10, 0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_pmevcntr_16( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c14, c10, 0" : : "r" ( value ) : "memory" + ); +} + +/* PMEVCNTR_17, Performance Monitors Event Count Registers */ + +static inline uint32_t _AArch32_Read_pmevcntr_17( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c14, c10, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_pmevcntr_17( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c14, c10, 1" : : "r" ( value ) : "memory" + ); +} + +/* PMEVCNTR_18, Performance Monitors Event Count Registers */ + +static inline uint32_t _AArch32_Read_pmevcntr_18( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c14, c10, 2" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_pmevcntr_18( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c14, c10, 2" : : "r" ( value ) : "memory" + ); +} + +/* PMEVCNTR_19, Performance Monitors Event Count Registers */ + +static inline uint32_t _AArch32_Read_pmevcntr_19( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c14, c10, 3" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_pmevcntr_19( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c14, c10, 3" : : "r" ( value ) : "memory" + ); +} + +/* PMEVCNTR_20, Performance Monitors Event Count Registers */ + +static inline uint32_t _AArch32_Read_pmevcntr_20( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c14, c10, 4" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_pmevcntr_20( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c14, c10, 4" : : "r" ( value ) : "memory" + ); +} + +/* PMEVCNTR_21, Performance Monitors Event Count Registers */ + +static inline uint32_t _AArch32_Read_pmevcntr_21( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c14, c10, 5" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_pmevcntr_21( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c14, c10, 5" : : "r" ( value ) : "memory" + ); +} + +/* PMEVCNTR_22, Performance Monitors Event Count Registers */ + +static inline uint32_t _AArch32_Read_pmevcntr_22( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c14, c10, 6" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_pmevcntr_22( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c14, c10, 6" : : "r" ( value ) : "memory" + ); +} + +/* PMEVCNTR_23, Performance Monitors Event Count Registers */ + +static inline uint32_t _AArch32_Read_pmevcntr_23( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c14, c10, 7" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_pmevcntr_23( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c14, c10, 7" : : "r" ( value ) : "memory" + ); +} + +/* PMEVCNTR_24, Performance Monitors Event Count Registers */ + +static inline uint32_t _AArch32_Read_pmevcntr_24( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c14, c11, 0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_pmevcntr_24( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c14, c11, 0" : : "r" ( value ) : "memory" + ); +} + +/* PMEVCNTR_25, Performance Monitors Event Count Registers */ + +static inline uint32_t _AArch32_Read_pmevcntr_25( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c14, c11, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_pmevcntr_25( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c14, c11, 1" : : "r" ( value ) : "memory" + ); +} + +/* PMEVCNTR_26, Performance Monitors Event Count Registers */ + +static inline uint32_t _AArch32_Read_pmevcntr_26( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c14, c11, 2" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_pmevcntr_26( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c14, c11, 2" : : "r" ( value ) : "memory" + ); +} + +/* PMEVCNTR_27, Performance Monitors Event Count Registers */ + +static inline uint32_t _AArch32_Read_pmevcntr_27( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c14, c11, 3" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_pmevcntr_27( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c14, c11, 3" : : "r" ( value ) : "memory" + ); +} + +/* PMEVCNTR_28, Performance Monitors Event Count Registers */ + +static inline uint32_t _AArch32_Read_pmevcntr_28( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c14, c11, 4" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_pmevcntr_28( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c14, c11, 4" : : "r" ( value ) : "memory" + ); +} + +/* PMEVCNTR_29, Performance Monitors Event Count Registers */ + +static inline uint32_t _AArch32_Read_pmevcntr_29( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c14, c11, 5" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_pmevcntr_29( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c14, c11, 5" : : "r" ( value ) : "memory" + ); +} + +/* PMEVCNTR_30, Performance Monitors Event Count Registers */ + +static inline uint32_t _AArch32_Read_pmevcntr_30( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c14, c11, 6" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_pmevcntr_30( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c14, c11, 6" : : "r" ( value ) : "memory" + ); +} + +/* PMEVTYPER, Performance Monitors Event Type Registers */ + +#define AARCH32_PMEVTYPER_EVTCOUNT_9_0( _val ) ( ( _val ) << 0 ) +#define AARCH32_PMEVTYPER_EVTCOUNT_9_0_SHIFT 0 +#define AARCH32_PMEVTYPER_EVTCOUNT_9_0_MASK 0x3ffU +#define AARCH32_PMEVTYPER_EVTCOUNT_9_0_GET( _reg ) \ + ( ( ( _reg ) >> 0 ) & 0x3ffU ) + +#define AARCH32_PMEVTYPER_EVTCOUNT_15_10( _val ) ( ( _val ) << 10 ) +#define AARCH32_PMEVTYPER_EVTCOUNT_15_10_SHIFT 10 +#define AARCH32_PMEVTYPER_EVTCOUNT_15_10_MASK 0xfc00U +#define AARCH32_PMEVTYPER_EVTCOUNT_15_10_GET( _reg ) \ + ( ( ( _reg ) >> 10 ) & 0x3fU ) + +#define AARCH32_PMEVTYPER_MT 0x2000000U + +#define AARCH32_PMEVTYPER_NSH 0x8000000U + +#define AARCH32_PMEVTYPER_NSU 0x10000000U + +#define AARCH32_PMEVTYPER_NSK 0x20000000U + +#define AARCH32_PMEVTYPER_U 0x40000000U + +#define AARCH32_PMEVTYPER_P 0x80000000U + +/* PMEVTYPER_0, Performance Monitors Event Type Registers */ + +static inline uint32_t _AArch32_Read_pmevtyper_0( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c14, c12, 0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_pmevtyper_0( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c14, c12, 0" : : "r" ( value ) : "memory" + ); +} + +/* PMEVTYPER_1, Performance Monitors Event Type Registers */ + +static inline uint32_t _AArch32_Read_pmevtyper_1( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c14, c12, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_pmevtyper_1( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c14, c12, 1" : : "r" ( value ) : "memory" + ); +} + +/* PMEVTYPER_2, Performance Monitors Event Type Registers */ + +static inline uint32_t _AArch32_Read_pmevtyper_2( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c14, c12, 2" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_pmevtyper_2( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c14, c12, 2" : : "r" ( value ) : "memory" + ); +} + +/* PMEVTYPER_3, Performance Monitors Event Type Registers */ + +static inline uint32_t _AArch32_Read_pmevtyper_3( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c14, c12, 3" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_pmevtyper_3( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c14, c12, 3" : : "r" ( value ) : "memory" + ); +} + +/* PMEVTYPER_4, Performance Monitors Event Type Registers */ + +static inline uint32_t _AArch32_Read_pmevtyper_4( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c14, c12, 4" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_pmevtyper_4( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c14, c12, 4" : : "r" ( value ) : "memory" + ); +} + +/* PMEVTYPER_5, Performance Monitors Event Type Registers */ + +static inline uint32_t _AArch32_Read_pmevtyper_5( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c14, c12, 5" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_pmevtyper_5( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c14, c12, 5" : : "r" ( value ) : "memory" + ); +} + +/* PMEVTYPER_6, Performance Monitors Event Type Registers */ + +static inline uint32_t _AArch32_Read_pmevtyper_6( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c14, c12, 6" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_pmevtyper_6( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c14, c12, 6" : : "r" ( value ) : "memory" + ); +} + +/* PMEVTYPER_7, Performance Monitors Event Type Registers */ + +static inline uint32_t _AArch32_Read_pmevtyper_7( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c14, c12, 7" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_pmevtyper_7( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c14, c12, 7" : : "r" ( value ) : "memory" + ); +} + +/* PMEVTYPER_8, Performance Monitors Event Type Registers */ + +static inline uint32_t _AArch32_Read_pmevtyper_8( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c14, c13, 0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_pmevtyper_8( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c14, c13, 0" : : "r" ( value ) : "memory" + ); +} + +/* PMEVTYPER_9, Performance Monitors Event Type Registers */ + +static inline uint32_t _AArch32_Read_pmevtyper_9( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c14, c13, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_pmevtyper_9( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c14, c13, 1" : : "r" ( value ) : "memory" + ); +} + +/* PMEVTYPER_10, Performance Monitors Event Type Registers */ + +static inline uint32_t _AArch32_Read_pmevtyper_10( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c14, c13, 2" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_pmevtyper_10( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c14, c13, 2" : : "r" ( value ) : "memory" + ); +} + +/* PMEVTYPER_11, Performance Monitors Event Type Registers */ + +static inline uint32_t _AArch32_Read_pmevtyper_11( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c14, c13, 3" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_pmevtyper_11( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c14, c13, 3" : : "r" ( value ) : "memory" + ); +} + +/* PMEVTYPER_12, Performance Monitors Event Type Registers */ + +static inline uint32_t _AArch32_Read_pmevtyper_12( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c14, c13, 4" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_pmevtyper_12( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c14, c13, 4" : : "r" ( value ) : "memory" + ); +} + +/* PMEVTYPER_13, Performance Monitors Event Type Registers */ + +static inline uint32_t _AArch32_Read_pmevtyper_13( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c14, c13, 5" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_pmevtyper_13( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c14, c13, 5" : : "r" ( value ) : "memory" + ); +} + +/* PMEVTYPER_14, Performance Monitors Event Type Registers */ + +static inline uint32_t _AArch32_Read_pmevtyper_14( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c14, c13, 6" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_pmevtyper_14( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c14, c13, 6" : : "r" ( value ) : "memory" + ); +} + +/* PMEVTYPER_15, Performance Monitors Event Type Registers */ + +static inline uint32_t _AArch32_Read_pmevtyper_15( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c14, c13, 7" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_pmevtyper_15( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c14, c13, 7" : : "r" ( value ) : "memory" + ); +} + +/* PMEVTYPER_16, Performance Monitors Event Type Registers */ + +static inline uint32_t _AArch32_Read_pmevtyper_16( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c14, c14, 0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_pmevtyper_16( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c14, c14, 0" : : "r" ( value ) : "memory" + ); +} + +/* PMEVTYPER_17, Performance Monitors Event Type Registers */ + +static inline uint32_t _AArch32_Read_pmevtyper_17( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c14, c14, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_pmevtyper_17( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c14, c14, 1" : : "r" ( value ) : "memory" + ); +} + +/* PMEVTYPER_18, Performance Monitors Event Type Registers */ + +static inline uint32_t _AArch32_Read_pmevtyper_18( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c14, c14, 2" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_pmevtyper_18( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c14, c14, 2" : : "r" ( value ) : "memory" + ); +} + +/* PMEVTYPER_19, Performance Monitors Event Type Registers */ + +static inline uint32_t _AArch32_Read_pmevtyper_19( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c14, c14, 3" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_pmevtyper_19( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c14, c14, 3" : : "r" ( value ) : "memory" + ); +} + +/* PMEVTYPER_20, Performance Monitors Event Type Registers */ + +static inline uint32_t _AArch32_Read_pmevtyper_20( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c14, c14, 4" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_pmevtyper_20( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c14, c14, 4" : : "r" ( value ) : "memory" + ); +} + +/* PMEVTYPER_21, Performance Monitors Event Type Registers */ + +static inline uint32_t _AArch32_Read_pmevtyper_21( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c14, c14, 5" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_pmevtyper_21( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c14, c14, 5" : : "r" ( value ) : "memory" + ); +} + +/* PMEVTYPER_22, Performance Monitors Event Type Registers */ + +static inline uint32_t _AArch32_Read_pmevtyper_22( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c14, c14, 6" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_pmevtyper_22( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c14, c14, 6" : : "r" ( value ) : "memory" + ); +} + +/* PMEVTYPER_23, Performance Monitors Event Type Registers */ + +static inline uint32_t _AArch32_Read_pmevtyper_23( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c14, c14, 7" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_pmevtyper_23( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c14, c14, 7" : : "r" ( value ) : "memory" + ); +} + +/* PMEVTYPER_24, Performance Monitors Event Type Registers */ + +static inline uint32_t _AArch32_Read_pmevtyper_24( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c14, c15, 0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_pmevtyper_24( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c14, c15, 0" : : "r" ( value ) : "memory" + ); +} + +/* PMEVTYPER_25, Performance Monitors Event Type Registers */ + +static inline uint32_t _AArch32_Read_pmevtyper_25( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c14, c15, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_pmevtyper_25( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c14, c15, 1" : : "r" ( value ) : "memory" + ); +} + +/* PMEVTYPER_26, Performance Monitors Event Type Registers */ + +static inline uint32_t _AArch32_Read_pmevtyper_26( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c14, c15, 2" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_pmevtyper_26( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c14, c15, 2" : : "r" ( value ) : "memory" + ); +} + +/* PMEVTYPER_27, Performance Monitors Event Type Registers */ + +static inline uint32_t _AArch32_Read_pmevtyper_27( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c14, c15, 3" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_pmevtyper_27( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c14, c15, 3" : : "r" ( value ) : "memory" + ); +} + +/* PMEVTYPER_28, Performance Monitors Event Type Registers */ + +static inline uint32_t _AArch32_Read_pmevtyper_28( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c14, c15, 4" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_pmevtyper_28( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c14, c15, 4" : : "r" ( value ) : "memory" + ); +} + +/* PMEVTYPER_29, Performance Monitors Event Type Registers */ + +static inline uint32_t _AArch32_Read_pmevtyper_29( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c14, c15, 5" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_pmevtyper_29( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c14, c15, 5" : : "r" ( value ) : "memory" + ); +} + +/* PMEVTYPER_30, Performance Monitors Event Type Registers */ + +static inline uint32_t _AArch32_Read_pmevtyper_30( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c14, c15, 6" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_pmevtyper_30( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c14, c15, 6" : : "r" ( value ) : "memory" + ); +} + +/* PMINTENCLR, Performance Monitors Interrupt Enable Clear Register */ + +#define AARCH32_PMINTENCLR_C 0x80000000U + +static inline uint32_t _AArch32_Read_pmintenclr( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c9, c14, 2" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_pmintenclr( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c9, c14, 2" : : "r" ( value ) : "memory" + ); +} + +/* PMINTENSET, Performance Monitors Interrupt Enable Set Register */ + +#define AARCH32_PMINTENSET_C 0x80000000U + +static inline uint32_t _AArch32_Read_pmintenset( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c9, c14, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_pmintenset( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c9, c14, 1" : : "r" ( value ) : "memory" + ); +} + +/* PMOVSR, Performance Monitors Overflow Flag Status Register */ + +#define AARCH32_PMOVSR_C 0x80000000U + +static inline uint32_t _AArch32_Read_pmovsr( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c9, c12, 3" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_pmovsr( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c9, c12, 3" : : "r" ( value ) : "memory" + ); +} + +/* PMOVSSET, Performance Monitors Overflow Flag Status Set Register */ + +#define AARCH32_PMOVSSET_C 0x80000000U + +static inline uint32_t _AArch32_Read_pmovsset( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c9, c14, 3" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_pmovsset( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c9, c14, 3" : : "r" ( value ) : "memory" + ); +} + +/* PMSELR, Performance Monitors Event Counter Selection Register */ + +#define AARCH32_PMSELR_SEL( _val ) ( ( _val ) << 0 ) +#define AARCH32_PMSELR_SEL_SHIFT 0 +#define AARCH32_PMSELR_SEL_MASK 0x1fU +#define AARCH32_PMSELR_SEL_GET( _reg ) \ + ( ( ( _reg ) >> 0 ) & 0x1fU ) + +static inline uint32_t _AArch32_Read_pmselr( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c9, c12, 5" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_pmselr( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c9, c12, 5" : : "r" ( value ) : "memory" + ); +} + +/* PMSWINC, Performance Monitors Software Increment Register */ + +static inline void _AArch32_Write_pmswinc( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c9, c12, 4" : : "r" ( value ) : "memory" + ); +} + +/* PMUSERENR, Performance Monitors User Enable Register */ + +#define AARCH32_PMUSERENR_EN 0x1U + +#define AARCH32_PMUSERENR_SW 0x2U + +#define AARCH32_PMUSERENR_CR 0x4U + +#define AARCH32_PMUSERENR_ER 0x8U + +static inline uint32_t _AArch32_Read_pmuserenr( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c9, c14, 0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_pmuserenr( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c9, c14, 0" : : "r" ( value ) : "memory" + ); +} + +/* PMXEVCNTR, Performance Monitors Selected Event Count Register */ + +static inline uint32_t _AArch32_Read_pmxevcntr( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c9, c13, 2" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_pmxevcntr( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c9, c13, 2" : : "r" ( value ) : "memory" + ); +} + +/* PMXEVTYPER, Performance Monitors Selected Event Type Register */ + +static inline uint32_t _AArch32_Read_pmxevtyper( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c9, c13, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_pmxevtyper( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c9, c13, 1" : : "r" ( value ) : "memory" + ); +} + +/* AMCFGR, Activity Monitors Configuration Register */ + +#define AARCH32_AMCFGR_N( _val ) ( ( _val ) << 0 ) +#define AARCH32_AMCFGR_N_SHIFT 0 +#define AARCH32_AMCFGR_N_MASK 0xffU +#define AARCH32_AMCFGR_N_GET( _reg ) \ + ( ( ( _reg ) >> 0 ) & 0xffU ) + +#define AARCH32_AMCFGR_SIZE( _val ) ( ( _val ) << 8 ) +#define AARCH32_AMCFGR_SIZE_SHIFT 8 +#define AARCH32_AMCFGR_SIZE_MASK 0x3f00U +#define AARCH32_AMCFGR_SIZE_GET( _reg ) \ + ( ( ( _reg ) >> 8 ) & 0x3fU ) + +#define AARCH32_AMCFGR_HDBG 0x1000000U + +#define AARCH32_AMCFGR_NCG( _val ) ( ( _val ) << 28 ) +#define AARCH32_AMCFGR_NCG_SHIFT 28 +#define AARCH32_AMCFGR_NCG_MASK 0xf0000000U +#define AARCH32_AMCFGR_NCG_GET( _reg ) \ + ( ( ( _reg ) >> 28 ) & 0xfU ) + +static inline uint32_t _AArch32_Read_amcfgr( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c13, c2, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +/* AMCGCR, Activity Monitors Counter Group Configuration Register */ + +#define AARCH32_AMCGCR_CG0NC( _val ) ( ( _val ) << 0 ) +#define AARCH32_AMCGCR_CG0NC_SHIFT 0 +#define AARCH32_AMCGCR_CG0NC_MASK 0xffU +#define AARCH32_AMCGCR_CG0NC_GET( _reg ) \ + ( ( ( _reg ) >> 0 ) & 0xffU ) + +#define AARCH32_AMCGCR_CG1NC( _val ) ( ( _val ) << 8 ) +#define AARCH32_AMCGCR_CG1NC_SHIFT 8 +#define AARCH32_AMCGCR_CG1NC_MASK 0xff00U +#define AARCH32_AMCGCR_CG1NC_GET( _reg ) \ + ( ( ( _reg ) >> 8 ) & 0xffU ) + +static inline uint32_t _AArch32_Read_amcgcr( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c13, c2, 2" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +/* AMCNTENCLR0, Activity Monitors Count Enable Clear Register 0 */ + +static inline uint32_t _AArch32_Read_amcntenclr0( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c13, c2, 4" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_amcntenclr0( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c13, c2, 4" : : "r" ( value ) : "memory" + ); +} + +/* AMCNTENCLR1, Activity Monitors Count Enable Clear Register 1 */ + +static inline uint32_t _AArch32_Read_amcntenclr1( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c13, c3, 0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_amcntenclr1( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c13, c3, 0" : : "r" ( value ) : "memory" + ); +} + +/* AMCNTENSET0, Activity Monitors Count Enable Set Register 0 */ + +static inline uint32_t _AArch32_Read_amcntenset0( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c13, c2, 5" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_amcntenset0( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c13, c2, 5" : : "r" ( value ) : "memory" + ); +} + +/* AMCNTENSET1, Activity Monitors Count Enable Set Register 1 */ + +static inline uint32_t _AArch32_Read_amcntenset1( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c13, c3, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_amcntenset1( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c13, c3, 1" : : "r" ( value ) : "memory" + ); +} + +/* AMCR, Activity Monitors Control Register */ + +#define AARCH32_AMCR_HDBG 0x400U + +#define AARCH32_AMCR_CG1RZ 0x20000U + +static inline uint32_t _AArch32_Read_amcr( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c13, c2, 0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_amcr( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c13, c2, 0" : : "r" ( value ) : "memory" + ); +} + +/* AMEVCNTR0, Activity Monitors Event Counter Registers 0 */ + +#define AARCH32_AMEVCNTR0_ACNT( _val ) ( ( _val ) << 0 ) +#define AARCH32_AMEVCNTR0_ACNT_SHIFT 0 +#define AARCH32_AMEVCNTR0_ACNT_MASK 0xffffffffffffffffULL +#define AARCH32_AMEVCNTR0_ACNT_GET( _reg ) \ + ( ( ( _reg ) >> 0 ) & 0xffffffffffffffffULL ) + +/* AMEVCNTR0_0, Activity Monitors Event Counter Registers 0 */ + +static inline uint64_t _AArch32_Read_amevcntr0_0( void ) +{ + uint64_t value; + + __asm__ volatile ( + "mrrc p15, 0, %Q0, %R0, c0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_amevcntr0_0( uint64_t value ) +{ + __asm__ volatile ( + "mcrr p15, 0, %Q0, %R0, c0" : : "r" ( value ) : "memory" + ); +} + +/* AMEVCNTR0_1, Activity Monitors Event Counter Registers 0 */ + +static inline uint64_t _AArch32_Read_amevcntr0_1( void ) +{ + uint64_t value; + + __asm__ volatile ( + "mrrc p15, 1, %Q0, %R0, c0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_amevcntr0_1( uint64_t value ) +{ + __asm__ volatile ( + "mcrr p15, 1, %Q0, %R0, c0" : : "r" ( value ) : "memory" + ); +} + +/* AMEVCNTR0_2, Activity Monitors Event Counter Registers 0 */ + +static inline uint64_t _AArch32_Read_amevcntr0_2( void ) +{ + uint64_t value; + + __asm__ volatile ( + "mrrc p15, 2, %Q0, %R0, c0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_amevcntr0_2( uint64_t value ) +{ + __asm__ volatile ( + "mcrr p15, 2, %Q0, %R0, c0" : : "r" ( value ) : "memory" + ); +} + +/* AMEVCNTR0_3, Activity Monitors Event Counter Registers 0 */ + +static inline uint64_t _AArch32_Read_amevcntr0_3( void ) +{ + uint64_t value; + + __asm__ volatile ( + "mrrc p15, 3, %Q0, %R0, c0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_amevcntr0_3( uint64_t value ) +{ + __asm__ volatile ( + "mcrr p15, 3, %Q0, %R0, c0" : : "r" ( value ) : "memory" + ); +} + +/* AMEVCNTR0_4, Activity Monitors Event Counter Registers 0 */ + +static inline uint64_t _AArch32_Read_amevcntr0_4( void ) +{ + uint64_t value; + + __asm__ volatile ( + "mrrc p15, 4, %Q0, %R0, c0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_amevcntr0_4( uint64_t value ) +{ + __asm__ volatile ( + "mcrr p15, 4, %Q0, %R0, c0" : : "r" ( value ) : "memory" + ); +} + +/* AMEVCNTR0_5, Activity Monitors Event Counter Registers 0 */ + +static inline uint64_t _AArch32_Read_amevcntr0_5( void ) +{ + uint64_t value; + + __asm__ volatile ( + "mrrc p15, 5, %Q0, %R0, c0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_amevcntr0_5( uint64_t value ) +{ + __asm__ volatile ( + "mcrr p15, 5, %Q0, %R0, c0" : : "r" ( value ) : "memory" + ); +} + +/* AMEVCNTR0_6, Activity Monitors Event Counter Registers 0 */ + +static inline uint64_t _AArch32_Read_amevcntr0_6( void ) +{ + uint64_t value; + + __asm__ volatile ( + "mrrc p15, 6, %Q0, %R0, c0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_amevcntr0_6( uint64_t value ) +{ + __asm__ volatile ( + "mcrr p15, 6, %Q0, %R0, c0" : : "r" ( value ) : "memory" + ); +} + +/* AMEVCNTR0_7, Activity Monitors Event Counter Registers 0 */ + +static inline uint64_t _AArch32_Read_amevcntr0_7( void ) +{ + uint64_t value; + + __asm__ volatile ( + "mrrc p15, 7, %Q0, %R0, c0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_amevcntr0_7( uint64_t value ) +{ + __asm__ volatile ( + "mcrr p15, 7, %Q0, %R0, c0" : : "r" ( value ) : "memory" + ); +} + +/* AMEVCNTR0_8, Activity Monitors Event Counter Registers 0 */ + +static inline uint64_t _AArch32_Read_amevcntr0_8( void ) +{ + uint64_t value; + + __asm__ volatile ( + "mrrc p15, 0, %Q0, %R0, c1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_amevcntr0_8( uint64_t value ) +{ + __asm__ volatile ( + "mcrr p15, 0, %Q0, %R0, c1" : : "r" ( value ) : "memory" + ); +} + +/* AMEVCNTR0_9, Activity Monitors Event Counter Registers 0 */ + +static inline uint64_t _AArch32_Read_amevcntr0_9( void ) +{ + uint64_t value; + + __asm__ volatile ( + "mrrc p15, 1, %Q0, %R0, c1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_amevcntr0_9( uint64_t value ) +{ + __asm__ volatile ( + "mcrr p15, 1, %Q0, %R0, c1" : : "r" ( value ) : "memory" + ); +} + +/* AMEVCNTR0_10, Activity Monitors Event Counter Registers 0 */ + +static inline uint64_t _AArch32_Read_amevcntr0_10( void ) +{ + uint64_t value; + + __asm__ volatile ( + "mrrc p15, 2, %Q0, %R0, c1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_amevcntr0_10( uint64_t value ) +{ + __asm__ volatile ( + "mcrr p15, 2, %Q0, %R0, c1" : : "r" ( value ) : "memory" + ); +} + +/* AMEVCNTR0_11, Activity Monitors Event Counter Registers 0 */ + +static inline uint64_t _AArch32_Read_amevcntr0_11( void ) +{ + uint64_t value; + + __asm__ volatile ( + "mrrc p15, 3, %Q0, %R0, c1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_amevcntr0_11( uint64_t value ) +{ + __asm__ volatile ( + "mcrr p15, 3, %Q0, %R0, c1" : : "r" ( value ) : "memory" + ); +} + +/* AMEVCNTR0_12, Activity Monitors Event Counter Registers 0 */ + +static inline uint64_t _AArch32_Read_amevcntr0_12( void ) +{ + uint64_t value; + + __asm__ volatile ( + "mrrc p15, 4, %Q0, %R0, c1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_amevcntr0_12( uint64_t value ) +{ + __asm__ volatile ( + "mcrr p15, 4, %Q0, %R0, c1" : : "r" ( value ) : "memory" + ); +} + +/* AMEVCNTR0_13, Activity Monitors Event Counter Registers 0 */ + +static inline uint64_t _AArch32_Read_amevcntr0_13( void ) +{ + uint64_t value; + + __asm__ volatile ( + "mrrc p15, 5, %Q0, %R0, c1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_amevcntr0_13( uint64_t value ) +{ + __asm__ volatile ( + "mcrr p15, 5, %Q0, %R0, c1" : : "r" ( value ) : "memory" + ); +} + +/* AMEVCNTR0_14, Activity Monitors Event Counter Registers 0 */ + +static inline uint64_t _AArch32_Read_amevcntr0_14( void ) +{ + uint64_t value; + + __asm__ volatile ( + "mrrc p15, 6, %Q0, %R0, c1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_amevcntr0_14( uint64_t value ) +{ + __asm__ volatile ( + "mcrr p15, 6, %Q0, %R0, c1" : : "r" ( value ) : "memory" + ); +} + +/* AMEVCNTR0_15, Activity Monitors Event Counter Registers 0 */ + +static inline uint64_t _AArch32_Read_amevcntr0_15( void ) +{ + uint64_t value; + + __asm__ volatile ( + "mrrc p15, 7, %Q0, %R0, c1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_amevcntr0_15( uint64_t value ) +{ + __asm__ volatile ( + "mcrr p15, 7, %Q0, %R0, c1" : : "r" ( value ) : "memory" + ); +} + +/* AMEVCNTR1, Activity Monitors Event Counter Registers 1 */ + +#define AARCH32_AMEVCNTR1_ACNT( _val ) ( ( _val ) << 0 ) +#define AARCH32_AMEVCNTR1_ACNT_SHIFT 0 +#define AARCH32_AMEVCNTR1_ACNT_MASK 0xffffffffffffffffULL +#define AARCH32_AMEVCNTR1_ACNT_GET( _reg ) \ + ( ( ( _reg ) >> 0 ) & 0xffffffffffffffffULL ) + +/* AMEVCNTR1_0, Activity Monitors Event Counter Registers 1 */ + +static inline uint64_t _AArch32_Read_amevcntr1_0( void ) +{ + uint64_t value; + + __asm__ volatile ( + "mrrc p15, 0, %Q0, %R0, c4" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_amevcntr1_0( uint64_t value ) +{ + __asm__ volatile ( + "mcrr p15, 0, %Q0, %R0, c4" : : "r" ( value ) : "memory" + ); +} + +/* AMEVCNTR1_1, Activity Monitors Event Counter Registers 1 */ + +static inline uint64_t _AArch32_Read_amevcntr1_1( void ) +{ + uint64_t value; + + __asm__ volatile ( + "mrrc p15, 1, %Q0, %R0, c4" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_amevcntr1_1( uint64_t value ) +{ + __asm__ volatile ( + "mcrr p15, 1, %Q0, %R0, c4" : : "r" ( value ) : "memory" + ); +} + +/* AMEVCNTR1_2, Activity Monitors Event Counter Registers 1 */ + +static inline uint64_t _AArch32_Read_amevcntr1_2( void ) +{ + uint64_t value; + + __asm__ volatile ( + "mrrc p15, 2, %Q0, %R0, c4" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_amevcntr1_2( uint64_t value ) +{ + __asm__ volatile ( + "mcrr p15, 2, %Q0, %R0, c4" : : "r" ( value ) : "memory" + ); +} + +/* AMEVCNTR1_3, Activity Monitors Event Counter Registers 1 */ + +static inline uint64_t _AArch32_Read_amevcntr1_3( void ) +{ + uint64_t value; + + __asm__ volatile ( + "mrrc p15, 3, %Q0, %R0, c4" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_amevcntr1_3( uint64_t value ) +{ + __asm__ volatile ( + "mcrr p15, 3, %Q0, %R0, c4" : : "r" ( value ) : "memory" + ); +} + +/* AMEVCNTR1_4, Activity Monitors Event Counter Registers 1 */ + +static inline uint64_t _AArch32_Read_amevcntr1_4( void ) +{ + uint64_t value; + + __asm__ volatile ( + "mrrc p15, 4, %Q0, %R0, c4" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_amevcntr1_4( uint64_t value ) +{ + __asm__ volatile ( + "mcrr p15, 4, %Q0, %R0, c4" : : "r" ( value ) : "memory" + ); +} + +/* AMEVCNTR1_5, Activity Monitors Event Counter Registers 1 */ + +static inline uint64_t _AArch32_Read_amevcntr1_5( void ) +{ + uint64_t value; + + __asm__ volatile ( + "mrrc p15, 5, %Q0, %R0, c4" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_amevcntr1_5( uint64_t value ) +{ + __asm__ volatile ( + "mcrr p15, 5, %Q0, %R0, c4" : : "r" ( value ) : "memory" + ); +} + +/* AMEVCNTR1_6, Activity Monitors Event Counter Registers 1 */ + +static inline uint64_t _AArch32_Read_amevcntr1_6( void ) +{ + uint64_t value; + + __asm__ volatile ( + "mrrc p15, 6, %Q0, %R0, c4" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_amevcntr1_6( uint64_t value ) +{ + __asm__ volatile ( + "mcrr p15, 6, %Q0, %R0, c4" : : "r" ( value ) : "memory" + ); +} + +/* AMEVCNTR1_7, Activity Monitors Event Counter Registers 1 */ + +static inline uint64_t _AArch32_Read_amevcntr1_7( void ) +{ + uint64_t value; + + __asm__ volatile ( + "mrrc p15, 7, %Q0, %R0, c4" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_amevcntr1_7( uint64_t value ) +{ + __asm__ volatile ( + "mcrr p15, 7, %Q0, %R0, c4" : : "r" ( value ) : "memory" + ); +} + +/* AMEVCNTR1_8, Activity Monitors Event Counter Registers 1 */ + +static inline uint64_t _AArch32_Read_amevcntr1_8( void ) +{ + uint64_t value; + + __asm__ volatile ( + "mrrc p15, 0, %Q0, %R0, c5" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_amevcntr1_8( uint64_t value ) +{ + __asm__ volatile ( + "mcrr p15, 0, %Q0, %R0, c5" : : "r" ( value ) : "memory" + ); +} + +/* AMEVCNTR1_9, Activity Monitors Event Counter Registers 1 */ + +static inline uint64_t _AArch32_Read_amevcntr1_9( void ) +{ + uint64_t value; + + __asm__ volatile ( + "mrrc p15, 1, %Q0, %R0, c5" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_amevcntr1_9( uint64_t value ) +{ + __asm__ volatile ( + "mcrr p15, 1, %Q0, %R0, c5" : : "r" ( value ) : "memory" + ); +} + +/* AMEVCNTR1_10, Activity Monitors Event Counter Registers 1 */ + +static inline uint64_t _AArch32_Read_amevcntr1_10( void ) +{ + uint64_t value; + + __asm__ volatile ( + "mrrc p15, 2, %Q0, %R0, c5" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_amevcntr1_10( uint64_t value ) +{ + __asm__ volatile ( + "mcrr p15, 2, %Q0, %R0, c5" : : "r" ( value ) : "memory" + ); +} + +/* AMEVCNTR1_11, Activity Monitors Event Counter Registers 1 */ + +static inline uint64_t _AArch32_Read_amevcntr1_11( void ) +{ + uint64_t value; + + __asm__ volatile ( + "mrrc p15, 3, %Q0, %R0, c5" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_amevcntr1_11( uint64_t value ) +{ + __asm__ volatile ( + "mcrr p15, 3, %Q0, %R0, c5" : : "r" ( value ) : "memory" + ); +} + +/* AMEVCNTR1_12, Activity Monitors Event Counter Registers 1 */ + +static inline uint64_t _AArch32_Read_amevcntr1_12( void ) +{ + uint64_t value; + + __asm__ volatile ( + "mrrc p15, 4, %Q0, %R0, c5" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_amevcntr1_12( uint64_t value ) +{ + __asm__ volatile ( + "mcrr p15, 4, %Q0, %R0, c5" : : "r" ( value ) : "memory" + ); +} + +/* AMEVCNTR1_13, Activity Monitors Event Counter Registers 1 */ + +static inline uint64_t _AArch32_Read_amevcntr1_13( void ) +{ + uint64_t value; + + __asm__ volatile ( + "mrrc p15, 5, %Q0, %R0, c5" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_amevcntr1_13( uint64_t value ) +{ + __asm__ volatile ( + "mcrr p15, 5, %Q0, %R0, c5" : : "r" ( value ) : "memory" + ); +} + +/* AMEVCNTR1_14, Activity Monitors Event Counter Registers 1 */ + +static inline uint64_t _AArch32_Read_amevcntr1_14( void ) +{ + uint64_t value; + + __asm__ volatile ( + "mrrc p15, 6, %Q0, %R0, c5" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_amevcntr1_14( uint64_t value ) +{ + __asm__ volatile ( + "mcrr p15, 6, %Q0, %R0, c5" : : "r" ( value ) : "memory" + ); +} + +/* AMEVCNTR1_15, Activity Monitors Event Counter Registers 1 */ + +static inline uint64_t _AArch32_Read_amevcntr1_15( void ) +{ + uint64_t value; + + __asm__ volatile ( + "mrrc p15, 7, %Q0, %R0, c5" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_amevcntr1_15( uint64_t value ) +{ + __asm__ volatile ( + "mcrr p15, 7, %Q0, %R0, c5" : : "r" ( value ) : "memory" + ); +} + +/* AMEVTYPER0, Activity Monitors Event Type Registers 0 */ + +#define AARCH32_AMEVTYPER0_EVTCOUNT( _val ) ( ( _val ) << 0 ) +#define AARCH32_AMEVTYPER0_EVTCOUNT_SHIFT 0 +#define AARCH32_AMEVTYPER0_EVTCOUNT_MASK 0xffffU +#define AARCH32_AMEVTYPER0_EVTCOUNT_GET( _reg ) \ + ( ( ( _reg ) >> 0 ) & 0xffffU ) + +/* AMEVTYPER0_0, Activity Monitors Event Type Registers 0 */ + +static inline uint32_t _AArch32_Read_amevtyper0_0( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c13, c6, 0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +/* AMEVTYPER0_1, Activity Monitors Event Type Registers 0 */ + +static inline uint32_t _AArch32_Read_amevtyper0_1( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c13, c6, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +/* AMEVTYPER0_2, Activity Monitors Event Type Registers 0 */ + +static inline uint32_t _AArch32_Read_amevtyper0_2( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c13, c6, 2" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +/* AMEVTYPER0_3, Activity Monitors Event Type Registers 0 */ + +static inline uint32_t _AArch32_Read_amevtyper0_3( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c13, c6, 3" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +/* AMEVTYPER0_4, Activity Monitors Event Type Registers 0 */ + +static inline uint32_t _AArch32_Read_amevtyper0_4( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c13, c6, 4" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +/* AMEVTYPER0_5, Activity Monitors Event Type Registers 0 */ + +static inline uint32_t _AArch32_Read_amevtyper0_5( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c13, c6, 5" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +/* AMEVTYPER0_6, Activity Monitors Event Type Registers 0 */ + +static inline uint32_t _AArch32_Read_amevtyper0_6( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c13, c6, 6" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +/* AMEVTYPER0_7, Activity Monitors Event Type Registers 0 */ + +static inline uint32_t _AArch32_Read_amevtyper0_7( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c13, c6, 7" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +/* AMEVTYPER0_8, Activity Monitors Event Type Registers 0 */ + +static inline uint32_t _AArch32_Read_amevtyper0_8( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c13, c7, 0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +/* AMEVTYPER0_9, Activity Monitors Event Type Registers 0 */ + +static inline uint32_t _AArch32_Read_amevtyper0_9( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c13, c7, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +/* AMEVTYPER0_10, Activity Monitors Event Type Registers 0 */ + +static inline uint32_t _AArch32_Read_amevtyper0_10( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c13, c7, 2" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +/* AMEVTYPER0_11, Activity Monitors Event Type Registers 0 */ + +static inline uint32_t _AArch32_Read_amevtyper0_11( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c13, c7, 3" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +/* AMEVTYPER0_12, Activity Monitors Event Type Registers 0 */ + +static inline uint32_t _AArch32_Read_amevtyper0_12( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c13, c7, 4" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +/* AMEVTYPER0_13, Activity Monitors Event Type Registers 0 */ + +static inline uint32_t _AArch32_Read_amevtyper0_13( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c13, c7, 5" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +/* AMEVTYPER0_14, Activity Monitors Event Type Registers 0 */ + +static inline uint32_t _AArch32_Read_amevtyper0_14( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c13, c7, 6" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +/* AMEVTYPER0_15, Activity Monitors Event Type Registers 0 */ + +static inline uint32_t _AArch32_Read_amevtyper0_15( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c13, c7, 7" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +/* AMEVTYPER1, Activity Monitors Event Type Registers 1 */ + +#define AARCH32_AMEVTYPER1_EVTCOUNT( _val ) ( ( _val ) << 0 ) +#define AARCH32_AMEVTYPER1_EVTCOUNT_SHIFT 0 +#define AARCH32_AMEVTYPER1_EVTCOUNT_MASK 0xffffU +#define AARCH32_AMEVTYPER1_EVTCOUNT_GET( _reg ) \ + ( ( ( _reg ) >> 0 ) & 0xffffU ) + +/* AMEVTYPER1_0, Activity Monitors Event Type Registers 1 */ + +static inline uint32_t _AArch32_Read_amevtyper1_0( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c13, c14, 0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_amevtyper1_0( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c13, c14, 0" : : "r" ( value ) : "memory" + ); +} + +/* AMEVTYPER1_1, Activity Monitors Event Type Registers 1 */ + +static inline uint32_t _AArch32_Read_amevtyper1_1( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c13, c14, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_amevtyper1_1( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c13, c14, 1" : : "r" ( value ) : "memory" + ); +} + +/* AMEVTYPER1_2, Activity Monitors Event Type Registers 1 */ + +static inline uint32_t _AArch32_Read_amevtyper1_2( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c13, c14, 2" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_amevtyper1_2( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c13, c14, 2" : : "r" ( value ) : "memory" + ); +} + +/* AMEVTYPER1_3, Activity Monitors Event Type Registers 1 */ + +static inline uint32_t _AArch32_Read_amevtyper1_3( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c13, c14, 3" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_amevtyper1_3( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c13, c14, 3" : : "r" ( value ) : "memory" + ); +} + +/* AMEVTYPER1_4, Activity Monitors Event Type Registers 1 */ + +static inline uint32_t _AArch32_Read_amevtyper1_4( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c13, c14, 4" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_amevtyper1_4( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c13, c14, 4" : : "r" ( value ) : "memory" + ); +} + +/* AMEVTYPER1_5, Activity Monitors Event Type Registers 1 */ + +static inline uint32_t _AArch32_Read_amevtyper1_5( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c13, c14, 5" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_amevtyper1_5( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c13, c14, 5" : : "r" ( value ) : "memory" + ); +} + +/* AMEVTYPER1_6, Activity Monitors Event Type Registers 1 */ + +static inline uint32_t _AArch32_Read_amevtyper1_6( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c13, c14, 6" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_amevtyper1_6( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c13, c14, 6" : : "r" ( value ) : "memory" + ); +} + +/* AMEVTYPER1_7, Activity Monitors Event Type Registers 1 */ + +static inline uint32_t _AArch32_Read_amevtyper1_7( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c13, c14, 7" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_amevtyper1_7( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c13, c14, 7" : : "r" ( value ) : "memory" + ); +} + +/* AMEVTYPER1_8, Activity Monitors Event Type Registers 1 */ + +static inline uint32_t _AArch32_Read_amevtyper1_8( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c13, c15, 0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_amevtyper1_8( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c13, c15, 0" : : "r" ( value ) : "memory" + ); +} + +/* AMEVTYPER1_9, Activity Monitors Event Type Registers 1 */ + +static inline uint32_t _AArch32_Read_amevtyper1_9( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c13, c15, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_amevtyper1_9( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c13, c15, 1" : : "r" ( value ) : "memory" + ); +} + +/* AMEVTYPER1_10, Activity Monitors Event Type Registers 1 */ + +static inline uint32_t _AArch32_Read_amevtyper1_10( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c13, c15, 2" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_amevtyper1_10( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c13, c15, 2" : : "r" ( value ) : "memory" + ); +} + +/* AMEVTYPER1_11, Activity Monitors Event Type Registers 1 */ + +static inline uint32_t _AArch32_Read_amevtyper1_11( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c13, c15, 3" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_amevtyper1_11( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c13, c15, 3" : : "r" ( value ) : "memory" + ); +} + +/* AMEVTYPER1_12, Activity Monitors Event Type Registers 1 */ + +static inline uint32_t _AArch32_Read_amevtyper1_12( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c13, c15, 4" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_amevtyper1_12( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c13, c15, 4" : : "r" ( value ) : "memory" + ); +} + +/* AMEVTYPER1_13, Activity Monitors Event Type Registers 1 */ + +static inline uint32_t _AArch32_Read_amevtyper1_13( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c13, c15, 5" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_amevtyper1_13( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c13, c15, 5" : : "r" ( value ) : "memory" + ); +} + +/* AMEVTYPER1_14, Activity Monitors Event Type Registers 1 */ + +static inline uint32_t _AArch32_Read_amevtyper1_14( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c13, c15, 6" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_amevtyper1_14( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c13, c15, 6" : : "r" ( value ) : "memory" + ); +} + +/* AMEVTYPER1_15, Activity Monitors Event Type Registers 1 */ + +static inline uint32_t _AArch32_Read_amevtyper1_15( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c13, c15, 7" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_amevtyper1_15( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c13, c15, 7" : : "r" ( value ) : "memory" + ); +} + +/* AMUSERENR, Activity Monitors User Enable Register */ + +#define AARCH32_AMUSERENR_EN 0x1U + +static inline uint32_t _AArch32_Read_amuserenr( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c13, c2, 3" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_amuserenr( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c13, c2, 3" : : "r" ( value ) : "memory" + ); +} + +/* DISR, Deferred Interrupt Status Register */ + +#define AARCH32_DISR_FS_3_0( _val ) ( ( _val ) << 0 ) +#define AARCH32_DISR_FS_3_0_SHIFT 0 +#define AARCH32_DISR_FS_3_0_MASK 0xfU +#define AARCH32_DISR_FS_3_0_GET( _reg ) \ + ( ( ( _reg ) >> 0 ) & 0xfU ) + +#define AARCH32_DISR_DFSC( _val ) ( ( _val ) << 0 ) +#define AARCH32_DISR_DFSC_SHIFT 0 +#define AARCH32_DISR_DFSC_MASK 0x3fU +#define AARCH32_DISR_DFSC_GET( _reg ) \ + ( ( ( _reg ) >> 0 ) & 0x3fU ) + +#define AARCH32_DISR_STATUS( _val ) ( ( _val ) << 0 ) +#define AARCH32_DISR_STATUS_SHIFT 0 +#define AARCH32_DISR_STATUS_MASK 0x3fU +#define AARCH32_DISR_STATUS_GET( _reg ) \ + ( ( ( _reg ) >> 0 ) & 0x3fU ) + +#define AARCH32_DISR_EA 0x200U + +#define AARCH32_DISR_LPAE 0x200U + +#define AARCH32_DISR_FS_4 0x400U + +#define AARCH32_DISR_AET_0( _val ) ( ( _val ) << 10 ) +#define AARCH32_DISR_AET_SHIFT_0 10 +#define AARCH32_DISR_AET_MASK_0 0xc00U +#define AARCH32_DISR_AET_GET_0( _reg ) \ + ( ( ( _reg ) >> 10 ) & 0x3U ) + +#define AARCH32_DISR_EXT 0x1000U + +#define AARCH32_DISR_AET_1( _val ) ( ( _val ) << 14 ) +#define AARCH32_DISR_AET_SHIFT_1 14 +#define AARCH32_DISR_AET_MASK_1 0xc000U +#define AARCH32_DISR_AET_GET_1( _reg ) \ + ( ( ( _reg ) >> 14 ) & 0x3U ) + +#define AARCH32_DISR_A 0x80000000U + +static inline uint32_t _AArch32_Read_disr( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c12, c1, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_disr( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c12, c1, 1" : : "r" ( value ) : "memory" + ); +} + +/* ERRIDR, Error Record ID Register */ + +#define AARCH32_ERRIDR_NUM( _val ) ( ( _val ) << 0 ) +#define AARCH32_ERRIDR_NUM_SHIFT 0 +#define AARCH32_ERRIDR_NUM_MASK 0xffffU +#define AARCH32_ERRIDR_NUM_GET( _reg ) \ + ( ( ( _reg ) >> 0 ) & 0xffffU ) + +static inline uint32_t _AArch32_Read_erridr( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c5, c3, 0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +/* ERRSELR, Error Record Select Register */ + +#define AARCH32_ERRSELR_SEL( _val ) ( ( _val ) << 0 ) +#define AARCH32_ERRSELR_SEL_SHIFT 0 +#define AARCH32_ERRSELR_SEL_MASK 0xffffU +#define AARCH32_ERRSELR_SEL_GET( _reg ) \ + ( ( ( _reg ) >> 0 ) & 0xffffU ) + +static inline uint32_t _AArch32_Read_errselr( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c5, c3, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_errselr( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c5, c3, 1" : : "r" ( value ) : "memory" + ); +} + +/* ERXADDR, Selected Error Record Address Register */ + +static inline uint32_t _AArch32_Read_erxaddr( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c5, c4, 3" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_erxaddr( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c5, c4, 3" : : "r" ( value ) : "memory" + ); +} + +/* ERXADDR2, Selected Error Record Address Register 2 */ + +static inline uint32_t _AArch32_Read_erxaddr2( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c5, c4, 7" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_erxaddr2( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c5, c4, 7" : : "r" ( value ) : "memory" + ); +} + +/* ERXCTLR, Selected Error Record Control Register */ + +static inline uint32_t _AArch32_Read_erxctlr( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c5, c4, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_erxctlr( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c5, c4, 1" : : "r" ( value ) : "memory" + ); +} + +/* ERXCTLR2, Selected Error Record Control Register 2 */ + +static inline uint32_t _AArch32_Read_erxctlr2( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c5, c4, 5" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_erxctlr2( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c5, c4, 5" : : "r" ( value ) : "memory" + ); +} + +/* ERXFR, Selected Error Record Feature Register */ + +static inline uint32_t _AArch32_Read_erxfr( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c5, c4, 0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +/* ERXFR2, Selected Error Record Feature Register 2 */ + +static inline uint32_t _AArch32_Read_erxfr2( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c5, c4, 4" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +/* ERXMISC0, Selected Error Record Miscellaneous Register 0 */ + +static inline uint32_t _AArch32_Read_erxmisc0( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c5, c5, 0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_erxmisc0( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c5, c5, 0" : : "r" ( value ) : "memory" + ); +} + +/* ERXMISC1, Selected Error Record Miscellaneous Register 1 */ + +static inline uint32_t _AArch32_Read_erxmisc1( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c5, c5, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_erxmisc1( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c5, c5, 1" : : "r" ( value ) : "memory" + ); +} + +/* ERXMISC2, Selected Error Record Miscellaneous Register 2 */ + +static inline uint32_t _AArch32_Read_erxmisc2( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c5, c5, 4" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_erxmisc2( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c5, c5, 4" : : "r" ( value ) : "memory" + ); +} + +/* ERXMISC3, Selected Error Record Miscellaneous Register 3 */ + +static inline uint32_t _AArch32_Read_erxmisc3( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c5, c5, 5" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_erxmisc3( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c5, c5, 5" : : "r" ( value ) : "memory" + ); +} + +/* ERXMISC4, Selected Error Record Miscellaneous Register 4 */ + +static inline uint32_t _AArch32_Read_erxmisc4( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c5, c5, 2" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_erxmisc4( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c5, c5, 2" : : "r" ( value ) : "memory" + ); +} + +/* ERXMISC5, Selected Error Record Miscellaneous Register 5 */ + +static inline uint32_t _AArch32_Read_erxmisc5( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c5, c5, 3" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_erxmisc5( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c5, c5, 3" : : "r" ( value ) : "memory" + ); +} + +/* ERXMISC6, Selected Error Record Miscellaneous Register 6 */ + +static inline uint32_t _AArch32_Read_erxmisc6( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c5, c5, 6" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_erxmisc6( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c5, c5, 6" : : "r" ( value ) : "memory" + ); +} + +/* ERXMISC7, Selected Error Record Miscellaneous Register 7 */ + +static inline uint32_t _AArch32_Read_erxmisc7( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c5, c5, 7" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_erxmisc7( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c5, c5, 7" : : "r" ( value ) : "memory" + ); +} + +/* ERXSTATUS, Selected Error Record Primary Status Register */ + +static inline uint32_t _AArch32_Read_erxstatus( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c5, c4, 2" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_erxstatus( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c5, c4, 2" : : "r" ( value ) : "memory" + ); +} + +/* VDFSR, Virtual SError Exception Syndrome Register */ + +#define AARCH32_VDFSR_EXT 0x1000U + +#define AARCH32_VDFSR_AET( _val ) ( ( _val ) << 14 ) +#define AARCH32_VDFSR_AET_SHIFT 14 +#define AARCH32_VDFSR_AET_MASK 0xc000U +#define AARCH32_VDFSR_AET_GET( _reg ) \ + ( ( ( _reg ) >> 14 ) & 0x3U ) + +static inline uint32_t _AArch32_Read_vdfsr( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 4, %0, c5, c2, 3" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_vdfsr( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 4, %0, c5, c2, 3" : : "r" ( value ) : "memory" + ); +} + +/* VDISR, Virtual Deferred Interrupt Status Register */ + +#define AARCH32_VDISR_FS_3_0( _val ) ( ( _val ) << 0 ) +#define AARCH32_VDISR_FS_3_0_SHIFT 0 +#define AARCH32_VDISR_FS_3_0_MASK 0xfU +#define AARCH32_VDISR_FS_3_0_GET( _reg ) \ + ( ( ( _reg ) >> 0 ) & 0xfU ) + +#define AARCH32_VDISR_STATUS( _val ) ( ( _val ) << 0 ) +#define AARCH32_VDISR_STATUS_SHIFT 0 +#define AARCH32_VDISR_STATUS_MASK 0x3fU +#define AARCH32_VDISR_STATUS_GET( _reg ) \ + ( ( ( _reg ) >> 0 ) & 0x3fU ) + +#define AARCH32_VDISR_LPAE 0x200U + +#define AARCH32_VDISR_FS_4 0x400U + +#define AARCH32_VDISR_EXT 0x1000U + +#define AARCH32_VDISR_AET( _val ) ( ( _val ) << 14 ) +#define AARCH32_VDISR_AET_SHIFT 14 +#define AARCH32_VDISR_AET_MASK 0xc000U +#define AARCH32_VDISR_AET_GET( _reg ) \ + ( ( ( _reg ) >> 14 ) & 0x3U ) + +#define AARCH32_VDISR_A 0x80000000U + +static inline uint32_t _AArch32_Read_vdisr( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 4, %0, c12, c1, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_vdisr( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 4, %0, c12, c1, 1" : : "r" ( value ) : "memory" + ); +} + +/* CNTFRQ, Counter-timer Frequency Register */ + +static inline uint32_t _AArch32_Read_cntfrq( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c14, c0, 0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_cntfrq( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c14, c0, 0" : : "r" ( value ) : "memory" + ); +} + +/* CNTHCTL, Counter-timer Hyp Control Register */ + +#define AARCH32_CNTHCTL_PL1PCTEN 0x1U + +#define AARCH32_CNTHCTL_PL1PCEN 0x2U + +#define AARCH32_CNTHCTL_EVNTEN 0x4U + +#define AARCH32_CNTHCTL_EVNTDIR 0x8U + +#define AARCH32_CNTHCTL_EVNTI( _val ) ( ( _val ) << 4 ) +#define AARCH32_CNTHCTL_EVNTI_SHIFT 4 +#define AARCH32_CNTHCTL_EVNTI_MASK 0xf0U +#define AARCH32_CNTHCTL_EVNTI_GET( _reg ) \ + ( ( ( _reg ) >> 4 ) & 0xfU ) + +#define AARCH32_CNTHCTL_EVNTIS 0x20000U + +static inline uint32_t _AArch32_Read_cnthctl( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 4, %0, c14, c1, 0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_cnthctl( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 4, %0, c14, c1, 0" : : "r" ( value ) : "memory" + ); +} + +/* CNTHP_CTL, Counter-timer Hyp Physical Timer Control Register */ + +#define AARCH32_CNTHP_CTL_ENABLE 0x1U + +#define AARCH32_CNTHP_CTL_IMASK 0x2U + +#define AARCH32_CNTHP_CTL_ISTATUS 0x4U + +static inline uint32_t _AArch32_Read_cnthp_ctl( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 4, %0, c14, c2, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_cnthp_ctl( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 4, %0, c14, c2, 1" : : "r" ( value ) : "memory" + ); +} + +/* CNTHP_CVAL, Counter-timer Hyp Physical CompareValue Register */ + +static inline uint64_t _AArch32_Read_cnthp_cval( void ) +{ + uint64_t value; + + __asm__ volatile ( + "mrrc p15, 6, %Q0, %R0, c14" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_cnthp_cval( uint64_t value ) +{ + __asm__ volatile ( + "mcrr p15, 6, %Q0, %R0, c14" : : "r" ( value ) : "memory" + ); +} + +/* CNTHP_TVAL, Counter-timer Hyp Physical Timer TimerValue Register */ + +static inline uint32_t _AArch32_Read_cnthp_tval( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 4, %0, c14, c2, 0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_cnthp_tval( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 4, %0, c14, c2, 0" : : "r" ( value ) : "memory" + ); +} + +/* CNTHPS_CTL, Counter-timer Secure Physical Timer Control Register (EL2) */ + +#define AARCH32_CNTHPS_CTL_ENABLE 0x1U + +#define AARCH32_CNTHPS_CTL_IMASK 0x2U + +#define AARCH32_CNTHPS_CTL_ISTATUS 0x4U + +static inline uint32_t _AArch32_Read_cnthps_ctl( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c14, c2, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_cnthps_ctl( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c14, c2, 1" : : "r" ( value ) : "memory" + ); +} + +/* CNTHPS_CVAL, Counter-timer Secure Physical Timer CompareValue Register (EL2) */ + +static inline uint64_t _AArch32_Read_cnthps_cval( void ) +{ + uint64_t value; + + __asm__ volatile ( + "mrrc p15, 2, %Q0, %R0, c14" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_cnthps_cval( uint64_t value ) +{ + __asm__ volatile ( + "mcrr p15, 2, %Q0, %R0, c14" : : "r" ( value ) : "memory" + ); +} + +/* CNTHPS_TVAL, Counter-timer Secure Physical Timer TimerValue Register (EL2) */ + +static inline uint32_t _AArch32_Read_cnthps_tval( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c14, c2, 0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_cnthps_tval( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c14, c2, 0" : : "r" ( value ) : "memory" + ); +} + +/* CNTHV_CTL, Counter-timer Virtual Timer Control Register (EL2) */ + +#define AARCH32_CNTHV_CTL_ENABLE 0x1U + +#define AARCH32_CNTHV_CTL_IMASK 0x2U + +#define AARCH32_CNTHV_CTL_ISTATUS 0x4U + +static inline uint32_t _AArch32_Read_cnthv_ctl( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c14, c3, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_cnthv_ctl( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c14, c3, 1" : : "r" ( value ) : "memory" + ); +} + +/* CNTHV_CVAL, Counter-timer Virtual Timer CompareValue Register (EL2) */ + +static inline uint64_t _AArch32_Read_cnthv_cval( void ) +{ + uint64_t value; + + __asm__ volatile ( + "mrrc p15, 3, %Q0, %R0, c14" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_cnthv_cval( uint64_t value ) +{ + __asm__ volatile ( + "mcrr p15, 3, %Q0, %R0, c14" : : "r" ( value ) : "memory" + ); +} + +/* CNTHV_TVAL, Counter-timer Virtual Timer TimerValue Register (EL2) */ + +static inline uint32_t _AArch32_Read_cnthv_tval( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c14, c3, 0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_cnthv_tval( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c14, c3, 0" : : "r" ( value ) : "memory" + ); +} + +/* CNTHVS_CTL, Counter-timer Secure Virtual Timer Control Register (EL2) */ + +#define AARCH32_CNTHVS_CTL_ENABLE 0x1U + +#define AARCH32_CNTHVS_CTL_IMASK 0x2U + +#define AARCH32_CNTHVS_CTL_ISTATUS 0x4U + +static inline uint32_t _AArch32_Read_cnthvs_ctl( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c14, c3, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_cnthvs_ctl( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c14, c3, 1" : : "r" ( value ) : "memory" + ); +} + +/* CNTHVS_CVAL, Counter-timer Secure Virtual Timer CompareValue Register (EL2) */ + +static inline uint64_t _AArch32_Read_cnthvs_cval( void ) +{ + uint64_t value; + + __asm__ volatile ( + "mrrc p15, 3, %Q0, %R0, c14" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_cnthvs_cval( uint64_t value ) +{ + __asm__ volatile ( + "mcrr p15, 3, %Q0, %R0, c14" : : "r" ( value ) : "memory" + ); +} + +/* CNTHVS_TVAL, Counter-timer Secure Virtual Timer TimerValue Register (EL2) */ + +static inline uint32_t _AArch32_Read_cnthvs_tval( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c14, c3, 0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_cnthvs_tval( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c14, c3, 0" : : "r" ( value ) : "memory" + ); +} + +/* CNTKCTL, Counter-timer Kernel Control Register */ + +#define AARCH32_CNTKCTL_PL0PCTEN 0x1U + +#define AARCH32_CNTKCTL_PL0VCTEN 0x2U + +#define AARCH32_CNTKCTL_EVNTEN 0x4U + +#define AARCH32_CNTKCTL_EVNTDIR 0x8U + +#define AARCH32_CNTKCTL_EVNTI( _val ) ( ( _val ) << 4 ) +#define AARCH32_CNTKCTL_EVNTI_SHIFT 4 +#define AARCH32_CNTKCTL_EVNTI_MASK 0xf0U +#define AARCH32_CNTKCTL_EVNTI_GET( _reg ) \ + ( ( ( _reg ) >> 4 ) & 0xfU ) + +#define AARCH32_CNTKCTL_PL0VTEN 0x100U + +#define AARCH32_CNTKCTL_PL0PTEN 0x200U + +#define AARCH32_CNTKCTL_EVNTIS 0x20000U + +static inline uint32_t _AArch32_Read_cntkctl( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c14, c1, 0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_cntkctl( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c14, c1, 0" : : "r" ( value ) : "memory" + ); +} + +/* CNTP_CTL, Counter-timer Physical Timer Control Register */ + +#define AARCH32_CNTP_CTL_ENABLE 0x1U + +#define AARCH32_CNTP_CTL_IMASK 0x2U + +#define AARCH32_CNTP_CTL_ISTATUS 0x4U + +static inline uint32_t _AArch32_Read_cntp_ctl( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c14, c2, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_cntp_ctl( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c14, c2, 1" : : "r" ( value ) : "memory" + ); +} + +/* CNTP_CVAL, Counter-timer Physical Timer CompareValue Register */ + +static inline uint64_t _AArch32_Read_cntp_cval( void ) +{ + uint64_t value; + + __asm__ volatile ( + "mrrc p15, 2, %Q0, %R0, c14" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_cntp_cval( uint64_t value ) +{ + __asm__ volatile ( + "mcrr p15, 2, %Q0, %R0, c14" : : "r" ( value ) : "memory" + ); +} + +/* CNTP_TVAL, Counter-timer Physical Timer TimerValue Register */ + +static inline uint32_t _AArch32_Read_cntp_tval( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c14, c2, 0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_cntp_tval( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c14, c2, 0" : : "r" ( value ) : "memory" + ); +} + +/* CNTPCT, Counter-timer Physical Count Register */ + +static inline uint64_t _AArch32_Read_cntpct( void ) +{ + uint64_t value; + + __asm__ volatile ( + "mrrc p15, 0, %Q0, %R0, c14" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +/* CNTPCTSS, Counter-timer Self-Synchronized Physical Count Register */ + +static inline uint64_t _AArch32_Read_cntpctss( void ) +{ + uint64_t value; + + __asm__ volatile ( + "mrrc p15, 8, %Q0, %R0, c14" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +/* CNTV_CTL, Counter-timer Virtual Timer Control Register */ + +#define AARCH32_CNTV_CTL_ENABLE 0x1U + +#define AARCH32_CNTV_CTL_IMASK 0x2U + +#define AARCH32_CNTV_CTL_ISTATUS 0x4U + +static inline uint32_t _AArch32_Read_cntv_ctl( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c14, c3, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_cntv_ctl( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c14, c3, 1" : : "r" ( value ) : "memory" + ); +} + +/* CNTV_CVAL, Counter-timer Virtual Timer CompareValue Register */ + +static inline uint64_t _AArch32_Read_cntv_cval( void ) +{ + uint64_t value; + + __asm__ volatile ( + "mrrc p15, 3, %Q0, %R0, c14" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_cntv_cval( uint64_t value ) +{ + __asm__ volatile ( + "mcrr p15, 3, %Q0, %R0, c14" : : "r" ( value ) : "memory" + ); +} + +/* CNTV_TVAL, Counter-timer Virtual Timer TimerValue Register */ + +static inline uint32_t _AArch32_Read_cntv_tval( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c14, c3, 0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_cntv_tval( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c14, c3, 0" : : "r" ( value ) : "memory" + ); +} + +/* CNTVCT, Counter-timer Virtual Count Register */ + +static inline uint64_t _AArch32_Read_cntvct( void ) +{ + uint64_t value; + + __asm__ volatile ( + "mrrc p15, 1, %Q0, %R0, c14" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +/* CNTVCTSS, Counter-timer Self-Synchronized Virtual Count Register */ + +static inline uint64_t _AArch32_Read_cntvctss( void ) +{ + uint64_t value; + + __asm__ volatile ( + "mrrc p15, 9, %Q0, %R0, c14" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +/* HMPUIR, Hypervisor MPU Type Register */ + +#define AARCH32_HMPUIR_REGION( _val ) ( ( _val ) << 0 ) +#define AARCH32_HMPUIR_REGION_SHIFT 0 +#define AARCH32_HMPUIR_REGION_MASK 0xffU +#define AARCH32_HMPUIR_REGION_GET( _reg ) \ + ( ( ( _reg ) >> 0 ) & 0xffU ) + +static inline uint32_t _AArch32_Read_hmpuir( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 4, %0, c0, c0, 4" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_hmpuir( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 4, %0, c0, c0, 4" : : "r" ( value ) : "memory" + ); +} + +/* HPRBAR, Hypervisor Protection Region Base Address Register */ + +#define AARCH32_HPRBAR_XN 0x1U + +#define AARCH32_HPRBAR_AP_2_1( _val ) ( ( _val ) << 1 ) +#define AARCH32_HPRBAR_AP_2_1_SHIFT 1 +#define AARCH32_HPRBAR_AP_2_1_MASK 0x6U +#define AARCH32_HPRBAR_AP_2_1_GET( _reg ) \ + ( ( ( _reg ) >> 1 ) & 0x3U ) + +#define AARCH32_HPRBAR_SH_1_0( _val ) ( ( _val ) << 3 ) +#define AARCH32_HPRBAR_SH_1_0_SHIFT 3 +#define AARCH32_HPRBAR_SH_1_0_MASK 0x18U +#define AARCH32_HPRBAR_SH_1_0_GET( _reg ) \ + ( ( ( _reg ) >> 3 ) & 0x3U ) + +#define AARCH32_HPRBAR_BASE( _val ) ( ( _val ) << 6 ) +#define AARCH32_HPRBAR_BASE_SHIFT 6 +#define AARCH32_HPRBAR_BASE_MASK 0xffffffc0U +#define AARCH32_HPRBAR_BASE_GET( _reg ) \ + ( ( ( _reg ) >> 6 ) & 0x3ffffffU ) + +static inline uint32_t _AArch32_Read_hprbar( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 4, %0, c6, c3, 0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_hprbar( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 4, %0, c6, c3, 0" : : "r" ( value ) : "memory" + ); +} + +/* HPRBAR_0, Hypervisor Protection Region Base Address Registers */ + +static inline uint32_t _AArch32_Read_hprbar_0( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 4, %0, c6, c8, 0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_hprbar_0( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 4, %0, c6, c8, 0" : : "r" ( value ) : "memory" + ); +} + +/* HPRBAR_1, Hypervisor Protection Region Base Address Registers */ + +static inline uint32_t _AArch32_Read_hprbar_1( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 4, %0, c6, c8, 4" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_hprbar_1( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 4, %0, c6, c8, 4" : : "r" ( value ) : "memory" + ); +} + +/* HPRBAR_2, Hypervisor Protection Region Base Address Registers */ + +static inline uint32_t _AArch32_Read_hprbar_2( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 4, %0, c6, c9, 0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_hprbar_2( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 4, %0, c6, c9, 0" : : "r" ( value ) : "memory" + ); +} + +/* HPRBAR_3, Hypervisor Protection Region Base Address Registers */ + +static inline uint32_t _AArch32_Read_hprbar_3( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 4, %0, c6, c9, 4" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_hprbar_3( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 4, %0, c6, c9, 4" : : "r" ( value ) : "memory" + ); +} + +/* HPRBAR_4, Hypervisor Protection Region Base Address Registers */ + +static inline uint32_t _AArch32_Read_hprbar_4( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 4, %0, c6, c10, 0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_hprbar_4( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 4, %0, c6, c10, 0" : : "r" ( value ) : "memory" + ); +} + +/* HPRBAR_5, Hypervisor Protection Region Base Address Registers */ + +static inline uint32_t _AArch32_Read_hprbar_5( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 4, %0, c6, c10, 4" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_hprbar_5( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 4, %0, c6, c10, 4" : : "r" ( value ) : "memory" + ); +} + +/* HPRBAR_6, Hypervisor Protection Region Base Address Registers */ + +static inline uint32_t _AArch32_Read_hprbar_6( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 4, %0, c6, c11, 0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_hprbar_6( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 4, %0, c6, c11, 0" : : "r" ( value ) : "memory" + ); +} + +/* HPRBAR_7, Hypervisor Protection Region Base Address Registers */ + +static inline uint32_t _AArch32_Read_hprbar_7( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 4, %0, c6, c11, 4" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_hprbar_7( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 4, %0, c6, c11, 4" : : "r" ( value ) : "memory" + ); +} + +/* HPRBAR_8, Hypervisor Protection Region Base Address Registers */ + +static inline uint32_t _AArch32_Read_hprbar_8( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 4, %0, c6, c12, 0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_hprbar_8( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 4, %0, c6, c12, 0" : : "r" ( value ) : "memory" + ); +} + +/* HPRBAR_9, Hypervisor Protection Region Base Address Registers */ + +static inline uint32_t _AArch32_Read_hprbar_9( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 4, %0, c6, c12, 4" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_hprbar_9( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 4, %0, c6, c12, 4" : : "r" ( value ) : "memory" + ); +} + +/* HPRBAR_10, Hypervisor Protection Region Base Address Registers */ + +static inline uint32_t _AArch32_Read_hprbar_10( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 4, %0, c6, c13, 0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_hprbar_10( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 4, %0, c6, c13, 0" : : "r" ( value ) : "memory" + ); +} + +/* HPRBAR_11, Hypervisor Protection Region Base Address Registers */ + +static inline uint32_t _AArch32_Read_hprbar_11( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 4, %0, c6, c13, 4" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_hprbar_11( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 4, %0, c6, c13, 4" : : "r" ( value ) : "memory" + ); +} + +/* HPRBAR_12, Hypervisor Protection Region Base Address Registers */ + +static inline uint32_t _AArch32_Read_hprbar_12( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 4, %0, c6, c14, 0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_hprbar_12( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 4, %0, c6, c14, 0" : : "r" ( value ) : "memory" + ); +} + +/* HPRBAR_13, Hypervisor Protection Region Base Address Registers */ + +static inline uint32_t _AArch32_Read_hprbar_13( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 4, %0, c6, c14, 4" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_hprbar_13( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 4, %0, c6, c14, 4" : : "r" ( value ) : "memory" + ); +} + +/* HPRBAR_14, Hypervisor Protection Region Base Address Registers */ + +static inline uint32_t _AArch32_Read_hprbar_14( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 4, %0, c6, c15, 0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_hprbar_14( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 4, %0, c6, c15, 0" : : "r" ( value ) : "memory" + ); +} + +/* HPRBAR_15, Hypervisor Protection Region Base Address Registers */ + +static inline uint32_t _AArch32_Read_hprbar_15( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 4, %0, c6, c15, 4" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_hprbar_15( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 4, %0, c6, c15, 4" : : "r" ( value ) : "memory" + ); +} + +/* HPRBAR_16, Hypervisor Protection Region Base Address Registers */ + +static inline uint32_t _AArch32_Read_hprbar_16( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 5, %0, c6, c8, 0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_hprbar_16( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 5, %0, c6, c8, 0" : : "r" ( value ) : "memory" + ); +} + +/* HPRBAR_17, Hypervisor Protection Region Base Address Registers */ + +static inline uint32_t _AArch32_Read_hprbar_17( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 5, %0, c6, c8, 4" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_hprbar_17( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 5, %0, c6, c8, 4" : : "r" ( value ) : "memory" + ); +} + +/* HPRBAR_18, Hypervisor Protection Region Base Address Registers */ + +static inline uint32_t _AArch32_Read_hprbar_18( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 5, %0, c6, c9, 0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_hprbar_18( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 5, %0, c6, c9, 0" : : "r" ( value ) : "memory" + ); +} + +/* HPRBAR_19, Hypervisor Protection Region Base Address Registers */ + +static inline uint32_t _AArch32_Read_hprbar_19( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 5, %0, c6, c9, 4" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_hprbar_19( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 5, %0, c6, c9, 4" : : "r" ( value ) : "memory" + ); +} + +/* HPRBAR_20, Hypervisor Protection Region Base Address Registers */ + +static inline uint32_t _AArch32_Read_hprbar_20( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 5, %0, c6, c10, 0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_hprbar_20( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 5, %0, c6, c10, 0" : : "r" ( value ) : "memory" + ); +} + +/* HPRBAR_21, Hypervisor Protection Region Base Address Registers */ + +static inline uint32_t _AArch32_Read_hprbar_21( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 5, %0, c6, c10, 4" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_hprbar_21( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 5, %0, c6, c10, 4" : : "r" ( value ) : "memory" + ); +} + +/* HPRBAR_22, Hypervisor Protection Region Base Address Registers */ + +static inline uint32_t _AArch32_Read_hprbar_22( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 5, %0, c6, c11, 0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_hprbar_22( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 5, %0, c6, c11, 0" : : "r" ( value ) : "memory" + ); +} + +/* HPRBAR_23, Hypervisor Protection Region Base Address Registers */ + +static inline uint32_t _AArch32_Read_hprbar_23( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 5, %0, c6, c11, 4" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_hprbar_23( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 5, %0, c6, c11, 4" : : "r" ( value ) : "memory" + ); +} + +/* HPRBAR_24, Hypervisor Protection Region Base Address Registers */ + +static inline uint32_t _AArch32_Read_hprbar_24( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 5, %0, c6, c12, 0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_hprbar_24( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 5, %0, c6, c12, 0" : : "r" ( value ) : "memory" + ); +} + +/* HPRBAR_25, Hypervisor Protection Region Base Address Registers */ + +static inline uint32_t _AArch32_Read_hprbar_25( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 5, %0, c6, c12, 4" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_hprbar_25( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 5, %0, c6, c12, 4" : : "r" ( value ) : "memory" + ); +} + +/* HPRBAR_26, Hypervisor Protection Region Base Address Registers */ + +static inline uint32_t _AArch32_Read_hprbar_26( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 5, %0, c6, c13, 0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_hprbar_26( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 5, %0, c6, c13, 0" : : "r" ( value ) : "memory" + ); +} + +/* HPRBAR_27, Hypervisor Protection Region Base Address Registers */ + +static inline uint32_t _AArch32_Read_hprbar_27( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 5, %0, c6, c13, 4" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_hprbar_27( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 5, %0, c6, c13, 4" : : "r" ( value ) : "memory" + ); +} + +/* HPRBAR_28, Hypervisor Protection Region Base Address Registers */ + +static inline uint32_t _AArch32_Read_hprbar_28( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 5, %0, c6, c14, 0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_hprbar_28( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 5, %0, c6, c14, 0" : : "r" ( value ) : "memory" + ); +} + +/* HPRBAR_29, Hypervisor Protection Region Base Address Registers */ + +static inline uint32_t _AArch32_Read_hprbar_29( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 5, %0, c6, c14, 4" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_hprbar_29( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 5, %0, c6, c14, 4" : : "r" ( value ) : "memory" + ); +} + +/* HPRBAR_30, Hypervisor Protection Region Base Address Registers */ + +static inline uint32_t _AArch32_Read_hprbar_30( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 5, %0, c6, c15, 0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_hprbar_30( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 5, %0, c6, c15, 0" : : "r" ( value ) : "memory" + ); +} + +/* HPRBAR_31, Hypervisor Protection Region Base Address Registers */ + +static inline uint32_t _AArch32_Read_hprbar_31( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 5, %0, c6, c15, 4" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_hprbar_31( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 5, %0, c6, c15, 4" : : "r" ( value ) : "memory" + ); +} + +/* HPRENR, Hypervisor Protection Region Enable Register */ + +static inline uint32_t _AArch32_Read_hprenr( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 4, %0, c6, c1, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_hprenr( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 4, %0, c6, c1, 1" : : "r" ( value ) : "memory" + ); +} + +/* HPRLAR, Hypervisor Protection Region Limit Address Register */ + +#define AARCH32_HPRLAR_EN 0x1U + +#define AARCH32_HPRLAR_ATTRINDX_2_0( _val ) ( ( _val ) << 1 ) +#define AARCH32_HPRLAR_ATTRINDX_2_0_SHIFT 1 +#define AARCH32_HPRLAR_ATTRINDX_2_0_MASK 0xeU +#define AARCH32_HPRLAR_ATTRINDX_2_0_GET( _reg ) \ + ( ( ( _reg ) >> 1 ) & 0x7U ) + +#define AARCH32_HPRLAR_LIMIT( _val ) ( ( _val ) << 6 ) +#define AARCH32_HPRLAR_LIMIT_SHIFT 6 +#define AARCH32_HPRLAR_LIMIT_MASK 0xffffffc0U +#define AARCH32_HPRLAR_LIMIT_GET( _reg ) \ + ( ( ( _reg ) >> 6 ) & 0x3ffffffU ) + +static inline uint32_t _AArch32_Read_hprlar( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 4, %0, c6, c3, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_hprlar( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 4, %0, c6, c3, 1" : : "r" ( value ) : "memory" + ); +} + +/* HPRLAR_0, Hypervisor Protection Region Limit Address Registers */ + +static inline uint32_t _AArch32_Read_hprlar_0( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 4, %0, c6, c8, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_hprlar_0( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 4, %0, c6, c8, 1" : : "r" ( value ) : "memory" + ); +} + +/* HPRLAR_1, Hypervisor Protection Region Limit Address Registers */ + +static inline uint32_t _AArch32_Read_hprlar_1( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 4, %0, c6, c8, 5" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_hprlar_1( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 4, %0, c6, c8, 5" : : "r" ( value ) : "memory" + ); +} + +/* HPRLAR_2, Hypervisor Protection Region Limit Address Registers */ + +static inline uint32_t _AArch32_Read_hprlar_2( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 4, %0, c6, c9, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_hprlar_2( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 4, %0, c6, c9, 1" : : "r" ( value ) : "memory" + ); +} + +/* HPRLAR_3, Hypervisor Protection Region Limit Address Registers */ + +static inline uint32_t _AArch32_Read_hprlar_3( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 4, %0, c6, c9, 5" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_hprlar_3( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 4, %0, c6, c9, 5" : : "r" ( value ) : "memory" + ); +} + +/* HPRLAR_4, Hypervisor Protection Region Limit Address Registers */ + +static inline uint32_t _AArch32_Read_hprlar_4( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 4, %0, c6, c10, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_hprlar_4( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 4, %0, c6, c10, 1" : : "r" ( value ) : "memory" + ); +} + +/* HPRLAR_5, Hypervisor Protection Region Limit Address Registers */ + +static inline uint32_t _AArch32_Read_hprlar_5( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 4, %0, c6, c10, 5" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_hprlar_5( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 4, %0, c6, c10, 5" : : "r" ( value ) : "memory" + ); +} + +/* HPRLAR_6, Hypervisor Protection Region Limit Address Registers */ + +static inline uint32_t _AArch32_Read_hprlar_6( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 4, %0, c6, c11, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_hprlar_6( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 4, %0, c6, c11, 1" : : "r" ( value ) : "memory" + ); +} + +/* HPRLAR_7, Hypervisor Protection Region Limit Address Registers */ + +static inline uint32_t _AArch32_Read_hprlar_7( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 4, %0, c6, c11, 5" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_hprlar_7( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 4, %0, c6, c11, 5" : : "r" ( value ) : "memory" + ); +} + +/* HPRLAR_8, Hypervisor Protection Region Limit Address Registers */ + +static inline uint32_t _AArch32_Read_hprlar_8( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 4, %0, c6, c12, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_hprlar_8( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 4, %0, c6, c12, 1" : : "r" ( value ) : "memory" + ); +} + +/* HPRLAR_9, Hypervisor Protection Region Limit Address Registers */ + +static inline uint32_t _AArch32_Read_hprlar_9( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 4, %0, c6, c12, 5" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_hprlar_9( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 4, %0, c6, c12, 5" : : "r" ( value ) : "memory" + ); +} + +/* HPRLAR_10, Hypervisor Protection Region Limit Address Registers */ + +static inline uint32_t _AArch32_Read_hprlar_10( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 4, %0, c6, c13, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_hprlar_10( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 4, %0, c6, c13, 1" : : "r" ( value ) : "memory" + ); +} + +/* HPRLAR_11, Hypervisor Protection Region Limit Address Registers */ + +static inline uint32_t _AArch32_Read_hprlar_11( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 4, %0, c6, c13, 5" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_hprlar_11( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 4, %0, c6, c13, 5" : : "r" ( value ) : "memory" + ); +} + +/* HPRLAR_12, Hypervisor Protection Region Limit Address Registers */ + +static inline uint32_t _AArch32_Read_hprlar_12( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 4, %0, c6, c14, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_hprlar_12( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 4, %0, c6, c14, 1" : : "r" ( value ) : "memory" + ); +} + +/* HPRLAR_13, Hypervisor Protection Region Limit Address Registers */ + +static inline uint32_t _AArch32_Read_hprlar_13( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 4, %0, c6, c14, 5" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_hprlar_13( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 4, %0, c6, c14, 5" : : "r" ( value ) : "memory" + ); +} + +/* HPRLAR_14, Hypervisor Protection Region Limit Address Registers */ + +static inline uint32_t _AArch32_Read_hprlar_14( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 4, %0, c6, c15, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_hprlar_14( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 4, %0, c6, c15, 1" : : "r" ( value ) : "memory" + ); +} + +/* HPRLAR_15, Hypervisor Protection Region Limit Address Registers */ + +static inline uint32_t _AArch32_Read_hprlar_15( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 4, %0, c6, c15, 5" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_hprlar_15( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 4, %0, c6, c15, 5" : : "r" ( value ) : "memory" + ); +} + +/* HPRLAR_16, Hypervisor Protection Region Limit Address Registers */ + +static inline uint32_t _AArch32_Read_hprlar_16( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 5, %0, c6, c8, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_hprlar_16( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 5, %0, c6, c8, 1" : : "r" ( value ) : "memory" + ); +} + +/* HPRLAR_17, Hypervisor Protection Region Limit Address Registers */ + +static inline uint32_t _AArch32_Read_hprlar_17( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 5, %0, c6, c8, 5" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_hprlar_17( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 5, %0, c6, c8, 5" : : "r" ( value ) : "memory" + ); +} + +/* HPRLAR_18, Hypervisor Protection Region Limit Address Registers */ + +static inline uint32_t _AArch32_Read_hprlar_18( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 5, %0, c6, c9, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_hprlar_18( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 5, %0, c6, c9, 1" : : "r" ( value ) : "memory" + ); +} + +/* HPRLAR_19, Hypervisor Protection Region Limit Address Registers */ + +static inline uint32_t _AArch32_Read_hprlar_19( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 5, %0, c6, c9, 5" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_hprlar_19( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 5, %0, c6, c9, 5" : : "r" ( value ) : "memory" + ); +} + +/* HPRLAR_20, Hypervisor Protection Region Limit Address Registers */ + +static inline uint32_t _AArch32_Read_hprlar_20( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 5, %0, c6, c10, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_hprlar_20( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 5, %0, c6, c10, 1" : : "r" ( value ) : "memory" + ); +} + +/* HPRLAR_21, Hypervisor Protection Region Limit Address Registers */ + +static inline uint32_t _AArch32_Read_hprlar_21( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 5, %0, c6, c10, 5" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_hprlar_21( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 5, %0, c6, c10, 5" : : "r" ( value ) : "memory" + ); +} + +/* HPRLAR_22, Hypervisor Protection Region Limit Address Registers */ + +static inline uint32_t _AArch32_Read_hprlar_22( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 5, %0, c6, c11, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_hprlar_22( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 5, %0, c6, c11, 1" : : "r" ( value ) : "memory" + ); +} + +/* HPRLAR_23, Hypervisor Protection Region Limit Address Registers */ + +static inline uint32_t _AArch32_Read_hprlar_23( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 5, %0, c6, c11, 5" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_hprlar_23( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 5, %0, c6, c11, 5" : : "r" ( value ) : "memory" + ); +} + +/* HPRLAR_24, Hypervisor Protection Region Limit Address Registers */ + +static inline uint32_t _AArch32_Read_hprlar_24( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 5, %0, c6, c12, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_hprlar_24( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 5, %0, c6, c12, 1" : : "r" ( value ) : "memory" + ); +} + +/* HPRLAR_25, Hypervisor Protection Region Limit Address Registers */ + +static inline uint32_t _AArch32_Read_hprlar_25( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 5, %0, c6, c12, 5" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_hprlar_25( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 5, %0, c6, c12, 5" : : "r" ( value ) : "memory" + ); +} + +/* HPRLAR_26, Hypervisor Protection Region Limit Address Registers */ + +static inline uint32_t _AArch32_Read_hprlar_26( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 5, %0, c6, c13, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_hprlar_26( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 5, %0, c6, c13, 1" : : "r" ( value ) : "memory" + ); +} + +/* HPRLAR_27, Hypervisor Protection Region Limit Address Registers */ + +static inline uint32_t _AArch32_Read_hprlar_27( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 5, %0, c6, c13, 5" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_hprlar_27( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 5, %0, c6, c13, 5" : : "r" ( value ) : "memory" + ); +} + +/* HPRLAR_28, Hypervisor Protection Region Limit Address Registers */ + +static inline uint32_t _AArch32_Read_hprlar_28( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 5, %0, c6, c14, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_hprlar_28( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 5, %0, c6, c14, 1" : : "r" ( value ) : "memory" + ); +} + +/* HPRLAR_29, Hypervisor Protection Region Limit Address Registers */ + +static inline uint32_t _AArch32_Read_hprlar_29( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 5, %0, c6, c14, 5" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_hprlar_29( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 5, %0, c6, c14, 5" : : "r" ( value ) : "memory" + ); +} + +/* HPRLAR_30, Hypervisor Protection Region Limit Address Registers */ + +static inline uint32_t _AArch32_Read_hprlar_30( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 5, %0, c6, c15, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_hprlar_30( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 5, %0, c6, c15, 1" : : "r" ( value ) : "memory" + ); +} + +/* HPRLAR_31, Hypervisor Protection Region Limit Address Registers */ + +static inline uint32_t _AArch32_Read_hprlar_31( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 5, %0, c6, c15, 5" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_hprlar_31( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 5, %0, c6, c15, 5" : : "r" ( value ) : "memory" + ); +} + +/* HPRSELR, Hypervisor Protection Region Selector Register */ + +#define AARCH32_HPRSELR_REGION( _val ) ( ( _val ) << 0 ) +#define AARCH32_HPRSELR_REGION_SHIFT 0 +#define AARCH32_HPRSELR_REGION_MASK 0xffU +#define AARCH32_HPRSELR_REGION_GET( _reg ) \ + ( ( ( _reg ) >> 0 ) & 0xffU ) + +static inline uint32_t _AArch32_Read_hprselr( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 4, %0, c6, c2, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_hprselr( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 4, %0, c6, c2, 1" : : "r" ( value ) : "memory" + ); +} + +/* MPUIR, MPU Type Register */ + +#define AARCH32_MPUIR_REGION( _val ) ( ( _val ) << 8 ) +#define AARCH32_MPUIR_REGION_SHIFT 8 +#define AARCH32_MPUIR_REGION_MASK 0xff00U +#define AARCH32_MPUIR_REGION_GET( _reg ) \ + ( ( ( _reg ) >> 8 ) & 0xffU ) + +static inline uint32_t _AArch32_Read_mpuir( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c0, c0, 4" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_mpuir( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c0, c0, 4" : : "r" ( value ) : "memory" + ); +} + +/* PRBAR, Protection Region Base Address Register */ + +#define AARCH32_PRBAR_XN 0x1U + +#define AARCH32_PRBAR_AP_2_1( _val ) ( ( _val ) << 1 ) +#define AARCH32_PRBAR_AP_2_1_SHIFT 1 +#define AARCH32_PRBAR_AP_2_1_MASK 0x6U +#define AARCH32_PRBAR_AP_2_1_GET( _reg ) \ + ( ( ( _reg ) >> 1 ) & 0x3U ) + +#define AARCH32_PRBAR_SH_1_0( _val ) ( ( _val ) << 3 ) +#define AARCH32_PRBAR_SH_1_0_SHIFT 3 +#define AARCH32_PRBAR_SH_1_0_MASK 0x18U +#define AARCH32_PRBAR_SH_1_0_GET( _reg ) \ + ( ( ( _reg ) >> 3 ) & 0x3U ) + +#define AARCH32_PRBAR_BASE( _val ) ( ( _val ) << 6 ) +#define AARCH32_PRBAR_BASE_SHIFT 6 +#define AARCH32_PRBAR_BASE_MASK 0xffffffc0U +#define AARCH32_PRBAR_BASE_GET( _reg ) \ + ( ( ( _reg ) >> 6 ) & 0x3ffffffU ) + +static inline uint32_t _AArch32_Read_prbar( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c6, c3, 0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_prbar( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c6, c3, 0" : : "r" ( value ) : "memory" + ); +} + +/* PRBAR_0, Protection Region Base Address Registers */ + +static inline uint32_t _AArch32_Read_prbar_0( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c6, c8, 0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_prbar_0( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c6, c8, 0" : : "r" ( value ) : "memory" + ); +} + +/* PRBAR_1, Protection Region Base Address Registers */ + +static inline uint32_t _AArch32_Read_prbar_1( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c6, c8, 4" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_prbar_1( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c6, c8, 4" : : "r" ( value ) : "memory" + ); +} + +/* PRBAR_2, Protection Region Base Address Registers */ + +static inline uint32_t _AArch32_Read_prbar_2( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c6, c9, 0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_prbar_2( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c6, c9, 0" : : "r" ( value ) : "memory" + ); +} + +/* PRBAR_3, Protection Region Base Address Registers */ + +static inline uint32_t _AArch32_Read_prbar_3( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c6, c9, 4" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_prbar_3( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c6, c9, 4" : : "r" ( value ) : "memory" + ); +} + +/* PRBAR_4, Protection Region Base Address Registers */ + +static inline uint32_t _AArch32_Read_prbar_4( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c6, c10, 0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_prbar_4( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c6, c10, 0" : : "r" ( value ) : "memory" + ); +} + +/* PRBAR_5, Protection Region Base Address Registers */ + +static inline uint32_t _AArch32_Read_prbar_5( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c6, c10, 4" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_prbar_5( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c6, c10, 4" : : "r" ( value ) : "memory" + ); +} + +/* PRBAR_6, Protection Region Base Address Registers */ + +static inline uint32_t _AArch32_Read_prbar_6( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c6, c11, 0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_prbar_6( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c6, c11, 0" : : "r" ( value ) : "memory" + ); +} + +/* PRBAR_7, Protection Region Base Address Registers */ + +static inline uint32_t _AArch32_Read_prbar_7( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c6, c11, 4" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_prbar_7( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c6, c11, 4" : : "r" ( value ) : "memory" + ); +} + +/* PRBAR_8, Protection Region Base Address Registers */ + +static inline uint32_t _AArch32_Read_prbar_8( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c6, c12, 0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_prbar_8( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c6, c12, 0" : : "r" ( value ) : "memory" + ); +} + +/* PRBAR_9, Protection Region Base Address Registers */ + +static inline uint32_t _AArch32_Read_prbar_9( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c6, c12, 4" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_prbar_9( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c6, c12, 4" : : "r" ( value ) : "memory" + ); +} + +/* PRBAR_10, Protection Region Base Address Registers */ + +static inline uint32_t _AArch32_Read_prbar_10( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c6, c13, 0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_prbar_10( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c6, c13, 0" : : "r" ( value ) : "memory" + ); +} + +/* PRBAR_11, Protection Region Base Address Registers */ + +static inline uint32_t _AArch32_Read_prbar_11( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c6, c13, 4" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_prbar_11( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c6, c13, 4" : : "r" ( value ) : "memory" + ); +} + +/* PRBAR_12, Protection Region Base Address Registers */ + +static inline uint32_t _AArch32_Read_prbar_12( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c6, c14, 0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_prbar_12( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c6, c14, 0" : : "r" ( value ) : "memory" + ); +} + +/* PRBAR_13, Protection Region Base Address Registers */ + +static inline uint32_t _AArch32_Read_prbar_13( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c6, c14, 4" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_prbar_13( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c6, c14, 4" : : "r" ( value ) : "memory" + ); +} + +/* PRBAR_14, Protection Region Base Address Registers */ + +static inline uint32_t _AArch32_Read_prbar_14( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c6, c15, 0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_prbar_14( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c6, c15, 0" : : "r" ( value ) : "memory" + ); +} + +/* PRBAR_15, Protection Region Base Address Registers */ + +static inline uint32_t _AArch32_Read_prbar_15( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c6, c15, 4" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_prbar_15( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c6, c15, 4" : : "r" ( value ) : "memory" + ); +} + +/* PRBAR_16, Protection Region Base Address Registers */ + +static inline uint32_t _AArch32_Read_prbar_16( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 1, %0, c6, c8, 0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_prbar_16( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 1, %0, c6, c8, 0" : : "r" ( value ) : "memory" + ); +} + +/* PRBAR_17, Protection Region Base Address Registers */ + +static inline uint32_t _AArch32_Read_prbar_17( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 1, %0, c6, c8, 4" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_prbar_17( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 1, %0, c6, c8, 4" : : "r" ( value ) : "memory" + ); +} + +/* PRBAR_18, Protection Region Base Address Registers */ + +static inline uint32_t _AArch32_Read_prbar_18( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 1, %0, c6, c9, 0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_prbar_18( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 1, %0, c6, c9, 0" : : "r" ( value ) : "memory" + ); +} + +/* PRBAR_19, Protection Region Base Address Registers */ + +static inline uint32_t _AArch32_Read_prbar_19( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 1, %0, c6, c9, 4" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_prbar_19( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 1, %0, c6, c9, 4" : : "r" ( value ) : "memory" + ); +} + +/* PRBAR_20, Protection Region Base Address Registers */ + +static inline uint32_t _AArch32_Read_prbar_20( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 1, %0, c6, c10, 0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_prbar_20( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 1, %0, c6, c10, 0" : : "r" ( value ) : "memory" + ); +} + +/* PRBAR_21, Protection Region Base Address Registers */ + +static inline uint32_t _AArch32_Read_prbar_21( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 1, %0, c6, c10, 4" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_prbar_21( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 1, %0, c6, c10, 4" : : "r" ( value ) : "memory" + ); +} + +/* PRBAR_22, Protection Region Base Address Registers */ + +static inline uint32_t _AArch32_Read_prbar_22( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 1, %0, c6, c11, 0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_prbar_22( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 1, %0, c6, c11, 0" : : "r" ( value ) : "memory" + ); +} + +/* PRBAR_23, Protection Region Base Address Registers */ + +static inline uint32_t _AArch32_Read_prbar_23( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 1, %0, c6, c11, 4" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_prbar_23( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 1, %0, c6, c11, 4" : : "r" ( value ) : "memory" + ); +} + +/* PRBAR_24, Protection Region Base Address Registers */ + +static inline uint32_t _AArch32_Read_prbar_24( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 1, %0, c6, c12, 0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_prbar_24( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 1, %0, c6, c12, 0" : : "r" ( value ) : "memory" + ); +} + +/* PRBAR_25, Protection Region Base Address Registers */ + +static inline uint32_t _AArch32_Read_prbar_25( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 1, %0, c6, c12, 4" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_prbar_25( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 1, %0, c6, c12, 4" : : "r" ( value ) : "memory" + ); +} + +/* PRBAR_26, Protection Region Base Address Registers */ + +static inline uint32_t _AArch32_Read_prbar_26( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 1, %0, c6, c13, 0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_prbar_26( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 1, %0, c6, c13, 0" : : "r" ( value ) : "memory" + ); +} + +/* PRBAR_27, Protection Region Base Address Registers */ + +static inline uint32_t _AArch32_Read_prbar_27( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 1, %0, c6, c13, 4" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_prbar_27( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 1, %0, c6, c13, 4" : : "r" ( value ) : "memory" + ); +} + +/* PRBAR_28, Protection Region Base Address Registers */ + +static inline uint32_t _AArch32_Read_prbar_28( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 1, %0, c6, c14, 0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_prbar_28( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 1, %0, c6, c14, 0" : : "r" ( value ) : "memory" + ); +} + +/* PRBAR_29, Protection Region Base Address Registers */ + +static inline uint32_t _AArch32_Read_prbar_29( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 1, %0, c6, c14, 4" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_prbar_29( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 1, %0, c6, c14, 4" : : "r" ( value ) : "memory" + ); +} + +/* PRBAR_30, Protection Region Base Address Registers */ + +static inline uint32_t _AArch32_Read_prbar_30( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 1, %0, c6, c15, 0" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_prbar_30( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 1, %0, c6, c15, 0" : : "r" ( value ) : "memory" + ); +} + +/* PRBAR_31, Protection Region Base Address Registers */ + +static inline uint32_t _AArch32_Read_prbar_31( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 1, %0, c6, c15, 4" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_prbar_31( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 1, %0, c6, c15, 4" : : "r" ( value ) : "memory" + ); +} + +/* PRLAR, Protection Region Limit Address Register */ + +#define AARCH32_PRLAR_EN 0x1U + +#define AARCH32_PRLAR_ATTRINDX_2_0( _val ) ( ( _val ) << 1 ) +#define AARCH32_PRLAR_ATTRINDX_2_0_SHIFT 1 +#define AARCH32_PRLAR_ATTRINDX_2_0_MASK 0xeU +#define AARCH32_PRLAR_ATTRINDX_2_0_GET( _reg ) \ + ( ( ( _reg ) >> 1 ) & 0x7U ) + +#define AARCH32_PRLAR_LIMIT( _val ) ( ( _val ) << 6 ) +#define AARCH32_PRLAR_LIMIT_SHIFT 6 +#define AARCH32_PRLAR_LIMIT_MASK 0xffffffc0U +#define AARCH32_PRLAR_LIMIT_GET( _reg ) \ + ( ( ( _reg ) >> 6 ) & 0x3ffffffU ) + +static inline uint32_t _AArch32_Read_prlar( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c6, c3, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_prlar( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c6, c3, 1" : : "r" ( value ) : "memory" + ); +} + +/* PRLAR_0, Protection Region Limit Address Registers */ + +static inline uint32_t _AArch32_Read_prlar_0( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c6, c8, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_prlar_0( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c6, c8, 1" : : "r" ( value ) : "memory" + ); +} + +/* PRLAR_1, Protection Region Limit Address Registers */ + +static inline uint32_t _AArch32_Read_prlar_1( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c6, c8, 5" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_prlar_1( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c6, c8, 5" : : "r" ( value ) : "memory" + ); +} + +/* PRLAR_2, Protection Region Limit Address Registers */ + +static inline uint32_t _AArch32_Read_prlar_2( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c6, c9, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_prlar_2( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c6, c9, 1" : : "r" ( value ) : "memory" + ); +} + +/* PRLAR_3, Protection Region Limit Address Registers */ + +static inline uint32_t _AArch32_Read_prlar_3( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c6, c9, 5" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_prlar_3( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c6, c9, 5" : : "r" ( value ) : "memory" + ); +} + +/* PRLAR_4, Protection Region Limit Address Registers */ + +static inline uint32_t _AArch32_Read_prlar_4( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c6, c10, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_prlar_4( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c6, c10, 1" : : "r" ( value ) : "memory" + ); +} + +/* PRLAR_5, Protection Region Limit Address Registers */ + +static inline uint32_t _AArch32_Read_prlar_5( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c6, c10, 5" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_prlar_5( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c6, c10, 5" : : "r" ( value ) : "memory" + ); +} + +/* PRLAR_6, Protection Region Limit Address Registers */ + +static inline uint32_t _AArch32_Read_prlar_6( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c6, c11, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_prlar_6( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c6, c11, 1" : : "r" ( value ) : "memory" + ); +} + +/* PRLAR_7, Protection Region Limit Address Registers */ + +static inline uint32_t _AArch32_Read_prlar_7( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c6, c11, 5" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_prlar_7( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c6, c11, 5" : : "r" ( value ) : "memory" + ); +} + +/* PRLAR_8, Protection Region Limit Address Registers */ + +static inline uint32_t _AArch32_Read_prlar_8( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c6, c12, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_prlar_8( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c6, c12, 1" : : "r" ( value ) : "memory" + ); +} + +/* PRLAR_9, Protection Region Limit Address Registers */ + +static inline uint32_t _AArch32_Read_prlar_9( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c6, c12, 5" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_prlar_9( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c6, c12, 5" : : "r" ( value ) : "memory" + ); +} + +/* PRLAR_10, Protection Region Limit Address Registers */ + +static inline uint32_t _AArch32_Read_prlar_10( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c6, c13, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_prlar_10( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c6, c13, 1" : : "r" ( value ) : "memory" + ); +} + +/* PRLAR_11, Protection Region Limit Address Registers */ + +static inline uint32_t _AArch32_Read_prlar_11( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c6, c13, 5" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_prlar_11( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c6, c13, 5" : : "r" ( value ) : "memory" + ); +} + +/* PRLAR_12, Protection Region Limit Address Registers */ + +static inline uint32_t _AArch32_Read_prlar_12( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c6, c14, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_prlar_12( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c6, c14, 1" : : "r" ( value ) : "memory" + ); +} + +/* PRLAR_13, Protection Region Limit Address Registers */ + +static inline uint32_t _AArch32_Read_prlar_13( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c6, c14, 5" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_prlar_13( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c6, c14, 5" : : "r" ( value ) : "memory" + ); +} + +/* PRLAR_14, Protection Region Limit Address Registers */ + +static inline uint32_t _AArch32_Read_prlar_14( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c6, c15, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_prlar_14( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c6, c15, 1" : : "r" ( value ) : "memory" + ); +} + +/* PRLAR_15, Protection Region Limit Address Registers */ + +static inline uint32_t _AArch32_Read_prlar_15( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c6, c15, 5" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_prlar_15( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c6, c15, 5" : : "r" ( value ) : "memory" + ); +} + +/* PRLAR_16, Protection Region Limit Address Registers */ + +static inline uint32_t _AArch32_Read_prlar_16( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 1, %0, c6, c8, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_prlar_16( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 1, %0, c6, c8, 1" : : "r" ( value ) : "memory" + ); +} + +/* PRLAR_17, Protection Region Limit Address Registers */ + +static inline uint32_t _AArch32_Read_prlar_17( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 1, %0, c6, c8, 5" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_prlar_17( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 1, %0, c6, c8, 5" : : "r" ( value ) : "memory" + ); +} + +/* PRLAR_18, Protection Region Limit Address Registers */ + +static inline uint32_t _AArch32_Read_prlar_18( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 1, %0, c6, c9, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_prlar_18( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 1, %0, c6, c9, 1" : : "r" ( value ) : "memory" + ); +} + +/* PRLAR_19, Protection Region Limit Address Registers */ + +static inline uint32_t _AArch32_Read_prlar_19( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 1, %0, c6, c9, 5" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_prlar_19( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 1, %0, c6, c9, 5" : : "r" ( value ) : "memory" + ); +} + +/* PRLAR_20, Protection Region Limit Address Registers */ + +static inline uint32_t _AArch32_Read_prlar_20( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 1, %0, c6, c10, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_prlar_20( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 1, %0, c6, c10, 1" : : "r" ( value ) : "memory" + ); +} + +/* PRLAR_21, Protection Region Limit Address Registers */ + +static inline uint32_t _AArch32_Read_prlar_21( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 1, %0, c6, c10, 5" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_prlar_21( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 1, %0, c6, c10, 5" : : "r" ( value ) : "memory" + ); +} + +/* PRLAR_22, Protection Region Limit Address Registers */ + +static inline uint32_t _AArch32_Read_prlar_22( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 1, %0, c6, c11, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_prlar_22( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 1, %0, c6, c11, 1" : : "r" ( value ) : "memory" + ); +} + +/* PRLAR_23, Protection Region Limit Address Registers */ + +static inline uint32_t _AArch32_Read_prlar_23( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 1, %0, c6, c11, 5" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_prlar_23( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 1, %0, c6, c11, 5" : : "r" ( value ) : "memory" + ); +} + +/* PRLAR_24, Protection Region Limit Address Registers */ + +static inline uint32_t _AArch32_Read_prlar_24( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 1, %0, c6, c12, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_prlar_24( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 1, %0, c6, c12, 1" : : "r" ( value ) : "memory" + ); +} + +/* PRLAR_25, Protection Region Limit Address Registers */ + +static inline uint32_t _AArch32_Read_prlar_25( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 1, %0, c6, c12, 5" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_prlar_25( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 1, %0, c6, c12, 5" : : "r" ( value ) : "memory" + ); +} + +/* PRLAR_26, Protection Region Limit Address Registers */ + +static inline uint32_t _AArch32_Read_prlar_26( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 1, %0, c6, c13, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_prlar_26( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 1, %0, c6, c13, 1" : : "r" ( value ) : "memory" + ); +} + +/* PRLAR_27, Protection Region Limit Address Registers */ + +static inline uint32_t _AArch32_Read_prlar_27( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 1, %0, c6, c13, 5" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_prlar_27( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 1, %0, c6, c13, 5" : : "r" ( value ) : "memory" + ); +} + +/* PRLAR_28, Protection Region Limit Address Registers */ + +static inline uint32_t _AArch32_Read_prlar_28( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 1, %0, c6, c14, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_prlar_28( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 1, %0, c6, c14, 1" : : "r" ( value ) : "memory" + ); +} + +/* PRLAR_29, Protection Region Limit Address Registers */ + +static inline uint32_t _AArch32_Read_prlar_29( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 1, %0, c6, c14, 5" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_prlar_29( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 1, %0, c6, c14, 5" : : "r" ( value ) : "memory" + ); +} + +/* PRLAR_30, Protection Region Limit Address Registers */ + +static inline uint32_t _AArch32_Read_prlar_30( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 1, %0, c6, c15, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_prlar_30( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 1, %0, c6, c15, 1" : : "r" ( value ) : "memory" + ); +} + +/* PRLAR_31, Protection Region Limit Address Registers */ + +static inline uint32_t _AArch32_Read_prlar_31( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 1, %0, c6, c15, 5" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_prlar_31( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 1, %0, c6, c15, 5" : : "r" ( value ) : "memory" + ); +} + +/* PRSELR, Protection Region Selector Register */ + +#define AARCH32_PRSELR_REGION( _val ) ( ( _val ) << 0 ) +#define AARCH32_PRSELR_REGION_SHIFT 0 +#define AARCH32_PRSELR_REGION_MASK 0xffU +#define AARCH32_PRSELR_REGION_GET( _reg ) \ + ( ( ( _reg ) >> 0 ) & 0xffU ) + +static inline uint32_t _AArch32_Read_prselr( void ) +{ + uint32_t value; + + __asm__ volatile ( + "mrc p15, 0, %0, c6, c2, 1" : "=&r" ( value ) : : "memory" + ); + + return value; +} + +static inline void _AArch32_Write_prselr( uint32_t value ) +{ + __asm__ volatile ( + "mcr p15, 0, %0, c6, c2, 1" : : "r" ( value ) : "memory" + ); +} + +/** @} */ + +#ifdef __cplusplus +} +#endif + +#endif /* _RTEMS_SCORE_AARCH32_SYSTEM_REGISTERS_H */ -- cgit v1.2.3