/* * Copyright : (C) 2022 Phytium Information Technology, Inc. * All Rights Reserved. * * This program is OPEN SOURCE software: you can redistribute it and/or modify it * under the terms of the Phytium Public License as published by the Phytium Technology Co.,Ltd, * either version 1.0 of the License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful,but WITHOUT ANY WARRANTY; * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. * See the Phytium Public License for more details. * * * FilePath: fgic_hw.h * Date: 2022-03-24 11:44:48 * LastEditTime: 2022-03-24 11:44:48 * Description: This file is for gic register definition. * * Modify History: * Ver   Who        Date         Changes * ----- ------     --------    -------------------------------------- * 1.0 huanghe 2022/4/16 init commit */ #ifndef FGIC_HW_H #define FGIC_HW_H #include "ftypes.h" #include "fio.h" #include "fkernel.h" #ifdef __cplusplus extern "C" { #endif /* Distributor */ #define FGIC_GICD_CTLR_OFFSET 0x00000000U /* Distributor Control Register ,RW */ #define FGIC_GICD_TYPER_OFFSET 0x00000004U /* Interrupt Controller Type Register ,RO */ #define FGIC_GICD_IIDR_OFFSET 0x00000008U /* Distributor Implementer Identification Register ,RO */ #define FGIC_GICD_TYPER2_OFFSET 0x0000000CU /* Interrupt controller Type Register 2,RO */ #define FGIC_GICD_STATUSR_OFFSET 0x00000010U /* Error Reporting Status Register, optional ,RW */ #define FGIC_GICD_SETSPI_NSR_OFFSET 0x00000040U /* Set SPI Register ,WO */ #define FGIC_GICD_CLRSPI_NSR_OFFSET 0x00000048U /* Clear SPI Register ,WO */ #define FGIC_GICD_SETSPI_SR_OFFSET 0x00000050U /* Set SPI, Secure Register ,WO */ #define FGIC_GICD_CLRSPI_SR_OFFSET 0x00000058U /* Clear SPI, Secure Register ,WO */ #define FGIC_GICD_IGROUPR_OFFSET 0x00000080U /* Interrupt Group Registers ,RW */ #define FGIC_GICD_ISENABLER_OFFSET 0x00000100U /* Interrupt Set-Enable Registers ,RW */ #define FGIC_GICD_ICENABLER_OFFSET 0x00000180U /* Interrupt Clear-Enable Registers ,RW */ #define FGIC_GICD_ISPENDR_OFFSET 0x00000200U /* Interrupt Set-Pending Registers ,RW */ #define FGIC_GICD_ICPENDR_OFFSET 0x00000280U /* Interrupt Clear-Pending Registers ,RW */ #define FGIC_GICD_ISACTIVER_OFFSET 0x00000300U /* Interrupt Set-Active Registers ,RW */ #define FGIC_GICD_ICACTIVER_OFFSET 0x00000380U /* Interrupt Clear-Active Registers ,RW */ #define FGIC_GICD_IPRIORITYR_OFFSET 0x00000400U /* Interrupt Priority Registers ,RW */ #define FGIC_GICD_ITARGETSR_OFFSET 0x00000800U /* Interrupt Processor Targets Registers ,RO */ #define FGIC_GICD_ICFGR_OFFSET 0x00000C00U /* Interrupt Configuration Registers ,RW */ #define FGIC_GICD_IGRPMODR_OFFSET 0x00000D00U /* Interrupt Group Modifier Registers */ #define FGIC_GICD_NSACR_OFFSET 0x00000E00U /* Non-secure Access Control ,RW */ #define FGIC_GICD_SGIR_OFFSET 0x00000F00U /* Software Generated Interrupt Register ,WO */ #define FGIC_GICD_CPENDSGIR_OFFSET 0x00000F10U /* SGI Clear-Pending Registers ,RW */ #define FGIC_GICD_SPENDSGIR_OFFSET 0x00000F20U /* SGI Set-Pending Registers ,RW */ #define FGIC_GICD_IGROUPR_E_OFFSET 0x00001000U /* Interrupt Group Registers for extended SPI ,RW */ #define FGIC_GICD_ISENABLER_E_OFFSET 0x00001200U /* Interrupt Set-Enable for extended SPI ,RW */ #define FGIC_GICD_ICENABLER_E_OFFSET 0x00001400U /* Interrupt Clear-Enable for extended SPI ,RW */ #define FGIC_GICD_ISPENDR_E_OFFSET 0x00001600U /* Interrupt Set-Pend for extended SPI range ,RW */ #define FGIC_GICD_ICPENDR_E_OFFSET 0x00001800U /* Interrupt Clear-Pend for extended SPI ,RW */ #define FGIC_GICD_ISACTIVER_E_OFFSET 0x00001A00U /* Interrupt Set-Active for extended SPI ,RW */ #define FGIC_GICD_ICACTIVER_E_OFFSET 0x00001C00U /* Interrupt Clear-Active for extended SPI ,RW */ #define FGIC_GICD_IPRIORITYR_E_OFFSET 0x00002000U /* Interrupt Priority for extended SPI range ,RW */ #define FGIC_GICD_ICFGR_E_OFFSET 0x00003000U /* Extended SPI Configuration Register ,RW */ #define FGIC_GICD_IGRPMODR_E_OFFSET 0x00003400U /* Interrupt Group Modifier for extended SPI ,RW */ #define FGIC_GICD_NSACR_E_OFFSET 0x00003600U /* Non-secure Access Control Registers for extended SPI range ,RW */ #define FGIC_GICD_IROUTER_OFFSET 0x00006000U /* Interrupt Routing Registers ,RW ,The offset of the GICD_IROUTER register is 0x6000 + 8n. */ #define FGIC_GICD_IROUTER_E_OFFSET 0x00008000U /* Interrupt Routing Registers for extended SPI range ,RW */ /* Redistributor - RD_BASE */ /* Each Redistributor defines two 64KB frames in the physical address map */ #define FGIC_GICR_CTLR_OFFSET 0x00000000U /* See the register description Redistributor Control Register ,RW */ #define FGIC_GICR_IIDR_OFFSET 0x00000004U /* Implementer Identification Register ,RO */ #define FGIC_GICR_TYPER_OFFSET 0x00000008U /* Redistributor Type Register ,RO */ #define FGIC_GICR_STATUSR_OFFSET 0x00000010U /* Error Reporting Status Register, optional ,RW */ #define FGIC_GICR_WAKER_OFFSET 0x00000014U /* See the register description Redistributor Wake Register ,RW */ #define FGIC_GICR_MPAMIDR_OFFSET 0x00000018U /* Report maximum PARTID and PMG Register ,RO */ #define FGIC_GICR_PARTIDR_OFFSET 0x0000001CU /* Set PARTID and PMG Register ,RW */ #define FGIC_GICR_SETLPIR_OFFSET 0x00000040U /* Set LPI Pending Register ,WO */ #define FGIC_GICR_CLRLPIR_OFFSET 0x00000048U /* Clear LPI Pending Register ,WO */ #define FGIC_GICR_PROPBASER_OFFSET 0x00000070U /* Redistributor Properties Base Address Register ,RW */ #define FGIC_GICR_PENDBASER_OFFSET 0x00000078U /* Redistributor LPI Pending Table Base Address Register ,RW */ /* Redistributor - SGI_BASE */ #define FGIC_GICR_SGI_BASE_OFFSET 0x10000U /* 64KB frames */ #define FGIC_GICR_IGROUPR0_OFFSET 0x00000080U /* Interrupt Group Register 0 ,RW */ #define FGIC_GICR_IGROUPR_E_OFFSET 0x00000084U /* Interrupt Group Registers for extended PPI range ,RW */ #define FGIC_GICR_ISENABLER0_OFFSET 0x00000100U /* Interrupt Set-Enable Register 0 ,RW */ #define FGIC_GICR_ISENABLER_E_OFFSET 0x00000104U /* Interrupt Set-Enable for extended PPI range ,RW */ #define FGIC_GICR_ICENABLER0_OFFSET 0x00000180U /* Interrupt Clear-Enable Register 0 ,RW */ #define FGIC_GICR_ICENABLER_E_OFFSET 0x00000184U /* Interrupt Clear-Enable for extended PPI range ,RW */ #define FGIC_GICR_ISPENDR0_OFFSET 0x00000200U /* Interrupt Set-Pend Register 0 ,RW */ #define FGIC_GICR_ISPENDR_E_OFFSET 0x00000204U /* Interrupt Set-Pend for extended PPI range ,RW */ #define FGIC_GICR_ICPENDR0_OFFSET 0x00000280U /* Interrupt Clear-Pend Register 0 ,RW */ #define FGIC_GICR_ICPENDR_E_OFFSET 0x00000284U /* Interrupt Clear-Pend for extended PPI range ,RW */ #define FGIC_GICR_ISACTIVER0_OFFSET 0x00000300U /* Interrupt Set-Active Register 0 ,RW */ #define FGIC_GICR_ISACTIVER_E_OFFSET 0x00000304U /* Interrupt Set-Active for extended PPI range ,RW */ #define FGIC_GICR_ICACTIVER0_OFFSET 0x00000380U /* Interrupt Clear-Active Register 0 ,RW */ #define FGIC_GICR_ICACTIVER_E_OFFSET 0x00000384U /* Interrput Clear-Active for extended PPI range ,RW */ #define FGIC_GICR_IPRIORITYR_OFFSET 0x00000400U /* Interrupt Priority Registers ,RW */ #define FGIC_GICR_IPRIORITYR_E_OFFSET 0x00000420U /* Interrupt Priority for extended PPI range ,RW */ #define FGIC_GICR_ICFGR0_OFFSET 0x00000C00U /* SGI Configuration Register ,RW*/ #define FGIC_GICR_ICFGR1_OFFSET 0x00000C04U /* PPI Configuration Register ,RW*/ #define FGIC_GICR_ICFGR_E_OFFSET 0x00000C08U /* Extended PPI Configuration Register ,RW */ #define FGIC_GICR_IGRPMODR0_OFFSET 0x00000D00U /* Interrupt Group Modifier Register 0 ,RW */ #define FGIC_GICR_IGRPMODR_E_OFFSET 0x00000D04U /* Interrupt Group Modifier for extended PPI range ,RW */ #define FGIC_GICR_NSACR_OFFSET 0x00000E00U /* Non-Secure Access Control Register ,RW */ #define FGIC_READREG8(addr, reg_offset) FtIn8(addr + (u8)reg_offset) #define FGIC_WRITEREG8(addr, reg_offset, reg_value) FtOut8(addr + (u8)reg_offset, (u8)reg_value) #define FGIC_READREG32(addr, reg_offset) FtIn32(addr + (u32)reg_offset) #define FGIC_WRITEREG32(addr, reg_offset, reg_value) FtOut32(addr + (u32)reg_offset, (u32)reg_value) #ifdef __aarch64__ #define FGIC_READREG64(addr, reg_offset) FtIn64(addr + (u64)reg_offset) #define FGIC_WRITEREG64(addr, reg_offset, reg_value) FtOut64(addr +(u64)reg_offset, (u64)reg_value) #else #define FGIC_READREG64(addr, reg_offset) \ ({ \ u64 reg_val; \ reg_val = FtIn32(addr + (u32)reg_offset + 4); \ reg_val = (reg_val << 32) | FtIn32(addr + (u32)reg_offset); \ reg_val; \ }) #define FGIC_WRITEREG64(addr, reg_offset, reg_value) \ ({ \ FtOut32(addr + (u32)reg_offset, (u32)reg_value); \ FtOut32(addr + (u32)reg_offset + 4, (u32)(((u64)reg_value) >> 32)); \ }) #endif #define FGIC_SETBIT(base_addr, reg_offset, data) \ FtSetBit32((base_addr) + (u32)(reg_offset), (u32)(data)) #define FGIC_CLEARBIT(base_addr, reg_offset, data) \ FtClearBit32((base_addr) + (u32)(reg_offset), (u32)(data)) /* FGIC_GICD_CTLR_OFFSET --- Distributor switch */ #define FGIC_GICD_CTLR_RWP_MASK BIT(31) #define FGIC_GICD_CTLR_DS_MASK BIT(6) /* Need check system whether support Security states */ #define FGIC_GICD_CTLR_WRITE(gicd_base, reg) FGIC_WRITEREG32(gicd_base , FGIC_GICD_CTLR_OFFSET, reg) #define FGIC_GICD_CTLR_READ(gicd_base) FGIC_READREG32(gicd_base , FGIC_GICD_CTLR_OFFSET) /* FGIC_GICD_ISENABLER_OFFSET --- SPI Open */ #define FGIC_GICD_ISENABLER_VALUE_OFFSET(itnum) ((itnum % 32U)) #define FGIC_GICD_ISENABLER_VALUE_MASK(itnum) (0x1U << FGIC_GICD_ISENABLER_VALUE_OFFSET(itnum)) #define FGIC_GICD_ISENABLER_READ_N_MASK(gicd_base,itnum) FGIC_READREG32(gicd_base , FGIC_GICD_ISENABLER_OFFSET + ((itnum >> 5)<<2) ) #define FGIC_GICD_ISENABLER_WRITE_N_MASK(gicd_base,itnum,reg) FGIC_WRITEREG32(gicd_base , FGIC_GICD_ISENABLER_OFFSET + ((itnum >> 5)<<2), reg) /* FGIC_GICD_TYPER_OFFSET --- Provides information about what features the GIC implementation supports. */ #define FGIC_GICD_TYPER_ITLINESNUMBER_MASK 0x1f /* FGIC_GICD_ICENABLER_OFFSET --- SPI close */ #define FGIC_GICD_ICENABLER_DEFAULT_MASK BIT_MASK(32) #define FGIC_GICD_ICENABLER_VALUE_OFFSET(itnum) ((itnum % 32U)) #define FGIC_GICD_ICENABLER_VALUE_MASK(itnum) (0x1U << FGIC_GICD_ICENABLER_VALUE_OFFSET(itnum)) #define FGIC_GICD_ICENABLER_READ_N_MASK(gicd_base,itnum) FGIC_READREG32(gicd_base , FGIC_GICD_ICENABLER_OFFSET + ((itnum >> 5)<<2) ) #define FGIC_GICD_ICENABLER_WRITE_N_MASK(gicd_base,itnum,reg) FGIC_WRITEREG32(gicd_base , FGIC_GICD_ICENABLER_OFFSET + ((itnum >> 5)<<2), reg) /* FGIC_GICD_IPRIORITYR_OFFSET --- SPI priority */ #define FGIC_GICD_IPRIORITYR_VALUE_MASK(itnum) (0xFFU << ((itnum % 4U) << 3)) #define FGIC_GICD_IPRIORITYR_READ_N_MASK(gicd_base,itnum) FGIC_READREG32(gicd_base , FGIC_GICD_IPRIORITYR_OFFSET + ((itnum >> 2)<<2) ) #define FGIC_GICD_IPRIORITYR_WRITE_N_MASK(gicd_base,itnum,reg) FGIC_WRITEREG32(gicd_base , FGIC_GICD_IPRIORITYR_OFFSET + ((itnum >> 2)<<2), reg) /* FGIC_GICD_IROUTER_OFFSET --- SPI Routing */ #define FGIC_GICD_IROUTER_AFFINITY_MASK (((0xFFULL) <<32)|((0xFFULL) <<16)|((0xFFULL)<<8)|(0xFFULL)) /* affinity mask */ #define FGIC_GICD_IROUTER_RANGE_LIMIT (1023) /* GICD_IROUTER, Interrupt Routing Registers, n = 0 - 1019 */ #define FGIC_GICD_IROUTER_BYTE_WIDTH 8 #define FGIC_GICD_IROUTER_WRITE(gicd_base, bank, reg) FGIC_WRITEREG64(gicd_base , FGIC_GICD_IROUTER_OFFSET + (bank * FGIC_GICD_IROUTER_BYTE_WIDTH), reg) #define FGIC_GICD_IROUTER_READ(gicd_base, bank) FGIC_READREG64(gicd_base , FGIC_GICD_IROUTER_OFFSET + (bank * FGIC_GICD_IROUTER_BYTE_WIDTH)) /* FGIC_GICD_ITARGETSR_OFFSET --- legacy operation （ affinity routing is not enabled） */ #define FGIC_GICD_ITARGETSR_BYTE_WIDTH 4 #define FGIC_GICD_ITARGETSR_WRITE(gicd_base, bank, reg) FGIC_WRITEREG32(gicd_base , FGIC_GICD_ITARGETSR_OFFSET + (bank * FGIC_GICD_ITARGETSR_BYTE_WIDTH), reg) #define FGIC_GICD_ITARGETSR_READ(gicd_base, bank) FGIC_READREG32(gicd_base , FGIC_GICD_ITARGETSR_OFFSET + (bank * FGIC_GICD_ITARGETSR_BYTE_WIDTH)) /* FGIC_GICD_ICFGR_OFFSET --- edge-triggered or level-sensitive */ #define FGIC_GICD_ICFGR_VALUE_OFFSET(itnum) ((itnum % 16U) << 1) #define FGIC_GICD_ICFGR_VALUE_MASK(itnum) (0x3U << FGIC_GICD_ICFGR_VALUE_OFFSET(itnum)) #define FGIC_GICD_ICFGR_READ_N_MASK(gicd_base,itnum) FGIC_READREG32(gicd_base , FGIC_GICD_ICFGR_OFFSET + ((itnum >> 4)<<2) ) #define FGIC_GICD_ICFGR_WRITE_N_MASK(gicd_base,itnum,reg) FGIC_WRITEREG32(gicd_base , FGIC_GICD_ICFGR_OFFSET + ((itnum >> 4)<<2), reg) /* FGIC_GICD_ISPENDR_OFFSET --- about spi pending */ #define FGIC_GICD_ISPENDR_BYTE_WIDTH 4 #define FGIC_GICD_ISPENDR_WRITE(gicd_base, bank, reg) FGIC_WRITEREG32(gicd_base , FGIC_GICD_ISPENDR_OFFSET + (bank * FGIC_GICD_ISPENDR_BYTE_WIDTH), reg) #define FGIC_GICD_ISPENDR_READ(gicd_base, bank) FGIC_READREG32(gicd_base , FGIC_GICD_ISPENDR_OFFSET + (bank * FGIC_GICD_ISPENDR_BYTE_WIDTH)) /* FGIC_GICD_ICPENDR_OFFSET --- about spi pending */ #define FGIC_GICD_ICPENDR_DEFAULT_MASK BIT_MASK(32) #define FGIC_GICD_ICPENDR_VALUE_OFFSET(itnum) ((itnum % 32U)) #define FGIC_GICD_ICPENDR_VALUE_MASK(itnum) (0x1U << FGIC_GICD_ICPENDR_VALUE_OFFSET(itnum)) #define FGIC_GICD_ICPENDR_READ_N_MASK(gicd_base,itnum) FGIC_READREG32(gicd_base , FGIC_GICD_ICPENDR_OFFSET + ((itnum >> 5)<<2) ) #define FGIC_GICD_ICPENDR_WRITE_N_MASK(gicd_base,itnum,reg) FGIC_WRITEREG32(gicd_base , FGIC_GICD_ICPENDR_OFFSET + ((itnum >> 5)<<2), reg) /* FGIC_GICD_IGROUPR_OFFSET --- */ #define FGIC_GICD_IGROUPR_VALUE_OFFSET(itnum) ((itnum % 32U)) #define FGIC_GICD_IGROUPR_VALUE_MASK(itnum) (0x1U << FGIC_GICD_IGROUPR_VALUE_OFFSET(itnum)) #define FGIC_GICD_IGROUPR_READ_N_MASK(gicd_base,itnum) FGIC_READREG32(gicd_base , FGIC_GICD_IGROUPR_OFFSET + ((itnum >> 5)<<2) ) #define FGIC_GICD_IGROUPR_WRITE_N_MASK(gicd_base,itnum,reg) FGIC_WRITEREG32(gicd_base , FGIC_GICD_IGROUPR_OFFSET + ((itnum >> 5)<<2), reg) /* FGIC_GICD_IGRPMODR_OFFSET --- Controls whether the corresponding interrupt is in Secure Group 0、Non-secure Group 1、 Secure Group 1 */ #define FGIC_GICD_IGRPMODR_DEFAULT_MASK BIT_MASK(32) #define FGIC_GICD_IGRPMODR_VALUE_OFFSET(itnum) ((itnum % 32U)) #define FGIC_GICD_IGRPMODR_VALUE_MASK(itnum) (0x1U << FGIC_GICD_IGRPMODR_VALUE_OFFSET(itnum)) #define FGIC_GICD_IGRPMODR_READ_N_MASK(gicd_base,itnum) FGIC_READREG32(gicd_base , FGIC_GICD_IGRPMODR_OFFSET + ((itnum >> 5)<<2) ) #define FGIC_GICD_IGRPMODR_WRITE_N_MASK(gicd_base,itnum,reg) FGIC_WRITEREG32(gicd_base , FGIC_GICD_IGRPMODR_OFFSET + ((itnum >> 5)<<2), reg) /* FGIC_GICR_TYPER_OFFSET --- Provides information about the configuration of this Redistributor. */ #define FGIC_GICR_TYPER_BYTE_WIDTH 4 #define FGIC_GICR_TYPER_L_READ(redis_base) FGIC_READREG32(redis_base , FGIC_GICR_TYPER_OFFSET) #define FGIC_GICR_TYPER_H_READ(redis_base) FGIC_READREG32(redis_base , FGIC_GICR_TYPER_OFFSET + FGIC_GICR_TYPER_BYTE_WIDTH) /* FGIC_GICR_WAKER_OFFSET --- Permits software to control the behavior of the WakeRequest power management signal corresponding to the Redistributor */ #define FGIC_GICR_WAKER_PROCESSOR_SLEEP_MASK BIT(1) #define FGIC_GICR_WAKER_CHILDREN_ASLEEP_MASK BIT(2) #define FGIC_GICR_WAKER_CLEAR_BIT(redis_base, bit) FGIC_CLEARBIT(redis_base,FGIC_GICR_WAKER_OFFSET,bit) #define FGIC_GICR_WAKER_WRITE(redis_base, reg) FGIC_WRITEREG32(redis_base , FGIC_GICR_WAKER_OFFSET, reg) #define FGIC_GICR_WAKER_READ(redis_base) FGIC_READREG32(redis_base , FGIC_GICR_WAKER_OFFSET) /* FGIC_GICR_IPRIORITYR_OFFSET --- Enables forwarding of the corresponding SGI or PPI to the CPU interfaces*/ #define FGIC_GICR_IPRIORITYR_VALUE_MASK(itnum) (0xFFU << ((itnum % 4U) << 3)) #define FGIC_GICR_IPRIORITYR_READ(sgi_base,itnum) FGIC_READREG32(sgi_base , FGIC_GICR_IPRIORITYR_OFFSET + ((itnum >> 2)<<2) ) #define FGIC_GICR_IPRIORITYR_WRITE(sgi_base,itnum,reg) FGIC_WRITEREG32(sgi_base , FGIC_GICR_IPRIORITYR_OFFSET + ((itnum >> 2)<<2), reg) /* FGIC_GICR_ISPENDR0_OFFSET --- Adds the pending state to the corresponding SGI or PPI. */ #define FGIC_GICR_ISPENDR0_WRITE(sgi_base, reg) FGIC_WRITEREG32(sgi_base , FGIC_GICR_ISPENDR0_OFFSET, reg) #define FGIC_GICR_ISPENDR0_READ(sgi_base) FGIC_READREG32(sgi_base , FGIC_GICR_ISPENDR0_OFFSET) /* FGIC_GICR_ICPENDR0_OFFSET --- Removes the pending state from the corresponding SGI or PPI. */ #define FGIC_GICR_ICPENDR0_DEFAULT_MASK BIT_MASK(32) #define FGIC_GICR_ICPENDR0_WRITE(sgi_base, reg) FGIC_WRITEREG32(sgi_base , FGIC_GICR_ICPENDR0_OFFSET, reg) #define FGIC_GICR_ICPENDR0_READ(sgi_base) FGIC_READREG32(sgi_base , FGIC_GICR_ICPENDR0_OFFSET) /* FGIC_GICR_ISACTIVER0_OFFSET --- Activates the corresponding SGI or PPI. These registers are used when saving and restoring GIC state. */ #define FGIC_GICR_ISACTIVER0_WRITE(sgi_base, reg) FGIC_WRITEREG32(sgi_base , FGIC_GICR_ISACTIVER0_OFFSET, reg) #define FGIC_GICR_ISACTIVER0_READ(sgi_base) FGIC_READREG32(sgi_base , FGIC_GICR_ISACTIVER0_OFFSET) /* FGIC_GICR_ICACTIVER0_OFFSET --- Deactivates the corresponding SGI or PPI. These registers are used when saving and restoring GIC state.*/ #define FGIC_GICR_ICACTIVER0_WRITE(sgi_base, reg) FGIC_WRITEREG32(sgi_base , FGIC_GICR_ICACTIVER0_OFFSET, reg) #define FGIC_GICR_ICACTIVER0_READ(sgi_base) FGIC_READREG32(sgi_base , FGIC_GICR_ICACTIVER0_OFFSET) /* FGIC_GICR_IGROUPR0_OFFSET --- Controls whether the corresponding SGI or PPI is in Group 0 or Group 1. */ #define FGIC_GICR_IGROUPR0_DEFAULT_MASK BIT_MASK(32) #define FGIC_GICR_IGROUPR0_VALUE_OFFSET(itnum) ((itnum % 32U)) #define FGIC_GICR_IGROUPR0_VALUE_MASK(itnum) (0x1U << FGIC_GICR_IGROUPR0_VALUE_OFFSET(itnum)) #define FGIC_GICR_IGROUPR0_WRITE(sgi_base, reg) FGIC_WRITEREG32(sgi_base , FGIC_GICR_IGROUPR0_OFFSET, reg) #define FGIC_GICR_IGROUPR0_READ(sgi_base) FGIC_READREG32(sgi_base , FGIC_GICR_IGROUPR0_OFFSET) /* FGIC_GICR_IGRPMODR0_OFFSET --- controls whether the corresponding interrupt is in: • Secure Group 0.• Non-secure Group 1.• When System register access is enabled, Secure Group 1. */ #define FGIC_GICR_IGRPMODR0_DEFAULT_MASK BIT_MASK(32) #define FGIC_GICR_IGRPMODR0_VALUE_OFFSET(itnum) ((itnum % 32U)) #define FGIC_GICR_IGRPMODR0_VALUE_MASK(itnum) (0x1U << FGIC_GICR_IGRPMODR0_VALUE_OFFSET(itnum)) #define FGIC_GICR_IGRPMODR0_WRITE(sgi_base, reg) FGIC_WRITEREG32(sgi_base , FGIC_GICR_IGRPMODR0_OFFSET, reg) #define FGIC_GICR_IGRPMODR0_READ(sgi_base) FGIC_READREG32(sgi_base , FGIC_GICR_IGRPMODR0_OFFSET) /* FGIC_GICR_ISENABLER0_OFFSET --- Enables forwarding of the corresponding interrupt to the CPU interfaces. */ #define FGIC_GICR_ISENABLER0_WRITE(sgi_base, reg) FGIC_WRITEREG32(sgi_base , FGIC_GICR_ISENABLER0_OFFSET, reg) #define FGIC_GICR_ISENABLER0_READ(sgi_base) FGIC_READREG32(sgi_base , FGIC_GICR_ISENABLER0_OFFSET) /* FGIC_GICR_ICENABLER0_OFFSET --- Disables forwarding of the corresponding interrupt to the CPU interfaces. */ #define FGIC_GICR_ICENABLER0_DEFAULT_MASK BIT_MASK(32) #define FGIC_GICR_ICENABLER0_WRITE(sgi_base, reg) FGIC_WRITEREG32(sgi_base , FGIC_GICR_ICENABLER0_OFFSET, reg) #define FGIC_GICR_ICENABLER0_READ(sgi_base) FGIC_READREG32(sgi_base , FGIC_GICR_ICENABLER0_OFFSET) /* FGIC_GICR_ICFGR0_OFFSET */ #define FGIC_GICR_ICFGR0_DEFAULT_MASK 0 #define FGIC_GICR_ICFGR0_VALUE_OFFSET(itnum) ((itnum % 16U) << 1) #define FGIC_GICR_ICFGR0_VALUE_MASK(itnum) (0x3U << FGIC_GICR_ICFGR0_VALUE_OFFSET(itnum)) #define FGIC_GICR_ICFGR0_WRITE(sgi_base, reg) FGIC_WRITEREG32(sgi_base , FGIC_GICR_ICFGR0_OFFSET, reg) #define FGIC_GICR_ICFGR0_READ(sgi_base) FGIC_READREG32(sgi_base , FGIC_GICR_ICFGR0_OFFSET) /* FGIC_GICR_ICFGR1_OFFSET */ #define FGIC_GICR_ICFGR1_VALUE_OFFSET(itnum) ((itnum % 16U) << 1) #define FGIC_GICR_ICFGR1_VALUE_MASK(itnum) (0x3U << FGIC_GICR_ICFGR1_VALUE_OFFSET(itnum)) #define FGIC_GICR_ICFGR1_WRITE(sgi_base, reg) FGIC_WRITEREG32(sgi_base , FGIC_GICR_ICFGR1_OFFSET, reg) #define FGIC_GICR_ICFGR1_READ(sgi_base) FGIC_READREG32(sgi_base , FGIC_GICR_ICFGR1_OFFSET) /* FGIC_GICR_CTLR_OFFSET */ #define FGIC_GICR_CTLR_RWP_MASK BIT(2) /* FGIC_GICR_NSACR_OFFSET */ #define FGIC_GICR_NSACR_WRITE(sgi_base, reg) FGIC_WRITEREG32(sgi_base , FGIC_GICR_NSACR_OFFSET, reg) #define FGIC_GICR_NSACR_READ(sgi_base) FGIC_READREG32(sgi_base , FGIC_GICR_NSACR_OFFSET) #ifdef __cplusplus } #endif #endif