Quelle  emulate-nested.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-only
/*
 * Copyright (C) 2016 - Linaro and Columbia University
 * Author: Jintack Lim <jintack.lim@linaro.org>
 */

#include <linux/kvm.h>
#include <linux/kvm_host.h>

#include <asm/kvm_emulate.h>
#include <asm/kvm_nested.h>

#include "hyp/include/hyp/adjust_pc.h"

#include "trace.h"

enum trap_behaviour {
 BEHAVE_HANDLE_LOCALLY = 0,

 BEHAVE_FORWARD_READ = BIT(0),
 BEHAVE_FORWARD_WRITE = BIT(1),
 BEHAVE_FORWARD_RW = BEHAVE_FORWARD_READ | BEHAVE_FORWARD_WRITE,

 /* Traps that take effect in Host EL0, this is rare! */
 BEHAVE_FORWARD_IN_HOST_EL0 = BIT(2),
};

struct trap_bits {
 const enum vcpu_sysreg  index;
 const enum trap_behaviour behaviour;
 const u64   value;
 const u64   mask;
};

/* Coarse Grained Trap definitions */
enum cgt_group_id {
 /* Indicates no coarse trap control */
 __RESERVED__,

 /*
 * The first batch of IDs denote coarse trapping that are used
 * on their own instead of being part of a combination of
 * trap controls.
 */
 CGT_HCR_TID1,
 CGT_HCR_TID2,
 CGT_HCR_TID3,
 CGT_HCR_IMO,
 CGT_HCR_FMO,
 CGT_HCR_TIDCP,
 CGT_HCR_TACR,
 CGT_HCR_TSW,
 CGT_HCR_TPC,
 CGT_HCR_TPU,
 CGT_HCR_TTLB,
 CGT_HCR_TVM,
 CGT_HCR_TDZ,
 CGT_HCR_TRVM,
 CGT_HCR_TLOR,
 CGT_HCR_TERR,
 CGT_HCR_APK,
 CGT_HCR_NV,
 CGT_HCR_NV_nNV2,
 CGT_HCR_NV1_nNV2,
 CGT_HCR_AT,
 CGT_HCR_nFIEN,
 CGT_HCR_TID4,
 CGT_HCR_TICAB,
 CGT_HCR_TOCU,
 CGT_HCR_ENSCXT,
 CGT_HCR_TTLBIS,
 CGT_HCR_TTLBOS,

 CGT_MDCR_TPMCR,
 CGT_MDCR_TPM,
 CGT_MDCR_TDE,
 CGT_MDCR_TDA,
 CGT_MDCR_TDOSA,
 CGT_MDCR_TDRA,
 CGT_MDCR_E2PB,
 CGT_MDCR_TPMS,
 CGT_MDCR_TTRF,
 CGT_MDCR_E2TB,
 CGT_MDCR_TDCC,

 CGT_CPTR_TAM,
 CGT_CPTR_TCPAC,

 CGT_HCRX_EnFPM,
 CGT_HCRX_TCR2En,
 CGT_HCRX_SCTLR2En,

 CGT_CNTHCTL_EL1TVT,
 CGT_CNTHCTL_EL1TVCT,

 CGT_ICH_HCR_TC,
 CGT_ICH_HCR_TALL0,
 CGT_ICH_HCR_TALL1,
 CGT_ICH_HCR_TDIR,

 /*
 * Anything after this point is a combination of coarse trap
 * controls, which must all be evaluated to decide what to do.
 */
 __MULTIPLE_CONTROL_BITS__,
 CGT_HCR_IMO_FMO_ICH_HCR_TC = __MULTIPLE_CONTROL_BITS__,
 CGT_HCR_TID2_TID4,
 CGT_HCR_TTLB_TTLBIS,
 CGT_HCR_TTLB_TTLBOS,
 CGT_HCR_TVM_TRVM,
 CGT_HCR_TVM_TRVM_HCRX_TCR2En,
 CGT_HCR_TVM_TRVM_HCRX_SCTLR2En,
 CGT_HCR_TPU_TICAB,
 CGT_HCR_TPU_TOCU,
 CGT_HCR_NV1_nNV2_ENSCXT,
 CGT_MDCR_TPM_TPMCR,
 CGT_MDCR_TPM_HPMN,
 CGT_MDCR_TDE_TDA,
 CGT_MDCR_TDE_TDOSA,
 CGT_MDCR_TDE_TDRA,
 CGT_MDCR_TDCC_TDE_TDA,

 CGT_ICH_HCR_TC_TDIR,

 /*
 * Anything after this point requires a callback evaluating a
 * complex trap condition. Ugly stuff.
 */
 __COMPLEX_CONDITIONS__,
 CGT_CNTHCTL_EL1PCTEN = __COMPLEX_CONDITIONS__,
 CGT_CNTHCTL_EL1PTEN,
 CGT_CNTHCTL_EL1NVPCT,
 CGT_CNTHCTL_EL1NVVCT,

 CGT_CPTR_TTA,
 CGT_MDCR_HPMN,

 /* Must be last */
 __NR_CGT_GROUP_IDS__
};

static const struct trap_bits coarse_trap_bits[] = {
 [CGT_HCR_TID1] = {
  .index  = HCR_EL2,
  .value   = HCR_TID1,
  .mask  = HCR_TID1,
  .behaviour = BEHAVE_FORWARD_READ,
 },
 [CGT_HCR_TID2] = {
  .index  = HCR_EL2,
  .value   = HCR_TID2,
  .mask  = HCR_TID2,
  .behaviour = BEHAVE_FORWARD_RW,
 },
 [CGT_HCR_TID3] = {
  .index  = HCR_EL2,
  .value   = HCR_TID3,
  .mask  = HCR_TID3,
  .behaviour = BEHAVE_FORWARD_READ,
 },
 [CGT_HCR_IMO] = {
  .index  = HCR_EL2,
  .value   = HCR_IMO,
  .mask  = HCR_IMO,
  .behaviour = BEHAVE_FORWARD_WRITE,
 },
 [CGT_HCR_FMO] = {
  .index  = HCR_EL2,
  .value   = HCR_FMO,
  .mask  = HCR_FMO,
  .behaviour = BEHAVE_FORWARD_WRITE,
 },
 [CGT_HCR_TIDCP] = {
  .index  = HCR_EL2,
  .value  = HCR_TIDCP,
  .mask  = HCR_TIDCP,
  .behaviour = BEHAVE_FORWARD_RW,
 },
 [CGT_HCR_TACR] = {
  .index  = HCR_EL2,
  .value  = HCR_TACR,
  .mask  = HCR_TACR,
  .behaviour = BEHAVE_FORWARD_RW,
 },
 [CGT_HCR_TSW] = {
  .index  = HCR_EL2,
  .value  = HCR_TSW,
  .mask  = HCR_TSW,
  .behaviour = BEHAVE_FORWARD_RW,
 },
 [CGT_HCR_TPC] = { /* Also called TCPC when FEAT_DPB is implemented */
  .index  = HCR_EL2,
  .value  = HCR_TPC,
  .mask  = HCR_TPC,
  .behaviour = BEHAVE_FORWARD_RW,
 },
 [CGT_HCR_TPU] = {
  .index  = HCR_EL2,
  .value  = HCR_TPU,
  .mask  = HCR_TPU,
  .behaviour = BEHAVE_FORWARD_RW,
 },
 [CGT_HCR_TTLB] = {
  .index  = HCR_EL2,
  .value  = HCR_TTLB,
  .mask  = HCR_TTLB,
  .behaviour = BEHAVE_FORWARD_RW,
 },
 [CGT_HCR_TVM] = {
  .index  = HCR_EL2,
  .value  = HCR_TVM,
  .mask  = HCR_TVM,
  .behaviour = BEHAVE_FORWARD_WRITE,
 },
 [CGT_HCR_TDZ] = {
  .index  = HCR_EL2,
  .value  = HCR_TDZ,
  .mask  = HCR_TDZ,
  .behaviour = BEHAVE_FORWARD_RW,
 },
 [CGT_HCR_TRVM] = {
  .index  = HCR_EL2,
  .value  = HCR_TRVM,
  .mask  = HCR_TRVM,
  .behaviour = BEHAVE_FORWARD_READ,
 },
 [CGT_HCR_TLOR] = {
  .index  = HCR_EL2,
  .value  = HCR_TLOR,
  .mask  = HCR_TLOR,
  .behaviour = BEHAVE_FORWARD_RW,
 },
 [CGT_HCR_TERR] = {
  .index  = HCR_EL2,
  .value  = HCR_TERR,
  .mask  = HCR_TERR,
  .behaviour = BEHAVE_FORWARD_RW,
 },
 [CGT_HCR_APK] = {
  .index  = HCR_EL2,
  .value  = 0,
  .mask  = HCR_APK,
  .behaviour = BEHAVE_FORWARD_RW,
 },
 [CGT_HCR_NV] = {
  .index  = HCR_EL2,
  .value  = HCR_NV,
  .mask  = HCR_NV,
  .behaviour = BEHAVE_FORWARD_RW,
 },
 [CGT_HCR_NV_nNV2] = {
  .index  = HCR_EL2,
  .value  = HCR_NV,
  .mask  = HCR_NV | HCR_NV2,
  .behaviour = BEHAVE_FORWARD_RW,
 },
 [CGT_HCR_NV1_nNV2] = {
  .index  = HCR_EL2,
  .value  = HCR_NV | HCR_NV1,
  .mask  = HCR_NV | HCR_NV1 | HCR_NV2,
  .behaviour = BEHAVE_FORWARD_RW,
 },
 [CGT_HCR_AT] = {
  .index  = HCR_EL2,
  .value  = HCR_AT,
  .mask  = HCR_AT,
  .behaviour = BEHAVE_FORWARD_RW,
 },
 [CGT_HCR_nFIEN] = {
  .index  = HCR_EL2,
  .value  = 0,
  .mask  = HCR_FIEN,
  .behaviour = BEHAVE_FORWARD_RW,
 },
 [CGT_HCR_TID4] = {
  .index  = HCR_EL2,
  .value   = HCR_TID4,
  .mask  = HCR_TID4,
  .behaviour = BEHAVE_FORWARD_RW,
 },
 [CGT_HCR_TICAB] = {
  .index  = HCR_EL2,
  .value   = HCR_TICAB,
  .mask  = HCR_TICAB,
  .behaviour = BEHAVE_FORWARD_RW,
 },
 [CGT_HCR_TOCU] = {
  .index  = HCR_EL2,
  .value   = HCR_TOCU,
  .mask  = HCR_TOCU,
  .behaviour = BEHAVE_FORWARD_RW,
 },
 [CGT_HCR_ENSCXT] = {
  .index  = HCR_EL2,
  .value   = 0,
  .mask  = HCR_ENSCXT,
  .behaviour = BEHAVE_FORWARD_RW,
 },
 [CGT_HCR_TTLBIS] = {
  .index  = HCR_EL2,
  .value  = HCR_TTLBIS,
  .mask  = HCR_TTLBIS,
  .behaviour = BEHAVE_FORWARD_RW,
 },
 [CGT_HCR_TTLBOS] = {
  .index  = HCR_EL2,
  .value  = HCR_TTLBOS,
  .mask  = HCR_TTLBOS,
  .behaviour = BEHAVE_FORWARD_RW,
 },
 [CGT_MDCR_TPMCR] = {
  .index  = MDCR_EL2,
  .value  = MDCR_EL2_TPMCR,
  .mask  = MDCR_EL2_TPMCR,
  .behaviour = BEHAVE_FORWARD_RW |
      BEHAVE_FORWARD_IN_HOST_EL0,
 },
 [CGT_MDCR_TPM] = {
  .index  = MDCR_EL2,
  .value  = MDCR_EL2_TPM,
  .mask  = MDCR_EL2_TPM,
  .behaviour = BEHAVE_FORWARD_RW |
      BEHAVE_FORWARD_IN_HOST_EL0,
 },
 [CGT_MDCR_TDE] = {
  .index  = MDCR_EL2,
  .value  = MDCR_EL2_TDE,
  .mask  = MDCR_EL2_TDE,
  .behaviour = BEHAVE_FORWARD_RW,
 },
 [CGT_MDCR_TDA] = {
  .index  = MDCR_EL2,
  .value  = MDCR_EL2_TDA,
  .mask  = MDCR_EL2_TDA,
  .behaviour = BEHAVE_FORWARD_RW,
 },
 [CGT_MDCR_TDOSA] = {
  .index  = MDCR_EL2,
  .value  = MDCR_EL2_TDOSA,
  .mask  = MDCR_EL2_TDOSA,
  .behaviour = BEHAVE_FORWARD_RW,
 },
 [CGT_MDCR_TDRA] = {
  .index  = MDCR_EL2,
  .value  = MDCR_EL2_TDRA,
  .mask  = MDCR_EL2_TDRA,
  .behaviour = BEHAVE_FORWARD_RW,
 },
 [CGT_MDCR_E2PB] = {
  .index  = MDCR_EL2,
  .value  = 0,
  .mask  = BIT(MDCR_EL2_E2PB_SHIFT),
  .behaviour = BEHAVE_FORWARD_RW,
 },
 [CGT_MDCR_TPMS] = {
  .index  = MDCR_EL2,
  .value  = MDCR_EL2_TPMS,
  .mask  = MDCR_EL2_TPMS,
  .behaviour = BEHAVE_FORWARD_RW,
 },
 [CGT_MDCR_TTRF] = {
  .index  = MDCR_EL2,
  .value  = MDCR_EL2_TTRF,
  .mask  = MDCR_EL2_TTRF,
  .behaviour = BEHAVE_FORWARD_RW,
 },
 [CGT_MDCR_E2TB] = {
  .index  = MDCR_EL2,
  .value  = 0,
  .mask  = BIT(MDCR_EL2_E2TB_SHIFT),
  .behaviour = BEHAVE_FORWARD_RW,
 },
 [CGT_MDCR_TDCC] = {
  .index  = MDCR_EL2,
  .value  = MDCR_EL2_TDCC,
  .mask  = MDCR_EL2_TDCC,
  .behaviour = BEHAVE_FORWARD_RW,
 },
 [CGT_CPTR_TAM] = {
  .index  = CPTR_EL2,
  .value  = CPTR_EL2_TAM,
  .mask  = CPTR_EL2_TAM,
  .behaviour = BEHAVE_FORWARD_RW,
 },
 [CGT_CPTR_TCPAC] = {
  .index  = CPTR_EL2,
  .value  = CPTR_EL2_TCPAC,
  .mask  = CPTR_EL2_TCPAC,
  .behaviour = BEHAVE_FORWARD_RW,
 },
 [CGT_HCRX_EnFPM] = {
  .index  = HCRX_EL2,
  .value   = 0,
  .mask  = HCRX_EL2_EnFPM,
  .behaviour = BEHAVE_FORWARD_RW,
 },
 [CGT_HCRX_TCR2En] = {
  .index  = HCRX_EL2,
  .value   = 0,
  .mask  = HCRX_EL2_TCR2En,
  .behaviour = BEHAVE_FORWARD_RW,
 },
 [CGT_HCRX_SCTLR2En] = {
  .index  = HCRX_EL2,
  .value  = 0,
  .mask  = HCRX_EL2_SCTLR2En,
  .behaviour = BEHAVE_FORWARD_RW,
 },
 [CGT_CNTHCTL_EL1TVT] = {
  .index  = CNTHCTL_EL2,
  .value  = CNTHCTL_EL1TVT,
  .mask  = CNTHCTL_EL1TVT,
  .behaviour = BEHAVE_FORWARD_RW,
 },
 [CGT_CNTHCTL_EL1TVCT] = {
  .index  = CNTHCTL_EL2,
  .value  = CNTHCTL_EL1TVCT,
  .mask  = CNTHCTL_EL1TVCT,
  .behaviour = BEHAVE_FORWARD_READ,
 },
 [CGT_ICH_HCR_TC] = {
  .index  = ICH_HCR_EL2,
  .value  = ICH_HCR_EL2_TC,
  .mask  = ICH_HCR_EL2_TC,
  .behaviour = BEHAVE_FORWARD_RW,
 },
 [CGT_ICH_HCR_TALL0] = {
  .index  = ICH_HCR_EL2,
  .value  = ICH_HCR_EL2_TALL0,
  .mask  = ICH_HCR_EL2_TALL0,
  .behaviour = BEHAVE_FORWARD_RW,
 },
 [CGT_ICH_HCR_TALL1] = {
  .index  = ICH_HCR_EL2,
  .value  = ICH_HCR_EL2_TALL1,
  .mask  = ICH_HCR_EL2_TALL1,
  .behaviour = BEHAVE_FORWARD_RW,
 },
 [CGT_ICH_HCR_TDIR] = {
  .index  = ICH_HCR_EL2,
  .value  = ICH_HCR_EL2_TDIR,
  .mask  = ICH_HCR_EL2_TDIR,
  .behaviour = BEHAVE_FORWARD_RW,
 },
};

#define MCB(id, ...)      \
 [id - __MULTIPLE_CONTROL_BITS__] =  \
  (const enum cgt_group_id[]){   \
  __VA_ARGS__, __RESERVED__   \
  }

