LXR linux/arch/arm/mach-msm/include/mach/iommu

   1/* Copyright (c) 2010, Code Aurora Forum. All rights reserved.
   2 *
   3 * This program is free software; you can redistribute it and/or modify
   4 * it under the terms of the GNU General Public License version 2 and
   5 * only version 2 as published by the Free Software Foundation.
   6 *
   7 * This program is distributed in the hope that it will be useful,
   8 * but WITHOUT ANY WARRANTY; without even the implied warranty of
   9 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  10 * GNU General Public License for more details.
  11 *
  12 * You should have received a copy of the GNU General Public License
  13 * along with this program; if not, write to the Free Software
  14 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  15 * 02110-1301, USA.
  16 */
  17
  18#ifndef __ARCH_ARM_MACH_MSM_IOMMU_HW_8XXX_H
  19#define __ARCH_ARM_MACH_MSM_IOMMU_HW_8XXX_H
  20
  21#define CTX_SHIFT 12
  22
  23#define GET_GLOBAL_REG(reg, base) (readl((base) + (reg)))
  24#define GET_CTX_REG(reg, base, ctx) \
  25                                (readl((base) + (reg) + ((ctx) << CTX_SHIFT)))
  26
  27#define SET_GLOBAL_REG(reg, base, val)  writel((val), ((base) + (reg)))
  28
  29#define SET_CTX_REG(reg, base, ctx, val) \
  30                        writel((val), ((base) + (reg) + ((ctx) << CTX_SHIFT)))
  31
  32/* Wrappers for numbered registers */
  33#define SET_GLOBAL_REG_N(b, n, r, v) SET_GLOBAL_REG(b, ((r) + (n << 2)), (v))
  34#define GET_GLOBAL_REG_N(b, n, r)    GET_GLOBAL_REG(b, ((r) + (n << 2)))
  35
  36/* Field wrappers */
  37#define GET_GLOBAL_FIELD(b, r, F)    GET_FIELD(((b) + (r)), F##_MASK, F##_SHIFT)
  38#define GET_CONTEXT_FIELD(b, c, r, F)   \
  39        GET_FIELD(((b) + (r) + ((c) << CTX_SHIFT)), F##_MASK, F##_SHIFT)
  40
  41#define SET_GLOBAL_FIELD(b, r, F, v) \
  42        SET_FIELD(((b) + (r)), F##_MASK, F##_SHIFT, (v))
  43#define SET_CONTEXT_FIELD(b, c, r, F, v)        \
  44        SET_FIELD(((b) + (r) + ((c) << CTX_SHIFT)), F##_MASK, F##_SHIFT, (v))
  45
  46#define GET_FIELD(addr, mask, shift)  ((readl(addr) >> (shift)) & (mask))
  47
  48#define SET_FIELD(addr, mask, shift, v) \
  49do { \
  50        int t = readl(addr); \
  51        writel((t & ~((mask) << (shift))) + (((v) & (mask)) << (shift)), addr);\
  52} while (0)
  53
  54
  55#define NUM_FL_PTE      4096
  56#define NUM_SL_PTE      256
  57#define NUM_TEX_CLASS   8
  58
  59/* First-level page table bits */
  60#define FL_BASE_MASK            0xFFFFFC00
  61#define FL_TYPE_TABLE           (1 << 0)
  62#define FL_TYPE_SECT            (2 << 0)
  63#define FL_SUPERSECTION         (1 << 18)
  64#define FL_AP_WRITE             (1 << 10)
  65#define FL_AP_READ              (1 << 11)
  66#define FL_SHARED               (1 << 16)
  67#define FL_BUFFERABLE           (1 << 2)
  68#define FL_CACHEABLE            (1 << 3)
  69#define FL_TEX0                 (1 << 12)
  70#define FL_OFFSET(va)           (((va) & 0xFFF00000) >> 20)
  71
  72/* Second-level page table bits */
  73#define SL_BASE_MASK_LARGE      0xFFFF0000
  74#define SL_BASE_MASK_SMALL      0xFFFFF000
  75#define SL_TYPE_LARGE           (1 << 0)
  76#define SL_TYPE_SMALL           (2 << 0)
  77#define SL_AP0                  (1 << 4)
  78#define SL_AP1                  (2 << 4)
  79#define SL_SHARED               (1 << 10)
  80#define SL_BUFFERABLE           (1 << 2)
  81#define SL_CACHEABLE            (1 << 3)
  82#define SL_TEX0                 (1 << 6)
  83#define SL_OFFSET(va)           (((va) & 0xFF000) >> 12)
  84
  85/* Memory type and cache policy attributes */
  86#define MT_SO                   0
  87#define MT_DEV                  1
  88#define MT_NORMAL               2
  89#define CP_NONCACHED            0
  90#define CP_WB_WA                1
  91#define CP_WT                   2
  92#define CP_WB_NWA               3
  93
  94/* Global register setters / getters */
  95#define SET_M2VCBR_N(b, N, v)    SET_GLOBAL_REG_N(M2VCBR_N, N, (b), (v))
  96#define SET_CBACR_N(b, N, v)     SET_GLOBAL_REG_N(CBACR_N, N, (b), (v))
  97#define SET_TLBRSW(b, v)         SET_GLOBAL_REG(TLBRSW, (b), (v))
  98#define SET_TLBTR0(b, v)         SET_GLOBAL_REG(TLBTR0, (b), (v))
  99#define SET_TLBTR1(b, v)         SET_GLOBAL_REG(TLBTR1, (b), (v))
 100#define SET_TLBTR2(b, v)         SET_GLOBAL_REG(TLBTR2, (b), (v))
 101#define SET_TESTBUSCR(b, v)      SET_GLOBAL_REG(TESTBUSCR, (b), (v))
 102#define SET_GLOBAL_TLBIALL(b, v) SET_GLOBAL_REG(GLOBAL_TLBIALL, (b), (v))
 103#define SET_TLBIVMID(b, v)       SET_GLOBAL_REG(TLBIVMID, (b), (v))
 104#define SET_CR(b, v)             SET_GLOBAL_REG(CR, (b), (v))
 105#define SET_EAR(b, v)            SET_GLOBAL_REG(EAR, (b), (v))
 106#define SET_ESR(b, v)            SET_GLOBAL_REG(ESR, (b), (v))
 107#define SET_ESRRESTORE(b, v)     SET_GLOBAL_REG(ESRRESTORE, (b), (v))
 108#define SET_ESYNR0(b, v)         SET_GLOBAL_REG(ESYNR0, (b), (v))
 109#define SET_ESYNR1(b, v)         SET_GLOBAL_REG(ESYNR1, (b), (v))
 110#define SET_RPU_ACR(b, v)        SET_GLOBAL_REG(RPU_ACR, (b), (v))
 111
 112#define GET_M2VCBR_N(b, N)       GET_GLOBAL_REG_N(M2VCBR_N, N, (b))
 113#define GET_CBACR_N(b, N)        GET_GLOBAL_REG_N(CBACR_N, N, (b))
 114#define GET_TLBTR0(b)            GET_GLOBAL_REG(TLBTR0, (b))
 115#define GET_TLBTR1(b)            GET_GLOBAL_REG(TLBTR1, (b))
 116#define GET_TLBTR2(b)            GET_GLOBAL_REG(TLBTR2, (b))
 117#define GET_TESTBUSCR(b)         GET_GLOBAL_REG(TESTBUSCR, (b))
 118#define GET_GLOBAL_TLBIALL(b)    GET_GLOBAL_REG(GLOBAL_TLBIALL, (b))
 119#define GET_TLBIVMID(b)          GET_GLOBAL_REG(TLBIVMID, (b))
 120#define GET_CR(b)                GET_GLOBAL_REG(CR, (b))
 121#define GET_EAR(b)               GET_GLOBAL_REG(EAR, (b))
 122#define GET_ESR(b)               GET_GLOBAL_REG(ESR, (b))
 123#define GET_ESRRESTORE(b)        GET_GLOBAL_REG(ESRRESTORE, (b))
 124#define GET_ESYNR0(b)            GET_GLOBAL_REG(ESYNR0, (b))
 125#define GET_ESYNR1(b)            GET_GLOBAL_REG(ESYNR1, (b))
 126#define GET_REV(b)               GET_GLOBAL_REG(REV, (b))
 127#define GET_IDR(b)               GET_GLOBAL_REG(IDR, (b))
 128#define GET_RPU_ACR(b)           GET_GLOBAL_REG(RPU_ACR, (b))
 129
 130
 131/* Context register setters/getters */
 132#define SET_SCTLR(b, c, v)       SET_CTX_REG(SCTLR, (b), (c), (v))
 133#define SET_ACTLR(b, c, v)       SET_CTX_REG(ACTLR, (b), (c), (v))
 134#define SET_CONTEXTIDR(b, c, v)  SET_CTX_REG(CONTEXTIDR, (b), (c), (v))
 135#define SET_TTBR0(b, c, v)       SET_CTX_REG(TTBR0, (b), (c), (v))
 136#define SET_TTBR1(b, c, v)       SET_CTX_REG(TTBR1, (b), (c), (v))
 137#define SET_TTBCR(b, c, v)       SET_CTX_REG(TTBCR, (b), (c), (v))
 138#define SET_PAR(b, c, v)         SET_CTX_REG(PAR, (b), (c), (v))
 139#define SET_FSR(b, c, v)         SET_CTX_REG(FSR, (b), (c), (v))
 140#define SET_FSRRESTORE(b, c, v)  SET_CTX_REG(FSRRESTORE, (b), (c), (v))
 141#define SET_FAR(b, c, v)         SET_CTX_REG(FAR, (b), (c), (v))
 142#define SET_FSYNR0(b, c, v)      SET_CTX_REG(FSYNR0, (b), (c), (v))
 143#define SET_FSYNR1(b, c, v)      SET_CTX_REG(FSYNR1, (b), (c), (v))
 144#define SET_PRRR(b, c, v)        SET_CTX_REG(PRRR, (b), (c), (v))
 145#define SET_NMRR(b, c, v)        SET_CTX_REG(NMRR, (b), (c), (v))
 146#define SET_TLBLKCR(b, c, v)     SET_CTX_REG(TLBLCKR, (b), (c), (v))
 147#define SET_V2PSR(b, c, v)       SET_CTX_REG(V2PSR, (b), (c), (v))
 148#define SET_TLBFLPTER(b, c, v)   SET_CTX_REG(TLBFLPTER, (b), (c), (v))
 149#define SET_TLBSLPTER(b, c, v)   SET_CTX_REG(TLBSLPTER, (b), (c), (v))
 150#define SET_BFBCR(b, c, v)       SET_CTX_REG(BFBCR, (b), (c), (v))
 151#define SET_CTX_TLBIALL(b, c, v) SET_CTX_REG(CTX_TLBIALL, (b), (c), (v))
 152#define SET_TLBIASID(b, c, v)    SET_CTX_REG(TLBIASID, (b), (c), (v))
 153#define SET_TLBIVA(b, c, v)      SET_CTX_REG(TLBIVA, (b), (c), (v))
 154#define SET_TLBIVAA(b, c, v)     SET_CTX_REG(TLBIVAA, (b), (c), (v))
 155#define SET_V2PPR(b, c, v)       SET_CTX_REG(V2PPR, (b), (c), (v))
 156#define SET_V2PPW(b, c, v)       SET_CTX_REG(V2PPW, (b), (c), (v))
 157#define SET_V2PUR(b, c, v)       SET_CTX_REG(V2PUR, (b), (c), (v))
 158#define SET_V2PUW(b, c, v)       SET_CTX_REG(V2PUW, (b), (c), (v))
 159#define SET_RESUME(b, c, v)      SET_CTX_REG(RESUME, (b), (c), (v))
 160
 161#define GET_SCTLR(b, c)          GET_CTX_REG(SCTLR, (b), (c))
 162#define GET_ACTLR(b, c)          GET_CTX_REG(ACTLR, (b), (c))
 163#define GET_CONTEXTIDR(b, c)     GET_CTX_REG(CONTEXTIDR, (b), (c))
 164#define GET_TTBR0(b, c)          GET_CTX_REG(TTBR0, (b), (c))
 165#define GET_TTBR1(b, c)          GET_CTX_REG(TTBR1, (b), (c))
 166#define GET_TTBCR(b, c)          GET_CTX_REG(TTBCR, (b), (c))
 167#define GET_PAR(b, c)            GET_CTX_REG(PAR, (b), (c))
 168#define GET_FSR(b, c)            GET_CTX_REG(FSR, (b), (c))
 169#define GET_FSRRESTORE(b, c)     GET_CTX_REG(FSRRESTORE, (b), (c))
 170#define GET_FAR(b, c)            GET_CTX_REG(FAR, (b), (c))
 171#define GET_FSYNR0(b, c)         GET_CTX_REG(FSYNR0, (b), (c))
 172#define GET_FSYNR1(b, c)         GET_CTX_REG(FSYNR1, (b), (c))
 173#define GET_PRRR(b, c)           GET_CTX_REG(PRRR, (b), (c))
 174#define GET_NMRR(b, c)           GET_CTX_REG(NMRR, (b), (c))
 175#define GET_TLBLCKR(b, c)        GET_CTX_REG(TLBLCKR, (b), (c))
 176#define GET_V2PSR(b, c)          GET_CTX_REG(V2PSR, (b), (c))
 177#define GET_TLBFLPTER(b, c)      GET_CTX_REG(TLBFLPTER, (b), (c))
 178#define GET_TLBSLPTER(b, c)      GET_CTX_REG(TLBSLPTER, (b), (c))
 179#define GET_BFBCR(b, c)          GET_CTX_REG(BFBCR, (b), (c))
 180#define GET_CTX_TLBIALL(b, c)    GET_CTX_REG(CTX_TLBIALL, (b), (c))
 181#define GET_TLBIASID(b, c)       GET_CTX_REG(TLBIASID, (b), (c))
 182#define GET_TLBIVA(b, c)         GET_CTX_REG(TLBIVA, (b), (c))
 183#define GET_TLBIVAA(b, c)        GET_CTX_REG(TLBIVAA, (b), (c))
 184#define GET_V2PPR(b, c)          GET_CTX_REG(V2PPR, (b), (c))
 185#define GET_V2PPW(b, c)          GET_CTX_REG(V2PPW, (b), (c))
 186#define GET_V2PUR(b, c)          GET_CTX_REG(V2PUR, (b), (c))
 187#define GET_V2PUW(b, c)          GET_CTX_REG(V2PUW, (b), (c))
 188#define GET_RESUME(b, c)         GET_CTX_REG(RESUME, (b), (c))
 189
 190
 191/* Global field setters / getters */
 192/* Global Field Setters: */
 193/* CBACR_N */
 194#define SET_RWVMID(b, n, v)   SET_GLOBAL_FIELD(b, (n<<2)|(CBACR_N), RWVMID, v)
 195#define SET_RWE(b, n, v)      SET_GLOBAL_FIELD(b, (n<<2)|(CBACR_N), RWE, v)
 196#define SET_RWGE(b, n, v)     SET_GLOBAL_FIELD(b, (n<<2)|(CBACR_N), RWGE, v)
 197#define SET_CBVMID(b, n, v)   SET_GLOBAL_FIELD(b, (n<<2)|(CBACR_N), CBVMID, v)
 198#define SET_IRPTNDX(b, n, v)  SET_GLOBAL_FIELD(b, (n<<2)|(CBACR_N), IRPTNDX, v)
 199
 200
 201/* M2VCBR_N */
 202#define SET_VMID(b, n, v)     SET_GLOBAL_FIELD(b, (n<<2)|(M2VCBR_N), VMID, v)
 203#define SET_CBNDX(b, n, v)    SET_GLOBAL_FIELD(b, (n<<2)|(M2VCBR_N), CBNDX, v)
 204#define SET_BYPASSD(b, n, v)  SET_GLOBAL_FIELD(b, (n<<2)|(M2VCBR_N), BYPASSD, v)
 205#define SET_BPRCOSH(b, n, v)  SET_GLOBAL_FIELD(b, (n<<2)|(M2VCBR_N), BPRCOSH, v)
 206#define SET_BPRCISH(b, n, v)  SET_GLOBAL_FIELD(b, (n<<2)|(M2VCBR_N), BPRCISH, v)
 207#define SET_BPRCNSH(b, n, v)  SET_GLOBAL_FIELD(b, (n<<2)|(M2VCBR_N), BPRCNSH, v)
 208#define SET_BPSHCFG(b, n, v)  SET_GLOBAL_FIELD(b, (n<<2)|(M2VCBR_N), BPSHCFG, v)
 209#define SET_NSCFG(b, n, v)    SET_GLOBAL_FIELD(b, (n<<2)|(M2VCBR_N), NSCFG, v)
 210#define SET_BPMTCFG(b, n, v)  SET_GLOBAL_FIELD(b, (n<<2)|(M2VCBR_N), BPMTCFG, v)
 211#define SET_BPMEMTYPE(b, n, v) \
 212        SET_GLOBAL_FIELD(b, (n<<2)|(M2VCBR_N), BPMEMTYPE, v)
 213
 214
 215/* CR */
 216#define SET_RPUE(b, v)           SET_GLOBAL_FIELD(b, CR, RPUE, v)
 217#define SET_RPUERE(b, v)         SET_GLOBAL_FIELD(b, CR, RPUERE, v)
 218#define SET_RPUEIE(b, v)         SET_GLOBAL_FIELD(b, CR, RPUEIE, v)
 219#define SET_DCDEE(b, v)          SET_GLOBAL_FIELD(b, CR, DCDEE, v)
 220#define SET_CLIENTPD(b, v)       SET_GLOBAL_FIELD(b, CR, CLIENTPD, v)
 221#define SET_STALLD(b, v)         SET_GLOBAL_FIELD(b, CR, STALLD, v)
 222#define SET_TLBLKCRWE(b, v)      SET_GLOBAL_FIELD(b, CR, TLBLKCRWE, v)
 223#define SET_CR_TLBIALLCFG(b, v)  SET_GLOBAL_FIELD(b, CR, CR_TLBIALLCFG, v)
 224#define SET_TLBIVMIDCFG(b, v)    SET_GLOBAL_FIELD(b, CR, TLBIVMIDCFG, v)
 225#define SET_CR_HUME(b, v)        SET_GLOBAL_FIELD(b, CR, CR_HUME, v)
 226
 227
 228/* ESR */
 229#define SET_CFG(b, v)            SET_GLOBAL_FIELD(b, ESR, CFG, v)
 230#define SET_BYPASS(b, v)         SET_GLOBAL_FIELD(b, ESR, BYPASS, v)
 231#define SET_ESR_MULTI(b, v)      SET_GLOBAL_FIELD(b, ESR, ESR_MULTI, v)
 232
 233
 234/* ESYNR0 */
 235#define SET_ESYNR0_AMID(b, v)    SET_GLOBAL_FIELD(b, ESYNR0, ESYNR0_AMID, v)
 236#define SET_ESYNR0_APID(b, v)    SET_GLOBAL_FIELD(b, ESYNR0, ESYNR0_APID, v)
 237#define SET_ESYNR0_ABID(b, v)    SET_GLOBAL_FIELD(b, ESYNR0, ESYNR0_ABID, v)
 238#define SET_ESYNR0_AVMID(b, v)   SET_GLOBAL_FIELD(b, ESYNR0, ESYNR0_AVMID, v)
 239#define SET_ESYNR0_ATID(b, v)    SET_GLOBAL_FIELD(b, ESYNR0, ESYNR0_ATID, v)
 240
 241
 242/* ESYNR1 */
 243#define SET_ESYNR1_AMEMTYPE(b, v) \
 244                        SET_GLOBAL_FIELD(b, ESYNR1, ESYNR1_AMEMTYPE, v)
 245#define SET_ESYNR1_ASHARED(b, v)  SET_GLOBAL_FIELD(b, ESYNR1, ESYNR1_ASHARED, v)
 246#define SET_ESYNR1_AINNERSHARED(b, v) \
 247                        SET_GLOBAL_FIELD(b, ESYNR1, ESYNR1_AINNERSHARED, v)
 248#define SET_ESYNR1_APRIV(b, v)   SET_GLOBAL_FIELD(b, ESYNR1, ESYNR1_APRIV, v)
 249#define SET_ESYNR1_APROTNS(b, v) SET_GLOBAL_FIELD(b, ESYNR1, ESYNR1_APROTNS, v)
 250#define SET_ESYNR1_AINST(b, v)   SET_GLOBAL_FIELD(b, ESYNR1, ESYNR1_AINST, v)
 251#define SET_ESYNR1_AWRITE(b, v)  SET_GLOBAL_FIELD(b, ESYNR1, ESYNR1_AWRITE, v)
 252#define SET_ESYNR1_ABURST(b, v)  SET_GLOBAL_FIELD(b, ESYNR1, ESYNR1_ABURST, v)
 253#define SET_ESYNR1_ALEN(b, v)    SET_GLOBAL_FIELD(b, ESYNR1, ESYNR1_ALEN, v)
 254#define SET_ESYNR1_ASIZE(b, v)   SET_GLOBAL_FIELD(b, ESYNR1, ESYNR1_ASIZE, v)
 255#define SET_ESYNR1_ALOCK(b, v)   SET_GLOBAL_FIELD(b, ESYNR1, ESYNR1_ALOCK, v)
 256#define SET_ESYNR1_AOOO(b, v)    SET_GLOBAL_FIELD(b, ESYNR1, ESYNR1_AOOO, v)
 257#define SET_ESYNR1_AFULL(b, v)   SET_GLOBAL_FIELD(b, ESYNR1, ESYNR1_AFULL, v)
 258#define SET_ESYNR1_AC(b, v)      SET_GLOBAL_FIELD(b, ESYNR1, ESYNR1_AC, v)
 259#define SET_ESYNR1_DCD(b, v)     SET_GLOBAL_FIELD(b, ESYNR1, ESYNR1_DCD, v)
 260
 261
 262/* TESTBUSCR */
 263#define SET_TBE(b, v)            SET_GLOBAL_FIELD(b, TESTBUSCR, TBE, v)
 264#define SET_SPDMBE(b, v)         SET_GLOBAL_FIELD(b, TESTBUSCR, SPDMBE, v)
 265#define SET_WGSEL(b, v)          SET_GLOBAL_FIELD(b, TESTBUSCR, WGSEL, v)
 266#define SET_TBLSEL(b, v)         SET_GLOBAL_FIELD(b, TESTBUSCR, TBLSEL, v)
 267#define SET_TBHSEL(b, v)         SET_GLOBAL_FIELD(b, TESTBUSCR, TBHSEL, v)
 268#define SET_SPDM0SEL(b, v)       SET_GLOBAL_FIELD(b, TESTBUSCR, SPDM0SEL, v)
 269#define SET_SPDM1SEL(b, v)       SET_GLOBAL_FIELD(b, TESTBUSCR, SPDM1SEL, v)
 270#define SET_SPDM2SEL(b, v)       SET_GLOBAL_FIELD(b, TESTBUSCR, SPDM2SEL, v)
 271#define SET_SPDM3SEL(b, v)       SET_GLOBAL_FIELD(b, TESTBUSCR, SPDM3SEL, v)
 272
 273
 274/* TLBIVMID */
 275#define SET_TLBIVMID_VMID(b, v)  SET_GLOBAL_FIELD(b, TLBIVMID, TLBIVMID_VMID, v)
 276
 277
 278/* TLBRSW */
 279#define SET_TLBRSW_INDEX(b, v)   SET_GLOBAL_FIELD(b, TLBRSW, TLBRSW_INDEX, v)
 280#define SET_TLBBFBS(b, v)        SET_GLOBAL_FIELD(b, TLBRSW, TLBBFBS, v)
 281
 282
 283/* TLBTR0 */
 284#define SET_PR(b, v)             SET_GLOBAL_FIELD(b, TLBTR0, PR, v)
 285#define SET_PW(b, v)             SET_GLOBAL_FIELD(b, TLBTR0, PW, v)
 286#define SET_UR(b, v)             SET_GLOBAL_FIELD(b, TLBTR0, UR, v)
 287#define SET_UW(b, v)             SET_GLOBAL_FIELD(b, TLBTR0, UW, v)
 288#define SET_XN(b, v)             SET_GLOBAL_FIELD(b, TLBTR0, XN, v)
 289#define SET_NSDESC(b, v)         SET_GLOBAL_FIELD(b, TLBTR0, NSDESC, v)
 290#define SET_ISH(b, v)            SET_GLOBAL_FIELD(b, TLBTR0, ISH, v)
 291#define SET_SH(b, v)             SET_GLOBAL_FIELD(b, TLBTR0, SH, v)
 292#define SET_MT(b, v)             SET_GLOBAL_FIELD(b, TLBTR0, MT, v)
 293#define SET_DPSIZR(b, v)         SET_GLOBAL_FIELD(b, TLBTR0, DPSIZR, v)
 294#define SET_DPSIZC(b, v)         SET_GLOBAL_FIELD(b, TLBTR0, DPSIZC, v)
 295
 296
 297/* TLBTR1 */
 298#define SET_TLBTR1_VMID(b, v)    SET_GLOBAL_FIELD(b, TLBTR1, TLBTR1_VMID, v)
 299#define SET_TLBTR1_PA(b, v)      SET_GLOBAL_FIELD(b, TLBTR1, TLBTR1_PA, v)
 300
 301
 302/* TLBTR2 */
 303#define SET_TLBTR2_ASID(b, v)    SET_GLOBAL_FIELD(b, TLBTR2, TLBTR2_ASID, v)
 304#define SET_TLBTR2_V(b, v)       SET_GLOBAL_FIELD(b, TLBTR2, TLBTR2_V, v)
 305#define SET_TLBTR2_NSTID(b, v)   SET_GLOBAL_FIELD(b, TLBTR2, TLBTR2_NSTID, v)
 306#define SET_TLBTR2_NV(b, v)      SET_GLOBAL_FIELD(b, TLBTR2, TLBTR2_NV, v)
 307#define SET_TLBTR2_VA(b, v)      SET_GLOBAL_FIELD(b, TLBTR2, TLBTR2_VA, v)
 308
 309
 310/* Global Field Getters */
 311/* CBACR_N */
 312#define GET_RWVMID(b, n)         GET_GLOBAL_FIELD(b, (n<<2)|(CBACR_N), RWVMID)
 313#define GET_RWE(b, n)            GET_GLOBAL_FIELD(b, (n<<2)|(CBACR_N), RWE)
 314#define GET_RWGE(b, n)           GET_GLOBAL_FIELD(b, (n<<2)|(CBACR_N), RWGE)
 315#define GET_CBVMID(b, n)         GET_GLOBAL_FIELD(b, (n<<2)|(CBACR_N), CBVMID)
 316#define GET_IRPTNDX(b, n)        GET_GLOBAL_FIELD(b, (n<<2)|(CBACR_N), IRPTNDX)
 317
 318
 319/* M2VCBR_N */
 320#define GET_VMID(b, n)       GET_GLOBAL_FIELD(b, (n<<2)|(M2VCBR_N), VMID)
 321#define GET_CBNDX(b, n)      GET_GLOBAL_FIELD(b, (n<<2)|(M2VCBR_N), CBNDX)
 322#define GET_BYPASSD(b, n)    GET_GLOBAL_FIELD(b, (n<<2)|(M2VCBR_N), BYPASSD)
 323#define GET_BPRCOSH(b, n)    GET_GLOBAL_FIELD(b, (n<<2)|(M2VCBR_N), BPRCOSH)
 324#define GET_BPRCISH(b, n)    GET_GLOBAL_FIELD(b, (n<<2)|(M2VCBR_N), BPRCISH)
 325#define GET_BPRCNSH(b, n)    GET_GLOBAL_FIELD(b, (n<<2)|(M2VCBR_N), BPRCNSH)
 326#define GET_BPSHCFG(b, n)    GET_GLOBAL_FIELD(b, (n<<2)|(M2VCBR_N), BPSHCFG)
 327#define GET_NSCFG(b, n)      GET_GLOBAL_FIELD(b, (n<<2)|(M2VCBR_N), NSCFG)
 328#define GET_BPMTCFG(b, n)    GET_GLOBAL_FIELD(b, (n<<2)|(M2VCBR_N), BPMTCFG)
 329#define GET_BPMEMTYPE(b, n)  GET_GLOBAL_FIELD(b, (n<<2)|(M2VCBR_N), BPMEMTYPE)
 330
 331
 332/* CR */
 333#define GET_RPUE(b)              GET_GLOBAL_FIELD(b, CR, RPUE)
 334#define GET_RPUERE(b)            GET_GLOBAL_FIELD(b, CR, RPUERE)
 335#define GET_RPUEIE(b)            GET_GLOBAL_FIELD(b, CR, RPUEIE)
 336#define GET_DCDEE(b)             GET_GLOBAL_FIELD(b, CR, DCDEE)
 337#define GET_CLIENTPD(b)          GET_GLOBAL_FIELD(b, CR, CLIENTPD)
 338#define GET_STALLD(b)            GET_GLOBAL_FIELD(b, CR, STALLD)
 339#define GET_TLBLKCRWE(b)         GET_GLOBAL_FIELD(b, CR, TLBLKCRWE)
 340#define GET_CR_TLBIALLCFG(b)     GET_GLOBAL_FIELD(b, CR, CR_TLBIALLCFG)
 341#define GET_TLBIVMIDCFG(b)       GET_GLOBAL_FIELD(b, CR, TLBIVMIDCFG)
 342#define GET_CR_HUME(b)           GET_GLOBAL_FIELD(b, CR, CR_HUME)
 343
 344
 345/* ESR */
 346#define GET_CFG(b)               GET_GLOBAL_FIELD(b, ESR, CFG)
 347#define GET_BYPASS(b)            GET_GLOBAL_FIELD(b, ESR, BYPASS)
 348#define GET_ESR_MULTI(b)         GET_GLOBAL_FIELD(b, ESR, ESR_MULTI)
 349
 350
 351/* ESYNR0 */
 352#define GET_ESYNR0_AMID(b)       GET_GLOBAL_FIELD(b, ESYNR0, ESYNR0_AMID)
 353#define GET_ESYNR0_APID(b)       GET_GLOBAL_FIELD(b, ESYNR0, ESYNR0_APID)
 354#define GET_ESYNR0_ABID(b)       GET_GLOBAL_FIELD(b, ESYNR0, ESYNR0_ABID)
 355#define GET_ESYNR0_AVMID(b)      GET_GLOBAL_FIELD(b, ESYNR0, ESYNR0_AVMID)
 356#define GET_ESYNR0_ATID(b)       GET_GLOBAL_FIELD(b, ESYNR0, ESYNR0_ATID)
 357
 358
 359/* ESYNR1 */
 360#define GET_ESYNR1_AMEMTYPE(b)   GET_GLOBAL_FIELD(b, ESYNR1, ESYNR1_AMEMTYPE)
 361#define GET_ESYNR1_ASHARED(b)    GET_GLOBAL_FIELD(b, ESYNR1, ESYNR1_ASHARED)
 362#define GET_ESYNR1_AINNERSHARED(b) \
 363                        GET_GLOBAL_FIELD(b, ESYNR1, ESYNR1_AINNERSHARED)
 364#define GET_ESYNR1_APRIV(b)      GET_GLOBAL_FIELD(b, ESYNR1, ESYNR1_APRIV)
 365#define GET_ESYNR1_APROTNS(b)    GET_GLOBAL_FIELD(b, ESYNR1, ESYNR1_APROTNS)
 366#define GET_ESYNR1_AINST(b)      GET_GLOBAL_FIELD(b, ESYNR1, ESYNR1_AINST)
 367#define GET_ESYNR1_AWRITE(b)     GET_GLOBAL_FIELD(b, ESYNR1, ESYNR1_AWRITE)
 368#define GET_ESYNR1_ABURST(b)     GET_GLOBAL_FIELD(b, ESYNR1, ESYNR1_ABURST)
 369#define GET_ESYNR1_ALEN(b)       GET_GLOBAL_FIELD(b, ESYNR1, ESYNR1_ALEN)
 370#define GET_ESYNR1_ASIZE(b)      GET_GLOBAL_FIELD(b, ESYNR1, ESYNR1_ASIZE)
 371#define GET_ESYNR1_ALOCK(b)      GET_GLOBAL_FIELD(b, ESYNR1, ESYNR1_ALOCK)
 372#define GET_ESYNR1_AOOO(b)       GET_GLOBAL_FIELD(b, ESYNR1, ESYNR1_AOOO)
 373#define GET_ESYNR1_AFULL(b)      GET_GLOBAL_FIELD(b, ESYNR1, ESYNR1_AFULL)
 374#define GET_ESYNR1_AC(b)         GET_GLOBAL_FIELD(b, ESYNR1, ESYNR1_AC)
 375#define GET_ESYNR1_DCD(b)        GET_GLOBAL_FIELD(b, ESYNR1, ESYNR1_DCD)
 376
 377
 378/* IDR */
 379#define GET_NM2VCBMT(b)          GET_GLOBAL_FIELD(b, IDR, NM2VCBMT)
 380#define GET_HTW(b)               GET_GLOBAL_FIELD(b, IDR, HTW)
 381#define GET_HUM(b)               GET_GLOBAL_FIELD(b, IDR, HUM)
 382#define GET_TLBSIZE(b)           GET_GLOBAL_FIELD(b, IDR, TLBSIZE)
 383#define GET_NCB(b)               GET_GLOBAL_FIELD(b, IDR, NCB)
 384#define GET_NIRPT(b)             GET_GLOBAL_FIELD(b, IDR, NIRPT)
 385
 386
 387/* REV */
 388#define GET_MAJOR(b)             GET_GLOBAL_FIELD(b, REV, MAJOR)
 389#define GET_MINOR(b)             GET_GLOBAL_FIELD(b, REV, MINOR)
 390
 391
 392/* TESTBUSCR */
 393#define GET_TBE(b)               GET_GLOBAL_FIELD(b, TESTBUSCR, TBE)
 394#define GET_SPDMBE(b)            GET_GLOBAL_FIELD(b, TESTBUSCR, SPDMBE)
 395#define GET_WGSEL(b)             GET_GLOBAL_FIELD(b, TESTBUSCR, WGSEL)
 396#define GET_TBLSEL(b)            GET_GLOBAL_FIELD(b, TESTBUSCR, TBLSEL)
 397#define GET_TBHSEL(b)            GET_GLOBAL_FIELD(b, TESTBUSCR, TBHSEL)
 398#define GET_SPDM0SEL(b)          GET_GLOBAL_FIELD(b, TESTBUSCR, SPDM0SEL)
 399#define GET_SPDM1SEL(b)          GET_GLOBAL_FIELD(b, TESTBUSCR, SPDM1SEL)
 400#define GET_SPDM2SEL(b)          GET_GLOBAL_FIELD(b, TESTBUSCR, SPDM2SEL)
 401#define GET_SPDM3SEL(b)          GET_GLOBAL_FIELD(b, TESTBUSCR, SPDM3SEL)
 402
 403
 404/* TLBIVMID */
 405#define GET_TLBIVMID_VMID(b)     GET_GLOBAL_FIELD(b, TLBIVMID, TLBIVMID_VMID)
 406
 407
 408/* TLBTR0 */
 409#define GET_PR(b)                GET_GLOBAL_FIELD(b, TLBTR0, PR)
 410#define GET_PW(b)                GET_GLOBAL_FIELD(b, TLBTR0, PW)
 411#define GET_UR(b)                GET_GLOBAL_FIELD(b, TLBTR0, UR)
 412#define GET_UW(b)                GET_GLOBAL_FIELD(b, TLBTR0, UW)
 413#define GET_XN(b)                GET_GLOBAL_FIELD(b, TLBTR0, XN)
 414#define GET_NSDESC(b)            GET_GLOBAL_FIELD(b, TLBTR0, NSDESC)
 415#define GET_ISH(b)               GET_GLOBAL_FIELD(b, TLBTR0, ISH)
 416#define GET_SH(b)                GET_GLOBAL_FIELD(b, TLBTR0, SH)
 417#define GET_MT(b)                GET_GLOBAL_FIELD(b, TLBTR0, MT)
 418#define GET_DPSIZR(b)            GET_GLOBAL_FIELD(b, TLBTR0, DPSIZR)
 419#define GET_DPSIZC(b)            GET_GLOBAL_FIELD(b, TLBTR0, DPSIZC)
 420
 421
 422/* TLBTR1 */
 423#define GET_TLBTR1_VMID(b)       GET_GLOBAL_FIELD(b, TLBTR1, TLBTR1_VMID)
 424#define GET_TLBTR1_PA(b)         GET_GLOBAL_FIELD(b, TLBTR1, TLBTR1_PA)
 425
 426
 427/* TLBTR2 */
 428#define GET_TLBTR2_ASID(b)       GET_GLOBAL_FIELD(b, TLBTR2, TLBTR2_ASID)
 429#define GET_TLBTR2_V(b)          GET_GLOBAL_FIELD(b, TLBTR2, TLBTR2_V)
 430#define GET_TLBTR2_NSTID(b)      GET_GLOBAL_FIELD(b, TLBTR2, TLBTR2_NSTID)
 431#define GET_TLBTR2_NV(b)         GET_GLOBAL_FIELD(b, TLBTR2, TLBTR2_NV)
 432#define GET_TLBTR2_VA(b)         GET_GLOBAL_FIELD(b, TLBTR2, TLBTR2_VA)
 433
 434
 435/* Context Register setters / getters */
 436/* Context Register setters */
 437/* ACTLR */
 438#define SET_CFERE(b, c, v)       SET_CONTEXT_FIELD(b, c, ACTLR, CFERE, v)
 439#define SET_CFEIE(b, c, v)       SET_CONTEXT_FIELD(b, c, ACTLR, CFEIE, v)
 440#define SET_PTSHCFG(b, c, v)     SET_CONTEXT_FIELD(b, c, ACTLR, PTSHCFG, v)
 441#define SET_RCOSH(b, c, v)       SET_CONTEXT_FIELD(b, c, ACTLR, RCOSH, v)
 442#define SET_RCISH(b, c, v)       SET_CONTEXT_FIELD(b, c, ACTLR, RCISH, v)
 443#define SET_RCNSH(b, c, v)       SET_CONTEXT_FIELD(b, c, ACTLR, RCNSH, v)
 444#define SET_PRIVCFG(b, c, v)     SET_CONTEXT_FIELD(b, c, ACTLR, PRIVCFG, v)
 445#define SET_DNA(b, c, v)         SET_CONTEXT_FIELD(b, c, ACTLR, DNA, v)
 446#define SET_DNLV2PA(b, c, v)     SET_CONTEXT_FIELD(b, c, ACTLR, DNLV2PA, v)
 447#define SET_TLBMCFG(b, c, v)     SET_CONTEXT_FIELD(b, c, ACTLR, TLBMCFG, v)
 448#define SET_CFCFG(b, c, v)       SET_CONTEXT_FIELD(b, c, ACTLR, CFCFG, v)
 449#define SET_TIPCF(b, c, v)       SET_CONTEXT_FIELD(b, c, ACTLR, TIPCF, v)
 450#define SET_V2PCFG(b, c, v)      SET_CONTEXT_FIELD(b, c, ACTLR, V2PCFG, v)
 451#define SET_HUME(b, c, v)        SET_CONTEXT_FIELD(b, c, ACTLR, HUME, v)
 452#define SET_PTMTCFG(b, c, v)     SET_CONTEXT_FIELD(b, c, ACTLR, PTMTCFG, v)
 453#define SET_PTMEMTYPE(b, c, v)   SET_CONTEXT_FIELD(b, c, ACTLR, PTMEMTYPE, v)
 454
 455
 456/* BFBCR */
 457#define SET_BFBDFE(b, c, v)      SET_CONTEXT_FIELD(b, c, BFBCR, BFBDFE, v)
 458#define SET_BFBSFE(b, c, v)      SET_CONTEXT_FIELD(b, c, BFBCR, BFBSFE, v)
 459#define SET_SFVS(b, c, v)        SET_CONTEXT_FIELD(b, c, BFBCR, SFVS, v)
 460#define SET_FLVIC(b, c, v)       SET_CONTEXT_FIELD(b, c, BFBCR, FLVIC, v)
 461#define SET_SLVIC(b, c, v)       SET_CONTEXT_FIELD(b, c, BFBCR, SLVIC, v)
 462
 463
 464/* CONTEXTIDR */
 465#define SET_CONTEXTIDR_ASID(b, c, v)   \
 466                SET_CONTEXT_FIELD(b, c, CONTEXTIDR, CONTEXTIDR_ASID, v)
 467#define SET_CONTEXTIDR_PROCID(b, c, v) \
 468                SET_CONTEXT_FIELD(b, c, CONTEXTIDR, PROCID, v)
 469
 470
 471/* FSR */
 472#define SET_TF(b, c, v)          SET_CONTEXT_FIELD(b, c, FSR, TF, v)
 473#define SET_AFF(b, c, v)         SET_CONTEXT_FIELD(b, c, FSR, AFF, v)
 474#define SET_APF(b, c, v)         SET_CONTEXT_FIELD(b, c, FSR, APF, v)
 475#define SET_TLBMF(b, c, v)       SET_CONTEXT_FIELD(b, c, FSR, TLBMF, v)
 476#define SET_HTWDEEF(b, c, v)     SET_CONTEXT_FIELD(b, c, FSR, HTWDEEF, v)
 477#define SET_HTWSEEF(b, c, v)     SET_CONTEXT_FIELD(b, c, FSR, HTWSEEF, v)
 478#define SET_MHF(b, c, v)         SET_CONTEXT_FIELD(b, c, FSR, MHF, v)
 479#define SET_SL(b, c, v)          SET_CONTEXT_FIELD(b, c, FSR, SL, v)
 480#define SET_SS(b, c, v)          SET_CONTEXT_FIELD(b, c, FSR, SS, v)
 481#define SET_MULTI(b, c, v)       SET_CONTEXT_FIELD(b, c, FSR, MULTI, v)
 482
 483
 484/* FSYNR0 */
 485#define SET_AMID(b, c, v)        SET_CONTEXT_FIELD(b, c, FSYNR0, AMID, v)
 486#define SET_APID(b, c, v)        SET_CONTEXT_FIELD(b, c, FSYNR0, APID, v)
 487#define SET_ABID(b, c, v)        SET_CONTEXT_FIELD(b, c, FSYNR0, ABID, v)
 488#define SET_ATID(b, c, v)        SET_CONTEXT_FIELD(b, c, FSYNR0, ATID, v)
 489
 490
 491/* FSYNR1 */
 492#define SET_AMEMTYPE(b, c, v)    SET_CONTEXT_FIELD(b, c, FSYNR1, AMEMTYPE, v)
 493#define SET_ASHARED(b, c, v)     SET_CONTEXT_FIELD(b, c, FSYNR1, ASHARED, v)
 494#define SET_AINNERSHARED(b, c, v)  \
 495                                SET_CONTEXT_FIELD(b, c, FSYNR1, AINNERSHARED, v)
 496#define SET_APRIV(b, c, v)       SET_CONTEXT_FIELD(b, c, FSYNR1, APRIV, v)
 497#define SET_APROTNS(b, c, v)     SET_CONTEXT_FIELD(b, c, FSYNR1, APROTNS, v)
 498#define SET_AINST(b, c, v)       SET_CONTEXT_FIELD(b, c, FSYNR1, AINST, v)
 499#define SET_AWRITE(b, c, v)      SET_CONTEXT_FIELD(b, c, FSYNR1, AWRITE, v)
 500#define SET_ABURST(b, c, v)      SET_CONTEXT_FIELD(b, c, FSYNR1, ABURST, v)
 501#define SET_ALEN(b, c, v)        SET_CONTEXT_FIELD(b, c, FSYNR1, ALEN, v)
 502#define SET_FSYNR1_ASIZE(b, c, v) \
 503                                SET_CONTEXT_FIELD(b, c, FSYNR1, FSYNR1_ASIZE, v)
 504#define SET_ALOCK(b, c, v)       SET_CONTEXT_FIELD(b, c, FSYNR1, ALOCK, v)
 505#define SET_AFULL(b, c, v)       SET_CONTEXT_FIELD(b, c, FSYNR1, AFULL, v)
 506
 507
 508/* NMRR */
 509#define SET_ICPC0(b, c, v)       SET_CONTEXT_FIELD(b, c, NMRR, ICPC0, v)
 510#define SET_ICPC1(b, c, v)       SET_CONTEXT_FIELD(b, c, NMRR, ICPC1, v)
 511#define SET_ICPC2(b, c, v)       SET_CONTEXT_FIELD(b, c, NMRR, ICPC2, v)
 512#define SET_ICPC3(b, c, v)       SET_CONTEXT_FIELD(b, c, NMRR, ICPC3, v)
 513#define SET_ICPC4(b, c, v)       SET_CONTEXT_FIELD(b, c, NMRR, ICPC4, v)
 514#define SET_ICPC5(b, c, v)       SET_CONTEXT_FIELD(b, c, NMRR, ICPC5, v)
 515#define SET_ICPC6(b, c, v)       SET_CONTEXT_FIELD(b, c, NMRR, ICPC6, v)
 516#define SET_ICPC7(b, c, v)       SET_CONTEXT_FIELD(b, c, NMRR, ICPC7, v)
 517#define SET_OCPC0(b, c, v)       SET_CONTEXT_FIELD(b, c, NMRR, OCPC0, v)
 518#define SET_OCPC1(b, c, v)       SET_CONTEXT_FIELD(b, c, NMRR, OCPC1, v)
 519#define SET_OCPC2(b, c, v)       SET_CONTEXT_FIELD(b, c, NMRR, OCPC2, v)
 520#define SET_OCPC3(b, c, v)       SET_CONTEXT_FIELD(b, c, NMRR, OCPC3, v)
 521#define SET_OCPC4(b, c, v)       SET_CONTEXT_FIELD(b, c, NMRR, OCPC4, v)
 522#define SET_OCPC5(b, c, v)       SET_CONTEXT_FIELD(b, c, NMRR, OCPC5, v)
 523#define SET_OCPC6(b, c, v)       SET_CONTEXT_FIELD(b, c, NMRR, OCPC6, v)
 524#define SET_OCPC7(b, c, v)       SET_CONTEXT_FIELD(b, c, NMRR, OCPC7, v)
 525
 526
 527/* PAR */
 528#define SET_FAULT(b, c, v)       SET_CONTEXT_FIELD(b, c, PAR, FAULT, v)
 529
 530#define SET_FAULT_TF(b, c, v)    SET_CONTEXT_FIELD(b, c, PAR, FAULT_TF, v)
 531#define SET_FAULT_AFF(b, c, v)   SET_CONTEXT_FIELD(b, c, PAR, FAULT_AFF, v)
 532#define SET_FAULT_APF(b, c, v)   SET_CONTEXT_FIELD(b, c, PAR, FAULT_APF, v)
 533#define SET_FAULT_TLBMF(b, c, v) SET_CONTEXT_FIELD(b, c, PAR, FAULT_TLBMF, v)
 534#define SET_FAULT_HTWDEEF(b, c, v) \
 535                                SET_CONTEXT_FIELD(b, c, PAR, FAULT_HTWDEEF, v)
 536#define SET_FAULT_HTWSEEF(b, c, v) \
 537                                SET_CONTEXT_FIELD(b, c, PAR, FAULT_HTWSEEF, v)
 538#define SET_FAULT_MHF(b, c, v)   SET_CONTEXT_FIELD(b, c, PAR, FAULT_MHF, v)
 539#define SET_FAULT_SL(b, c, v)    SET_CONTEXT_FIELD(b, c, PAR, FAULT_SL, v)
 540#define SET_FAULT_SS(b, c, v)    SET_CONTEXT_FIELD(b, c, PAR, FAULT_SS, v)
 541
 542#define SET_NOFAULT_SS(b, c, v)  SET_CONTEXT_FIELD(b, c, PAR, NOFAULT_SS, v)
 543#define SET_NOFAULT_MT(b, c, v)  SET_CONTEXT_FIELD(b, c, PAR, NOFAULT_MT, v)
 544#define SET_NOFAULT_SH(b, c, v)  SET_CONTEXT_FIELD(b, c, PAR, NOFAULT_SH, v)
 545#define SET_NOFAULT_NS(b, c, v)  SET_CONTEXT_FIELD(b, c, PAR, NOFAULT_NS, v)
 546#define SET_NOFAULT_NOS(b, c, v) SET_CONTEXT_FIELD(b, c, PAR, NOFAULT_NOS, v)
 547#define SET_NPFAULT_PA(b, c, v)  SET_CONTEXT_FIELD(b, c, PAR, NPFAULT_PA, v)
 548
 549
 550/* PRRR */
 551#define SET_MTC0(b, c, v)        SET_CONTEXT_FIELD(b, c, PRRR, MTC0, v)
 552#define SET_MTC1(b, c, v)        SET_CONTEXT_FIELD(b, c, PRRR, MTC1, v)
 553#define SET_MTC2(b, c, v)        SET_CONTEXT_FIELD(b, c, PRRR, MTC2, v)
 554#define SET_MTC3(b, c, v)        SET_CONTEXT_FIELD(b, c, PRRR, MTC3, v)
 555#define SET_MTC4(b, c, v)        SET_CONTEXT_FIELD(b, c, PRRR, MTC4, v)
 556#define SET_MTC5(b, c, v)        SET_CONTEXT_FIELD(b, c, PRRR, MTC5, v)
 557#define SET_MTC6(b, c, v)        SET_CONTEXT_FIELD(b, c, PRRR, MTC6, v)
 558#define SET_MTC7(b, c, v)        SET_CONTEXT_FIELD(b, c, PRRR, MTC7, v)
 559#define SET_SHDSH0(b, c, v)      SET_CONTEXT_FIELD(b, c, PRRR, SHDSH0, v)
 560#define SET_SHDSH1(b, c, v)      SET_CONTEXT_FIELD(b, c, PRRR, SHDSH1, v)
 561#define SET_SHNMSH0(b, c, v)     SET_CONTEXT_FIELD(b, c, PRRR, SHNMSH0, v)
 562#define SET_SHNMSH1(b, c, v)     SET_CONTEXT_FIELD(b, c, PRRR, SHNMSH1, v)
 563#define SET_NOS0(b, c, v)        SET_CONTEXT_FIELD(b, c, PRRR, NOS0, v)
 564#define SET_NOS1(b, c, v)        SET_CONTEXT_FIELD(b, c, PRRR, NOS1, v)
 565#define SET_NOS2(b, c, v)        SET_CONTEXT_FIELD(b, c, PRRR, NOS2, v)
 566#define SET_NOS3(b, c, v)        SET_CONTEXT_FIELD(b, c, PRRR, NOS3, v)
 567#define SET_NOS4(b, c, v)        SET_CONTEXT_FIELD(b, c, PRRR, NOS4, v)
 568#define SET_NOS5(b, c, v)        SET_CONTEXT_FIELD(b, c, PRRR, NOS5, v)
 569#define SET_NOS6(b, c, v)        SET_CONTEXT_FIELD(b, c, PRRR, NOS6, v)
 570#define SET_NOS7(b, c, v)        SET_CONTEXT_FIELD(b, c, PRRR, NOS7, v)
 571
 572
 573/* RESUME */
 574#define SET_TNR(b, c, v)         SET_CONTEXT_FIELD(b, c, RESUME, TNR, v)
 575
 576
 577/* SCTLR */
 578#define SET_M(b, c, v)           SET_CONTEXT_FIELD(b, c, SCTLR, M, v)
 579#define SET_TRE(b, c, v)         SET_CONTEXT_FIELD(b, c, SCTLR, TRE, v)
 580#define SET_AFE(b, c, v)         SET_CONTEXT_FIELD(b, c, SCTLR, AFE, v)
 581#define SET_HAF(b, c, v)         SET_CONTEXT_FIELD(b, c, SCTLR, HAF, v)
 582#define SET_BE(b, c, v)          SET_CONTEXT_FIELD(b, c, SCTLR, BE, v)
 583#define SET_AFFD(b, c, v)        SET_CONTEXT_FIELD(b, c, SCTLR, AFFD, v)
 584
 585
 586/* TLBLKCR */
 587#define SET_LKE(b, c, v)           SET_CONTEXT_FIELD(b, c, TLBLKCR, LKE, v)
 588#define SET_TLBLKCR_TLBIALLCFG(b, c, v) \
 589                        SET_CONTEXT_FIELD(b, c, TLBLKCR, TLBLCKR_TLBIALLCFG, v)
 590#define SET_TLBIASIDCFG(b, c, v) \
 591                        SET_CONTEXT_FIELD(b, c, TLBLKCR, TLBIASIDCFG, v)
 592#define SET_TLBIVAACFG(b, c, v) SET_CONTEXT_FIELD(b, c, TLBLKCR, TLBIVAACFG, v)
 593#define SET_FLOOR(b, c, v)      SET_CONTEXT_FIELD(b, c, TLBLKCR, FLOOR, v)
 594#define SET_VICTIM(b, c, v)     SET_CONTEXT_FIELD(b, c, TLBLKCR, VICTIM, v)
 595
 596
 597/* TTBCR */
 598#define SET_N(b, c, v)           SET_CONTEXT_FIELD(b, c, TTBCR, N, v)
 599#define SET_PD0(b, c, v)         SET_CONTEXT_FIELD(b, c, TTBCR, PD0, v)
 600#define SET_PD1(b, c, v)         SET_CONTEXT_FIELD(b, c, TTBCR, PD1, v)
 601
 602
 603/* TTBR0 */
 604#define SET_TTBR0_IRGNH(b, c, v) SET_CONTEXT_FIELD(b, c, TTBR0, TTBR0_IRGNH, v)
 605#define SET_TTBR0_SH(b, c, v)    SET_CONTEXT_FIELD(b, c, TTBR0, TTBR0_SH, v)
 606#define SET_TTBR0_ORGN(b, c, v)  SET_CONTEXT_FIELD(b, c, TTBR0, TTBR0_ORGN, v)
 607#define SET_TTBR0_NOS(b, c, v)   SET_CONTEXT_FIELD(b, c, TTBR0, TTBR0_NOS, v)
 608#define SET_TTBR0_IRGNL(b, c, v) SET_CONTEXT_FIELD(b, c, TTBR0, TTBR0_IRGNL, v)
 609#define SET_TTBR0_PA(b, c, v)    SET_CONTEXT_FIELD(b, c, TTBR0, TTBR0_PA, v)
 610
 611
 612/* TTBR1 */
 613#define SET_TTBR1_IRGNH(b, c, v) SET_CONTEXT_FIELD(b, c, TTBR1, TTBR1_IRGNH, v)
 614#define SET_TTBR1_SH(b, c, v)    SET_CONTEXT_FIELD(b, c, TTBR1, TTBR1_SH, v)
 615#define SET_TTBR1_ORGN(b, c, v)  SET_CONTEXT_FIELD(b, c, TTBR1, TTBR1_ORGN, v)
 616#define SET_TTBR1_NOS(b, c, v)   SET_CONTEXT_FIELD(b, c, TTBR1, TTBR1_NOS, v)
 617#define SET_TTBR1_IRGNL(b, c, v) SET_CONTEXT_FIELD(b, c, TTBR1, TTBR1_IRGNL, v)
 618#define SET_TTBR1_PA(b, c, v)    SET_CONTEXT_FIELD(b, c, TTBR1, TTBR1_PA, v)
 619
 620
 621/* V2PSR */
 622#define SET_HIT(b, c, v)         SET_CONTEXT_FIELD(b, c, V2PSR, HIT, v)
 623#define SET_INDEX(b, c, v)       SET_CONTEXT_FIELD(b, c, V2PSR, INDEX, v)
 624
 625
 626/* V2Pxx UW UR PW PR */
 627#define SET_V2PUW_INDEX(b, c, v) SET_CONTEXT_FIELD(b, c, V2PUW, V2Pxx_INDEX, v)
 628#define SET_V2PUW_VA(b, c, v)    SET_CONTEXT_FIELD(b, c, V2PUW, V2Pxx_VA, v)
 629
 630#define SET_V2PUR_INDEX(b, c, v) SET_CONTEXT_FIELD(b, c, V2PUR, V2Pxx_INDEX, v)
 631#define SET_V2PUR_VA(b, c, v)    SET_CONTEXT_FIELD(b, c, V2PUR, V2Pxx_VA, v)
 632
 633#define SET_V2PPW_INDEX(b, c, v) SET_CONTEXT_FIELD(b, c, V2PPW, V2Pxx_INDEX, v)
 634#define SET_V2PPW_VA(b, c, v)    SET_CONTEXT_FIELD(b, c, V2PPW, V2Pxx_VA, v)
 635
 636#define SET_V2PPR_INDEX(b, c, v) SET_CONTEXT_FIELD(b, c, V2PPR, V2Pxx_INDEX, v)
 637#define SET_V2PPR_VA(b, c, v)    SET_CONTEXT_FIELD(b, c, V2PPR, V2Pxx_VA, v)
 638
 639
 640/* Context Register getters */
 641/* ACTLR */
 642#define GET_CFERE(b, c)         GET_CONTEXT_FIELD(b, c, ACTLR, CFERE)
 643#define GET_CFEIE(b, c)         GET_CONTEXT_FIELD(b, c, ACTLR, CFEIE)
 644#define GET_PTSHCFG(b, c)       GET_CONTEXT_FIELD(b, c, ACTLR, PTSHCFG)
 645#define GET_RCOSH(b, c)         GET_CONTEXT_FIELD(b, c, ACTLR, RCOSH)
 646#define GET_RCISH(b, c)         GET_CONTEXT_FIELD(b, c, ACTLR, RCISH)
 647#define GET_RCNSH(b, c)         GET_CONTEXT_FIELD(b, c, ACTLR, RCNSH)
 648#define GET_PRIVCFG(b, c)       GET_CONTEXT_FIELD(b, c, ACTLR, PRIVCFG)
 649#define GET_DNA(b, c)           GET_CONTEXT_FIELD(b, c, ACTLR, DNA)
 650#define GET_DNLV2PA(b, c)       GET_CONTEXT_FIELD(b, c, ACTLR, DNLV2PA)
 651#define GET_TLBMCFG(b, c)       GET_CONTEXT_FIELD(b, c, ACTLR, TLBMCFG)
 652#define GET_CFCFG(b, c)         GET_CONTEXT_FIELD(b, c, ACTLR, CFCFG)
 653#define GET_TIPCF(b, c)         GET_CONTEXT_FIELD(b, c, ACTLR, TIPCF)
 654#define GET_V2PCFG(b, c)        GET_CONTEXT_FIELD(b, c, ACTLR, V2PCFG)
 655#define GET_HUME(b, c)          GET_CONTEXT_FIELD(b, c, ACTLR, HUME)
 656#define GET_PTMTCFG(b, c)       GET_CONTEXT_FIELD(b, c, ACTLR, PTMTCFG)
 657#define GET_PTMEMTYPE(b, c)     GET_CONTEXT_FIELD(b, c, ACTLR, PTMEMTYPE)
 658
 659/* BFBCR */
 660#define GET_BFBDFE(b, c)        GET_CONTEXT_FIELD(b, c, BFBCR, BFBDFE)
 661#define GET_BFBSFE(b, c)        GET_CONTEXT_FIELD(b, c, BFBCR, BFBSFE)
 662#define GET_SFVS(b, c)          GET_CONTEXT_FIELD(b, c, BFBCR, SFVS)
 663#define GET_FLVIC(b, c)         GET_CONTEXT_FIELD(b, c, BFBCR, FLVIC)
 664#define GET_SLVIC(b, c)         GET_CONTEXT_FIELD(b, c, BFBCR, SLVIC)
 665
 666
 667/* CONTEXTIDR */
 668#define GET_CONTEXTIDR_ASID(b, c) \
 669                        GET_CONTEXT_FIELD(b, c, CONTEXTIDR, CONTEXTIDR_ASID)
 670#define GET_CONTEXTIDR_PROCID(b, c) GET_CONTEXT_FIELD(b, c, CONTEXTIDR, PROCID)
 671
 672
 673/* FSR */
 674#define GET_TF(b, c)            GET_CONTEXT_FIELD(b, c, FSR, TF)
 675#define GET_AFF(b, c)           GET_CONTEXT_FIELD(b, c, FSR, AFF)
 676#define GET_APF(b, c)           GET_CONTEXT_FIELD(b, c, FSR, APF)
 677#define GET_TLBMF(b, c)         GET_CONTEXT_FIELD(b, c, FSR, TLBMF)
 678#define GET_HTWDEEF(b, c)       GET_CONTEXT_FIELD(b, c, FSR, HTWDEEF)
 679#define GET_HTWSEEF(b, c)       GET_CONTEXT_FIELD(b, c, FSR, HTWSEEF)
 680#define GET_MHF(b, c)           GET_CONTEXT_FIELD(b, c, FSR, MHF)
 681#define GET_SL(b, c)            GET_CONTEXT_FIELD(b, c, FSR, SL)
 682#define GET_SS(b, c)            GET_CONTEXT_FIELD(b, c, FSR, SS)
 683#define GET_MULTI(b, c)         GET_CONTEXT_FIELD(b, c, FSR, MULTI)
 684
 685
 686/* FSYNR0 */
 687#define GET_AMID(b, c)          GET_CONTEXT_FIELD(b, c, FSYNR0, AMID)
 688#define GET_APID(b, c)          GET_CONTEXT_FIELD(b, c, FSYNR0, APID)
 689#define GET_ABID(b, c)          GET_CONTEXT_FIELD(b, c, FSYNR0, ABID)
 690#define GET_ATID(b, c)          GET_CONTEXT_FIELD(b, c, FSYNR0, ATID)
 691
 692
 693/* FSYNR1 */
 694#define GET_AMEMTYPE(b, c)      GET_CONTEXT_FIELD(b, c, FSYNR1, AMEMTYPE)
 695#define GET_ASHARED(b, c)       GET_CONTEXT_FIELD(b, c, FSYNR1, ASHARED)
 696#define GET_AINNERSHARED(b, c)  GET_CONTEXT_FIELD(b, c, FSYNR1, AINNERSHARED)
 697#define GET_APRIV(b, c)         GET_CONTEXT_FIELD(b, c, FSYNR1, APRIV)
 698#define GET_APROTNS(b, c)       GET_CONTEXT_FIELD(b, c, FSYNR1, APROTNS)
 699#define GET_AINST(b, c)         GET_CONTEXT_FIELD(b, c, FSYNR1, AINST)
 700#define GET_AWRITE(b, c)        GET_CONTEXT_FIELD(b, c, FSYNR1, AWRITE)
 701#define GET_ABURST(b, c)        GET_CONTEXT_FIELD(b, c, FSYNR1, ABURST)
 702#define GET_ALEN(b, c)          GET_CONTEXT_FIELD(b, c, FSYNR1, ALEN)
 703#define GET_FSYNR1_ASIZE(b, c)  GET_CONTEXT_FIELD(b, c, FSYNR1, FSYNR1_ASIZE)
 704#define GET_ALOCK(b, c)         GET_CONTEXT_FIELD(b, c, FSYNR1, ALOCK)
 705#define GET_AFULL(b, c)         GET_CONTEXT_FIELD(b, c, FSYNR1, AFULL)
 706
 707
 708/* NMRR */
 709#define GET_ICPC0(b, c)         GET_CONTEXT_FIELD(b, c, NMRR, ICPC0)
 710#define GET_ICPC1(b, c)         GET_CONTEXT_FIELD(b, c, NMRR, ICPC1)
 711#define GET_ICPC2(b, c)         GET_CONTEXT_FIELD(b, c, NMRR, ICPC2)
 712#define GET_ICPC3(b, c)         GET_CONTEXT_FIELD(b, c, NMRR, ICPC3)
 713#define GET_ICPC4(b, c)         GET_CONTEXT_FIELD(b, c, NMRR, ICPC4)
 714#define GET_ICPC5(b, c)         GET_CONTEXT_FIELD(b, c, NMRR, ICPC5)
 715#define GET_ICPC6(b, c)         GET_CONTEXT_FIELD(b, c, NMRR, ICPC6)
 716#define GET_ICPC7(b, c)         GET_CONTEXT_FIELD(b, c, NMRR, ICPC7)
 717#define GET_OCPC0(b, c)         GET_CONTEXT_FIELD(b, c, NMRR, OCPC0)
 718#define GET_OCPC1(b, c)         GET_CONTEXT_FIELD(b, c, NMRR, OCPC1)
 719#define GET_OCPC2(b, c)         GET_CONTEXT_FIELD(b, c, NMRR, OCPC2)
 720#define GET_OCPC3(b, c)         GET_CONTEXT_FIELD(b, c, NMRR, OCPC3)
 721#define GET_OCPC4(b, c)         GET_CONTEXT_FIELD(b, c, NMRR, OCPC4)
 722#define GET_OCPC5(b, c)         GET_CONTEXT_FIELD(b, c, NMRR, OCPC5)
 723#define GET_OCPC6(b, c)         GET_CONTEXT_FIELD(b, c, NMRR, OCPC6)
 724#define GET_OCPC7(b, c)         GET_CONTEXT_FIELD(b, c, NMRR, OCPC7)
 725#define NMRR_ICP(nmrr, n)       (((nmrr) & (3 << ((n) * 2))) >> ((n) * 2))
 726#define NMRR_OCP(nmrr, n)       (((nmrr) & (3 << ((n) * 2 + 16))) >> \
 727                                                                ((n) * 2 + 16))
 728
 729/* PAR */
 730#define GET_FAULT(b, c)         GET_CONTEXT_FIELD(b, c, PAR, FAULT)
 731
 732#define GET_FAULT_TF(b, c)      GET_CONTEXT_FIELD(b, c, PAR, FAULT_TF)
 733#define GET_FAULT_AFF(b, c)     GET_CONTEXT_FIELD(b, c, PAR, FAULT_AFF)
 734#define GET_FAULT_APF(b, c)     GET_CONTEXT_FIELD(b, c, PAR, FAULT_APF)
 735#define GET_FAULT_TLBMF(b, c)   GET_CONTEXT_FIELD(b, c, PAR, FAULT_TLBMF)
 736#define GET_FAULT_HTWDEEF(b, c) GET_CONTEXT_FIELD(b, c, PAR, FAULT_HTWDEEF)
 737#define GET_FAULT_HTWSEEF(b, c) GET_CONTEXT_FIELD(b, c, PAR, FAULT_HTWSEEF)
 738#define GET_FAULT_MHF(b, c)     GET_CONTEXT_FIELD(b, c, PAR, FAULT_MHF)
 739#define GET_FAULT_SL(b, c)      GET_CONTEXT_FIELD(b, c, PAR, FAULT_SL)
 740#define GET_FAULT_SS(b, c)      GET_CONTEXT_FIELD(b, c, PAR, FAULT_SS)
 741
 742#define GET_NOFAULT_SS(b, c)    GET_CONTEXT_FIELD(b, c, PAR, PAR_NOFAULT_SS)
 743#define GET_NOFAULT_MT(b, c)    GET_CONTEXT_FIELD(b, c, PAR, PAR_NOFAULT_MT)
 744#define GET_NOFAULT_SH(b, c)    GET_CONTEXT_FIELD(b, c, PAR, PAR_NOFAULT_SH)
 745#define GET_NOFAULT_NS(b, c)    GET_CONTEXT_FIELD(b, c, PAR, PAR_NOFAULT_NS)
 746#define GET_NOFAULT_NOS(b, c)   GET_CONTEXT_FIELD(b, c, PAR, PAR_NOFAULT_NOS)
 747#define GET_NPFAULT_PA(b, c)    GET_CONTEXT_FIELD(b, c, PAR, PAR_NPFAULT_PA)
 748
 749
 750/* PRRR */
 751#define GET_MTC0(b, c)          GET_CONTEXT_FIELD(b, c, PRRR, MTC0)
 752#define GET_MTC1(b, c)          GET_CONTEXT_FIELD(b, c, PRRR, MTC1)
 753#define GET_MTC2(b, c)          GET_CONTEXT_FIELD(b, c, PRRR, MTC2)
 754#define GET_MTC3(b, c)          GET_CONTEXT_FIELD(b, c, PRRR, MTC3)
 755#define GET_MTC4(b, c)          GET_CONTEXT_FIELD(b, c, PRRR, MTC4)
 756#define GET_MTC5(b, c)          GET_CONTEXT_FIELD(b, c, PRRR, MTC5)
 757#define GET_MTC6(b, c)          GET_CONTEXT_FIELD(b, c, PRRR, MTC6)
 758#define GET_MTC7(b, c)          GET_CONTEXT_FIELD(b, c, PRRR, MTC7)
 759#define GET_SHDSH0(b, c)        GET_CONTEXT_FIELD(b, c, PRRR, SHDSH0)
 760#define GET_SHDSH1(b, c)        GET_CONTEXT_FIELD(b, c, PRRR, SHDSH1)
 761#define GET_SHNMSH0(b, c)       GET_CONTEXT_FIELD(b, c, PRRR, SHNMSH0)
 762#define GET_SHNMSH1(b, c)       GET_CONTEXT_FIELD(b, c, PRRR, SHNMSH1)
 763#define GET_NOS0(b, c)          GET_CONTEXT_FIELD(b, c, PRRR, NOS0)
 764#define GET_NOS1(b, c)          GET_CONTEXT_FIELD(b, c, PRRR, NOS1)
 765#define GET_NOS2(b, c)          GET_CONTEXT_FIELD(b, c, PRRR, NOS2)
 766#define GET_NOS3(b, c)          GET_CONTEXT_FIELD(b, c, PRRR, NOS3)
 767#define GET_NOS4(b, c)          GET_CONTEXT_FIELD(b, c, PRRR, NOS4)
 768#define GET_NOS5(b, c)          GET_CONTEXT_FIELD(b, c, PRRR, NOS5)
 769#define GET_NOS6(b, c)          GET_CONTEXT_FIELD(b, c, PRRR, NOS6)
 770#define GET_NOS7(b, c)          GET_CONTEXT_FIELD(b, c, PRRR, NOS7)
 771#define PRRR_NOS(prrr, n)        ((prrr) & (1 << ((n) + 24)) ? 1 : 0)
 772#define PRRR_MT(prrr, n)         ((((prrr) & (3 << ((n) * 2))) >> ((n) * 2)))
 773
 774
 775/* RESUME */
 776#define GET_TNR(b, c)           GET_CONTEXT_FIELD(b, c, RESUME, TNR)
 777
 778
 779/* SCTLR */
 780#define GET_M(b, c)             GET_CONTEXT_FIELD(b, c, SCTLR, M)
 781#define GET_TRE(b, c)           GET_CONTEXT_FIELD(b, c, SCTLR, TRE)
 782#define GET_AFE(b, c)           GET_CONTEXT_FIELD(b, c, SCTLR, AFE)
 783#define GET_HAF(b, c)           GET_CONTEXT_FIELD(b, c, SCTLR, HAF)
 784#define GET_BE(b, c)            GET_CONTEXT_FIELD(b, c, SCTLR, BE)
 785#define GET_AFFD(b, c)          GET_CONTEXT_FIELD(b, c, SCTLR, AFFD)
 786
 787
 788/* TLBLKCR */
 789#define GET_LKE(b, c)           GET_CONTEXT_FIELD(b, c, TLBLKCR, LKE)
 790#define GET_TLBLCKR_TLBIALLCFG(b, c) \
 791                        GET_CONTEXT_FIELD(b, c, TLBLKCR, TLBLCKR_TLBIALLCFG)
 792#define GET_TLBIASIDCFG(b, c)   GET_CONTEXT_FIELD(b, c, TLBLKCR, TLBIASIDCFG)
 793#define GET_TLBIVAACFG(b, c)    GET_CONTEXT_FIELD(b, c, TLBLKCR, TLBIVAACFG)
 794#define GET_FLOOR(b, c)         GET_CONTEXT_FIELD(b, c, TLBLKCR, FLOOR)
 795#define GET_VICTIM(b, c)        GET_CONTEXT_FIELD(b, c, TLBLKCR, VICTIM)
 796
 797
 798/* TTBCR */
 799#define GET_N(b, c)             GET_CONTEXT_FIELD(b, c, TTBCR, N)
 800#define GET_PD0(b, c)           GET_CONTEXT_FIELD(b, c, TTBCR, PD0)
 801#define GET_PD1(b, c)           GET_CONTEXT_FIELD(b, c, TTBCR, PD1)
 802
 803
 804/* TTBR0 */
 805#define GET_TTBR0_IRGNH(b, c)   GET_CONTEXT_FIELD(b, c, TTBR0, TTBR0_IRGNH)
 806#define GET_TTBR0_SH(b, c)      GET_CONTEXT_FIELD(b, c, TTBR0, TTBR0_SH)
 807#define GET_TTBR0_ORGN(b, c)    GET_CONTEXT_FIELD(b, c, TTBR0, TTBR0_ORGN)
 808#define GET_TTBR0_NOS(b, c)     GET_CONTEXT_FIELD(b, c, TTBR0, TTBR0_NOS)
 809#define GET_TTBR0_IRGNL(b, c)   GET_CONTEXT_FIELD(b, c, TTBR0, TTBR0_IRGNL)
 810#define GET_TTBR0_PA(b, c)      GET_CONTEXT_FIELD(b, c, TTBR0, TTBR0_PA)
 811
 812
 813/* TTBR1 */
 814#define GET_TTBR1_IRGNH(b, c)   GET_CONTEXT_FIELD(b, c, TTBR1, TTBR1_IRGNH)
 815#define GET_TTBR1_SH(b, c)      GET_CONTEXT_FIELD(b, c, TTBR1, TTBR1_SH)
 816#define GET_TTBR1_ORGN(b, c)    GET_CONTEXT_FIELD(b, c, TTBR1, TTBR1_ORGN)
 817#define GET_TTBR1_NOS(b, c)     GET_CONTEXT_FIELD(b, c, TTBR1, TTBR1_NOS)
 818#define GET_TTBR1_IRGNL(b, c)   GET_CONTEXT_FIELD(b, c, TTBR1, TTBR1_IRGNL)
 819#define GET_TTBR1_PA(b, c)      GET_CONTEXT_FIELD(b, c, TTBR1, TTBR1_PA)
 820
 821
 822/* V2PSR */
 823#define GET_HIT(b, c)           GET_CONTEXT_FIELD(b, c, V2PSR, HIT)
 824#define GET_INDEX(b, c)         GET_CONTEXT_FIELD(b, c, V2PSR, INDEX)
 825
 826
 827/* V2Pxx UW UR PW PR */
 828#define GET_V2PUW_INDEX(b, c)   GET_CONTEXT_FIELD(b, c, V2PUW, V2Pxx_INDEX)
 829#define GET_V2PUW_VA(b, c)      GET_CONTEXT_FIELD(b, c, V2PUW, V2Pxx_VA)
 830
 831#define GET_V2PUR_INDEX(b, c)   GET_CONTEXT_FIELD(b, c, V2PUR, V2Pxx_INDEX)
 832#define GET_V2PUR_VA(b, c)      GET_CONTEXT_FIELD(b, c, V2PUR, V2Pxx_VA)
 833
 834#define GET_V2PPW_INDEX(b, c)   GET_CONTEXT_FIELD(b, c, V2PPW, V2Pxx_INDEX)
 835#define GET_V2PPW_VA(b, c)      GET_CONTEXT_FIELD(b, c, V2PPW, V2Pxx_VA)
 836
 837#define GET_V2PPR_INDEX(b, c)   GET_CONTEXT_FIELD(b, c, V2PPR, V2Pxx_INDEX)
 838#define GET_V2PPR_VA(b, c)      GET_CONTEXT_FIELD(b, c, V2PPR, V2Pxx_VA)
 839
 840
 841/* Global Registers */
 842#define M2VCBR_N        (0xFF000)
 843#define CBACR_N         (0xFF800)
 844#define TLBRSW          (0xFFE00)
 845#define TLBTR0          (0xFFE80)
 846#define TLBTR1          (0xFFE84)
 847#define TLBTR2          (0xFFE88)
 848#define TESTBUSCR       (0xFFE8C)
 849#define GLOBAL_TLBIALL  (0xFFF00)
 850#define TLBIVMID        (0xFFF04)
 851#define CR              (0xFFF80)
 852#define EAR             (0xFFF84)
 853#define ESR             (0xFFF88)
 854#define ESRRESTORE      (0xFFF8C)
 855#define ESYNR0          (0xFFF90)
 856#define ESYNR1          (0xFFF94)
 857#define REV             (0xFFFF4)
 858#define IDR             (0xFFFF8)
 859#define RPU_ACR         (0xFFFFC)
 860
 861
 862/* Context Bank Registers */
 863#define SCTLR           (0x000)
 864#define ACTLR           (0x004)
 865#define CONTEXTIDR      (0x008)
 866#define TTBR0           (0x010)
 867#define TTBR1           (0x014)
 868#define TTBCR           (0x018)
 869#define PAR             (0x01C)
 870#define FSR             (0x020)
 871#define FSRRESTORE      (0x024)
 872#define FAR             (0x028)
 873#define FSYNR0          (0x02C)
 874#define FSYNR1          (0x030)
 875#define PRRR            (0x034)
 876#define NMRR            (0x038)
 877#define TLBLCKR         (0x03C)
 878#define V2PSR           (0x040)
 879#define TLBFLPTER       (0x044)
 880#define TLBSLPTER       (0x048)
 881#define BFBCR           (0x04C)
 882#define CTX_TLBIALL     (0x800)
 883#define TLBIASID        (0x804)
 884#define TLBIVA          (0x808)
 885#define TLBIVAA         (0x80C)
 886#define V2PPR           (0x810)
 887#define V2PPW           (0x814)
 888#define V2PUR           (0x818)
 889#define V2PUW           (0x81C)
 890#define RESUME          (0x820)
 891
 892
 893/* Global Register Fields */
 894/* CBACRn */
 895#define RWVMID        (RWVMID_MASK       << RWVMID_SHIFT)
 896#define RWE           (RWE_MASK          << RWE_SHIFT)
 897#define RWGE          (RWGE_MASK         << RWGE_SHIFT)
 898#define CBVMID        (CBVMID_MASK       << CBVMID_SHIFT)
 899#define IRPTNDX       (IRPTNDX_MASK      << IRPTNDX_SHIFT)
 900
 901
 902/* CR */
 903#define RPUE          (RPUE_MASK          << RPUE_SHIFT)
 904#define RPUERE        (RPUERE_MASK        << RPUERE_SHIFT)
 905#define RPUEIE        (RPUEIE_MASK        << RPUEIE_SHIFT)
 906#define DCDEE         (DCDEE_MASK         << DCDEE_SHIFT)
 907#define CLIENTPD      (CLIENTPD_MASK      << CLIENTPD_SHIFT)
 908#define STALLD        (STALLD_MASK        << STALLD_SHIFT)
 909#define TLBLKCRWE     (TLBLKCRWE_MASK     << TLBLKCRWE_SHIFT)
 910#define CR_TLBIALLCFG (CR_TLBIALLCFG_MASK << CR_TLBIALLCFG_SHIFT)
 911#define TLBIVMIDCFG   (TLBIVMIDCFG_MASK   << TLBIVMIDCFG_SHIFT)
 912#define CR_HUME       (CR_HUME_MASK       << CR_HUME_SHIFT)
 913
 914
 915/* ESR */
 916#define CFG           (CFG_MASK          << CFG_SHIFT)
 917#define BYPASS        (BYPASS_MASK       << BYPASS_SHIFT)
 918#define ESR_MULTI     (ESR_MULTI_MASK    << ESR_MULTI_SHIFT)
 919
 920
 921/* ESYNR0 */
 922#define ESYNR0_AMID   (ESYNR0_AMID_MASK  << ESYNR0_AMID_SHIFT)
 923#define ESYNR0_APID   (ESYNR0_APID_MASK  << ESYNR0_APID_SHIFT)
 924#define ESYNR0_ABID   (ESYNR0_ABID_MASK  << ESYNR0_ABID_SHIFT)
 925#define ESYNR0_AVMID  (ESYNR0_AVMID_MASK << ESYNR0_AVMID_SHIFT)
 926#define ESYNR0_ATID   (ESYNR0_ATID_MASK  << ESYNR0_ATID_SHIFT)
 927
 928
 929/* ESYNR1 */
 930#define ESYNR1_AMEMTYPE      (ESYNR1_AMEMTYPE_MASK    << ESYNR1_AMEMTYPE_SHIFT)
 931#define ESYNR1_ASHARED       (ESYNR1_ASHARED_MASK     << ESYNR1_ASHARED_SHIFT)
 932#define ESYNR1_AINNERSHARED  (ESYNR1_AINNERSHARED_MASK<< \
 933                                                ESYNR1_AINNERSHARED_SHIFT)
 934#define ESYNR1_APRIV         (ESYNR1_APRIV_MASK       << ESYNR1_APRIV_SHIFT)
 935#define ESYNR1_APROTNS       (ESYNR1_APROTNS_MASK     << ESYNR1_APROTNS_SHIFT)
 936#define ESYNR1_AINST         (ESYNR1_AINST_MASK       << ESYNR1_AINST_SHIFT)
 937#define ESYNR1_AWRITE        (ESYNR1_AWRITE_MASK      << ESYNR1_AWRITE_SHIFT)
 938#define ESYNR1_ABURST        (ESYNR1_ABURST_MASK      << ESYNR1_ABURST_SHIFT)
 939#define ESYNR1_ALEN          (ESYNR1_ALEN_MASK        << ESYNR1_ALEN_SHIFT)
 940#define ESYNR1_ASIZE         (ESYNR1_ASIZE_MASK       << ESYNR1_ASIZE_SHIFT)
 941#define ESYNR1_ALOCK         (ESYNR1_ALOCK_MASK       << ESYNR1_ALOCK_SHIFT)
 942#define ESYNR1_AOOO          (ESYNR1_AOOO_MASK        << ESYNR1_AOOO_SHIFT)
 943#define ESYNR1_AFULL         (ESYNR1_AFULL_MASK       << ESYNR1_AFULL_SHIFT)
 944#define ESYNR1_AC            (ESYNR1_AC_MASK          << ESYNR1_AC_SHIFT)
 945#define ESYNR1_DCD           (ESYNR1_DCD_MASK         << ESYNR1_DCD_SHIFT)
 946
 947
 948/* IDR */
 949#define NM2VCBMT      (NM2VCBMT_MASK     << NM2VCBMT_SHIFT)
 950#define HTW           (HTW_MASK          << HTW_SHIFT)
 951#define HUM           (HUM_MASK          << HUM_SHIFT)
 952#define TLBSIZE       (TLBSIZE_MASK      << TLBSIZE_SHIFT)
 953#define NCB           (NCB_MASK          << NCB_SHIFT)
 954#define NIRPT         (NIRPT_MASK        << NIRPT_SHIFT)
 955
 956
 957/* M2VCBRn */
 958#define VMID          (VMID_MASK         << VMID_SHIFT)
 959#define CBNDX         (CBNDX_MASK        << CBNDX_SHIFT)
 960#define BYPASSD       (BYPASSD_MASK      << BYPASSD_SHIFT)
 961#define BPRCOSH       (BPRCOSH_MASK      << BPRCOSH_SHIFT)
 962#define BPRCISH       (BPRCISH_MASK      << BPRCISH_SHIFT)
 963#define BPRCNSH       (BPRCNSH_MASK      << BPRCNSH_SHIFT)
 964#define BPSHCFG       (BPSHCFG_MASK      << BPSHCFG_SHIFT)
 965#define NSCFG         (NSCFG_MASK        << NSCFG_SHIFT)
 966#define BPMTCFG       (BPMTCFG_MASK      << BPMTCFG_SHIFT)
 967#define BPMEMTYPE     (BPMEMTYPE_MASK    << BPMEMTYPE_SHIFT)
 968
 969
 970/* REV */
 971#define IDR_MINOR     (MINOR_MASK        << MINOR_SHIFT)
 972#define IDR_MAJOR     (MAJOR_MASK        << MAJOR_SHIFT)
 973
 974
 975/* TESTBUSCR */
 976#define TBE           (TBE_MASK          << TBE_SHIFT)
 977#define SPDMBE        (SPDMBE_MASK       << SPDMBE_SHIFT)
 978#define WGSEL         (WGSEL_MASK        << WGSEL_SHIFT)
 979#define TBLSEL        (TBLSEL_MASK       << TBLSEL_SHIFT)
 980#define TBHSEL        (TBHSEL_MASK       << TBHSEL_SHIFT)
 981#define SPDM0SEL      (SPDM0SEL_MASK     << SPDM0SEL_SHIFT)
 982#define SPDM1SEL      (SPDM1SEL_MASK     << SPDM1SEL_SHIFT)
 983#define SPDM2SEL      (SPDM2SEL_MASK     << SPDM2SEL_SHIFT)
 984#define SPDM3SEL      (SPDM3SEL_MASK     << SPDM3SEL_SHIFT)
 985
 986
 987/* TLBIVMID */
 988#define TLBIVMID_VMID (TLBIVMID_VMID_MASK << TLBIVMID_VMID_SHIFT)
 989
 990
 991/* TLBRSW */
 992#define TLBRSW_INDEX  (TLBRSW_INDEX_MASK << TLBRSW_INDEX_SHIFT)
 993#define TLBBFBS       (TLBBFBS_MASK      << TLBBFBS_SHIFT)
 994
 995
 996/* TLBTR0 */
 997#define PR            (PR_MASK           << PR_SHIFT)
 998#define PW            (PW_MASK           << PW_SHIFT)
 999#define UR            (UR_MASK           << UR_SHIFT)
1000#define UW            (UW_MASK           << UW_SHIFT)

1001#define XN            (XN_MASK           << XN_SHIFT)
1002#define NSDESC        (NSDESC_MASK       << NSDESC_SHIFT)
1003#define ISH           (ISH_MASK          << ISH_SHIFT)
1004#define SH            (SH_MASK           << SH_SHIFT)
1005#define MT            (MT_MASK           << MT_SHIFT)
1006#define DPSIZR        (DPSIZR_MASK       << DPSIZR_SHIFT)
1007#define DPSIZC        (DPSIZC_MASK       << DPSIZC_SHIFT)
1008
1009
1010/* TLBTR1 */
1011#define TLBTR1_VMID   (TLBTR1_VMID_MASK  << TLBTR1_VMID_SHIFT)
1012#define TLBTR1_PA     (TLBTR1_PA_MASK    << TLBTR1_PA_SHIFT)
1013
1014
1015/* TLBTR2 */
1016#define TLBTR2_ASID   (TLBTR2_ASID_MASK  << TLBTR2_ASID_SHIFT)
1017#define TLBTR2_V      (TLBTR2_V_MASK     << TLBTR2_V_SHIFT)
1018#define TLBTR2_NSTID  (TLBTR2_NSTID_MASK << TLBTR2_NSTID_SHIFT)
1019#define TLBTR2_NV     (TLBTR2_NV_MASK    << TLBTR2_NV_SHIFT)
1020#define TLBTR2_VA     (TLBTR2_VA_MASK    << TLBTR2_VA_SHIFT)
1021
1022
1023/* Context Register Fields */
1024/* ACTLR */
1025#define CFERE              (CFERE_MASK              << CFERE_SHIFT)
1026#define CFEIE              (CFEIE_MASK              << CFEIE_SHIFT)
1027#define PTSHCFG            (PTSHCFG_MASK            << PTSHCFG_SHIFT)
1028#define RCOSH              (RCOSH_MASK              << RCOSH_SHIFT)
1029#define RCISH              (RCISH_MASK              << RCISH_SHIFT)
1030#define RCNSH              (RCNSH_MASK              << RCNSH_SHIFT)
1031#define PRIVCFG            (PRIVCFG_MASK            << PRIVCFG_SHIFT)
1032#define DNA                (DNA_MASK                << DNA_SHIFT)
1033#define DNLV2PA            (DNLV2PA_MASK            << DNLV2PA_SHIFT)
1034#define TLBMCFG            (TLBMCFG_MASK            << TLBMCFG_SHIFT)
1035#define CFCFG              (CFCFG_MASK              << CFCFG_SHIFT)
1036#define TIPCF              (TIPCF_MASK              << TIPCF_SHIFT)
1037#define V2PCFG             (V2PCFG_MASK             << V2PCFG_SHIFT)
1038#define HUME               (HUME_MASK               << HUME_SHIFT)
1039#define PTMTCFG            (PTMTCFG_MASK            << PTMTCFG_SHIFT)
1040#define PTMEMTYPE          (PTMEMTYPE_MASK          << PTMEMTYPE_SHIFT)
1041
1042
1043/* BFBCR */
1044#define BFBDFE             (BFBDFE_MASK             << BFBDFE_SHIFT)
1045#define BFBSFE             (BFBSFE_MASK             << BFBSFE_SHIFT)
1046#define SFVS               (SFVS_MASK               << SFVS_SHIFT)
1047#define FLVIC              (FLVIC_MASK              << FLVIC_SHIFT)
1048#define SLVIC              (SLVIC_MASK              << SLVIC_SHIFT)
1049
1050
1051/* CONTEXTIDR */
1052#define CONTEXTIDR_ASID    (CONTEXTIDR_ASID_MASK    << CONTEXTIDR_ASID_SHIFT)
1053#define PROCID             (PROCID_MASK             << PROCID_SHIFT)
1054
1055
1056/* FSR */
1057#define TF                 (TF_MASK                 << TF_SHIFT)
1058#define AFF                (AFF_MASK                << AFF_SHIFT)
1059#define APF                (APF_MASK                << APF_SHIFT)
1060#define TLBMF              (TLBMF_MASK              << TLBMF_SHIFT)
1061#define HTWDEEF            (HTWDEEF_MASK            << HTWDEEF_SHIFT)
1062#define HTWSEEF            (HTWSEEF_MASK            << HTWSEEF_SHIFT)
1063#define MHF                (MHF_MASK                << MHF_SHIFT)
1064#define SL                 (SL_MASK                 << SL_SHIFT)
1065#define SS                 (SS_MASK                 << SS_SHIFT)
1066#define MULTI              (MULTI_MASK              << MULTI_SHIFT)
1067
1068
1069/* FSYNR0 */
1070#define AMID               (AMID_MASK               << AMID_SHIFT)
1071#define APID               (APID_MASK               << APID_SHIFT)
1072#define ABID               (ABID_MASK               << ABID_SHIFT)
1073#define ATID               (ATID_MASK               << ATID_SHIFT)
1074
1075
1076/* FSYNR1 */
1077#define AMEMTYPE           (AMEMTYPE_MASK           << AMEMTYPE_SHIFT)
1078#define ASHARED            (ASHARED_MASK            << ASHARED_SHIFT)
1079#define AINNERSHARED       (AINNERSHARED_MASK       << AINNERSHARED_SHIFT)
1080#define APRIV              (APRIV_MASK              << APRIV_SHIFT)
1081#define APROTNS            (APROTNS_MASK            << APROTNS_SHIFT)
1082#define AINST              (AINST_MASK              << AINST_SHIFT)
1083#define AWRITE             (AWRITE_MASK             << AWRITE_SHIFT)
1084#define ABURST             (ABURST_MASK             << ABURST_SHIFT)
1085#define ALEN               (ALEN_MASK               << ALEN_SHIFT)
1086#define FSYNR1_ASIZE       (FSYNR1_ASIZE_MASK       << FSYNR1_ASIZE_SHIFT)
1087#define ALOCK              (ALOCK_MASK              << ALOCK_SHIFT)
1088#define AFULL              (AFULL_MASK              << AFULL_SHIFT)
1089
1090
1091/* NMRR */
1092#define ICPC0              (ICPC0_MASK              << ICPC0_SHIFT)
1093#define ICPC1              (ICPC1_MASK              << ICPC1_SHIFT)
1094#define ICPC2              (ICPC2_MASK              << ICPC2_SHIFT)
1095#define ICPC3              (ICPC3_MASK              << ICPC3_SHIFT)
1096#define ICPC4              (ICPC4_MASK              << ICPC4_SHIFT)
1097#define ICPC5              (ICPC5_MASK              << ICPC5_SHIFT)
1098#define ICPC6              (ICPC6_MASK              << ICPC6_SHIFT)
1099#define ICPC7              (ICPC7_MASK              << ICPC7_SHIFT)
1100#define OCPC0              (OCPC0_MASK              << OCPC0_SHIFT)
1101#define OCPC1              (OCPC1_MASK              << OCPC1_SHIFT)
1102#define OCPC2              (OCPC2_MASK              << OCPC2_SHIFT)
1103#define OCPC3              (OCPC3_MASK              << OCPC3_SHIFT)
1104#define OCPC4              (OCPC4_MASK              << OCPC4_SHIFT)
1105#define OCPC5              (OCPC5_MASK              << OCPC5_SHIFT)
1106#define OCPC6              (OCPC6_MASK              << OCPC6_SHIFT)
1107#define OCPC7              (OCPC7_MASK              << OCPC7_SHIFT)
1108
1109
1110/* PAR */
1111#define FAULT              (FAULT_MASK              << FAULT_SHIFT)
1112/* If a fault is present, these are the
1113same as the fault fields in the FAR */
1114#define FAULT_TF           (FAULT_TF_MASK           << FAULT_TF_SHIFT)
1115#define FAULT_AFF          (FAULT_AFF_MASK          << FAULT_AFF_SHIFT)
1116#define FAULT_APF          (FAULT_APF_MASK          << FAULT_APF_SHIFT)
1117#define FAULT_TLBMF        (FAULT_TLBMF_MASK        << FAULT_TLBMF_SHIFT)
1118#define FAULT_HTWDEEF      (FAULT_HTWDEEF_MASK      << FAULT_HTWDEEF_SHIFT)
1119#define FAULT_HTWSEEF      (FAULT_HTWSEEF_MASK      << FAULT_HTWSEEF_SHIFT)
1120#define FAULT_MHF          (FAULT_MHF_MASK          << FAULT_MHF_SHIFT)
1121#define FAULT_SL           (FAULT_SL_MASK           << FAULT_SL_SHIFT)
1122#define FAULT_SS           (FAULT_SS_MASK           << FAULT_SS_SHIFT)
1123
1124/* If NO fault is present, the following fields are in effect */
1125/* (FAULT remains as before) */
1126#define PAR_NOFAULT_SS     (PAR_NOFAULT_SS_MASK     << PAR_NOFAULT_SS_SHIFT)
1127#define PAR_NOFAULT_MT     (PAR_NOFAULT_MT_MASK     << PAR_NOFAULT_MT_SHIFT)
1128#define PAR_NOFAULT_SH     (PAR_NOFAULT_SH_MASK     << PAR_NOFAULT_SH_SHIFT)
1129#define PAR_NOFAULT_NS     (PAR_NOFAULT_NS_MASK     << PAR_NOFAULT_NS_SHIFT)
1130#define PAR_NOFAULT_NOS    (PAR_NOFAULT_NOS_MASK    << PAR_NOFAULT_NOS_SHIFT)
1131#define PAR_NPFAULT_PA     (PAR_NPFAULT_PA_MASK     << PAR_NPFAULT_PA_SHIFT)
1132
1133
1134/* PRRR */
1135#define MTC0               (MTC0_MASK               << MTC0_SHIFT)
1136#define MTC1               (MTC1_MASK               << MTC1_SHIFT)
1137#define MTC2               (MTC2_MASK               << MTC2_SHIFT)
1138#define MTC3               (MTC3_MASK               << MTC3_SHIFT)
1139#define MTC4               (MTC4_MASK               << MTC4_SHIFT)
1140#define MTC5               (MTC5_MASK               << MTC5_SHIFT)
1141#define MTC6               (MTC6_MASK               << MTC6_SHIFT)
1142#define MTC7               (MTC7_MASK               << MTC7_SHIFT)
1143#define SHDSH0             (SHDSH0_MASK             << SHDSH0_SHIFT)
1144#define SHDSH1             (SHDSH1_MASK             << SHDSH1_SHIFT)
1145#define SHNMSH0            (SHNMSH0_MASK            << SHNMSH0_SHIFT)
1146#define SHNMSH1            (SHNMSH1_MASK            << SHNMSH1_SHIFT)
1147#define NOS0               (NOS0_MASK               << NOS0_SHIFT)
1148#define NOS1               (NOS1_MASK               << NOS1_SHIFT)
1149#define NOS2               (NOS2_MASK               << NOS2_SHIFT)
1150#define NOS3               (NOS3_MASK               << NOS3_SHIFT)
1151#define NOS4               (NOS4_MASK               << NOS4_SHIFT)
1152#define NOS5               (NOS5_MASK               << NOS5_SHIFT)
1153#define NOS6               (NOS6_MASK               << NOS6_SHIFT)
1154#define NOS7               (NOS7_MASK               << NOS7_SHIFT)
1155
1156
1157/* RESUME */
1158#define TNR                (TNR_MASK                << TNR_SHIFT)
1159
1160
1161/* SCTLR */
1162#define M                  (M_MASK                  << M_SHIFT)
1163#define TRE                (TRE_MASK                << TRE_SHIFT)
1164#define AFE                (AFE_MASK                << AFE_SHIFT)
1165#define HAF                (HAF_MASK                << HAF_SHIFT)
1166#define BE                 (BE_MASK                 << BE_SHIFT)
1167#define AFFD               (AFFD_MASK               << AFFD_SHIFT)
1168
1169
1170/* TLBIASID */
1171#define TLBIASID_ASID      (TLBIASID_ASID_MASK      << TLBIASID_ASID_SHIFT)
1172
1173
1174/* TLBIVA */
1175#define TLBIVA_ASID        (TLBIVA_ASID_MASK        << TLBIVA_ASID_SHIFT)
1176#define TLBIVA_VA          (TLBIVA_VA_MASK          << TLBIVA_VA_SHIFT)
1177
1178
1179/* TLBIVAA */
1180#define TLBIVAA_VA         (TLBIVAA_VA_MASK         << TLBIVAA_VA_SHIFT)
1181
1182
1183/* TLBLCKR */
1184#define LKE                (LKE_MASK                << LKE_SHIFT)
1185#define TLBLCKR_TLBIALLCFG (TLBLCKR_TLBIALLCFG_MASK<<TLBLCKR_TLBIALLCFG_SHIFT)
1186#define TLBIASIDCFG        (TLBIASIDCFG_MASK        << TLBIASIDCFG_SHIFT)
1187#define TLBIVAACFG         (TLBIVAACFG_MASK         << TLBIVAACFG_SHIFT)
1188#define FLOOR              (FLOOR_MASK              << FLOOR_SHIFT)
1189#define VICTIM             (VICTIM_MASK             << VICTIM_SHIFT)
1190
1191
1192/* TTBCR */
1193#define N                  (N_MASK                  << N_SHIFT)
1194#define PD0                (PD0_MASK                << PD0_SHIFT)
1195#define PD1                (PD1_MASK                << PD1_SHIFT)
1196
1197
1198/* TTBR0 */
1199#define TTBR0_IRGNH        (TTBR0_IRGNH_MASK        << TTBR0_IRGNH_SHIFT)
1200#define TTBR0_SH           (TTBR0_SH_MASK           << TTBR0_SH_SHIFT)
1201#define TTBR0_ORGN         (TTBR0_ORGN_MASK         << TTBR0_ORGN_SHIFT)
1202#define TTBR0_NOS          (TTBR0_NOS_MASK          << TTBR0_NOS_SHIFT)
1203#define TTBR0_IRGNL        (TTBR0_IRGNL_MASK        << TTBR0_IRGNL_SHIFT)
1204#define TTBR0_PA           (TTBR0_PA_MASK           << TTBR0_PA_SHIFT)
1205
1206
1207/* TTBR1 */
1208#define TTBR1_IRGNH        (TTBR1_IRGNH_MASK        << TTBR1_IRGNH_SHIFT)
1209#define TTBR1_SH           (TTBR1_SH_MASK           << TTBR1_SH_SHIFT)
1210#define TTBR1_ORGN         (TTBR1_ORGN_MASK         << TTBR1_ORGN_SHIFT)
1211#define TTBR1_NOS          (TTBR1_NOS_MASK          << TTBR1_NOS_SHIFT)
1212#define TTBR1_IRGNL        (TTBR1_IRGNL_MASK        << TTBR1_IRGNL_SHIFT)
1213#define TTBR1_PA           (TTBR1_PA_MASK           << TTBR1_PA_SHIFT)
1214
1215
1216/* V2PSR */
1217#define HIT                (HIT_MASK                << HIT_SHIFT)
1218#define INDEX              (INDEX_MASK              << INDEX_SHIFT)
1219
1220
1221/* V2Pxx */
1222#define V2Pxx_INDEX        (V2Pxx_INDEX_MASK        << V2Pxx_INDEX_SHIFT)
1223#define V2Pxx_VA           (V2Pxx_VA_MASK           << V2Pxx_VA_SHIFT)
1224
1225
1226/* Global Register Masks */
1227/* CBACRn */
1228#define RWVMID_MASK               0x1F
1229#define RWE_MASK                  0x01
1230#define RWGE_MASK                 0x01
1231#define CBVMID_MASK               0x1F
1232#define IRPTNDX_MASK              0xFF
1233
1234
1235/* CR */
1236#define RPUE_MASK                 0x01
1237#define RPUERE_MASK               0x01
1238#define RPUEIE_MASK               0x01
1239#define DCDEE_MASK                0x01
1240#define CLIENTPD_MASK             0x01
1241#define STALLD_MASK               0x01
1242#define TLBLKCRWE_MASK            0x01
1243#define CR_TLBIALLCFG_MASK        0x01
1244#define TLBIVMIDCFG_MASK          0x01
1245#define CR_HUME_MASK              0x01
1246
1247
1248/* ESR */
1249#define CFG_MASK                  0x01
1250#define BYPASS_MASK               0x01
1251#define ESR_MULTI_MASK            0x01
1252
1253
1254/* ESYNR0 */
1255#define ESYNR0_AMID_MASK          0xFF
1256#define ESYNR0_APID_MASK          0x1F
1257#define ESYNR0_ABID_MASK          0x07
1258#define ESYNR0_AVMID_MASK         0x1F
1259#define ESYNR0_ATID_MASK          0xFF
1260
1261
1262/* ESYNR1 */
1263#define ESYNR1_AMEMTYPE_MASK             0x07
1264#define ESYNR1_ASHARED_MASK              0x01
1265#define ESYNR1_AINNERSHARED_MASK         0x01
1266#define ESYNR1_APRIV_MASK                0x01
1267#define ESYNR1_APROTNS_MASK              0x01
1268#define ESYNR1_AINST_MASK                0x01
1269#define ESYNR1_AWRITE_MASK               0x01
1270#define ESYNR1_ABURST_MASK               0x01
1271#define ESYNR1_ALEN_MASK                 0x0F
1272#define ESYNR1_ASIZE_MASK                0x01
1273#define ESYNR1_ALOCK_MASK                0x03
1274#define ESYNR1_AOOO_MASK                 0x01
1275#define ESYNR1_AFULL_MASK                0x01
1276#define ESYNR1_AC_MASK                   0x01
1277#define ESYNR1_DCD_MASK                  0x01
1278
1279
1280/* IDR */
1281#define NM2VCBMT_MASK             0x1FF
1282#define HTW_MASK                  0x01
1283#define HUM_MASK                  0x01
1284#define TLBSIZE_MASK              0x0F
1285#define NCB_MASK                  0xFF
1286#define NIRPT_MASK                0xFF
1287
1288
1289/* M2VCBRn */
1290#define VMID_MASK                 0x1F
1291#define CBNDX_MASK                0xFF
1292#define BYPASSD_MASK              0x01
1293#define BPRCOSH_MASK              0x01
1294#define BPRCISH_MASK              0x01
1295#define BPRCNSH_MASK              0x01
1296#define BPSHCFG_MASK              0x03
1297#define NSCFG_MASK                0x03
1298#define BPMTCFG_MASK              0x01
1299#define BPMEMTYPE_MASK            0x07
1300
1301
1302/* REV */
1303#define MINOR_MASK                0x0F
1304#define MAJOR_MASK                0x0F
1305
1306
1307/* TESTBUSCR */
1308#define TBE_MASK                  0x01
1309#define SPDMBE_MASK               0x01
1310#define WGSEL_MASK                0x03
1311#define TBLSEL_MASK               0x03
1312#define TBHSEL_MASK               0x03
1313#define SPDM0SEL_MASK             0x0F
1314#define SPDM1SEL_MASK             0x0F
1315#define SPDM2SEL_MASK             0x0F
1316#define SPDM3SEL_MASK             0x0F
1317
1318
1319/* TLBIMID */
1320#define TLBIVMID_VMID_MASK        0x1F
1321
1322
1323/* TLBRSW */
1324#define TLBRSW_INDEX_MASK         0xFF
1325#define TLBBFBS_MASK              0x03
1326
1327
1328/* TLBTR0 */
1329#define PR_MASK                   0x01
1330#define PW_MASK                   0x01
1331#define UR_MASK                   0x01
1332#define UW_MASK                   0x01
1333#define XN_MASK                   0x01
1334#define NSDESC_MASK               0x01
1335#define ISH_MASK                  0x01
1336#define SH_MASK                   0x01
1337#define MT_MASK                   0x07
1338#define DPSIZR_MASK               0x07
1339#define DPSIZC_MASK               0x07
1340
1341
1342/* TLBTR1 */
1343#define TLBTR1_VMID_MASK          0x1F
1344#define TLBTR1_PA_MASK            0x000FFFFF
1345
1346
1347/* TLBTR2 */
1348#define TLBTR2_ASID_MASK          0xFF
1349#define TLBTR2_V_MASK             0x01
1350#define TLBTR2_NSTID_MASK         0x01
1351#define TLBTR2_NV_MASK            0x01
1352#define TLBTR2_VA_MASK            0x000FFFFF
1353
1354
1355/* Global Register Shifts */
1356/* CBACRn */
1357#define RWVMID_SHIFT             0
1358#define RWE_SHIFT                8
1359#define RWGE_SHIFT               9
1360#define CBVMID_SHIFT             16
1361#define IRPTNDX_SHIFT            24
1362
1363
1364/* CR */
1365#define RPUE_SHIFT               0
1366#define RPUERE_SHIFT             1
1367#define RPUEIE_SHIFT             2
1368#define DCDEE_SHIFT              3
1369#define CLIENTPD_SHIFT           4
1370#define STALLD_SHIFT             5
1371#define TLBLKCRWE_SHIFT          6
1372#define CR_TLBIALLCFG_SHIFT      7
1373#define TLBIVMIDCFG_SHIFT        8
1374#define CR_HUME_SHIFT            9
1375
1376
1377/* ESR */
1378#define CFG_SHIFT                0
1379#define BYPASS_SHIFT             1
1380#define ESR_MULTI_SHIFT          31
1381
1382
1383/* ESYNR0 */
1384#define ESYNR0_AMID_SHIFT        0
1385#define ESYNR0_APID_SHIFT        8
1386#define ESYNR0_ABID_SHIFT        13
1387#define ESYNR0_AVMID_SHIFT       16
1388#define ESYNR0_ATID_SHIFT        24
1389
1390
1391/* ESYNR1 */
1392#define ESYNR1_AMEMTYPE_SHIFT           0
1393#define ESYNR1_ASHARED_SHIFT            3
1394#define ESYNR1_AINNERSHARED_SHIFT       4
1395#define ESYNR1_APRIV_SHIFT              5
1396#define ESYNR1_APROTNS_SHIFT            6
1397#define ESYNR1_AINST_SHIFT              7
1398#define ESYNR1_AWRITE_SHIFT             8
1399#define ESYNR1_ABURST_SHIFT             10
1400#define ESYNR1_ALEN_SHIFT               12
1401#define ESYNR1_ASIZE_SHIFT              16
1402#define ESYNR1_ALOCK_SHIFT              20
1403#define ESYNR1_AOOO_SHIFT               22
1404#define ESYNR1_AFULL_SHIFT              24
1405#define ESYNR1_AC_SHIFT                 30
1406#define ESYNR1_DCD_SHIFT                31
1407
1408
1409/* IDR */
1410#define NM2VCBMT_SHIFT           0
1411#define HTW_SHIFT                9
1412#define HUM_SHIFT                10
1413#define TLBSIZE_SHIFT            12
1414#define NCB_SHIFT                16
1415#define NIRPT_SHIFT              24
1416
1417
1418/* M2VCBRn */
1419#define VMID_SHIFT               0
1420#define CBNDX_SHIFT              8
1421#define BYPASSD_SHIFT            16
1422#define BPRCOSH_SHIFT            17
1423#define BPRCISH_SHIFT            18
1424#define BPRCNSH_SHIFT            19
1425#define BPSHCFG_SHIFT            20
1426#define NSCFG_SHIFT              22
1427#define BPMTCFG_SHIFT            24
1428#define BPMEMTYPE_SHIFT          25
1429
1430
1431/* REV */
1432#define MINOR_SHIFT              0
1433#define MAJOR_SHIFT              4
1434
1435
1436/* TESTBUSCR */
1437#define TBE_SHIFT                0
1438#define SPDMBE_SHIFT             1
1439#define WGSEL_SHIFT              8
1440#define TBLSEL_SHIFT             12
1441#define TBHSEL_SHIFT             14
1442#define SPDM0SEL_SHIFT           16
1443#define SPDM1SEL_SHIFT           20
1444#define SPDM2SEL_SHIFT           24
1445#define SPDM3SEL_SHIFT           28
1446
1447
1448/* TLBIMID */
1449#define TLBIVMID_VMID_SHIFT      0
1450
1451
1452/* TLBRSW */
1453#define TLBRSW_INDEX_SHIFT       0
1454#define TLBBFBS_SHIFT            8
1455
1456
1457/* TLBTR0 */
1458#define PR_SHIFT                 0
1459#define PW_SHIFT                 1
1460#define UR_SHIFT                 2
1461#define UW_SHIFT                 3
1462#define XN_SHIFT                 4
1463#define NSDESC_SHIFT             6
1464#define ISH_SHIFT                7
1465#define SH_SHIFT                 8
1466#define MT_SHIFT                 9
1467#define DPSIZR_SHIFT             16
1468#define DPSIZC_SHIFT             20
1469
1470
1471/* TLBTR1 */
1472#define TLBTR1_VMID_SHIFT        0
1473#define TLBTR1_PA_SHIFT          12
1474
1475
1476/* TLBTR2 */
1477#define TLBTR2_ASID_SHIFT        0
1478#define TLBTR2_V_SHIFT           8
1479#define TLBTR2_NSTID_SHIFT       9
1480#define TLBTR2_NV_SHIFT          10
1481#define TLBTR2_VA_SHIFT          12
1482
1483
1484/* Context Register Masks */
1485/* ACTLR */
1486#define CFERE_MASK                       0x01
1487#define CFEIE_MASK                       0x01
1488#define PTSHCFG_MASK                     0x03
1489#define RCOSH_MASK                       0x01
1490#define RCISH_MASK                       0x01
1491#define RCNSH_MASK                       0x01
1492#define PRIVCFG_MASK                     0x03
1493#define DNA_MASK                         0x01
1494#define DNLV2PA_MASK                     0x01
1495#define TLBMCFG_MASK                     0x03
1496#define CFCFG_MASK                       0x01
1497#define TIPCF_MASK                       0x01
1498#define V2PCFG_MASK                      0x03
1499#define HUME_MASK                        0x01
1500#define PTMTCFG_MASK                     0x01
1501#define PTMEMTYPE_MASK                   0x07
1502
1503
1504/* BFBCR */
1505#define BFBDFE_MASK                      0x01
1506#define BFBSFE_MASK                      0x01
1507#define SFVS_MASK                        0x01
1508#define FLVIC_MASK                       0x0F
1509#define SLVIC_MASK                       0x0F
1510
1511
1512/* CONTEXTIDR */
1513#define CONTEXTIDR_ASID_MASK             0xFF
1514#define PROCID_MASK                      0x00FFFFFF
1515
1516
1517/* FSR */
1518#define TF_MASK                          0x01
1519#define AFF_MASK                         0x01
1520#define APF_MASK                         0x01
1521#define TLBMF_MASK                       0x01
1522#define HTWDEEF_MASK                     0x01
1523#define HTWSEEF_MASK                     0x01
1524#define MHF_MASK                         0x01
1525#define SL_MASK                          0x01
1526#define SS_MASK                          0x01
1527#define MULTI_MASK                       0x01
1528
1529
1530/* FSYNR0 */
1531#define AMID_MASK                        0xFF
1532#define APID_MASK                        0x1F
1533#define ABID_MASK                        0x07
1534#define ATID_MASK                        0xFF
1535
1536
1537/* FSYNR1 */
1538#define AMEMTYPE_MASK                    0x07
1539#define ASHARED_MASK                     0x01
1540#define AINNERSHARED_MASK                0x01
1541#define APRIV_MASK                       0x01
1542#define APROTNS_MASK                     0x01
1543#define AINST_MASK                       0x01
1544#define AWRITE_MASK                      0x01
1545#define ABURST_MASK                      0x01
1546#define ALEN_MASK                        0x0F
1547#define FSYNR1_ASIZE_MASK                0x07
1548#define ALOCK_MASK                       0x03
1549#define AFULL_MASK                       0x01
1550
1551
1552/* NMRR */
1553#define ICPC0_MASK                       0x03
1554#define ICPC1_MASK                       0x03
1555#define ICPC2_MASK                       0x03
1556#define ICPC3_MASK                       0x03
1557#define ICPC4_MASK                       0x03
1558#define ICPC5_MASK                       0x03
1559#define ICPC6_MASK                       0x03
1560#define ICPC7_MASK                       0x03
1561#define OCPC0_MASK                       0x03
1562#define OCPC1_MASK                       0x03
1563#define OCPC2_MASK                       0x03
1564#define OCPC3_MASK                       0x03
1565#define OCPC4_MASK                       0x03
1566#define OCPC5_MASK                       0x03
1567#define OCPC6_MASK                       0x03
1568#define OCPC7_MASK                       0x03
1569
1570
1571/* PAR */
1572#define FAULT_MASK                       0x01
1573/* If a fault is present, these are the
1574same as the fault fields in the FAR */
1575#define FAULT_TF_MASK                    0x01
1576#define FAULT_AFF_MASK                   0x01
1577#define FAULT_APF_MASK                   0x01
1578#define FAULT_TLBMF_MASK                 0x01
1579#define FAULT_HTWDEEF_MASK               0x01
1580#define FAULT_HTWSEEF_MASK               0x01
1581#define FAULT_MHF_MASK                   0x01
1582#define FAULT_SL_MASK                    0x01
1583#define FAULT_SS_MASK                    0x01
1584
1585/* If NO fault is present, the following
1586 * fields are in effect
1587 * (FAULT remains as before) */
1588#define PAR_NOFAULT_SS_MASK              0x01
1589#define PAR_NOFAULT_MT_MASK              0x07
1590#define PAR_NOFAULT_SH_MASK              0x01
1591#define PAR_NOFAULT_NS_MASK              0x01
1592#define PAR_NOFAULT_NOS_MASK             0x01
1593#define PAR_NPFAULT_PA_MASK              0x000FFFFF
1594
1595
1596/* PRRR */
1597#define MTC0_MASK                        0x03
1598#define MTC1_MASK                        0x03
1599#define MTC2_MASK                        0x03
1600#define MTC3_MASK                        0x03
1601#define MTC4_MASK                        0x03
1602#define MTC5_MASK                        0x03
1603#define MTC6_MASK                        0x03
1604#define MTC7_MASK                        0x03
1605#define SHDSH0_MASK                      0x01
1606#define SHDSH1_MASK                      0x01
1607#define SHNMSH0_MASK                     0x01
1608#define SHNMSH1_MASK                     0x01
1609#define NOS0_MASK                        0x01
1610#define NOS1_MASK                        0x01
1611#define NOS2_MASK                        0x01
1612#define NOS3_MASK                        0x01
1613#define NOS4_MASK                        0x01
1614#define NOS5_MASK                        0x01
1615#define NOS6_MASK                        0x01
1616#define NOS7_MASK                        0x01
1617
1618
1619/* RESUME */
1620#define TNR_MASK                         0x01
1621
1622
1623/* SCTLR */
1624#define M_MASK                           0x01
1625#define TRE_MASK                         0x01
1626#define AFE_MASK                         0x01
1627#define HAF_MASK                         0x01
1628#define BE_MASK                          0x01
1629#define AFFD_MASK                        0x01
1630
1631
1632/* TLBIASID */
1633#define TLBIASID_ASID_MASK               0xFF
1634
1635
1636/* TLBIVA */
1637#define TLBIVA_ASID_MASK                 0xFF
1638#define TLBIVA_VA_MASK                   0x000FFFFF
1639
1640
1641/* TLBIVAA */
1642#define TLBIVAA_VA_MASK                  0x000FFFFF
1643
1644
1645/* TLBLCKR */
1646#define LKE_MASK                         0x01
1647#define TLBLCKR_TLBIALLCFG_MASK          0x01
1648#define TLBIASIDCFG_MASK                 0x01
1649#define TLBIVAACFG_MASK                  0x01
1650#define FLOOR_MASK                       0xFF
1651#define VICTIM_MASK                      0xFF
1652
1653
1654/* TTBCR */
1655#define N_MASK                           0x07
1656#define PD0_MASK                         0x01
1657#define PD1_MASK                         0x01
1658
1659
1660/* TTBR0 */
1661#define TTBR0_IRGNH_MASK                 0x01
1662#define TTBR0_SH_MASK                    0x01
1663#define TTBR0_ORGN_MASK                  0x03
1664#define TTBR0_NOS_MASK                   0x01
1665#define TTBR0_IRGNL_MASK                 0x01
1666#define TTBR0_PA_MASK                    0x0003FFFF
1667
1668
1669/* TTBR1 */
1670#define TTBR1_IRGNH_MASK                 0x01
1671#define TTBR1_SH_MASK                    0x01
1672#define TTBR1_ORGN_MASK                  0x03
1673#define TTBR1_NOS_MASK                   0x01
1674#define TTBR1_IRGNL_MASK                 0x01
1675#define TTBR1_PA_MASK                    0x0003FFFF
1676
1677
1678/* V2PSR */
1679#define HIT_MASK                         0x01
1680#define INDEX_MASK                       0xFF
1681
1682
1683/* V2Pxx */
1684#define V2Pxx_INDEX_MASK                 0xFF
1685#define V2Pxx_VA_MASK                    0x000FFFFF
1686
1687
1688/* Context Register Shifts */
1689/* ACTLR */
1690#define CFERE_SHIFT                    0
1691#define CFEIE_SHIFT                    1
1692#define PTSHCFG_SHIFT                  2
1693#define RCOSH_SHIFT                    4
1694#define RCISH_SHIFT                    5
1695#define RCNSH_SHIFT                    6
1696#define PRIVCFG_SHIFT                  8
1697#define DNA_SHIFT                      10
1698#define DNLV2PA_SHIFT                  11
1699#define TLBMCFG_SHIFT                  12
1700#define CFCFG_SHIFT                    14
1701#define TIPCF_SHIFT                    15
1702#define V2PCFG_SHIFT                   16
1703#define HUME_SHIFT                     18
1704#define PTMTCFG_SHIFT                  20
1705#define PTMEMTYPE_SHIFT                21
1706
1707
1708/* BFBCR */
1709#define BFBDFE_SHIFT                   0
1710#define BFBSFE_SHIFT                   1
1711#define SFVS_SHIFT                     2
1712#define FLVIC_SHIFT                    4
1713#define SLVIC_SHIFT                    8
1714
1715
1716/* CONTEXTIDR */
1717#define CONTEXTIDR_ASID_SHIFT          0
1718#define PROCID_SHIFT                   8
1719
1720
1721/* FSR */
1722#define TF_SHIFT                       1
1723#define AFF_SHIFT                      2
1724#define APF_SHIFT                      3
1725#define TLBMF_SHIFT                    4
1726#define HTWDEEF_SHIFT                  5
1727#define HTWSEEF_SHIFT                  6
1728#define MHF_SHIFT                      7
1729#define SL_SHIFT                       16
1730#define SS_SHIFT                       30
1731#define MULTI_SHIFT                    31
1732
1733
1734/* FSYNR0 */
1735#define AMID_SHIFT                     0
1736#define APID_SHIFT                     8
1737#define ABID_SHIFT                     13
1738#define ATID_SHIFT                     24
1739
1740
1741/* FSYNR1 */
1742#define AMEMTYPE_SHIFT                 0
1743#define ASHARED_SHIFT                  3
1744#define AINNERSHARED_SHIFT             4
1745#define APRIV_SHIFT                    5
1746#define APROTNS_SHIFT                  6
1747#define AINST_SHIFT                    7
1748#define AWRITE_SHIFT                   8
1749#define ABURST_SHIFT                   10
1750#define ALEN_SHIFT                     12
1751#define FSYNR1_ASIZE_SHIFT             16
1752#define ALOCK_SHIFT                    20
1753#define AFULL_SHIFT                    24
1754
1755
1756/* NMRR */
1757#define ICPC0_SHIFT                    0
1758#define ICPC1_SHIFT                    2
1759#define ICPC2_SHIFT                    4
1760#define ICPC3_SHIFT                    6
1761#define ICPC4_SHIFT                    8
1762#define ICPC5_SHIFT                    10
1763#define ICPC6_SHIFT                    12
1764#define ICPC7_SHIFT                    14
1765#define OCPC0_SHIFT                    16
1766#define OCPC1_SHIFT                    18
1767#define OCPC2_SHIFT                    20
1768#define OCPC3_SHIFT                    22
1769#define OCPC4_SHIFT                    24
1770#define OCPC5_SHIFT                    26
1771#define OCPC6_SHIFT                    28
1772#define OCPC7_SHIFT                    30
1773
1774
1775/* PAR */
1776#define FAULT_SHIFT                    0
1777/* If a fault is present, these are the
1778same as the fault fields in the FAR */
1779#define FAULT_TF_SHIFT                 1
1780#define FAULT_AFF_SHIFT                2
1781#define FAULT_APF_SHIFT                3
1782#define FAULT_TLBMF_SHIFT              4
1783#define FAULT_HTWDEEF_SHIFT            5
1784#define FAULT_HTWSEEF_SHIFT            6
1785#define FAULT_MHF_SHIFT                7
1786#define FAULT_SL_SHIFT                 16
1787#define FAULT_SS_SHIFT                 30
1788
1789/* If NO fault is present, the following
1790 * fields are in effect
1791 * (FAULT remains as before) */
1792#define PAR_NOFAULT_SS_SHIFT           1
1793#define PAR_NOFAULT_MT_SHIFT           4
1794#define PAR_NOFAULT_SH_SHIFT           7
1795#define PAR_NOFAULT_NS_SHIFT           9
1796#define PAR_NOFAULT_NOS_SHIFT          10
1797#define PAR_NPFAULT_PA_SHIFT           12
1798
1799
1800/* PRRR */
1801#define MTC0_SHIFT                     0
1802#define MTC1_SHIFT                     2
1803#define MTC2_SHIFT                     4
1804#define MTC3_SHIFT                     6
1805#define MTC4_SHIFT                     8
1806#define MTC5_SHIFT                     10
1807#define MTC6_SHIFT                     12
1808#define MTC7_SHIFT                     14
1809#define SHDSH0_SHIFT                   16
1810#define SHDSH1_SHIFT                   17
1811#define SHNMSH0_SHIFT                  18
1812#define SHNMSH1_SHIFT                  19
1813#define NOS0_SHIFT                     24
1814#define NOS1_SHIFT                     25
1815#define NOS2_SHIFT                     26
1816#define NOS3_SHIFT                     27
1817#define NOS4_SHIFT                     28
1818#define NOS5_SHIFT                     29
1819#define NOS6_SHIFT                     30
1820#define NOS7_SHIFT                     31
1821
1822
1823/* RESUME */
1824#define TNR_SHIFT                      0
1825
1826
1827/* SCTLR */
1828#define M_SHIFT                        0
1829#define TRE_SHIFT                      1
1830#define AFE_SHIFT                      2
1831#define HAF_SHIFT                      3
1832#define BE_SHIFT                       4
1833#define AFFD_SHIFT                     5
1834
1835
1836/* TLBIASID */
1837#define TLBIASID_ASID_SHIFT            0
1838
1839
1840/* TLBIVA */
1841#define TLBIVA_ASID_SHIFT              0
1842#define TLBIVA_VA_SHIFT                12
1843
1844
1845/* TLBIVAA */
1846#define TLBIVAA_VA_SHIFT               12
1847
1848
1849/* TLBLCKR */
1850#define LKE_SHIFT                      0
1851#define TLBLCKR_TLBIALLCFG_SHIFT       1
1852#define TLBIASIDCFG_SHIFT              2
1853#define TLBIVAACFG_SHIFT               3
1854#define FLOOR_SHIFT                    8
1855#define VICTIM_SHIFT                   8
1856
1857
1858/* TTBCR */
1859#define N_SHIFT                        3
1860#define PD0_SHIFT                      4
1861#define PD1_SHIFT                      5
1862
1863
1864/* TTBR0 */
1865#define TTBR0_IRGNH_SHIFT              0
1866#define TTBR0_SH_SHIFT                 1
1867#define TTBR0_ORGN_SHIFT               3
1868#define TTBR0_NOS_SHIFT                5
1869#define TTBR0_IRGNL_SHIFT              6
1870#define TTBR0_PA_SHIFT                 14
1871
1872
1873/* TTBR1 */
1874#define TTBR1_IRGNH_SHIFT              0
1875#define TTBR1_SH_SHIFT                 1
1876#define TTBR1_ORGN_SHIFT               3
1877#define TTBR1_NOS_SHIFT                5
1878#define TTBR1_IRGNL_SHIFT              6
1879#define TTBR1_PA_SHIFT                 14
1880
1881
1882/* V2PSR */
1883#define HIT_SHIFT                      0
1884#define INDEX_SHIFT                    8
1885
1886
1887/* V2Pxx */
1888#define V2Pxx_INDEX_SHIFT              0
1889#define V2Pxx_VA_SHIFT                 12
1890
1891#endif
1892