static const enum cgt_group_id *coarse_control_combo[] = {
 MCB(CGT_HCR_TID2_TID4,  CGT_HCR_TID2, CGT_HCR_TID4),
 MCB(CGT_HCR_TTLB_TTLBIS, CGT_HCR_TTLB, CGT_HCR_TTLBIS),
 MCB(CGT_HCR_TTLB_TTLBOS, CGT_HCR_TTLB, CGT_HCR_TTLBOS),
 MCB(CGT_HCR_TVM_TRVM,  CGT_HCR_TVM, CGT_HCR_TRVM),
 MCB(CGT_HCR_TVM_TRVM_HCRX_TCR2En,
     CGT_HCR_TVM, CGT_HCR_TRVM, CGT_HCRX_TCR2En),
 MCB(CGT_HCR_TVM_TRVM_HCRX_SCTLR2En,
     CGT_HCR_TVM, CGT_HCR_TRVM, CGT_HCRX_SCTLR2En),
 MCB(CGT_HCR_TPU_TICAB,  CGT_HCR_TPU, CGT_HCR_TICAB),
 MCB(CGT_HCR_TPU_TOCU,  CGT_HCR_TPU, CGT_HCR_TOCU),
 MCB(CGT_HCR_NV1_nNV2_ENSCXT, CGT_HCR_NV1_nNV2, CGT_HCR_ENSCXT),
 MCB(CGT_MDCR_TPM_TPMCR,  CGT_MDCR_TPM, CGT_MDCR_TPMCR),
 MCB(CGT_MDCR_TPM_HPMN,  CGT_MDCR_TPM, CGT_MDCR_HPMN),
 MCB(CGT_MDCR_TDE_TDA,  CGT_MDCR_TDE, CGT_MDCR_TDA),
 MCB(CGT_MDCR_TDE_TDOSA,  CGT_MDCR_TDE, CGT_MDCR_TDOSA),
 MCB(CGT_MDCR_TDE_TDRA,  CGT_MDCR_TDE, CGT_MDCR_TDRA),
 MCB(CGT_MDCR_TDCC_TDE_TDA, CGT_MDCR_TDCC, CGT_MDCR_TDE, CGT_MDCR_TDA),

 MCB(CGT_HCR_IMO_FMO_ICH_HCR_TC, CGT_HCR_IMO, CGT_HCR_FMO, CGT_ICH_HCR_TC),
 MCB(CGT_ICH_HCR_TC_TDIR, CGT_ICH_HCR_TC, CGT_ICH_HCR_TDIR),
};

typedef enum trap_behaviour (*complex_condition_check)(struct kvm_vcpu *);

/*
 * Warning, maximum confusion ahead.
 *
 * When E2H=0, CNTHCTL_EL2[1:0] are defined as EL1PCEN:EL1PCTEN
 * When E2H=1, CNTHCTL_EL2[11:10] are defined as EL1PTEN:EL1PCTEN
 *
 * Note the single letter difference? Yet, the bits have the same
 * function despite a different layout and a different name.
 *
 * We don't try to reconcile this mess. We just use the E2H=0 bits
 * to generate something that is in the E2H=1 format, and live with
 * it. You're welcome.
 */
static u64 get_sanitized_cnthctl(struct kvm_vcpu *vcpu)
{
 u64 val = __vcpu_sys_reg(vcpu, CNTHCTL_EL2);

 if (!vcpu_el2_e2h_is_set(vcpu))
  val = (val & (CNTHCTL_EL1PCEN | CNTHCTL_EL1PCTEN)) << 10;

 return val & ((CNTHCTL_EL1PCEN | CNTHCTL_EL1PCTEN) << 10);
}

static enum trap_behaviour check_cnthctl_el1pcten(struct kvm_vcpu *vcpu)
{
 if (get_sanitized_cnthctl(vcpu) & (CNTHCTL_EL1PCTEN << 10))
  return BEHAVE_HANDLE_LOCALLY;

 return BEHAVE_FORWARD_RW;
}

static enum trap_behaviour check_cnthctl_el1pten(struct kvm_vcpu *vcpu)
{
 if (get_sanitized_cnthctl(vcpu) & (CNTHCTL_EL1PCEN << 10))
  return BEHAVE_HANDLE_LOCALLY;

 return BEHAVE_FORWARD_RW;
}

static bool is_nested_nv2_guest(struct kvm_vcpu *vcpu)
{
 u64 val;

 val = __vcpu_sys_reg(vcpu, HCR_EL2);
 return ((val & (HCR_E2H | HCR_TGE | HCR_NV2 | HCR_NV1 | HCR_NV)) == (HCR_E2H | HCR_NV2 | HCR_NV));
}

static enum trap_behaviour check_cnthctl_el1nvpct(struct kvm_vcpu *vcpu)
{
 if (!is_nested_nv2_guest(vcpu) ||
     !(__vcpu_sys_reg(vcpu, CNTHCTL_EL2) & CNTHCTL_EL1NVPCT))
  return BEHAVE_HANDLE_LOCALLY;

 return BEHAVE_FORWARD_RW;
}

static enum trap_behaviour check_cnthctl_el1nvvct(struct kvm_vcpu *vcpu)
{
 if (!is_nested_nv2_guest(vcpu) ||
     !(__vcpu_sys_reg(vcpu, CNTHCTL_EL2) & CNTHCTL_EL1NVVCT))
  return BEHAVE_HANDLE_LOCALLY;

 return BEHAVE_FORWARD_RW;
}

static enum trap_behaviour check_cptr_tta(struct kvm_vcpu *vcpu)
{
 u64 val = __vcpu_sys_reg(vcpu, CPTR_EL2);

 if (!vcpu_el2_e2h_is_set(vcpu))
  val = translate_cptr_el2_to_cpacr_el1(val);

 if (val & CPACR_EL1_TTA)
  return BEHAVE_FORWARD_RW;

 return BEHAVE_HANDLE_LOCALLY;
}

static enum trap_behaviour check_mdcr_hpmn(struct kvm_vcpu *vcpu)
{
 u32 sysreg = esr_sys64_to_sysreg(kvm_vcpu_get_esr(vcpu));
 unsigned int idx;


 switch (sysreg) {
 case SYS_PMEVTYPERn_EL0(0) ... SYS_PMEVTYPERn_EL0(30):
 case SYS_PMEVCNTRn_EL0(0) ... SYS_PMEVCNTRn_EL0(30):
  idx = (sys_reg_CRm(sysreg) & 0x3) << 3 | sys_reg_Op2(sysreg);
  break;
 case SYS_PMXEVTYPER_EL0:
 case SYS_PMXEVCNTR_EL0:
  idx = SYS_FIELD_GET(PMSELR_EL0, SEL,
        __vcpu_sys_reg(vcpu, PMSELR_EL0));
  break;
 default:
  /* Someone used this trap helper for something else... */
  KVM_BUG_ON(1, vcpu->kvm);
  return BEHAVE_HANDLE_LOCALLY;
 }

 if (kvm_pmu_counter_is_hyp(vcpu, idx))
  return BEHAVE_FORWARD_RW | BEHAVE_FORWARD_IN_HOST_EL0;

 return BEHAVE_HANDLE_LOCALLY;
}

#define CCC(id, fn)    \
 [id - __COMPLEX_CONDITIONS__] = fn

static const complex_condition_check ccc[] = {
 CCC(CGT_CNTHCTL_EL1PCTEN, check_cnthctl_el1pcten),
 CCC(CGT_CNTHCTL_EL1PTEN, check_cnthctl_el1pten),
 CCC(CGT_CNTHCTL_EL1NVPCT, check_cnthctl_el1nvpct),
 CCC(CGT_CNTHCTL_EL1NVVCT, check_cnthctl_el1nvvct),
 CCC(CGT_CPTR_TTA, check_cptr_tta),
 CCC(CGT_MDCR_HPMN, check_mdcr_hpmn),
};

/*
 * Bit assignment for the trap controls. We use a 64bit word with the
 * following layout for each trapped sysreg:
 *
 * [9:0] enum cgt_group_id (10 bits)
 * [13:10] enum fgt_group_id (4 bits)
 * [19:14] bit number in the FGT register (6 bits)
 * [20] trap polarity (1 bit)
 * [25:21] FG filter (5 bits)
 * [35:26] Main SysReg table index (10 bits)
 * [62:36] Unused (27 bits)
 * [63] RES0 - Must be zero, as lost on insertion in the xarray
 */
#define TC_CGT_BITS 10
#define TC_FGT_BITS 4
#define TC_FGF_BITS 5
#define TC_SRI_BITS 10

union trap_config {
 u64 val;
 struct {
  unsigned long cgt:TC_CGT_BITS; /* Coarse Grained Trap id */
  unsigned long fgt:TC_FGT_BITS; /* Fine Grained Trap id */
  unsigned long bit:6;   /* Bit number */
  unsigned long pol:1;   /* Polarity */
  unsigned long fgf:TC_FGF_BITS; /* Fine Grained Filter */
  unsigned long sri:TC_SRI_BITS; /* SysReg Index */
  unsigned long unused:27;  /* Unused, should be zero */
  unsigned long mbz:1;   /* Must Be Zero */
 };
};

struct encoding_to_trap_config {
 const u32   encoding;
 const u32   end;
 const union trap_config  tc;
 const unsigned int  line;
};

/*
 * WARNING: using ranges is a treacherous endeavour, as sysregs that
 * are part of an architectural range are not necessarily contiguous
 * in the [Op0,Op1,CRn,CRm,Ops] space. Tread carefully.
 */
#define SR_RANGE_TRAP(sr_start, sr_end, trap_id)   \
 {        \
  .encoding = sr_start,    \
  .end  = sr_end,    \
  .tc  = {     \
   .cgt  = trap_id,   \
  },       \
  .line = __LINE__,     \
 }

#define SR_TRAP(sr, trap_id)  SR_RANGE_TRAP(sr, sr, trap_id)

/*
 * Map encoding to trap bits for exception reported with EC=0x18.
 * These must only be evaluated when running a nested hypervisor, but
 * that the current context is not a hypervisor context. When the
 * trapped access matches one of the trap controls, the exception is
 * re-injected in the nested hypervisor.
 */
static const struct encoding_to_trap_config encoding_to_cgt[] __initconst = {
 SR_TRAP(SYS_REVIDR_EL1,  CGT_HCR_TID1),
 SR_TRAP(SYS_AIDR_EL1,  CGT_HCR_TID1),
 SR_TRAP(SYS_SMIDR_EL1,  CGT_HCR_TID1),
 SR_TRAP(SYS_CTR_EL0,  CGT_HCR_TID2),
 SR_TRAP(SYS_CCSIDR_EL1,  CGT_HCR_TID2_TID4),
 SR_TRAP(SYS_CCSIDR2_EL1, CGT_HCR_TID2_TID4),
 SR_TRAP(SYS_CLIDR_EL1,  CGT_HCR_TID2_TID4),
 SR_TRAP(SYS_CSSELR_EL1,  CGT_HCR_TID2_TID4),
 SR_RANGE_TRAP(SYS_ID_PFR0_EL1,
        sys_reg(3, 0, 0, 7, 7), CGT_HCR_TID3),
 SR_TRAP(SYS_ICC_SGI0R_EL1, CGT_HCR_IMO_FMO_ICH_HCR_TC),
 SR_TRAP(SYS_ICC_ASGI1R_EL1, CGT_HCR_IMO_FMO_ICH_HCR_TC),
 SR_TRAP(SYS_ICC_SGI1R_EL1, CGT_HCR_IMO_FMO_ICH_HCR_TC),
 SR_RANGE_TRAP(sys_reg(3, 0, 11, 0, 0),
        sys_reg(3, 0, 11, 15, 7), CGT_HCR_TIDCP),
 SR_RANGE_TRAP(sys_reg(3, 1, 11, 0, 0),
        sys_reg(3, 1, 11, 15, 7), CGT_HCR_TIDCP),
 SR_RANGE_TRAP(sys_reg(3, 2, 11, 0, 0),
        sys_reg(3, 2, 11, 15, 7), CGT_HCR_TIDCP),
 SR_RANGE_TRAP(sys_reg(3, 3, 11, 0, 0),
        sys_reg(3, 3, 11, 15, 7), CGT_HCR_TIDCP),
 SR_RANGE_TRAP(sys_reg(3, 4, 11, 0, 0),
        sys_reg(3, 4, 11, 15, 7), CGT_HCR_TIDCP),
 SR_RANGE_TRAP(sys_reg(3, 5, 11, 0, 0),
        sys_reg(3, 5, 11, 15, 7), CGT_HCR_TIDCP),
 SR_RANGE_TRAP(sys_reg(3, 6, 11, 0, 0),
        sys_reg(3, 6, 11, 15, 7), CGT_HCR_TIDCP),
 SR_RANGE_TRAP(sys_reg(3, 7, 11, 0, 0),
        sys_reg(3, 7, 11, 15, 7), CGT_HCR_TIDCP),
 SR_RANGE_TRAP(sys_reg(3, 0, 15, 0, 0),
        sys_reg(3, 0, 15, 15, 7), CGT_HCR_TIDCP),
 SR_RANGE_TRAP(sys_reg(3, 1, 15, 0, 0),
        sys_reg(3, 1, 15, 15, 7), CGT_HCR_TIDCP),
 SR_RANGE_TRAP(sys_reg(3, 2, 15, 0, 0),
        sys_reg(3, 2, 15, 15, 7), CGT_HCR_TIDCP),
 SR_RANGE_TRAP(sys_reg(3, 3, 15, 0, 0),
        sys_reg(3, 3, 15, 15, 7), CGT_HCR_TIDCP),
 SR_RANGE_TRAP(sys_reg(3, 4, 15, 0, 0),
        sys_reg(3, 4, 15, 15, 7), CGT_HCR_TIDCP),
 SR_RANGE_TRAP(sys_reg(3, 5, 15, 0, 0),
        sys_reg(3, 5, 15, 15, 7), CGT_HCR_TIDCP),
 SR_RANGE_TRAP(sys_reg(3, 6, 15, 0, 0),
        sys_reg(3, 6, 15, 15, 7), CGT_HCR_TIDCP),
 SR_RANGE_TRAP(sys_reg(3, 7, 15, 0, 0),
        sys_reg(3, 7, 15, 15, 7), CGT_HCR_TIDCP),
 SR_TRAP(SYS_ACTLR_EL1,  CGT_HCR_TACR),
 SR_TRAP(SYS_DC_ISW,  CGT_HCR_TSW),
 SR_TRAP(SYS_DC_CSW,  CGT_HCR_TSW),
 SR_TRAP(SYS_DC_CISW,  CGT_HCR_TSW),
 SR_TRAP(SYS_DC_IGSW,  CGT_HCR_TSW),
 SR_TRAP(SYS_DC_IGDSW,  CGT_HCR_TSW),
 SR_TRAP(SYS_DC_CGSW,  CGT_HCR_TSW),
 SR_TRAP(SYS_DC_CGDSW,  CGT_HCR_TSW),
 SR_TRAP(SYS_DC_CIGSW,  CGT_HCR_TSW),
 SR_TRAP(SYS_DC_CIGDSW,  CGT_HCR_TSW),
 SR_TRAP(SYS_DC_CIVAC,  CGT_HCR_TPC),
 SR_TRAP(SYS_DC_CVAC,  CGT_HCR_TPC),
 SR_TRAP(SYS_DC_CVAP,  CGT_HCR_TPC),
 SR_TRAP(SYS_DC_CVADP,  CGT_HCR_TPC),
 SR_TRAP(SYS_DC_IVAC,  CGT_HCR_TPC),
 SR_TRAP(SYS_DC_CIGVAC,  CGT_HCR_TPC),
 SR_TRAP(SYS_DC_CIGDVAC,  CGT_HCR_TPC),
 SR_TRAP(SYS_DC_IGVAC,  CGT_HCR_TPC),
 SR_TRAP(SYS_DC_IGDVAC,  CGT_HCR_TPC),
 SR_TRAP(SYS_DC_CGVAC,  CGT_HCR_TPC),
 SR_TRAP(SYS_DC_CGDVAC,  CGT_HCR_TPC),
 SR_TRAP(SYS_DC_CGVAP,  CGT_HCR_TPC),
 SR_TRAP(SYS_DC_CGDVAP,  CGT_HCR_TPC),
 SR_TRAP(SYS_DC_CGVADP,  CGT_HCR_TPC),
 SR_TRAP(SYS_DC_CGDVADP,  CGT_HCR_TPC),
 SR_TRAP(SYS_IC_IVAU,  CGT_HCR_TPU_TOCU),
 SR_TRAP(SYS_IC_IALLU,  CGT_HCR_TPU_TOCU),
 SR_TRAP(SYS_IC_IALLUIS,  CGT_HCR_TPU_TICAB),
 SR_TRAP(SYS_DC_CVAU,  CGT_HCR_TPU_TOCU),
 SR_TRAP(OP_TLBI_RVAE1,  CGT_HCR_TTLB),
 SR_TRAP(OP_TLBI_RVAAE1,  CGT_HCR_TTLB),
 SR_TRAP(OP_TLBI_RVALE1,  CGT_HCR_TTLB),
 SR_TRAP(OP_TLBI_RVAALE1, CGT_HCR_TTLB),
 SR_TRAP(OP_TLBI_VMALLE1, CGT_HCR_TTLB),
 SR_TRAP(OP_TLBI_VAE1,  CGT_HCR_TTLB),
 SR_TRAP(OP_TLBI_ASIDE1,  CGT_HCR_TTLB),
 SR_TRAP(OP_TLBI_VAAE1,  CGT_HCR_TTLB),
 SR_TRAP(OP_TLBI_VALE1,  CGT_HCR_TTLB),
 SR_TRAP(OP_TLBI_VAALE1,  CGT_HCR_TTLB),
 SR_TRAP(OP_TLBI_RVAE1NXS, CGT_HCR_TTLB),
 SR_TRAP(OP_TLBI_RVAAE1NXS, CGT_HCR_TTLB),
 SR_TRAP(OP_TLBI_RVALE1NXS, CGT_HCR_TTLB),
 SR_TRAP(OP_TLBI_RVAALE1NXS, CGT_HCR_TTLB),
 SR_TRAP(OP_TLBI_VMALLE1NXS, CGT_HCR_TTLB),
 SR_TRAP(OP_TLBI_VAE1NXS, CGT_HCR_TTLB),
 SR_TRAP(OP_TLBI_ASIDE1NXS, CGT_HCR_TTLB),
 SR_TRAP(OP_TLBI_VAAE1NXS, CGT_HCR_TTLB),
 SR_TRAP(OP_TLBI_VALE1NXS, CGT_HCR_TTLB),
 SR_TRAP(OP_TLBI_VAALE1NXS, CGT_HCR_TTLB),
 SR_TRAP(OP_TLBI_RVAE1IS, CGT_HCR_TTLB_TTLBIS),
 SR_TRAP(OP_TLBI_RVAAE1IS, CGT_HCR_TTLB_TTLBIS),
 SR_TRAP(OP_TLBI_RVALE1IS, CGT_HCR_TTLB_TTLBIS),
 SR_TRAP(OP_TLBI_RVAALE1IS, CGT_HCR_TTLB_TTLBIS),
 SR_TRAP(OP_TLBI_VMALLE1IS, CGT_HCR_TTLB_TTLBIS),
 SR_TRAP(OP_TLBI_VAE1IS,  CGT_HCR_TTLB_TTLBIS),
 SR_TRAP(OP_TLBI_ASIDE1IS, CGT_HCR_TTLB_TTLBIS),
 SR_TRAP(OP_TLBI_VAAE1IS, CGT_HCR_TTLB_TTLBIS),
 SR_TRAP(OP_TLBI_VALE1IS, CGT_HCR_TTLB_TTLBIS),
 SR_TRAP(OP_TLBI_VAALE1IS, CGT_HCR_TTLB_TTLBIS),
 SR_TRAP(OP_TLBI_RVAE1ISNXS, CGT_HCR_TTLB_TTLBIS),
 SR_TRAP(OP_TLBI_RVAAE1ISNXS, CGT_HCR_TTLB_TTLBIS),
 SR_TRAP(OP_TLBI_RVALE1ISNXS, CGT_HCR_TTLB_TTLBIS),
 SR_TRAP(OP_TLBI_RVAALE1ISNXS, CGT_HCR_TTLB_TTLBIS),
 SR_TRAP(OP_TLBI_VMALLE1ISNXS, CGT_HCR_TTLB_TTLBIS),
 SR_TRAP(OP_TLBI_VAE1ISNXS, CGT_HCR_TTLB_TTLBIS),
 SR_TRAP(OP_TLBI_ASIDE1ISNXS, CGT_HCR_TTLB_TTLBIS),
 SR_TRAP(OP_TLBI_VAAE1ISNXS, CGT_HCR_TTLB_TTLBIS),
 SR_TRAP(OP_TLBI_VALE1ISNXS, CGT_HCR_TTLB_TTLBIS),
 SR_TRAP(OP_TLBI_VAALE1ISNXS, CGT_HCR_TTLB_TTLBIS),
 SR_TRAP(OP_TLBI_VMALLE1OS, CGT_HCR_TTLB_TTLBOS),
 SR_TRAP(OP_TLBI_VAE1OS,  CGT_HCR_TTLB_TTLBOS),
 SR_TRAP(OP_TLBI_ASIDE1OS, CGT_HCR_TTLB_TTLBOS),
 SR_TRAP(OP_TLBI_VAAE1OS, CGT_HCR_TTLB_TTLBOS),
 SR_TRAP(OP_TLBI_VALE1OS, CGT_HCR_TTLB_TTLBOS),
 SR_TRAP(OP_TLBI_VAALE1OS, CGT_HCR_TTLB_TTLBOS),
 SR_TRAP(OP_TLBI_RVAE1OS, CGT_HCR_TTLB_TTLBOS),
 SR_TRAP(OP_TLBI_RVAAE1OS, CGT_HCR_TTLB_TTLBOS),
 SR_TRAP(OP_TLBI_RVALE1OS, CGT_HCR_TTLB_TTLBOS),
 SR_TRAP(OP_TLBI_RVAALE1OS, CGT_HCR_TTLB_TTLBOS),
 SR_TRAP(OP_TLBI_VMALLE1OSNXS, CGT_HCR_TTLB_TTLBOS),
 SR_TRAP(OP_TLBI_VAE1OSNXS, CGT_HCR_TTLB_TTLBOS),
 SR_TRAP(OP_TLBI_ASIDE1OSNXS, CGT_HCR_TTLB_TTLBOS),
 SR_TRAP(OP_TLBI_VAAE1OSNXS, CGT_HCR_TTLB_TTLBOS),
 SR_TRAP(OP_TLBI_VALE1OSNXS, CGT_HCR_TTLB_TTLBOS),
 SR_TRAP(OP_TLBI_VAALE1OSNXS, CGT_HCR_TTLB_TTLBOS),
 SR_TRAP(OP_TLBI_RVAE1OSNXS, CGT_HCR_TTLB_TTLBOS),
 SR_TRAP(OP_TLBI_RVAAE1OSNXS, CGT_HCR_TTLB_TTLBOS),
 SR_TRAP(OP_TLBI_RVALE1OSNXS, CGT_HCR_TTLB_TTLBOS),
 SR_TRAP(OP_TLBI_RVAALE1OSNXS, CGT_HCR_TTLB_TTLBOS),
 SR_TRAP(SYS_SCTLR_EL1,  CGT_HCR_TVM_TRVM),
 SR_TRAP(SYS_SCTLR2_EL1,  CGT_HCR_TVM_TRVM_HCRX_SCTLR2En),
 SR_TRAP(SYS_TTBR0_EL1,  CGT_HCR_TVM_TRVM),
 SR_TRAP(SYS_TTBR1_EL1,  CGT_HCR_TVM_TRVM),
 SR_TRAP(SYS_TCR_EL1,  CGT_HCR_TVM_TRVM),
 SR_TRAP(SYS_ESR_EL1,  CGT_HCR_TVM_TRVM),
 SR_TRAP(SYS_FAR_EL1,  CGT_HCR_TVM_TRVM),
 SR_TRAP(SYS_AFSR0_EL1,  CGT_HCR_TVM_TRVM),
 SR_TRAP(SYS_AFSR1_EL1,  CGT_HCR_TVM_TRVM),
 SR_TRAP(SYS_MAIR_EL1,  CGT_HCR_TVM_TRVM),
 SR_TRAP(SYS_AMAIR_EL1,  CGT_HCR_TVM_TRVM),
 SR_TRAP(SYS_CONTEXTIDR_EL1, CGT_HCR_TVM_TRVM),
 SR_TRAP(SYS_PIR_EL1,  CGT_HCR_TVM_TRVM),
 SR_TRAP(SYS_PIRE0_EL1,  CGT_HCR_TVM_TRVM),
 SR_TRAP(SYS_POR_EL0,  CGT_HCR_TVM_TRVM),
 SR_TRAP(SYS_POR_EL1,  CGT_HCR_TVM_TRVM),
 SR_TRAP(SYS_TCR2_EL1,  CGT_HCR_TVM_TRVM_HCRX_TCR2En),
 SR_TRAP(SYS_DC_ZVA,  CGT_HCR_TDZ),
 SR_TRAP(SYS_DC_GVA,  CGT_HCR_TDZ),
 SR_TRAP(SYS_DC_GZVA,  CGT_HCR_TDZ),
 SR_TRAP(SYS_LORSA_EL1,  CGT_HCR_TLOR),
 SR_TRAP(SYS_LOREA_EL1,   CGT_HCR_TLOR),
 SR_TRAP(SYS_LORN_EL1,   CGT_HCR_TLOR),
 SR_TRAP(SYS_LORC_EL1,   CGT_HCR_TLOR),
 SR_TRAP(SYS_LORID_EL1,  CGT_HCR_TLOR),
 SR_TRAP(SYS_ERRIDR_EL1,  CGT_HCR_TERR),
 SR_TRAP(SYS_ERRSELR_EL1, CGT_HCR_TERR),
 SR_TRAP(SYS_ERXADDR_EL1, CGT_HCR_TERR),
 SR_TRAP(SYS_ERXCTLR_EL1, CGT_HCR_TERR),
 SR_TRAP(SYS_ERXFR_EL1,  CGT_HCR_TERR),
 SR_TRAP(SYS_ERXMISC0_EL1, CGT_HCR_TERR),
 SR_TRAP(SYS_ERXMISC1_EL1, CGT_HCR_TERR),
 SR_TRAP(SYS_ERXMISC2_EL1, CGT_HCR_TERR),
 SR_TRAP(SYS_ERXMISC3_EL1, CGT_HCR_TERR),
 SR_TRAP(SYS_ERXSTATUS_EL1, CGT_HCR_TERR),
 SR_TRAP(SYS_APIAKEYLO_EL1, CGT_HCR_APK),
 SR_TRAP(SYS_APIAKEYHI_EL1, CGT_HCR_APK),
 SR_TRAP(SYS_APIBKEYLO_EL1, CGT_HCR_APK),
 SR_TRAP(SYS_APIBKEYHI_EL1, CGT_HCR_APK),
 SR_TRAP(SYS_APDAKEYLO_EL1, CGT_HCR_APK),
 SR_TRAP(SYS_APDAKEYHI_EL1, CGT_HCR_APK),
 SR_TRAP(SYS_APDBKEYLO_EL1, CGT_HCR_APK),
 SR_TRAP(SYS_APDBKEYHI_EL1, CGT_HCR_APK),
 SR_TRAP(SYS_APGAKEYLO_EL1, CGT_HCR_APK),
 SR_TRAP(SYS_APGAKEYHI_EL1, CGT_HCR_APK),
 /* All _EL2 registers */
 SR_TRAP(SYS_BRBCR_EL2,  CGT_HCR_NV),
 SR_TRAP(SYS_VPIDR_EL2,  CGT_HCR_NV),
 SR_TRAP(SYS_VMPIDR_EL2,  CGT_HCR_NV),
 SR_TRAP(SYS_SCTLR_EL2,  CGT_HCR_NV),
 SR_TRAP(SYS_ACTLR_EL2,  CGT_HCR_NV),
 SR_TRAP(SYS_SCTLR2_EL2,  CGT_HCR_NV),
 SR_RANGE_TRAP(SYS_HCR_EL2,
        SYS_HCRX_EL2, CGT_HCR_NV),
 SR_TRAP(SYS_SMPRIMAP_EL2, CGT_HCR_NV),
 SR_TRAP(SYS_SMCR_EL2,  CGT_HCR_NV),
 SR_RANGE_TRAP(SYS_TTBR0_EL2,
        SYS_TCR2_EL2, CGT_HCR_NV),
 SR_TRAP(SYS_VTTBR_EL2,  CGT_HCR_NV),
 SR_TRAP(SYS_VTCR_EL2,  CGT_HCR_NV),
 SR_TRAP(SYS_VNCR_EL2,  CGT_HCR_NV),
 SR_RANGE_TRAP(SYS_HDFGRTR_EL2,
        SYS_HAFGRTR_EL2, CGT_HCR_NV),
 /* Skip the SP_EL1 encoding... */
 SR_TRAP(SYS_SPSR_EL2,  CGT_HCR_NV),
 SR_TRAP(SYS_ELR_EL2,  CGT_HCR_NV),
 /* Skip SPSR_irq, SPSR_abt, SPSR_und, SPSR_fiq */
 SR_TRAP(SYS_AFSR0_EL2,  CGT_HCR_NV),
 SR_TRAP(SYS_AFSR1_EL2,  CGT_HCR_NV),
 SR_TRAP(SYS_ESR_EL2,  CGT_HCR_NV),
 SR_TRAP(SYS_VSESR_EL2,  CGT_HCR_NV),
 SR_TRAP(SYS_TFSR_EL2,  CGT_HCR_NV),
 SR_TRAP(SYS_FAR_EL2,  CGT_HCR_NV),
 SR_TRAP(SYS_HPFAR_EL2,  CGT_HCR_NV),
 SR_TRAP(SYS_PMSCR_EL2,  CGT_HCR_NV),
 SR_TRAP(SYS_MAIR_EL2,  CGT_HCR_NV),
 SR_TRAP(SYS_AMAIR_EL2,  CGT_HCR_NV),
 SR_TRAP(SYS_MPAMHCR_EL2, CGT_HCR_NV),
 SR_TRAP(SYS_MPAMVPMV_EL2, CGT_HCR_NV),
 SR_TRAP(SYS_MPAM2_EL2,  CGT_HCR_NV),
 SR_RANGE_TRAP(SYS_MPAMVPM0_EL2,
        SYS_MPAMVPM7_EL2, CGT_HCR_NV),
 /*
 * Note that the spec. describes a group of MEC registers
 * whose access should not trap, therefore skip the following:
 * MECID_A0_EL2, MECID_A1_EL2, MECID_P0_EL2,
 * MECID_P1_EL2, MECIDR_EL2, VMECID_A_EL2,
 * VMECID_P_EL2.
 */
 SR_RANGE_TRAP(SYS_VBAR_EL2,
        SYS_RMR_EL2, CGT_HCR_NV),
 SR_TRAP(SYS_VDISR_EL2,  CGT_HCR_NV),
 /* ICH_AP0R<m>_EL2 */
 SR_RANGE_TRAP(SYS_ICH_AP0R0_EL2,
        SYS_ICH_AP0R3_EL2, CGT_HCR_NV),
 /* ICH_AP1R<m>_EL2 */
 SR_RANGE_TRAP(SYS_ICH_AP1R0_EL2,
        SYS_ICH_AP1R3_EL2, CGT_HCR_NV),
 SR_TRAP(SYS_ICC_SRE_EL2, CGT_HCR_NV),
 SR_RANGE_TRAP(SYS_ICH_HCR_EL2,
        SYS_ICH_EISR_EL2, CGT_HCR_NV),
 SR_TRAP(SYS_ICH_ELRSR_EL2, CGT_HCR_NV),
 SR_TRAP(SYS_ICH_VMCR_EL2, CGT_HCR_NV),
 /* ICH_LR<m>_EL2 */
 SR_RANGE_TRAP(SYS_ICH_LR0_EL2,
        SYS_ICH_LR15_EL2, CGT_HCR_NV),
 SR_TRAP(SYS_CONTEXTIDR_EL2, CGT_HCR_NV),
 SR_TRAP(SYS_TPIDR_EL2,  CGT_HCR_NV),
 SR_TRAP(SYS_SCXTNUM_EL2, CGT_HCR_NV),
 /* AMEVCNTVOFF0<n>_EL2, AMEVCNTVOFF1<n>_EL2  */
 SR_RANGE_TRAP(SYS_AMEVCNTVOFF0n_EL2(0),
        SYS_AMEVCNTVOFF1n_EL2(15), CGT_HCR_NV),
 /* CNT*_EL2 */
 SR_TRAP(SYS_CNTVOFF_EL2, CGT_HCR_NV),
 SR_TRAP(SYS_CNTPOFF_EL2, CGT_HCR_NV),
 SR_TRAP(SYS_CNTHCTL_EL2, CGT_HCR_NV),
 SR_RANGE_TRAP(SYS_CNTHP_TVAL_EL2,
        SYS_CNTHP_CVAL_EL2, CGT_HCR_NV),
 SR_RANGE_TRAP(SYS_CNTHV_TVAL_EL2,
        SYS_CNTHV_CVAL_EL2, CGT_HCR_NV),
 /* All _EL02, _EL12 registers up to CNTKCTL_EL12*/
 SR_RANGE_TRAP(sys_reg(3, 5, 0, 0, 0),
        sys_reg(3, 5, 10, 15, 7), CGT_HCR_NV),
 SR_RANGE_TRAP(sys_reg(3, 5, 12, 0, 0),
        sys_reg(3, 5, 14, 1, 0), CGT_HCR_NV),
 SR_TRAP(SYS_CNTP_CTL_EL02, CGT_CNTHCTL_EL1NVPCT),
 SR_TRAP(SYS_CNTP_CVAL_EL02, CGT_CNTHCTL_EL1NVPCT),
 SR_TRAP(SYS_CNTV_CTL_EL02, CGT_CNTHCTL_EL1NVVCT),
 SR_TRAP(SYS_CNTV_CVAL_EL02, CGT_CNTHCTL_EL1NVVCT),
 SR_TRAP(OP_AT_S1E2R,  CGT_HCR_NV),
 SR_TRAP(OP_AT_S1E2W,  CGT_HCR_NV),
 SR_TRAP(OP_AT_S12E1R,  CGT_HCR_NV),
 SR_TRAP(OP_AT_S12E1W,  CGT_HCR_NV),
 SR_TRAP(OP_AT_S12E0R,  CGT_HCR_NV),
 SR_TRAP(OP_AT_S12E0W,  CGT_HCR_NV),
 SR_TRAP(OP_AT_S1E2A,  CGT_HCR_NV),
 SR_TRAP(OP_TLBI_IPAS2E1, CGT_HCR_NV),
 SR_TRAP(OP_TLBI_RIPAS2E1, CGT_HCR_NV),
 SR_TRAP(OP_TLBI_IPAS2LE1, CGT_HCR_NV),
 SR_TRAP(OP_TLBI_RIPAS2LE1, CGT_HCR_NV),
 SR_TRAP(OP_TLBI_RVAE2,  CGT_HCR_NV),
 SR_TRAP(OP_TLBI_RVALE2,  CGT_HCR_NV),
 SR_TRAP(OP_TLBI_ALLE2,  CGT_HCR_NV),
 SR_TRAP(OP_TLBI_VAE2,  CGT_HCR_NV),
 SR_TRAP(OP_TLBI_ALLE1,  CGT_HCR_NV),
 SR_TRAP(OP_TLBI_VALE2,  CGT_HCR_NV),
 SR_TRAP(OP_TLBI_VMALLS12E1, CGT_HCR_NV),
 SR_TRAP(OP_TLBI_IPAS2E1NXS, CGT_HCR_NV),
 SR_TRAP(OP_TLBI_RIPAS2E1NXS, CGT_HCR_NV),
 SR_TRAP(OP_TLBI_IPAS2LE1NXS, CGT_HCR_NV),
 SR_TRAP(OP_TLBI_RIPAS2LE1NXS, CGT_HCR_NV),
 SR_TRAP(OP_TLBI_RVAE2NXS, CGT_HCR_NV),
 SR_TRAP(OP_TLBI_RVALE2NXS, CGT_HCR_NV),
 SR_TRAP(OP_TLBI_ALLE2NXS, CGT_HCR_NV),
 SR_TRAP(OP_TLBI_VAE2NXS, CGT_HCR_NV),
 SR_TRAP(OP_TLBI_ALLE1NXS, CGT_HCR_NV),
 SR_TRAP(OP_TLBI_VALE2NXS, CGT_HCR_NV),
 SR_TRAP(OP_TLBI_VMALLS12E1NXS, CGT_HCR_NV),
 SR_TRAP(OP_TLBI_IPAS2E1IS, CGT_HCR_NV),
 SR_TRAP(OP_TLBI_RIPAS2E1IS, CGT_HCR_NV),
 SR_TRAP(OP_TLBI_IPAS2LE1IS, CGT_HCR_NV),
 SR_TRAP(OP_TLBI_RIPAS2LE1IS, CGT_HCR_NV),
 SR_TRAP(OP_TLBI_RVAE2IS, CGT_HCR_NV),
 SR_TRAP(OP_TLBI_RVALE2IS, CGT_HCR_NV),
 SR_TRAP(OP_TLBI_ALLE2IS, CGT_HCR_NV),
 SR_TRAP(OP_TLBI_VAE2IS,  CGT_HCR_NV),
 SR_TRAP(OP_TLBI_ALLE1IS, CGT_HCR_NV),
 SR_TRAP(OP_TLBI_VALE2IS, CGT_HCR_NV),
 SR_TRAP(OP_TLBI_VMALLS12E1IS, CGT_HCR_NV),
 SR_TRAP(OP_TLBI_IPAS2E1ISNXS, CGT_HCR_NV),
 SR_TRAP(OP_TLBI_RIPAS2E1ISNXS, CGT_HCR_NV),
 SR_TRAP(OP_TLBI_IPAS2LE1ISNXS, CGT_HCR_NV),
 SR_TRAP(OP_TLBI_RIPAS2LE1ISNXS, CGT_HCR_NV),
 SR_TRAP(OP_TLBI_RVAE2ISNXS, CGT_HCR_NV),
 SR_TRAP(OP_TLBI_RVALE2ISNXS, CGT_HCR_NV),
 SR_TRAP(OP_TLBI_ALLE2ISNXS, CGT_HCR_NV),
 SR_TRAP(OP_TLBI_VAE2ISNXS, CGT_HCR_NV),
 SR_TRAP(OP_TLBI_ALLE1ISNXS, CGT_HCR_NV),
 SR_TRAP(OP_TLBI_VALE2ISNXS, CGT_HCR_NV),
 SR_TRAP(OP_TLBI_VMALLS12E1ISNXS,CGT_HCR_NV),
 SR_TRAP(OP_TLBI_ALLE2OS, CGT_HCR_NV),
 SR_TRAP(OP_TLBI_VAE2OS,  CGT_HCR_NV),
 SR_TRAP(OP_TLBI_ALLE1OS, CGT_HCR_NV),
 SR_TRAP(OP_TLBI_VALE2OS, CGT_HCR_NV),
 SR_TRAP(OP_TLBI_VMALLS12E1OS, CGT_HCR_NV),
 SR_TRAP(OP_TLBI_IPAS2E1OS, CGT_HCR_NV),
 SR_TRAP(OP_TLBI_RIPAS2E1OS, CGT_HCR_NV),
 SR_TRAP(OP_TLBI_IPAS2LE1OS, CGT_HCR_NV),
 SR_TRAP(OP_TLBI_RIPAS2LE1OS, CGT_HCR_NV),
 SR_TRAP(OP_TLBI_RVAE2OS, CGT_HCR_NV),
 SR_TRAP(OP_TLBI_RVALE2OS, CGT_HCR_NV),
 SR_TRAP(OP_TLBI_ALLE2OSNXS, CGT_HCR_NV),
 SR_TRAP(OP_TLBI_VAE2OSNXS, CGT_HCR_NV),
 SR_TRAP(OP_TLBI_ALLE1OSNXS, CGT_HCR_NV),
 SR_TRAP(OP_TLBI_VALE2OSNXS, CGT_HCR_NV),
 SR_TRAP(OP_TLBI_VMALLS12E1OSNXS,CGT_HCR_NV),
 SR_TRAP(OP_TLBI_IPAS2E1OSNXS, CGT_HCR_NV),
 SR_TRAP(OP_TLBI_RIPAS2E1OSNXS, CGT_HCR_NV),
 SR_TRAP(OP_TLBI_IPAS2LE1OSNXS, CGT_HCR_NV),
 SR_TRAP(OP_TLBI_RIPAS2LE1OSNXS, CGT_HCR_NV),
 SR_TRAP(OP_TLBI_RVAE2OSNXS, CGT_HCR_NV),
 SR_TRAP(OP_TLBI_RVALE2OSNXS, CGT_HCR_NV),
 SR_TRAP(OP_CPP_RCTX,   CGT_HCR_NV),
 SR_TRAP(OP_DVP_RCTX,   CGT_HCR_NV),
 SR_TRAP(OP_CFP_RCTX,   CGT_HCR_NV),
 SR_TRAP(SYS_SP_EL1,  CGT_HCR_NV_nNV2),
 SR_TRAP(SYS_VBAR_EL1,  CGT_HCR_NV1_nNV2),
 SR_TRAP(SYS_ELR_EL1,  CGT_HCR_NV1_nNV2),
 SR_TRAP(SYS_SPSR_EL1,  CGT_HCR_NV1_nNV2),
 SR_TRAP(SYS_SCXTNUM_EL1, CGT_HCR_NV1_nNV2_ENSCXT),
 SR_TRAP(SYS_SCXTNUM_EL0, CGT_HCR_ENSCXT),
 SR_TRAP(OP_AT_S1E1R,   CGT_HCR_AT),
 SR_TRAP(OP_AT_S1E1W,   CGT_HCR_AT),
 SR_TRAP(OP_AT_S1E0R,   CGT_HCR_AT),
 SR_TRAP(OP_AT_S1E0W,   CGT_HCR_AT),
 SR_TRAP(OP_AT_S1E1RP,   CGT_HCR_AT),
 SR_TRAP(OP_AT_S1E1WP,   CGT_HCR_AT),
 SR_TRAP(OP_AT_S1E1A,  CGT_HCR_AT),
 SR_TRAP(SYS_ERXPFGF_EL1, CGT_HCR_nFIEN),
 SR_TRAP(SYS_ERXPFGCTL_EL1, CGT_HCR_nFIEN),
 SR_TRAP(SYS_ERXPFGCDN_EL1, CGT_HCR_nFIEN),
 SR_TRAP(SYS_PMCR_EL0,  CGT_MDCR_TPM_TPMCR),
 SR_TRAP(SYS_PMCNTENSET_EL0, CGT_MDCR_TPM),
 SR_TRAP(SYS_PMCNTENCLR_EL0, CGT_MDCR_TPM),
 SR_TRAP(SYS_PMOVSSET_EL0, CGT_MDCR_TPM),
 SR_TRAP(SYS_PMOVSCLR_EL0, CGT_MDCR_TPM),
 SR_TRAP(SYS_PMCEID0_EL0, CGT_MDCR_TPM),
 SR_TRAP(SYS_PMCEID1_EL0, CGT_MDCR_TPM),
 SR_TRAP(SYS_PMXEVTYPER_EL0, CGT_MDCR_TPM_HPMN),
 SR_TRAP(SYS_PMSWINC_EL0, CGT_MDCR_TPM),
 SR_TRAP(SYS_PMSELR_EL0,  CGT_MDCR_TPM),
 SR_TRAP(SYS_PMXEVCNTR_EL0, CGT_MDCR_TPM_HPMN),
 SR_TRAP(SYS_PMCCNTR_EL0, CGT_MDCR_TPM),
 SR_TRAP(SYS_PMUSERENR_EL0, CGT_MDCR_TPM),
 SR_TRAP(SYS_PMINTENSET_EL1, CGT_MDCR_TPM),
 SR_TRAP(SYS_PMINTENCLR_EL1, CGT_MDCR_TPM),
 SR_TRAP(SYS_PMMIR_EL1,  CGT_MDCR_TPM),
 SR_TRAP(SYS_PMEVCNTRn_EL0(0), CGT_MDCR_TPM_HPMN),
 SR_TRAP(SYS_PMEVCNTRn_EL0(1), CGT_MDCR_TPM_HPMN),
 SR_TRAP(SYS_PMEVCNTRn_EL0(2), CGT_MDCR_TPM_HPMN),
 SR_TRAP(SYS_PMEVCNTRn_EL0(3), CGT_MDCR_TPM_HPMN),
 SR_TRAP(SYS_PMEVCNTRn_EL0(4), CGT_MDCR_TPM_HPMN),
 SR_TRAP(SYS_PMEVCNTRn_EL0(5), CGT_MDCR_TPM_HPMN),
 SR_TRAP(SYS_PMEVCNTRn_EL0(6), CGT_MDCR_TPM_HPMN),
 SR_TRAP(SYS_PMEVCNTRn_EL0(7), CGT_MDCR_TPM_HPMN),
 SR_TRAP(SYS_PMEVCNTRn_EL0(8), CGT_MDCR_TPM_HPMN),
 SR_TRAP(SYS_PMEVCNTRn_EL0(9), CGT_MDCR_TPM_HPMN),
 SR_TRAP(SYS_PMEVCNTRn_EL0(10), CGT_MDCR_TPM_HPMN),
 SR_TRAP(SYS_PMEVCNTRn_EL0(11), CGT_MDCR_TPM_HPMN),
 SR_TRAP(SYS_PMEVCNTRn_EL0(12), CGT_MDCR_TPM_HPMN),
 SR_TRAP(SYS_PMEVCNTRn_EL0(13), CGT_MDCR_TPM_HPMN),
 SR_TRAP(SYS_PMEVCNTRn_EL0(14), CGT_MDCR_TPM_HPMN),
 SR_TRAP(SYS_PMEVCNTRn_EL0(15), CGT_MDCR_TPM_HPMN),
 SR_TRAP(SYS_PMEVCNTRn_EL0(16), CGT_MDCR_TPM_HPMN),
 SR_TRAP(SYS_PMEVCNTRn_EL0(17), CGT_MDCR_TPM_HPMN),
 SR_TRAP(SYS_PMEVCNTRn_EL0(18), CGT_MDCR_TPM_HPMN),
 SR_TRAP(SYS_PMEVCNTRn_EL0(19), CGT_MDCR_TPM_HPMN),
 SR_TRAP(SYS_PMEVCNTRn_EL0(20), CGT_MDCR_TPM_HPMN),
 SR_TRAP(SYS_PMEVCNTRn_EL0(21), CGT_MDCR_TPM_HPMN),
 SR_TRAP(SYS_PMEVCNTRn_EL0(22), CGT_MDCR_TPM_HPMN),
 SR_TRAP(SYS_PMEVCNTRn_EL0(23), CGT_MDCR_TPM_HPMN),
 SR_TRAP(SYS_PMEVCNTRn_EL0(24), CGT_MDCR_TPM_HPMN),
 SR_TRAP(SYS_PMEVCNTRn_EL0(25), CGT_MDCR_TPM_HPMN),
 SR_TRAP(SYS_PMEVCNTRn_EL0(26), CGT_MDCR_TPM_HPMN),
 SR_TRAP(SYS_PMEVCNTRn_EL0(27), CGT_MDCR_TPM_HPMN),
 SR_TRAP(SYS_PMEVCNTRn_EL0(28), CGT_MDCR_TPM_HPMN),
 SR_TRAP(SYS_PMEVCNTRn_EL0(29), CGT_MDCR_TPM_HPMN),
 SR_TRAP(SYS_PMEVCNTRn_EL0(30), CGT_MDCR_TPM_HPMN),
 SR_TRAP(SYS_PMEVTYPERn_EL0(0), CGT_MDCR_TPM_HPMN),
 SR_TRAP(SYS_PMEVTYPERn_EL0(1), CGT_MDCR_TPM_HPMN),
 SR_TRAP(SYS_PMEVTYPERn_EL0(2), CGT_MDCR_TPM_HPMN),
 SR_TRAP(SYS_PMEVTYPERn_EL0(3), CGT_MDCR_TPM_HPMN),
 SR_TRAP(SYS_PMEVTYPERn_EL0(4), CGT_MDCR_TPM_HPMN),
 SR_TRAP(SYS_PMEVTYPERn_EL0(5), CGT_MDCR_TPM_HPMN),
 SR_TRAP(SYS_PMEVTYPERn_EL0(6), CGT_MDCR_TPM_HPMN),
 SR_TRAP(SYS_PMEVTYPERn_EL0(7), CGT_MDCR_TPM_HPMN),
 SR_TRAP(SYS_PMEVTYPERn_EL0(8), CGT_MDCR_TPM_HPMN),
 SR_TRAP(SYS_PMEVTYPERn_EL0(9), CGT_MDCR_TPM_HPMN),
 SR_TRAP(SYS_PMEVTYPERn_EL0(10), CGT_MDCR_TPM_HPMN),
 SR_TRAP(SYS_PMEVTYPERn_EL0(11), CGT_MDCR_TPM_HPMN),
 SR_TRAP(SYS_PMEVTYPERn_EL0(12), CGT_MDCR_TPM_HPMN),
 SR_TRAP(SYS_PMEVTYPERn_EL0(13), CGT_MDCR_TPM_HPMN),
 SR_TRAP(SYS_PMEVTYPERn_EL0(14), CGT_MDCR_TPM_HPMN),
 SR_TRAP(SYS_PMEVTYPERn_EL0(15), CGT_MDCR_TPM_HPMN),
 SR_TRAP(SYS_PMEVTYPERn_EL0(16), CGT_MDCR_TPM_HPMN),
 SR_TRAP(SYS_PMEVTYPERn_EL0(17), CGT_MDCR_TPM_HPMN),
 SR_TRAP(SYS_PMEVTYPERn_EL0(18), CGT_MDCR_TPM_HPMN),
 SR_TRAP(SYS_PMEVTYPERn_EL0(19), CGT_MDCR_TPM_HPMN),
 SR_TRAP(SYS_PMEVTYPERn_EL0(20), CGT_MDCR_TPM_HPMN),
 SR_TRAP(SYS_PMEVTYPERn_EL0(21), CGT_MDCR_TPM_HPMN),
 SR_TRAP(SYS_PMEVTYPERn_EL0(22), CGT_MDCR_TPM_HPMN),
 SR_TRAP(SYS_PMEVTYPERn_EL0(23), CGT_MDCR_TPM_HPMN),
 SR_TRAP(SYS_PMEVTYPERn_EL0(24), CGT_MDCR_TPM_HPMN),
 SR_TRAP(SYS_PMEVTYPERn_EL0(25), CGT_MDCR_TPM_HPMN),
 SR_TRAP(SYS_PMEVTYPERn_EL0(26), CGT_MDCR_TPM_HPMN),
 SR_TRAP(SYS_PMEVTYPERn_EL0(27), CGT_MDCR_TPM_HPMN),
 SR_TRAP(SYS_PMEVTYPERn_EL0(28), CGT_MDCR_TPM_HPMN),
 SR_TRAP(SYS_PMEVTYPERn_EL0(29), CGT_MDCR_TPM_HPMN),
 SR_TRAP(SYS_PMEVTYPERn_EL0(30), CGT_MDCR_TPM_HPMN),
 SR_TRAP(SYS_PMCCFILTR_EL0, CGT_MDCR_TPM),
 SR_TRAP(SYS_MDCCSR_EL0,  CGT_MDCR_TDCC_TDE_TDA),
 SR_TRAP(SYS_MDCCINT_EL1, CGT_MDCR_TDCC_TDE_TDA),
 SR_TRAP(SYS_OSDTRRX_EL1, CGT_MDCR_TDCC_TDE_TDA),
 SR_TRAP(SYS_OSDTRTX_EL1, CGT_MDCR_TDCC_TDE_TDA),
 SR_TRAP(SYS_DBGDTR_EL0,  CGT_MDCR_TDCC_TDE_TDA),
 /*
 * Also covers DBGDTRRX_EL0, which has the same encoding as
 * SYS_DBGDTRTX_EL0...
 */
 SR_TRAP(SYS_DBGDTRTX_EL0, CGT_MDCR_TDCC_TDE_TDA),
 SR_TRAP(SYS_MDSCR_EL1,  CGT_MDCR_TDE_TDA),
 SR_TRAP(SYS_OSECCR_EL1,  CGT_MDCR_TDE_TDA),
 SR_TRAP(SYS_DBGBVRn_EL1(0), CGT_MDCR_TDE_TDA),
 SR_TRAP(SYS_DBGBVRn_EL1(1), CGT_MDCR_TDE_TDA),
 SR_TRAP(SYS_DBGBVRn_EL1(2), CGT_MDCR_TDE_TDA),
 SR_TRAP(SYS_DBGBVRn_EL1(3), CGT_MDCR_TDE_TDA),
 SR_TRAP(SYS_DBGBVRn_EL1(4), CGT_MDCR_TDE_TDA),
 SR_TRAP(SYS_DBGBVRn_EL1(5), CGT_MDCR_TDE_TDA),
 SR_TRAP(SYS_DBGBVRn_EL1(6), CGT_MDCR_TDE_TDA),
 SR_TRAP(SYS_DBGBVRn_EL1(7), CGT_MDCR_TDE_TDA),
 SR_TRAP(SYS_DBGBVRn_EL1(8), CGT_MDCR_TDE_TDA),
 SR_TRAP(SYS_DBGBVRn_EL1(9), CGT_MDCR_TDE_TDA),
 SR_TRAP(SYS_DBGBVRn_EL1(10), CGT_MDCR_TDE_TDA),
 SR_TRAP(SYS_DBGBVRn_EL1(11), CGT_MDCR_TDE_TDA),
 SR_TRAP(SYS_DBGBVRn_EL1(12), CGT_MDCR_TDE_TDA),
 SR_TRAP(SYS_DBGBVRn_EL1(13), CGT_MDCR_TDE_TDA),
 SR_TRAP(SYS_DBGBVRn_EL1(14), CGT_MDCR_TDE_TDA),
 SR_TRAP(SYS_DBGBVRn_EL1(15), CGT_MDCR_TDE_TDA),
 SR_TRAP(SYS_DBGBCRn_EL1(0), CGT_MDCR_TDE_TDA),
 SR_TRAP(SYS_DBGBCRn_EL1(1), CGT_MDCR_TDE_TDA),
 SR_TRAP(SYS_DBGBCRn_EL1(2), CGT_MDCR_TDE_TDA),
 SR_TRAP(SYS_DBGBCRn_EL1(3), CGT_MDCR_TDE_TDA),
 SR_TRAP(SYS_DBGBCRn_EL1(4), CGT_MDCR_TDE_TDA),
 SR_TRAP(SYS_DBGBCRn_EL1(5), CGT_MDCR_TDE_TDA),
 SR_TRAP(SYS_DBGBCRn_EL1(6), CGT_MDCR_TDE_TDA),
 SR_TRAP(SYS_DBGBCRn_EL1(7), CGT_MDCR_TDE_TDA),
 SR_TRAP(SYS_DBGBCRn_EL1(8), CGT_MDCR_TDE_TDA),
 SR_TRAP(SYS_DBGBCRn_EL1(9), CGT_MDCR_TDE_TDA),
 SR_TRAP(SYS_DBGBCRn_EL1(10), CGT_MDCR_TDE_TDA),
 SR_TRAP(SYS_DBGBCRn_EL1(11), CGT_MDCR_TDE_TDA),
 SR_TRAP(SYS_DBGBCRn_EL1(12), CGT_MDCR_TDE_TDA),
 SR_TRAP(SYS_DBGBCRn_EL1(13), CGT_MDCR_TDE_TDA),
 SR_TRAP(SYS_DBGBCRn_EL1(14), CGT_MDCR_TDE_TDA),
 SR_TRAP(SYS_DBGBCRn_EL1(15), CGT_MDCR_TDE_TDA),
 SR_TRAP(SYS_DBGWVRn_EL1(0), CGT_MDCR_TDE_TDA),
 SR_TRAP(SYS_DBGWVRn_EL1(1), CGT_MDCR_TDE_TDA),
 SR_TRAP(SYS_DBGWVRn_EL1(2), CGT_MDCR_TDE_TDA),
 SR_TRAP(SYS_DBGWVRn_EL1(3), CGT_MDCR_TDE_TDA),
 SR_TRAP(SYS_DBGWVRn_EL1(4), CGT_MDCR_TDE_TDA),
 SR_TRAP(SYS_DBGWVRn_EL1(5), CGT_MDCR_TDE_TDA),
 SR_TRAP(SYS_DBGWVRn_EL1(6), CGT_MDCR_TDE_TDA),
 SR_TRAP(SYS_DBGWVRn_EL1(7), CGT_MDCR_TDE_TDA),
 SR_TRAP(SYS_DBGWVRn_EL1(8), CGT_MDCR_TDE_TDA),
 SR_TRAP(SYS_DBGWVRn_EL1(9), CGT_MDCR_TDE_TDA),
 SR_TRAP(SYS_DBGWVRn_EL1(10), CGT_MDCR_TDE_TDA),
 SR_TRAP(SYS_DBGWVRn_EL1(11), CGT_MDCR_TDE_TDA),
 SR_TRAP(SYS_DBGWVRn_EL1(12), CGT_MDCR_TDE_TDA),
 SR_TRAP(SYS_DBGWVRn_EL1(13), CGT_MDCR_TDE_TDA),
 SR_TRAP(SYS_DBGWVRn_EL1(14), CGT_MDCR_TDE_TDA),
 SR_TRAP(SYS_DBGWVRn_EL1(15), CGT_MDCR_TDE_TDA),
 SR_TRAP(SYS_DBGWCRn_EL1(0), CGT_MDCR_TDE_TDA),
 SR_TRAP(SYS_DBGWCRn_EL1(1), CGT_MDCR_TDE_TDA),
 SR_TRAP(SYS_DBGWCRn_EL1(2), CGT_MDCR_TDE_TDA),
 SR_TRAP(SYS_DBGWCRn_EL1(3), CGT_MDCR_TDE_TDA),
 SR_TRAP(SYS_DBGWCRn_EL1(4), CGT_MDCR_TDE_TDA),
 SR_TRAP(SYS_DBGWCRn_EL1(5), CGT_MDCR_TDE_TDA),
 SR_TRAP(SYS_DBGWCRn_EL1(6), CGT_MDCR_TDE_TDA),
 SR_TRAP(SYS_DBGWCRn_EL1(7), CGT_MDCR_TDE_TDA),
 SR_TRAP(SYS_DBGWCRn_EL1(8), CGT_MDCR_TDE_TDA),
 SR_TRAP(SYS_DBGWCRn_EL1(9), CGT_MDCR_TDE_TDA),
 SR_TRAP(SYS_DBGWCRn_EL1(10), CGT_MDCR_TDE_TDA),
 SR_TRAP(SYS_DBGWCRn_EL1(11), CGT_MDCR_TDE_TDA),
 SR_TRAP(SYS_DBGWCRn_EL1(12), CGT_MDCR_TDE_TDA),
 SR_TRAP(SYS_DBGWCRn_EL1(13), CGT_MDCR_TDE_TDA),
 SR_TRAP(SYS_DBGWCRn_EL1(14), CGT_MDCR_TDE_TDA),
 SR_TRAP(SYS_DBGCLAIMSET_EL1, CGT_MDCR_TDE_TDA),
 SR_TRAP(SYS_DBGCLAIMCLR_EL1, CGT_MDCR_TDE_TDA),
 SR_TRAP(SYS_DBGAUTHSTATUS_EL1, CGT_MDCR_TDE_TDA),
 SR_TRAP(SYS_OSLAR_EL1,  CGT_MDCR_TDE_TDOSA),
 SR_TRAP(SYS_OSLSR_EL1,  CGT_MDCR_TDE_TDOSA),
 SR_TRAP(SYS_OSDLR_EL1,  CGT_MDCR_TDE_TDOSA),
 SR_TRAP(SYS_DBGPRCR_EL1, CGT_MDCR_TDE_TDOSA),
 SR_TRAP(SYS_MDRAR_EL1,  CGT_MDCR_TDE_TDRA),
 SR_TRAP(SYS_PMBLIMITR_EL1, CGT_MDCR_E2PB),
 SR_TRAP(SYS_PMBPTR_EL1,  CGT_MDCR_E2PB),
 SR_TRAP(SYS_PMBSR_EL1,  CGT_MDCR_E2PB),
 SR_TRAP(SYS_PMSCR_EL1,  CGT_MDCR_TPMS),
 SR_TRAP(SYS_PMSEVFR_EL1, CGT_MDCR_TPMS),
 SR_TRAP(SYS_PMSFCR_EL1,  CGT_MDCR_TPMS),
 SR_TRAP(SYS_PMSICR_EL1,  CGT_MDCR_TPMS),
 SR_TRAP(SYS_PMSIDR_EL1,  CGT_MDCR_TPMS),
 SR_TRAP(SYS_PMSIRR_EL1,  CGT_MDCR_TPMS),
 SR_TRAP(SYS_PMSLATFR_EL1, CGT_MDCR_TPMS),
 SR_TRAP(SYS_PMSNEVFR_EL1, CGT_MDCR_TPMS),
 SR_TRAP(SYS_TRFCR_EL1,  CGT_MDCR_TTRF),
 SR_TRAP(SYS_TRBBASER_EL1, CGT_MDCR_E2TB),
 SR_TRAP(SYS_TRBLIMITR_EL1, CGT_MDCR_E2TB),
 SR_TRAP(SYS_TRBMAR_EL1,  CGT_MDCR_E2TB),
 SR_TRAP(SYS_TRBPTR_EL1,  CGT_MDCR_E2TB),
 SR_TRAP(SYS_TRBSR_EL1,   CGT_MDCR_E2TB),
 SR_TRAP(SYS_TRBTRG_EL1,  CGT_MDCR_E2TB),
 SR_TRAP(SYS_CPACR_EL1,  CGT_CPTR_TCPAC),
 SR_TRAP(SYS_AMUSERENR_EL0, CGT_CPTR_TAM),
 SR_TRAP(SYS_AMCFGR_EL0,  CGT_CPTR_TAM),
 SR_TRAP(SYS_AMCGCR_EL0,  CGT_CPTR_TAM),
 SR_TRAP(SYS_AMCNTENCLR0_EL0, CGT_CPTR_TAM),
 SR_TRAP(SYS_AMCNTENCLR1_EL0, CGT_CPTR_TAM),
 SR_TRAP(SYS_AMCNTENSET0_EL0, CGT_CPTR_TAM),
 SR_TRAP(SYS_AMCNTENSET1_EL0, CGT_CPTR_TAM),
 SR_TRAP(SYS_AMCR_EL0,  CGT_CPTR_TAM),
 SR_TRAP(SYS_AMEVCNTR0_EL0(0), CGT_CPTR_TAM),
 SR_TRAP(SYS_AMEVCNTR0_EL0(1), CGT_CPTR_TAM),
 SR_TRAP(SYS_AMEVCNTR0_EL0(2), CGT_CPTR_TAM),
 SR_TRAP(SYS_AMEVCNTR0_EL0(3), CGT_CPTR_TAM),
 SR_TRAP(SYS_AMEVCNTR1_EL0(0), CGT_CPTR_TAM),
 SR_TRAP(SYS_AMEVCNTR1_EL0(1), CGT_CPTR_TAM),
 SR_TRAP(SYS_AMEVCNTR1_EL0(2), CGT_CPTR_TAM),
 SR_TRAP(SYS_AMEVCNTR1_EL0(3), CGT_CPTR_TAM),
 SR_TRAP(SYS_AMEVCNTR1_EL0(4), CGT_CPTR_TAM),
 SR_TRAP(SYS_AMEVCNTR1_EL0(5), CGT_CPTR_TAM),
 SR_TRAP(SYS_AMEVCNTR1_EL0(6), CGT_CPTR_TAM),
 SR_TRAP(SYS_AMEVCNTR1_EL0(7), CGT_CPTR_TAM),
 SR_TRAP(SYS_AMEVCNTR1_EL0(8), CGT_CPTR_TAM),
 SR_TRAP(SYS_AMEVCNTR1_EL0(9), CGT_CPTR_TAM),
 SR_TRAP(SYS_AMEVCNTR1_EL0(10), CGT_CPTR_TAM),
 SR_TRAP(SYS_AMEVCNTR1_EL0(11), CGT_CPTR_TAM),
 SR_TRAP(SYS_AMEVCNTR1_EL0(12), CGT_CPTR_TAM),
 SR_TRAP(SYS_AMEVCNTR1_EL0(13), CGT_CPTR_TAM),
 SR_TRAP(SYS_AMEVCNTR1_EL0(14), CGT_CPTR_TAM),
 SR_TRAP(SYS_AMEVCNTR1_EL0(15), CGT_CPTR_TAM),
 SR_TRAP(SYS_AMEVTYPER0_EL0(0), CGT_CPTR_TAM),
 SR_TRAP(SYS_AMEVTYPER0_EL0(1), CGT_CPTR_TAM),
 SR_TRAP(SYS_AMEVTYPER0_EL0(2), CGT_CPTR_TAM),
 SR_TRAP(SYS_AMEVTYPER0_EL0(3), CGT_CPTR_TAM),
 SR_TRAP(SYS_AMEVTYPER1_EL0(0), CGT_CPTR_TAM),
 SR_TRAP(SYS_AMEVTYPER1_EL0(1), CGT_CPTR_TAM),
 SR_TRAP(SYS_AMEVTYPER1_EL0(2), CGT_CPTR_TAM),
 SR_TRAP(SYS_AMEVTYPER1_EL0(3), CGT_CPTR_TAM),
 SR_TRAP(SYS_AMEVTYPER1_EL0(4), CGT_CPTR_TAM),
 SR_TRAP(SYS_AMEVTYPER1_EL0(5), CGT_CPTR_TAM),
 SR_TRAP(SYS_AMEVTYPER1_EL0(6), CGT_CPTR_TAM),
 SR_TRAP(SYS_AMEVTYPER1_EL0(7), CGT_CPTR_TAM),
 SR_TRAP(SYS_AMEVTYPER1_EL0(8), CGT_CPTR_TAM),
 SR_TRAP(SYS_AMEVTYPER1_EL0(9), CGT_CPTR_TAM),
 SR_TRAP(SYS_AMEVTYPER1_EL0(10), CGT_CPTR_TAM),
 SR_TRAP(SYS_AMEVTYPER1_EL0(11), CGT_CPTR_TAM),
 SR_TRAP(SYS_AMEVTYPER1_EL0(12), CGT_CPTR_TAM),
 SR_TRAP(SYS_AMEVTYPER1_EL0(13), CGT_CPTR_TAM),
 SR_TRAP(SYS_AMEVTYPER1_EL0(14), CGT_CPTR_TAM),
 SR_TRAP(SYS_AMEVTYPER1_EL0(15), CGT_CPTR_TAM),
 /* op0=2, op1=1, and CRn<0b1000 */
 SR_RANGE_TRAP(sys_reg(2, 1, 0, 0, 0),
        sys_reg(2, 1, 7, 15, 7), CGT_CPTR_TTA),
 SR_TRAP(SYS_CNTP_TVAL_EL0, CGT_CNTHCTL_EL1PTEN),
 SR_TRAP(SYS_CNTP_CVAL_EL0, CGT_CNTHCTL_EL1PTEN),
 SR_TRAP(SYS_CNTP_CTL_EL0, CGT_CNTHCTL_EL1PTEN),
 SR_TRAP(SYS_CNTPCT_EL0,  CGT_CNTHCTL_EL1PCTEN),
 SR_TRAP(SYS_CNTPCTSS_EL0, CGT_CNTHCTL_EL1PCTEN),
 SR_TRAP(SYS_CNTV_TVAL_EL0, CGT_CNTHCTL_EL1TVT),
 SR_TRAP(SYS_CNTV_CVAL_EL0, CGT_CNTHCTL_EL1TVT),
 SR_TRAP(SYS_CNTV_CTL_EL0, CGT_CNTHCTL_EL1TVT),
 SR_TRAP(SYS_CNTVCT_EL0,  CGT_CNTHCTL_EL1TVCT),
 SR_TRAP(SYS_CNTVCTSS_EL0, CGT_CNTHCTL_EL1TVCT),
 SR_TRAP(SYS_FPMR,  CGT_HCRX_EnFPM),
 /*
 * IMPDEF choice:
 * We treat ICC_SRE_EL2.{SRE,Enable) and ICV_SRE_EL1.SRE as
 * RAO/WI. We therefore never consider ICC_SRE_EL2.Enable for
 * ICC_SRE_EL1 access, and always handle it locally.
 */
 SR_TRAP(SYS_ICC_AP0R0_EL1, CGT_ICH_HCR_TALL0),
 SR_TRAP(SYS_ICC_AP0R1_EL1, CGT_ICH_HCR_TALL0),
 SR_TRAP(SYS_ICC_AP0R2_EL1, CGT_ICH_HCR_TALL0),
 SR_TRAP(SYS_ICC_AP0R3_EL1, CGT_ICH_HCR_TALL0),
 SR_TRAP(SYS_ICC_AP1R0_EL1, CGT_ICH_HCR_TALL1),
 SR_TRAP(SYS_ICC_AP1R1_EL1, CGT_ICH_HCR_TALL1),
 SR_TRAP(SYS_ICC_AP1R2_EL1, CGT_ICH_HCR_TALL1),
 SR_TRAP(SYS_ICC_AP1R3_EL1, CGT_ICH_HCR_TALL1),
 SR_TRAP(SYS_ICC_BPR0_EL1, CGT_ICH_HCR_TALL0),
 SR_TRAP(SYS_ICC_BPR1_EL1, CGT_ICH_HCR_TALL1),
 SR_TRAP(SYS_ICC_CTLR_EL1, CGT_ICH_HCR_TC),
 SR_TRAP(SYS_ICC_DIR_EL1, CGT_ICH_HCR_TC_TDIR),
 SR_TRAP(SYS_ICC_EOIR0_EL1, CGT_ICH_HCR_TALL0),
 SR_TRAP(SYS_ICC_EOIR1_EL1, CGT_ICH_HCR_TALL1),
 SR_TRAP(SYS_ICC_HPPIR0_EL1, CGT_ICH_HCR_TALL0),
 SR_TRAP(SYS_ICC_HPPIR1_EL1, CGT_ICH_HCR_TALL1),
 SR_TRAP(SYS_ICC_IAR0_EL1, CGT_ICH_HCR_TALL0),
 SR_TRAP(SYS_ICC_IAR1_EL1, CGT_ICH_HCR_TALL1),
 SR_TRAP(SYS_ICC_IGRPEN0_EL1, CGT_ICH_HCR_TALL0),
 SR_TRAP(SYS_ICC_IGRPEN1_EL1, CGT_ICH_HCR_TALL1),
 SR_TRAP(SYS_ICC_PMR_EL1, CGT_ICH_HCR_TC),
 SR_TRAP(SYS_ICC_RPR_EL1, CGT_ICH_HCR_TC),
};

static DEFINE_XARRAY(sr_forward_xa);

enum fg_filter_id {
 __NO_FGF__,
 HCRX_FGTnXS,

 /* Must be last */
 __NR_FG_FILTER_IDS__
};

#define __FGT(g, b, p, f)     \
  {      \
   .fgt = g ## _GROUP,   \
   .bit = g ## _EL2_ ## b ## _SHIFT, \
   .pol = p,    \
   .fgf = f,    \
  }

#define FGT(g, b, p)  __FGT(g, b, p, __NO_FGF__)

/*
 * See the warning next to SR_RANGE_TRAP(), and apply the same
 * level of caution.
 */
#define SR_FGF_RANGE(sr, e, g, b, p, f)    \
 {       \
  .encoding = sr,    \
  .end  = e,    \
  .tc  = __FGT(g, b, p, f),  \
  .line = __LINE__,    \
 }

#define SR_FGF(sr, g, b, p, f)  SR_FGF_RANGE(sr, sr, g, b, p, f)
#define SR_FGT(sr, g, b, p) SR_FGF_RANGE(sr, sr, g, b, p, __NO_FGF__)
#define SR_FGT_RANGE(sr, end, g, b, p) \
    SR_FGF_RANGE(sr, end, g, b, p, __NO_FGF__)

static const struct encoding_to_trap_config encoding_to_fgt[] __initconst = {
 /* HFGRTR_EL2, HFGWTR_EL2 */
 SR_FGT(SYS_AMAIR2_EL1,  HFGRTR, nAMAIR2_EL1, 0),
 SR_FGT(SYS_MAIR2_EL1,  HFGRTR, nMAIR2_EL1, 0),
 SR_FGT(SYS_S2POR_EL1,  HFGRTR, nS2POR_EL1, 0),
 SR_FGT(SYS_POR_EL1,  HFGRTR, nPOR_EL1, 0),
 SR_FGT(SYS_POR_EL0,  HFGRTR, nPOR_EL0, 0),
 SR_FGT(SYS_PIR_EL1,  HFGRTR, nPIR_EL1, 0),
 SR_FGT(SYS_PIRE0_EL1,  HFGRTR, nPIRE0_EL1, 0),
 SR_FGT(SYS_RCWMASK_EL1,  HFGRTR, nRCWMASK_EL1, 0),
 SR_FGT(SYS_TPIDR2_EL0,  HFGRTR, nTPIDR2_EL0, 0),
 SR_FGT(SYS_SMPRI_EL1,  HFGRTR, nSMPRI_EL1, 0),
 SR_FGT(SYS_GCSCR_EL1,  HFGRTR, nGCS_EL1, 0),
 SR_FGT(SYS_GCSPR_EL1,  HFGRTR, nGCS_EL1, 0),
 SR_FGT(SYS_GCSCRE0_EL1,  HFGRTR, nGCS_EL0, 0),
 SR_FGT(SYS_GCSPR_EL0,  HFGRTR, nGCS_EL0, 0),
 SR_FGT(SYS_ACCDATA_EL1,  HFGRTR, nACCDATA_EL1, 0),
 SR_FGT(SYS_ERXADDR_EL1,  HFGRTR, ERXADDR_EL1, 1),
 SR_FGT(SYS_ERXPFGCDN_EL1, HFGRTR, ERXPFGCDN_EL1, 1),
 SR_FGT(SYS_ERXPFGCTL_EL1, HFGRTR, ERXPFGCTL_EL1, 1),
 SR_FGT(SYS_ERXPFGF_EL1,  HFGRTR, ERXPFGF_EL1, 1),
 SR_FGT(SYS_ERXMISC0_EL1, HFGRTR, ERXMISCn_EL1, 1),
 SR_FGT(SYS_ERXMISC1_EL1, HFGRTR, ERXMISCn_EL1, 1),
 SR_FGT(SYS_ERXMISC2_EL1, HFGRTR, ERXMISCn_EL1, 1),
 SR_FGT(SYS_ERXMISC3_EL1, HFGRTR, ERXMISCn_EL1, 1),
 SR_FGT(SYS_ERXSTATUS_EL1, HFGRTR, ERXSTATUS_EL1, 1),
 SR_FGT(SYS_ERXCTLR_EL1,  HFGRTR, ERXCTLR_EL1, 1),
 SR_FGT(SYS_ERXFR_EL1,  HFGRTR, ERXFR_EL1, 1),
 SR_FGT(SYS_ERRSELR_EL1,  HFGRTR, ERRSELR_EL1, 1),
 SR_FGT(SYS_ERRIDR_EL1,  HFGRTR, ERRIDR_EL1, 1),
 SR_FGT(SYS_ICC_IGRPEN0_EL1, HFGRTR, ICC_IGRPENn_EL1, 1),
 SR_FGT(SYS_ICC_IGRPEN1_EL1, HFGRTR, ICC_IGRPENn_EL1, 1),
 SR_FGT(SYS_VBAR_EL1,  HFGRTR, VBAR_EL1, 1),
 SR_FGT(SYS_TTBR1_EL1,  HFGRTR, TTBR1_EL1, 1),
 SR_FGT(SYS_TTBR0_EL1,  HFGRTR, TTBR0_EL1, 1),
 SR_FGT(SYS_TPIDR_EL0,  HFGRTR, TPIDR_EL0, 1),
 SR_FGT(SYS_TPIDRRO_EL0,  HFGRTR, TPIDRRO_EL0, 1),
 SR_FGT(SYS_TPIDR_EL1,  HFGRTR, TPIDR_EL1, 1),
 SR_FGT(SYS_TCR_EL1,  HFGRTR, TCR_EL1, 1),
 SR_FGT(SYS_TCR2_EL1,  HFGRTR, TCR_EL1, 1),
 SR_FGT(SYS_SCXTNUM_EL0,  HFGRTR, SCXTNUM_EL0, 1),
 SR_FGT(SYS_SCXTNUM_EL1,  HFGRTR, SCXTNUM_EL1, 1),
 SR_FGT(SYS_SCTLR_EL1,   HFGRTR, SCTLR_EL1, 1),
 SR_FGT(SYS_SCTLR2_EL1,  HFGRTR, SCTLR_EL1, 1),
 SR_FGT(SYS_REVIDR_EL1,   HFGRTR, REVIDR_EL1, 1),
 SR_FGT(SYS_PAR_EL1,   HFGRTR, PAR_EL1, 1),
 SR_FGT(SYS_MPIDR_EL1,   HFGRTR, MPIDR_EL1, 1),
 SR_FGT(SYS_MIDR_EL1,   HFGRTR, MIDR_EL1, 1),
 SR_FGT(SYS_MAIR_EL1,   HFGRTR, MAIR_EL1, 1),
 SR_FGT(SYS_LORSA_EL1,   HFGRTR, LORSA_EL1, 1),
 SR_FGT(SYS_LORN_EL1,   HFGRTR, LORN_EL1, 1),
 SR_FGT(SYS_LORID_EL1,   HFGRTR, LORID_EL1, 1),
 SR_FGT(SYS_LOREA_EL1,   HFGRTR, LOREA_EL1, 1),
 SR_FGT(SYS_LORC_EL1,   HFGRTR, LORC_EL1, 1),
 SR_FGT(SYS_ISR_EL1,   HFGRTR, ISR_EL1, 1),
 SR_FGT(SYS_FAR_EL1,   HFGRTR, FAR_EL1, 1),
 SR_FGT(SYS_ESR_EL1,   HFGRTR, ESR_EL1, 1),
 SR_FGT(SYS_DCZID_EL0,   HFGRTR, DCZID_EL0, 1),
 SR_FGT(SYS_CTR_EL0,   HFGRTR, CTR_EL0, 1),
 SR_FGT(SYS_CSSELR_EL1,   HFGRTR, CSSELR_EL1, 1),
 SR_FGT(SYS_CPACR_EL1,   HFGRTR, CPACR_EL1, 1),
 SR_FGT(SYS_CONTEXTIDR_EL1,  HFGRTR, CONTEXTIDR_EL1, 1),
 SR_FGT(SYS_CLIDR_EL1,   HFGRTR, CLIDR_EL1, 1),
 SR_FGT(SYS_CCSIDR_EL1,   HFGRTR, CCSIDR_EL1, 1),
 SR_FGT(SYS_APIBKEYLO_EL1,  HFGRTR, APIBKey, 1),
 SR_FGT(SYS_APIBKEYHI_EL1,  HFGRTR, APIBKey, 1),
 SR_FGT(SYS_APIAKEYLO_EL1,  HFGRTR, APIAKey, 1),
 SR_FGT(SYS_APIAKEYHI_EL1,  HFGRTR, APIAKey, 1),
 SR_FGT(SYS_APGAKEYLO_EL1,  HFGRTR, APGAKey, 1),
 SR_FGT(SYS_APGAKEYHI_EL1,  HFGRTR, APGAKey, 1),
 SR_FGT(SYS_APDBKEYLO_EL1,  HFGRTR, APDBKey, 1),
 SR_FGT(SYS_APDBKEYHI_EL1,  HFGRTR, APDBKey, 1),
 SR_FGT(SYS_APDAKEYLO_EL1,  HFGRTR, APDAKey, 1),
 SR_FGT(SYS_APDAKEYHI_EL1,  HFGRTR, APDAKey, 1),
 SR_FGT(SYS_AMAIR_EL1,   HFGRTR, AMAIR_EL1, 1),
 SR_FGT(SYS_AIDR_EL1,   HFGRTR, AIDR_EL1, 1),
 SR_FGT(SYS_AFSR1_EL1,   HFGRTR, AFSR1_EL1, 1),
 SR_FGT(SYS_AFSR0_EL1,   HFGRTR, AFSR0_EL1, 1),

 /* HFGRTR2_EL2, HFGWTR2_EL2 */
 SR_FGT(SYS_ACTLRALIAS_EL1, HFGRTR2, nACTLRALIAS_EL1, 0),
 SR_FGT(SYS_ACTLRMASK_EL1, HFGRTR2, nACTLRMASK_EL1, 0),
 SR_FGT(SYS_CPACRALIAS_EL1, HFGRTR2, nCPACRALIAS_EL1, 0),
 SR_FGT(SYS_CPACRMASK_EL1, HFGRTR2, nCPACRMASK_EL1, 0),
 SR_FGT(SYS_PFAR_EL1,  HFGRTR2, nPFAR_EL1, 0),
 SR_FGT(SYS_RCWSMASK_EL1, HFGRTR2, nRCWSMASK_EL1, 0),
 SR_FGT(SYS_SCTLR2ALIAS_EL1, HFGRTR2, nSCTLRALIAS2_EL1, 0),
 SR_FGT(SYS_SCTLR2MASK_EL1, HFGRTR2, nSCTLR2MASK_EL1, 0),
 SR_FGT(SYS_SCTLRALIAS_EL1, HFGRTR2, nSCTLRALIAS_EL1, 0),
 SR_FGT(SYS_SCTLRMASK_EL1, HFGRTR2, nSCTLRMASK_EL1, 0),
 SR_FGT(SYS_TCR2ALIAS_EL1, HFGRTR2, nTCR2ALIAS_EL1, 0),
 SR_FGT(SYS_TCR2MASK_EL1, HFGRTR2, nTCR2MASK_EL1, 0),
 SR_FGT(SYS_TCRALIAS_EL1, HFGRTR2, nTCRALIAS_EL1, 0),
 SR_FGT(SYS_TCRMASK_EL1,  HFGRTR2, nTCRMASK_EL1, 0),
 SR_FGT(SYS_ERXGSR_EL1,  HFGRTR2, nERXGSR_EL1, 0),

 /* HFGITR_EL2 */
 SR_FGT(OP_AT_S1E1A,   HFGITR, ATS1E1A, 1),
 SR_FGT(OP_COSP_RCTX,   HFGITR, COSPRCTX, 1),
 SR_FGT(OP_GCSPUSHX,   HFGITR, nGCSEPP, 0),
 SR_FGT(OP_GCSPOPX,   HFGITR, nGCSEPP, 0),
 SR_FGT(OP_GCSPUSHM,   HFGITR, nGCSPUSHM_EL1, 0),
 SR_FGT(OP_BRB_IALL,   HFGITR, nBRBIALL, 0),
 SR_FGT(OP_BRB_INJ,   HFGITR, nBRBINJ, 0),
 SR_FGT(SYS_DC_CVAC,   HFGITR, DCCVAC, 1),
 SR_FGT(SYS_DC_CGVAC,   HFGITR, DCCVAC, 1),
 SR_FGT(SYS_DC_CGDVAC,   HFGITR, DCCVAC, 1),
 SR_FGT(OP_CPP_RCTX,   HFGITR, CPPRCTX, 1),
 SR_FGT(OP_DVP_RCTX,   HFGITR, DVPRCTX, 1),
 SR_FGT(OP_CFP_RCTX,   HFGITR, CFPRCTX, 1),
 SR_FGT(OP_TLBI_VAALE1,   HFGITR, TLBIVAALE1, 1),
 SR_FGT(OP_TLBI_VALE1,   HFGITR, TLBIVALE1, 1),
 SR_FGT(OP_TLBI_VAAE1,   HFGITR, TLBIVAAE1, 1),
 SR_FGT(OP_TLBI_ASIDE1,   HFGITR, TLBIASIDE1, 1),
 SR_FGT(OP_TLBI_VAE1,   HFGITR, TLBIVAE1, 1),
 SR_FGT(OP_TLBI_VMALLE1,  HFGITR, TLBIVMALLE1, 1),
 SR_FGT(OP_TLBI_RVAALE1,  HFGITR, TLBIRVAALE1, 1),
 SR_FGT(OP_TLBI_RVALE1,   HFGITR, TLBIRVALE1, 1),
 SR_FGT(OP_TLBI_RVAAE1,   HFGITR, TLBIRVAAE1, 1),
 SR_FGT(OP_TLBI_RVAE1,   HFGITR, TLBIRVAE1, 1),
 SR_FGT(OP_TLBI_RVAALE1IS,  HFGITR, TLBIRVAALE1IS, 1),
 SR_FGT(OP_TLBI_RVALE1IS,  HFGITR, TLBIRVALE1IS, 1),
 SR_FGT(OP_TLBI_RVAAE1IS,  HFGITR, TLBIRVAAE1IS, 1),
 SR_FGT(OP_TLBI_RVAE1IS,  HFGITR, TLBIRVAE1IS, 1),
 SR_FGT(OP_TLBI_VAALE1IS,  HFGITR, TLBIVAALE1IS, 1),
 SR_FGT(OP_TLBI_VALE1IS,  HFGITR, TLBIVALE1IS, 1),
 SR_FGT(OP_TLBI_VAAE1IS,  HFGITR, TLBIVAAE1IS, 1),
 SR_FGT(OP_TLBI_ASIDE1IS,  HFGITR, TLBIASIDE1IS, 1),
 SR_FGT(OP_TLBI_VAE1IS,   HFGITR, TLBIVAE1IS, 1),
 SR_FGT(OP_TLBI_VMALLE1IS,  HFGITR, TLBIVMALLE1IS, 1),
 SR_FGT(OP_TLBI_RVAALE1OS,  HFGITR, TLBIRVAALE1OS, 1),
 SR_FGT(OP_TLBI_RVALE1OS,  HFGITR, TLBIRVALE1OS, 1),
 SR_FGT(OP_TLBI_RVAAE1OS,  HFGITR, TLBIRVAAE1OS, 1),
 SR_FGT(OP_TLBI_RVAE1OS,  HFGITR, TLBIRVAE1OS, 1),
 SR_FGT(OP_TLBI_VAALE1OS,  HFGITR, TLBIVAALE1OS, 1),
 SR_FGT(OP_TLBI_VALE1OS,  HFGITR, TLBIVALE1OS, 1),
 SR_FGT(OP_TLBI_VAAE1OS,  HFGITR, TLBIVAAE1OS, 1),
 SR_FGT(OP_TLBI_ASIDE1OS,  HFGITR, TLBIASIDE1OS, 1),
 SR_FGT(OP_TLBI_VAE1OS,   HFGITR, TLBIVAE1OS, 1),
 SR_FGT(OP_TLBI_VMALLE1OS,  HFGITR, TLBIVMALLE1OS, 1),
 /* nXS variants must be checked against HCRX_EL2.FGTnXS */
 SR_FGF(OP_TLBI_VAALE1NXS,  HFGITR, TLBIVAALE1, 1, HCRX_FGTnXS),
 SR_FGF(OP_TLBI_VALE1NXS,  HFGITR, TLBIVALE1, 1, HCRX_FGTnXS),
 SR_FGF(OP_TLBI_VAAE1NXS,  HFGITR, TLBIVAAE1, 1, HCRX_FGTnXS),
 SR_FGF(OP_TLBI_ASIDE1NXS,  HFGITR, TLBIASIDE1, 1, HCRX_FGTnXS),
 SR_FGF(OP_TLBI_VAE1NXS,  HFGITR, TLBIVAE1, 1, HCRX_FGTnXS),
 SR_FGF(OP_TLBI_VMALLE1NXS,  HFGITR, TLBIVMALLE1, 1, HCRX_FGTnXS),
 SR_FGF(OP_TLBI_RVAALE1NXS,  HFGITR, TLBIRVAALE1, 1, HCRX_FGTnXS),
 SR_FGF(OP_TLBI_RVALE1NXS,  HFGITR, TLBIRVALE1, 1, HCRX_FGTnXS),
 SR_FGF(OP_TLBI_RVAAE1NXS,  HFGITR, TLBIRVAAE1, 1, HCRX_FGTnXS),
 SR_FGF(OP_TLBI_RVAE1NXS,  HFGITR, TLBIRVAE1, 1, HCRX_FGTnXS),
 SR_FGF(OP_TLBI_RVAALE1ISNXS,  HFGITR, TLBIRVAALE1IS, 1, HCRX_FGTnXS),
 SR_FGF(OP_TLBI_RVALE1ISNXS,  HFGITR, TLBIRVALE1IS, 1, HCRX_FGTnXS),
 SR_FGF(OP_TLBI_RVAAE1ISNXS,  HFGITR, TLBIRVAAE1IS, 1, HCRX_FGTnXS),
 SR_FGF(OP_TLBI_RVAE1ISNXS,  HFGITR, TLBIRVAE1IS, 1, HCRX_FGTnXS),
 SR_FGF(OP_TLBI_VAALE1ISNXS,  HFGITR, TLBIVAALE1IS, 1, HCRX_FGTnXS),
 SR_FGF(OP_TLBI_VALE1ISNXS,  HFGITR, TLBIVALE1IS, 1, HCRX_FGTnXS),
 SR_FGF(OP_TLBI_VAAE1ISNXS,  HFGITR, TLBIVAAE1IS, 1, HCRX_FGTnXS),
 SR_FGF(OP_TLBI_ASIDE1ISNXS,  HFGITR, TLBIASIDE1IS, 1, HCRX_FGTnXS),
 SR_FGF(OP_TLBI_VAE1ISNXS,  HFGITR, TLBIVAE1IS, 1, HCRX_FGTnXS),
 SR_FGF(OP_TLBI_VMALLE1ISNXS,  HFGITR, TLBIVMALLE1IS, 1, HCRX_FGTnXS),
 SR_FGF(OP_TLBI_RVAALE1OSNXS,  HFGITR, TLBIRVAALE1OS, 1, HCRX_FGTnXS),
 SR_FGF(OP_TLBI_RVALE1OSNXS,  HFGITR, TLBIRVALE1OS, 1, HCRX_FGTnXS),
 SR_FGF(OP_TLBI_RVAAE1OSNXS,  HFGITR, TLBIRVAAE1OS, 1, HCRX_FGTnXS),
 SR_FGF(OP_TLBI_RVAE1OSNXS,  HFGITR, TLBIRVAE1OS, 1, HCRX_FGTnXS),
 SR_FGF(OP_TLBI_VAALE1OSNXS,  HFGITR, TLBIVAALE1OS, 1, HCRX_FGTnXS),
 SR_FGF(OP_TLBI_VALE1OSNXS,  HFGITR, TLBIVALE1OS, 1, HCRX_FGTnXS),
 SR_FGF(OP_TLBI_VAAE1OSNXS,  HFGITR, TLBIVAAE1OS, 1, HCRX_FGTnXS),
 SR_FGF(OP_TLBI_ASIDE1OSNXS,  HFGITR, TLBIASIDE1OS, 1, HCRX_FGTnXS),
 SR_FGF(OP_TLBI_VAE1OSNXS,  HFGITR, TLBIVAE1OS, 1, HCRX_FGTnXS),
 SR_FGF(OP_TLBI_VMALLE1OSNXS,  HFGITR, TLBIVMALLE1OS, 1, HCRX_FGTnXS),
 SR_FGT(OP_AT_S1E1WP,   HFGITR, ATS1E1WP, 1),
 SR_FGT(OP_AT_S1E1RP,   HFGITR, ATS1E1RP, 1),
 SR_FGT(OP_AT_S1E0W,   HFGITR, ATS1E0W, 1),
 SR_FGT(OP_AT_S1E0R,   HFGITR, ATS1E0R, 1),
 SR_FGT(OP_AT_S1E1W,   HFGITR, ATS1E1W, 1),
 SR_FGT(OP_AT_S1E1R,   HFGITR, ATS1E1R, 1),
 SR_FGT(SYS_DC_ZVA,   HFGITR, DCZVA, 1),
 SR_FGT(SYS_DC_GVA,   HFGITR, DCZVA, 1),
 SR_FGT(SYS_DC_GZVA,   HFGITR, DCZVA, 1),
 SR_FGT(SYS_DC_CIVAC,   HFGITR, DCCIVAC, 1),
 SR_FGT(SYS_DC_CIGVAC,   HFGITR, DCCIVAC, 1),
 SR_FGT(SYS_DC_CIGDVAC,   HFGITR, DCCIVAC, 1),
 SR_FGT(SYS_DC_CVADP,   HFGITR, DCCVADP, 1),
 SR_FGT(SYS_DC_CGVADP,   HFGITR, DCCVADP, 1),
 SR_FGT(SYS_DC_CGDVADP,   HFGITR, DCCVADP, 1),
 SR_FGT(SYS_DC_CVAP,   HFGITR, DCCVAP, 1),
 SR_FGT(SYS_DC_CGVAP,   HFGITR, DCCVAP, 1),
 SR_FGT(SYS_DC_CGDVAP,   HFGITR, DCCVAP, 1),
 SR_FGT(SYS_DC_CVAU,   HFGITR, DCCVAU, 1),
 SR_FGT(SYS_DC_CISW,   HFGITR, DCCISW, 1),
 SR_FGT(SYS_DC_CIGSW,   HFGITR, DCCISW, 1),
 SR_FGT(SYS_DC_CIGDSW,   HFGITR, DCCISW, 1),
 SR_FGT(SYS_DC_CSW,   HFGITR, DCCSW, 1),
 SR_FGT(SYS_DC_CGSW,   HFGITR, DCCSW, 1),
 SR_FGT(SYS_DC_CGDSW,   HFGITR, DCCSW, 1),
 SR_FGT(SYS_DC_ISW,   HFGITR, DCISW, 1),
 SR_FGT(SYS_DC_IGSW,   HFGITR, DCISW, 1),
 SR_FGT(SYS_DC_IGDSW,   HFGITR, DCISW, 1),
 SR_FGT(SYS_DC_IVAC,   HFGITR, DCIVAC, 1),
 SR_FGT(SYS_DC_IGVAC,   HFGITR, DCIVAC, 1),
 SR_FGT(SYS_DC_IGDVAC,   HFGITR, DCIVAC, 1),
 SR_FGT(SYS_IC_IVAU,   HFGITR, ICIVAU, 1),
 SR_FGT(SYS_IC_IALLU,   HFGITR, ICIALLU, 1),
 SR_FGT(SYS_IC_IALLUIS,   HFGITR, ICIALLUIS, 1),

 /* HFGITR2_EL2 */
 SR_FGT(SYS_DC_CIGDVAPS,  HFGITR2, nDCCIVAPS, 0),
 SR_FGT(SYS_DC_CIVAPS,  HFGITR2, nDCCIVAPS, 0),

 /* HDFGRTR_EL2 */
 SR_FGT(SYS_PMBIDR_EL1,   HDFGRTR, PMBIDR_EL1, 1),
 SR_FGT(SYS_PMSNEVFR_EL1,  HDFGRTR, nPMSNEVFR_EL1, 0),
 SR_FGT(SYS_BRBINF_EL1(0),  HDFGRTR, nBRBDATA, 0),
 SR_FGT(SYS_BRBINF_EL1(1),  HDFGRTR, nBRBDATA, 0),
 SR_FGT(SYS_BRBINF_EL1(2),  HDFGRTR, nBRBDATA, 0),
 SR_FGT(SYS_BRBINF_EL1(3),  HDFGRTR, nBRBDATA, 0),
 SR_FGT(SYS_BRBINF_EL1(4),  HDFGRTR, nBRBDATA, 0),
 SR_FGT(SYS_BRBINF_EL1(5),  HDFGRTR, nBRBDATA, 0),
 SR_FGT(SYS_BRBINF_EL1(6),  HDFGRTR, nBRBDATA, 0),
 SR_FGT(SYS_BRBINF_EL1(7),  HDFGRTR, nBRBDATA, 0),
 SR_FGT(SYS_BRBINF_EL1(8),  HDFGRTR, nBRBDATA, 0),
 SR_FGT(SYS_BRBINF_EL1(9),  HDFGRTR, nBRBDATA, 0),
 SR_FGT(SYS_BRBINF_EL1(10),  HDFGRTR, nBRBDATA, 0),
 SR_FGT(SYS_BRBINF_EL1(11),  HDFGRTR, nBRBDATA, 0),
 SR_FGT(SYS_BRBINF_EL1(12),  HDFGRTR, nBRBDATA, 0),
 SR_FGT(SYS_BRBINF_EL1(13),  HDFGRTR, nBRBDATA, 0),
 SR_FGT(SYS_BRBINF_EL1(14),  HDFGRTR, nBRBDATA, 0),
 SR_FGT(SYS_BRBINF_EL1(15),  HDFGRTR, nBRBDATA, 0),
 SR_FGT(SYS_BRBINF_EL1(16),  HDFGRTR, nBRBDATA, 0),
 SR_FGT(SYS_BRBINF_EL1(17),  HDFGRTR, nBRBDATA, 0),
 SR_FGT(SYS_BRBINF_EL1(18),  HDFGRTR, nBRBDATA, 0),
 SR_FGT(SYS_BRBINF_EL1(19),  HDFGRTR, nBRBDATA, 0),
 SR_FGT(SYS_BRBINF_EL1(20),  HDFGRTR, nBRBDATA, 0),
 SR_FGT(SYS_BRBINF_EL1(21),  HDFGRTR, nBRBDATA, 0),
 SR_FGT(SYS_BRBINF_EL1(22),  HDFGRTR, nBRBDATA, 0),
 SR_FGT(SYS_BRBINF_EL1(23),  HDFGRTR, nBRBDATA, 0),
 SR_FGT(SYS_BRBINF_EL1(24),  HDFGRTR, nBRBDATA, 0),
 SR_FGT(SYS_BRBINF_EL1(25),  HDFGRTR, nBRBDATA, 0),
 SR_FGT(SYS_BRBINF_EL1(26),  HDFGRTR, nBRBDATA, 0),
 SR_FGT(SYS_BRBINF_EL1(27),  HDFGRTR, nBRBDATA, 0),
 SR_FGT(SYS_BRBINF_EL1(28),  HDFGRTR, nBRBDATA, 0),
 SR_FGT(SYS_BRBINF_EL1(29),  HDFGRTR, nBRBDATA, 0),
 SR_FGT(SYS_BRBINF_EL1(30),  HDFGRTR, nBRBDATA, 0),
 SR_FGT(SYS_BRBINF_EL1(31),  HDFGRTR, nBRBDATA, 0),
 SR_FGT(SYS_BRBINFINJ_EL1,  HDFGRTR, nBRBDATA, 0),
 SR_FGT(SYS_BRBSRC_EL1(0),  HDFGRTR, nBRBDATA, 0),
 SR_FGT(SYS_BRBSRC_EL1(1),  HDFGRTR, nBRBDATA, 0),
 SR_FGT(SYS_BRBSRC_EL1(2),  HDFGRTR, nBRBDATA, 0),
 SR_FGT(SYS_BRBSRC_EL1(3),  HDFGRTR, nBRBDATA, 0),
 SR_FGT(SYS_BRBSRC_EL1(4),  HDFGRTR, nBRBDATA, 0),
 SR_FGT(SYS_BRBSRC_EL1(5),  HDFGRTR, nBRBDATA, 0),
 SR_FGT(SYS_BRBSRC_EL1(6),  HDFGRTR, nBRBDATA, 0),
 SR_FGT(SYS_BRBSRC_EL1(7),  HDFGRTR, nBRBDATA, 0),
 SR_FGT(SYS_BRBSRC_EL1(8),  HDFGRTR, nBRBDATA, 0),
 SR_FGT(SYS_BRBSRC_EL1(9),  HDFGRTR, nBRBDATA, 0),
 SR_FGT(SYS_BRBSRC_EL1(10),  HDFGRTR, nBRBDATA, 0),
 SR_FGT(SYS_BRBSRC_EL1(11),  HDFGRTR, nBRBDATA, 0),
 SR_FGT(SYS_BRBSRC_EL1(12),  HDFGRTR, nBRBDATA, 0),
 SR_FGT(SYS_BRBSRC_EL1(13),  HDFGRTR, nBRBDATA, 0),
 SR_FGT(SYS_BRBSRC_EL1(14),  HDFGRTR, nBRBDATA, 0),
 SR_FGT(SYS_BRBSRC_EL1(15),  HDFGRTR, nBRBDATA, 0),
 SR_FGT(SYS_BRBSRC_EL1(16),  HDFGRTR, nBRBDATA, 0),
 SR_FGT(SYS_BRBSRC_EL1(17),  HDFGRTR, nBRBDATA, 0),
 SR_FGT(SYS_BRBSRC_EL1(18),  HDFGRTR, nBRBDATA, 0),
 SR_FGT(SYS_BRBSRC_EL1(19),  HDFGRTR, nBRBDATA, 0),
 SR_FGT(SYS_BRBSRC_EL1(20),  HDFGRTR, nBRBDATA, 0),
 SR_FGT(SYS_BRBSRC_EL1(21),  HDFGRTR, nBRBDATA, 0),
 SR_FGT(SYS_BRBSRC_EL1(22),  HDFGRTR, nBRBDATA, 0),
 SR_FGT(SYS_BRBSRC_EL1(23),  HDFGRTR, nBRBDATA, 0),
 SR_FGT(SYS_BRBSRC_EL1(24),  HDFGRTR, nBRBDATA, 0),
 SR_FGT(SYS_BRBSRC_EL1(25),  HDFGRTR, nBRBDATA, 0),
 SR_FGT(SYS_BRBSRC_EL1(26),  HDFGRTR, nBRBDATA, 0),
 SR_FGT(SYS_BRBSRC_EL1(27),  HDFGRTR, nBRBDATA, 0),
 SR_FGT(SYS_BRBSRC_EL1(28),  HDFGRTR, nBRBDATA, 0),
 SR_FGT(SYS_BRBSRC_EL1(29),  HDFGRTR, nBRBDATA, 0),
 SR_FGT(SYS_BRBSRC_EL1(30),  HDFGRTR, nBRBDATA, 0),
 SR_FGT(SYS_BRBSRC_EL1(31),  HDFGRTR, nBRBDATA, 0),
 SR_FGT(SYS_BRBSRCINJ_EL1,  HDFGRTR, nBRBDATA, 0),
 SR_FGT(SYS_BRBTGT_EL1(0),  HDFGRTR, nBRBDATA, 0),
 SR_FGT(SYS_BRBTGT_EL1(1),  HDFGRTR, nBRBDATA, 0),
 SR_FGT(SYS_BRBTGT_EL1(2),  HDFGRTR, nBRBDATA, 0),
 SR_FGT(SYS_BRBTGT_EL1(3),  HDFGRTR, nBRBDATA, 0),
 SR_FGT(SYS_BRBTGT_EL1(4),  HDFGRTR, nBRBDATA, 0),
 SR_FGT(SYS_BRBTGT_EL1(5),  HDFGRTR, nBRBDATA, 0),
 SR_FGT(SYS_BRBTGT_EL1(6),  HDFGRTR, nBRBDATA, 0),
 SR_FGT(SYS_BRBTGT_EL1(7),  HDFGRTR, nBRBDATA, 0),
 SR_FGT(SYS_BRBTGT_EL1(8),  HDFGRTR, nBRBDATA, 0),
 SR_FGT(SYS_BRBTGT_EL1(9),  HDFGRTR, nBRBDATA, 0),
 SR_FGT(SYS_BRBTGT_EL1(10),  HDFGRTR, nBRBDATA, 0),
 SR_FGT(SYS_BRBTGT_EL1(11),  HDFGRTR, nBRBDATA, 0),
 SR_FGT(SYS_BRBTGT_EL1(12),  HDFGRTR, nBRBDATA, 0),
 SR_FGT(SYS_BRBTGT_EL1(13),  HDFGRTR, nBRBDATA, 0),
 SR_FGT(SYS_BRBTGT_EL1(14),  HDFGRTR, nBRBDATA, 0),
 SR_FGT(SYS_BRBTGT_EL1(15),  HDFGRTR, nBRBDATA, 0),
 SR_FGT(SYS_BRBTGT_EL1(16),  HDFGRTR, nBRBDATA, 0),
 SR_FGT(SYS_BRBTGT_EL1(17),  HDFGRTR, nBRBDATA, 0),
 SR_FGT(SYS_BRBTGT_EL1(18),  HDFGRTR, nBRBDATA, 0),
 SR_FGT(SYS_BRBTGT_EL1(19),  HDFGRTR, nBRBDATA, 0),
 SR_FGT(SYS_BRBTGT_EL1(20),  HDFGRTR, nBRBDATA, 0),
 SR_FGT(SYS_BRBTGT_EL1(21),  HDFGRTR, nBRBDATA, 0),
 SR_FGT(SYS_BRBTGT_EL1(22),  HDFGRTR, nBRBDATA, 0),
 SR_FGT(SYS_BRBTGT_EL1(23),  HDFGRTR, nBRBDATA, 0),
 SR_FGT(SYS_BRBTGT_EL1(24),  HDFGRTR, nBRBDATA, 0),
 SR_FGT(SYS_BRBTGT_EL1(25),  HDFGRTR, nBRBDATA, 0),
 SR_FGT(SYS_BRBTGT_EL1(26),  HDFGRTR, nBRBDATA, 0),
 SR_FGT(SYS_BRBTGT_EL1(27),  HDFGRTR, nBRBDATA, 0),
 SR_FGT(SYS_BRBTGT_EL1(28),  HDFGRTR, nBRBDATA, 0),
 SR_FGT(SYS_BRBTGT_EL1(29),  HDFGRTR, nBRBDATA, 0),
 SR_FGT(SYS_BRBTGT_EL1(30),  HDFGRTR, nBRBDATA, 0),
 SR_FGT(SYS_BRBTGT_EL1(31),  HDFGRTR, nBRBDATA, 0),
 SR_FGT(SYS_BRBTGTINJ_EL1,  HDFGRTR, nBRBDATA, 0),
 SR_FGT(SYS_BRBTS_EL1,   HDFGRTR, nBRBDATA, 0),
 SR_FGT(SYS_BRBCR_EL1,   HDFGRTR, nBRBCTL, 0),
 SR_FGT(SYS_BRBFCR_EL1,   HDFGRTR, nBRBCTL, 0),
 SR_FGT(SYS_BRBIDR0_EL1,  HDFGRTR, nBRBIDR, 0),
 SR_FGT(SYS_PMCEID0_EL0,  HDFGRTR, PMCEIDn_EL0, 1),
 SR_FGT(SYS_PMCEID1_EL0,  HDFGRTR, PMCEIDn_EL0, 1),
 SR_FGT(SYS_PMUSERENR_EL0,  HDFGRTR, PMUSERENR_EL0, 1),
 SR_FGT(SYS_TRBTRG_EL1,   HDFGRTR, TRBTRG_EL1, 1),
 SR_FGT(SYS_TRBSR_EL1,   HDFGRTR, TRBSR_EL1, 1),
 SR_FGT(SYS_TRBPTR_EL1,   HDFGRTR, TRBPTR_EL1, 1),
 SR_FGT(SYS_TRBMAR_EL1,   HDFGRTR, TRBMAR_EL1, 1),
 SR_FGT(SYS_TRBLIMITR_EL1,  HDFGRTR, TRBLIMITR_EL1, 1),
 SR_FGT(SYS_TRBIDR_EL1,   HDFGRTR, TRBIDR_EL1, 1),
 SR_FGT(SYS_TRBBASER_EL1,  HDFGRTR, TRBBASER_EL1, 1),
 SR_FGT(SYS_TRCVICTLR,   HDFGRTR, TRCVICTLR, 1),
 SR_FGT(SYS_TRCSTATR,   HDFGRTR, TRCSTATR, 1),
 SR_FGT(SYS_TRCSSCSR(0),  HDFGRTR, TRCSSCSRn, 1),
 SR_FGT(SYS_TRCSSCSR(1),  HDFGRTR, TRCSSCSRn, 1),
 SR_FGT(SYS_TRCSSCSR(2),  HDFGRTR, TRCSSCSRn, 1),
 SR_FGT(SYS_TRCSSCSR(3),  HDFGRTR, TRCSSCSRn, 1),
 SR_FGT(SYS_TRCSSCSR(4),  HDFGRTR, TRCSSCSRn, 1),
 SR_FGT(SYS_TRCSSCSR(5),  HDFGRTR, TRCSSCSRn, 1),
 SR_FGT(SYS_TRCSSCSR(6),  HDFGRTR, TRCSSCSRn, 1),
 SR_FGT(SYS_TRCSSCSR(7),  HDFGRTR, TRCSSCSRn, 1),
 SR_FGT(SYS_TRCSEQSTR,   HDFGRTR, TRCSEQSTR, 1),
 SR_FGT(SYS_TRCPRGCTLR,   HDFGRTR, TRCPRGCTLR, 1),
 SR_FGT(SYS_TRCOSLSR,   HDFGRTR, TRCOSLSR, 1),
 SR_FGT(SYS_TRCIMSPEC(0),  HDFGRTR, TRCIMSPECn, 1),
 SR_FGT(SYS_TRCIMSPEC(1),  HDFGRTR, TRCIMSPECn, 1),
 SR_FGT(SYS_TRCIMSPEC(2),  HDFGRTR, TRCIMSPECn, 1),
 SR_FGT(SYS_TRCIMSPEC(3),  HDFGRTR, TRCIMSPECn, 1),
 SR_FGT(SYS_TRCIMSPEC(4),  HDFGRTR, TRCIMSPECn, 1),
 SR_FGT(SYS_TRCIMSPEC(5),  HDFGRTR, TRCIMSPECn, 1),
 SR_FGT(SYS_TRCIMSPEC(6),  HDFGRTR, TRCIMSPECn, 1),
 SR_FGT(SYS_TRCIMSPEC(7),  HDFGRTR, TRCIMSPECn, 1),
 SR_FGT(SYS_TRCDEVARCH,   HDFGRTR, TRCID, 1),
 SR_FGT(SYS_TRCDEVID,   HDFGRTR, TRCID, 1),
 SR_FGT(SYS_TRCIDR0,   HDFGRTR, TRCID, 1),
 SR_FGT(SYS_TRCIDR1,   HDFGRTR, TRCID, 1),
 SR_FGT(SYS_TRCIDR2,   HDFGRTR, TRCID, 1),
 SR_FGT(SYS_TRCIDR3,   HDFGRTR, TRCID, 1),
 SR_FGT(SYS_TRCIDR4,   HDFGRTR, TRCID, 1),
 SR_FGT(SYS_TRCIDR5,   HDFGRTR, TRCID, 1),
 SR_FGT(SYS_TRCIDR6,   HDFGRTR, TRCID, 1),
 SR_FGT(SYS_TRCIDR7,   HDFGRTR, TRCID, 1),
 SR_FGT(SYS_TRCIDR8,   HDFGRTR, TRCID, 1),
 SR_FGT(SYS_TRCIDR9,   HDFGRTR, TRCID, 1),
 SR_FGT(SYS_TRCIDR10,   HDFGRTR, TRCID, 1),
 SR_FGT(SYS_TRCIDR11,   HDFGRTR, TRCID, 1),
 SR_FGT(SYS_TRCIDR12,   HDFGRTR, TRCID, 1),
 SR_FGT(SYS_TRCIDR13,   HDFGRTR, TRCID, 1),
 SR_FGT(SYS_TRCCNTVR(0),  HDFGRTR, TRCCNTVRn, 1),
 SR_FGT(SYS_TRCCNTVR(1),  HDFGRTR, TRCCNTVRn, 1),
 SR_FGT(SYS_TRCCNTVR(2),  HDFGRTR, TRCCNTVRn, 1),
 SR_FGT(SYS_TRCCNTVR(3),  HDFGRTR, TRCCNTVRn, 1),
 SR_FGT(SYS_TRCCLAIMCLR,  HDFGRTR, TRCCLAIM, 1),
 SR_FGT(SYS_TRCCLAIMSET,  HDFGRTR, TRCCLAIM, 1),
 SR_FGT(SYS_TRCAUXCTLR,   HDFGRTR, TRCAUXCTLR, 1),
 SR_FGT(SYS_TRCAUTHSTATUS,  HDFGRTR, TRCAUTHSTATUS, 1),
 SR_FGT(SYS_TRCACATR(0),  HDFGRTR, TRC, 1),
 SR_FGT(SYS_TRCACATR(1),  HDFGRTR, TRC, 1),
 SR_FGT(SYS_TRCACATR(2),  HDFGRTR, TRC, 1),
 SR_FGT(SYS_TRCACATR(3),  HDFGRTR, TRC, 1),
 SR_FGT(SYS_TRCACATR(4),  HDFGRTR, TRC, 1),
 SR_FGT(SYS_TRCACATR(5),  HDFGRTR, TRC, 1),
 SR_FGT(SYS_TRCACATR(6),  HDFGRTR, TRC, 1),
 SR_FGT(SYS_TRCACATR(7),  HDFGRTR, TRC, 1),
 SR_FGT(SYS_TRCACATR(8),  HDFGRTR, TRC, 1),
 SR_FGT(SYS_TRCACATR(9),  HDFGRTR, TRC, 1),
 SR_FGT(SYS_TRCACATR(10),  HDFGRTR, TRC, 1),
 SR_FGT(SYS_TRCACATR(11),  HDFGRTR, TRC, 1),
 SR_FGT(SYS_TRCACATR(12),  HDFGRTR, TRC, 1),
 SR_FGT(SYS_TRCACATR(13),  HDFGRTR, TRC, 1),
 SR_FGT(SYS_TRCACATR(14),  HDFGRTR, TRC, 1),
 SR_FGT(SYS_TRCACATR(15),  HDFGRTR, TRC, 1),
 SR_FGT(SYS_TRCACVR(0),   HDFGRTR, TRC, 1),
 SR_FGT(SYS_TRCACVR(1),   HDFGRTR, TRC, 1),
 SR_FGT(SYS_TRCACVR(2),   HDFGRTR, TRC, 1),
 SR_FGT(SYS_TRCACVR(3),   HDFGRTR, TRC, 1),
 SR_FGT(SYS_TRCACVR(4),   HDFGRTR, TRC, 1),
 SR_FGT(SYS_TRCACVR(5),   HDFGRTR, TRC, 1),
 SR_FGT(SYS_TRCACVR(6),   HDFGRTR, TRC, 1),
 SR_FGT(SYS_TRCACVR(7),   HDFGRTR, TRC, 1),
 SR_FGT(SYS_TRCACVR(8),   HDFGRTR, TRC, 1),
 SR_FGT(SYS_TRCACVR(9),   HDFGRTR, TRC, 1),
 SR_FGT(SYS_TRCACVR(10),  HDFGRTR, TRC, 1),
 SR_FGT(SYS_TRCACVR(11),  HDFGRTR, TRC, 1),
 SR_FGT(SYS_TRCACVR(12),  HDFGRTR, TRC, 1),
 SR_FGT(SYS_TRCACVR(13),  HDFGRTR, TRC, 1),
 SR_FGT(SYS_TRCACVR(14),  HDFGRTR, TRC, 1),
 SR_FGT(SYS_TRCACVR(15),  HDFGRTR, TRC, 1),
 SR_FGT(SYS_TRCBBCTLR,   HDFGRTR, TRC, 1),
 SR_FGT(SYS_TRCCCCTLR,   HDFGRTR, TRC, 1),
 SR_FGT(SYS_TRCCIDCCTLR0,  HDFGRTR, TRC, 1),
 SR_FGT(SYS_TRCCIDCCTLR1,  HDFGRTR, TRC, 1),
 SR_FGT(SYS_TRCCIDCVR(0),  HDFGRTR, TRC, 1),
 SR_FGT(SYS_TRCCIDCVR(1),  HDFGRTR, TRC, 1),
 SR_FGT(SYS_TRCCIDCVR(2),  HDFGRTR, TRC, 1),
 SR_FGT(SYS_TRCCIDCVR(3),  HDFGRTR, TRC, 1),
 SR_FGT(SYS_TRCCIDCVR(4),  HDFGRTR, TRC, 1),
 SR_FGT(SYS_TRCCIDCVR(5),  HDFGRTR, TRC, 1),
 SR_FGT(SYS_TRCCIDCVR(6),  HDFGRTR, TRC, 1),
 SR_FGT(SYS_TRCCIDCVR(7),  HDFGRTR, TRC, 1),
 SR_FGT(SYS_TRCCNTCTLR(0),  HDFGRTR, TRC, 1),
 SR_FGT(SYS_TRCCNTCTLR(1),  HDFGRTR, TRC, 1),
 SR_FGT(SYS_TRCCNTCTLR(2),  HDFGRTR, TRC, 1),
 SR_FGT(SYS_TRCCNTCTLR(3),  HDFGRTR, TRC, 1),
 SR_FGT(SYS_TRCCNTRLDVR(0),  HDFGRTR, TRC, 1),
 SR_FGT(SYS_TRCCNTRLDVR(1),  HDFGRTR, TRC, 1),
 SR_FGT(SYS_TRCCNTRLDVR(2),  HDFGRTR, TRC, 1),
 SR_FGT(SYS_TRCCNTRLDVR(3),  HDFGRTR, TRC, 1),
 SR_FGT(SYS_TRCCONFIGR,   HDFGRTR, TRC, 1),
 SR_FGT(SYS_TRCEVENTCTL0R,  HDFGRTR, TRC, 1),
 SR_FGT(SYS_TRCEVENTCTL1R,  HDFGRTR, TRC, 1),
 SR_FGT(SYS_TRCEXTINSELR(0),  HDFGRTR, TRC, 1),
 SR_FGT(SYS_TRCEXTINSELR(1),  HDFGRTR, TRC, 1),
--> --------------------

--> maximum size reached

--> --------------------