hw/arm/smmuv3-internal.h

   1 /*
   2  * ARM SMMUv3 support - Internal API
   3  *
   4  * Copyright (C) 2014-2016 Broadcom Corporation
   5  * Copyright (c) 2017 Red Hat, Inc.
   6  * Written by Prem Mallappa, Eric Auger
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License version 2 as
  10  * published by the Free Software Foundation.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License along
  18  * with this program; if not, see <http://www.gnu.org/licenses/>.
  19  */
  20
  21 #ifndef HW_ARM_SMMUV3_INTERNAL_H
  22 #define HW_ARM_SMMUV3_INTERNAL_H
  23
  24 #include "hw/arm/smmu-common.h"
  25
  26 typedef enum SMMUTranslationStatus {
  27     SMMU_TRANS_DISABLE,
  28     SMMU_TRANS_ABORT,
  29     SMMU_TRANS_BYPASS,
  30     SMMU_TRANS_ERROR,
  31     SMMU_TRANS_SUCCESS,
  32 } SMMUTranslationStatus;
  33
  34 /* MMIO Registers */
  35
  36 REG32(IDR0,                0x0)
  37     FIELD(IDR0, S1P,         1 , 1)
  38     FIELD(IDR0, TTF,         2 , 2)
  39     FIELD(IDR0, COHACC,      4 , 1)
  40     FIELD(IDR0, ASID16,      12, 1)
  41     FIELD(IDR0, TTENDIAN,    21, 2)
  42     FIELD(IDR0, STALL_MODEL, 24, 2)
  43     FIELD(IDR0, TERM_MODEL,  26, 1)
  44     FIELD(IDR0, STLEVEL,     27, 2)
  45
  46 REG32(IDR1,                0x4)
  47     FIELD(IDR1, SIDSIZE,      0 , 6)
  48     FIELD(IDR1, EVENTQS,      16, 5)
  49     FIELD(IDR1, CMDQS,        21, 5)
  50
  51 #define SMMU_IDR1_SIDSIZE 16
  52 #define SMMU_CMDQS   19
  53 #define SMMU_EVENTQS 19
  54
  55 REG32(IDR2,                0x8)
  56 REG32(IDR3,                0xc)
  57      FIELD(IDR3, HAD,         2, 1);
  58 REG32(IDR4,                0x10)
  59 REG32(IDR5,                0x14)
  60      FIELD(IDR5, OAS,         0, 3);
  61      FIELD(IDR5, GRAN4K,      4, 1);
  62      FIELD(IDR5, GRAN16K,     5, 1);
  63      FIELD(IDR5, GRAN64K,     6, 1);
  64
  65 #define SMMU_IDR5_OAS 4
  66
  67 REG32(IIDR,                0x18)
  68 REG32(AIDR,                0x1c)
  69 REG32(CR0,                 0x20)
  70     FIELD(CR0, SMMU_ENABLE,   0, 1)
  71     FIELD(CR0, EVENTQEN,      2, 1)
  72     FIELD(CR0, CMDQEN,        3, 1)
  73
  74 #define SMMU_CR0_RESERVED 0xFFFFFC20
  75
  76 REG32(CR0ACK,              0x24)
  77 REG32(CR1,                 0x28)
  78 REG32(CR2,                 0x2c)
  79 REG32(STATUSR,             0x40)
  80 REG32(IRQ_CTRL,            0x50)
  81     FIELD(IRQ_CTRL, GERROR_IRQEN,        0, 1)
  82     FIELD(IRQ_CTRL, PRI_IRQEN,           1, 1)
  83     FIELD(IRQ_CTRL, EVENTQ_IRQEN,        2, 1)
  84
  85 REG32(IRQ_CTRL_ACK,        0x54)
  86 REG32(GERROR,              0x60)
  87     FIELD(GERROR, CMDQ_ERR,           0, 1)
  88     FIELD(GERROR, EVENTQ_ABT_ERR,     2, 1)
  89     FIELD(GERROR, PRIQ_ABT_ERR,       3, 1)
  90     FIELD(GERROR, MSI_CMDQ_ABT_ERR,   4, 1)
  91     FIELD(GERROR, MSI_EVENTQ_ABT_ERR, 5, 1)
  92     FIELD(GERROR, MSI_PRIQ_ABT_ERR,   6, 1)
  93     FIELD(GERROR, MSI_GERROR_ABT_ERR, 7, 1)
  94     FIELD(GERROR, MSI_SFM_ERR,        8, 1)
  95
  96 REG32(GERRORN,             0x64)
  97
  98 #define A_GERROR_IRQ_CFG0  0x68 /* 64b */
  99 REG32(GERROR_IRQ_CFG1, 0x70)
 100 REG32(GERROR_IRQ_CFG2, 0x74)
 101
 102 #define A_STRTAB_BASE      0x80 /* 64b */
 103
 104 #define SMMU_BASE_ADDR_MASK 0xfffffffffffc0
 105
 106 REG32(STRTAB_BASE_CFG,     0x88)
 107     FIELD(STRTAB_BASE_CFG, FMT,      16, 2)
 108     FIELD(STRTAB_BASE_CFG, SPLIT,    6 , 5)
 109     FIELD(STRTAB_BASE_CFG, LOG2SIZE, 0 , 6)
 110
 111 #define A_CMDQ_BASE        0x90 /* 64b */
 112 REG32(CMDQ_PROD,           0x98)
 113 REG32(CMDQ_CONS,           0x9c)
 114     FIELD(CMDQ_CONS, ERR, 24, 7)
 115
 116 #define A_EVENTQ_BASE      0xa0 /* 64b */
 117 REG32(EVENTQ_PROD,         0xa8)
 118 REG32(EVENTQ_CONS,         0xac)
 119
 120 #define A_EVENTQ_IRQ_CFG0  0xb0 /* 64b */
 121 REG32(EVENTQ_IRQ_CFG1,     0xb8)
 122 REG32(EVENTQ_IRQ_CFG2,     0xbc)
 123
 124 #define A_IDREGS           0xfd0
 125
 126 static inline int smmu_enabled(SMMUv3State *s)
 127 {
 128     return FIELD_EX32(s->cr[0], CR0, SMMU_ENABLE);
 129 }
 130
 131 /* Command Queue Entry */
 132 typedef struct Cmd {
 133     uint32_t word[4];
 134 } Cmd;
 135
 136 /* Event Queue Entry */
 137 typedef struct Evt  {
 138     uint32_t word[8];
 139 } Evt;
 140
 141 static inline uint32_t smmuv3_idreg(int regoffset)
 142 {
 143     /*
 144      * Return the value of the Primecell/Corelink ID registers at the
 145      * specified offset from the first ID register.
 146      * These value indicate an ARM implementation of MMU600 p1
 147      */
 148     static const uint8_t smmuv3_ids[] = {
 149         0x04, 0, 0, 0, 0x84, 0xB4, 0xF0, 0x10, 0x0D, 0xF0, 0x05, 0xB1
 150     };
 151     return smmuv3_ids[regoffset / 4];
 152 }
 153
 154 static inline bool smmuv3_eventq_irq_enabled(SMMUv3State *s)
 155 {
 156     return FIELD_EX32(s->irq_ctrl, IRQ_CTRL, EVENTQ_IRQEN);
 157 }
 158
 159 static inline bool smmuv3_gerror_irq_enabled(SMMUv3State *s)
 160 {
 161     return FIELD_EX32(s->irq_ctrl, IRQ_CTRL, GERROR_IRQEN);
 162 }
 163
 164 /* Queue Handling */
 165
 166 #define Q_BASE(q)          ((q)->base & SMMU_BASE_ADDR_MASK)
 167 #define WRAP_MASK(q)       (1 << (q)->log2size)
 168 #define INDEX_MASK(q)      (((1 << (q)->log2size)) - 1)
 169 #define WRAP_INDEX_MASK(q) ((1 << ((q)->log2size + 1)) - 1)
 170
 171 #define Q_CONS(q) ((q)->cons & INDEX_MASK(q))
 172 #define Q_PROD(q) ((q)->prod & INDEX_MASK(q))
 173
 174 #define Q_CONS_ENTRY(q)  (Q_BASE(q) + (q)->entry_size * Q_CONS(q))
 175 #define Q_PROD_ENTRY(q)  (Q_BASE(q) + (q)->entry_size * Q_PROD(q))
 176
 177 #define Q_CONS_WRAP(q) (((q)->cons & WRAP_MASK(q)) >> (q)->log2size)
 178 #define Q_PROD_WRAP(q) (((q)->prod & WRAP_MASK(q)) >> (q)->log2size)
 179
 180 static inline bool smmuv3_q_full(SMMUQueue *q)
 181 {
 182     return ((q->cons ^ q->prod) & WRAP_INDEX_MASK(q)) == WRAP_MASK(q);
 183 }
 184
 185 static inline bool smmuv3_q_empty(SMMUQueue *q)
 186 {
 187     return (q->cons & WRAP_INDEX_MASK(q)) == (q->prod & WRAP_INDEX_MASK(q));
 188 }
 189
 190 static inline void queue_prod_incr(SMMUQueue *q)
 191 {
 192     q->prod = (q->prod + 1) & WRAP_INDEX_MASK(q);
 193 }
 194
 195 static inline void queue_cons_incr(SMMUQueue *q)
 196 {
 197     /*
 198      * We have to use deposit for the CONS registers to preserve
 199      * the ERR field in the high bits.
 200      */
 201     q->cons = deposit32(q->cons, 0, q->log2size + 1, q->cons + 1);
 202 }
 203
 204 static inline bool smmuv3_cmdq_enabled(SMMUv3State *s)
 205 {
 206     return FIELD_EX32(s->cr[0], CR0, CMDQEN);
 207 }
 208
 209 static inline bool smmuv3_eventq_enabled(SMMUv3State *s)
 210 {
 211     return FIELD_EX32(s->cr[0], CR0, EVENTQEN);
 212 }
 213
 214 static inline void smmu_write_cmdq_err(SMMUv3State *s, uint32_t err_type)
 215 {
 216     s->cmdq.cons = FIELD_DP32(s->cmdq.cons, CMDQ_CONS, ERR, err_type);
 217 }
 218
 219 /* Commands */
 220
 221 typedef enum SMMUCommandType {
 222     SMMU_CMD_NONE            = 0x00,
 223     SMMU_CMD_PREFETCH_CONFIG       ,
 224     SMMU_CMD_PREFETCH_ADDR,
 225     SMMU_CMD_CFGI_STE,
 226     SMMU_CMD_CFGI_STE_RANGE,
 227     SMMU_CMD_CFGI_CD,
 228     SMMU_CMD_CFGI_CD_ALL,
 229     SMMU_CMD_CFGI_ALL,
 230     SMMU_CMD_TLBI_NH_ALL     = 0x10,
 231     SMMU_CMD_TLBI_NH_ASID,
 232     SMMU_CMD_TLBI_NH_VA,
 233     SMMU_CMD_TLBI_NH_VAA,
 234     SMMU_CMD_TLBI_EL3_ALL    = 0x18,
 235     SMMU_CMD_TLBI_EL3_VA     = 0x1a,
 236     SMMU_CMD_TLBI_EL2_ALL    = 0x20,
 237     SMMU_CMD_TLBI_EL2_ASID,
 238     SMMU_CMD_TLBI_EL2_VA,
 239     SMMU_CMD_TLBI_EL2_VAA,
 240     SMMU_CMD_TLBI_S12_VMALL  = 0x28,
 241     SMMU_CMD_TLBI_S2_IPA     = 0x2a,
 242     SMMU_CMD_TLBI_NSNH_ALL   = 0x30,
 243     SMMU_CMD_ATC_INV         = 0x40,
 244     SMMU_CMD_PRI_RESP,
 245     SMMU_CMD_RESUME          = 0x44,
 246     SMMU_CMD_STALL_TERM,
 247     SMMU_CMD_SYNC,
 248 } SMMUCommandType;
 249
 250 static const char *cmd_stringify[] = {
 251     [SMMU_CMD_PREFETCH_CONFIG] = "SMMU_CMD_PREFETCH_CONFIG",
 252     [SMMU_CMD_PREFETCH_ADDR]   = "SMMU_CMD_PREFETCH_ADDR",
 253     [SMMU_CMD_CFGI_STE]        = "SMMU_CMD_CFGI_STE",
 254     [SMMU_CMD_CFGI_STE_RANGE]  = "SMMU_CMD_CFGI_STE_RANGE",
 255     [SMMU_CMD_CFGI_CD]         = "SMMU_CMD_CFGI_CD",
 256     [SMMU_CMD_CFGI_CD_ALL]     = "SMMU_CMD_CFGI_CD_ALL",
 257     [SMMU_CMD_CFGI_ALL]        = "SMMU_CMD_CFGI_ALL",
 258     [SMMU_CMD_TLBI_NH_ALL]     = "SMMU_CMD_TLBI_NH_ALL",
 259     [SMMU_CMD_TLBI_NH_ASID]    = "SMMU_CMD_TLBI_NH_ASID",
 260     [SMMU_CMD_TLBI_NH_VA]      = "SMMU_CMD_TLBI_NH_VA",
 261     [SMMU_CMD_TLBI_NH_VAA]     = "SMMU_CMD_TLBI_NH_VAA",
 262     [SMMU_CMD_TLBI_EL3_ALL]    = "SMMU_CMD_TLBI_EL3_ALL",
 263     [SMMU_CMD_TLBI_EL3_VA]     = "SMMU_CMD_TLBI_EL3_VA",
 264     [SMMU_CMD_TLBI_EL2_ALL]    = "SMMU_CMD_TLBI_EL2_ALL",
 265     [SMMU_CMD_TLBI_EL2_ASID]   = "SMMU_CMD_TLBI_EL2_ASID",
 266     [SMMU_CMD_TLBI_EL2_VA]     = "SMMU_CMD_TLBI_EL2_VA",
 267     [SMMU_CMD_TLBI_EL2_VAA]    = "SMMU_CMD_TLBI_EL2_VAA",
 268     [SMMU_CMD_TLBI_S12_VMALL]  = "SMMU_CMD_TLBI_S12_VMALL",
 269     [SMMU_CMD_TLBI_S2_IPA]     = "SMMU_CMD_TLBI_S2_IPA",
 270     [SMMU_CMD_TLBI_NSNH_ALL]   = "SMMU_CMD_TLBI_NSNH_ALL",
 271     [SMMU_CMD_ATC_INV]         = "SMMU_CMD_ATC_INV",
 272     [SMMU_CMD_PRI_RESP]        = "SMMU_CMD_PRI_RESP",
 273     [SMMU_CMD_RESUME]          = "SMMU_CMD_RESUME",
 274     [SMMU_CMD_STALL_TERM]      = "SMMU_CMD_STALL_TERM",
 275     [SMMU_CMD_SYNC]            = "SMMU_CMD_SYNC",
 276 };
 277
 278 static inline const char *smmu_cmd_string(SMMUCommandType type)
 279 {
 280     if (type > SMMU_CMD_NONE && type < ARRAY_SIZE(cmd_stringify)) {
 281         return cmd_stringify[type] ? cmd_stringify[type] : "UNKNOWN";
 282     } else {
 283         return "INVALID";
 284     }
 285 }
 286
 287 /* CMDQ fields */
 288
 289 typedef enum {
 290     SMMU_CERROR_NONE = 0,
 291     SMMU_CERROR_ILL,
 292     SMMU_CERROR_ABT,
 293     SMMU_CERROR_ATC_INV_SYNC,
 294 } SMMUCmdError;
 295
 296 enum { /* Command completion notification */
 297     CMD_SYNC_SIG_NONE,
 298     CMD_SYNC_SIG_IRQ,
 299     CMD_SYNC_SIG_SEV,
 300 };
 301
 302 #define CMD_TYPE(x)         extract32((x)->word[0], 0 , 8)
 303 #define CMD_NUM(x)          extract32((x)->word[0], 12 , 5)
 304 #define CMD_SCALE(x)        extract32((x)->word[0], 20 , 5)
 305 #define CMD_SSEC(x)         extract32((x)->word[0], 10, 1)
 306 #define CMD_SSV(x)          extract32((x)->word[0], 11, 1)
 307 #define CMD_RESUME_AC(x)    extract32((x)->word[0], 12, 1)
 308 #define CMD_RESUME_AB(x)    extract32((x)->word[0], 13, 1)
 309 #define CMD_SYNC_CS(x)      extract32((x)->word[0], 12, 2)
 310 #define CMD_SSID(x)         extract32((x)->word[0], 12, 20)
 311 #define CMD_SID(x)          ((x)->word[1])
 312 #define CMD_VMID(x)         extract32((x)->word[1], 0 , 16)
 313 #define CMD_ASID(x)         extract32((x)->word[1], 16, 16)
 314 #define CMD_RESUME_STAG(x)  extract32((x)->word[2], 0 , 16)
 315 #define CMD_RESP(x)         extract32((x)->word[2], 11, 2)
 316 #define CMD_LEAF(x)         extract32((x)->word[2], 0 , 1)
 317 #define CMD_TTL(x)          extract32((x)->word[2], 8 , 2)
 318 #define CMD_TG(x)           extract32((x)->word[2], 10, 2)
 319 #define CMD_STE_RANGE(x)    extract32((x)->word[2], 0 , 5)
 320 #define CMD_ADDR(x) ({                                        \
 321             uint64_t high = (uint64_t)(x)->word[3];           \
 322             uint64_t low = extract32((x)->word[2], 12, 20);    \
 323             uint64_t addr = high << 32 | (low << 12);         \
 324             addr;                                             \
 325         })
 326
 327 #define SMMU_FEATURE_2LVL_STE (1 << 0)
 328
 329 /* Events */
 330
 331 typedef enum SMMUEventType {
 332     SMMU_EVT_NONE               = 0x00,
 333     SMMU_EVT_F_UUT                    ,
 334     SMMU_EVT_C_BAD_STREAMID           ,
 335     SMMU_EVT_F_STE_FETCH              ,
 336     SMMU_EVT_C_BAD_STE                ,
 337     SMMU_EVT_F_BAD_ATS_TREQ           ,
 338     SMMU_EVT_F_STREAM_DISABLED        ,
 339     SMMU_EVT_F_TRANS_FORBIDDEN        ,
 340     SMMU_EVT_C_BAD_SUBSTREAMID        ,
 341     SMMU_EVT_F_CD_FETCH               ,
 342     SMMU_EVT_C_BAD_CD                 ,
 343     SMMU_EVT_F_WALK_EABT              ,
 344     SMMU_EVT_F_TRANSLATION      = 0x10,
 345     SMMU_EVT_F_ADDR_SIZE              ,
 346     SMMU_EVT_F_ACCESS                 ,
 347     SMMU_EVT_F_PERMISSION             ,
 348     SMMU_EVT_F_TLB_CONFLICT     = 0x20,
 349     SMMU_EVT_F_CFG_CONFLICT           ,
 350     SMMU_EVT_E_PAGE_REQ         = 0x24,
 351 } SMMUEventType;
 352
 353 static const char *event_stringify[] = {
 354     [SMMU_EVT_NONE]                     = "no recorded event",
 355     [SMMU_EVT_F_UUT]                    = "SMMU_EVT_F_UUT",
 356     [SMMU_EVT_C_BAD_STREAMID]           = "SMMU_EVT_C_BAD_STREAMID",
 357     [SMMU_EVT_F_STE_FETCH]              = "SMMU_EVT_F_STE_FETCH",
 358     [SMMU_EVT_C_BAD_STE]                = "SMMU_EVT_C_BAD_STE",
 359     [SMMU_EVT_F_BAD_ATS_TREQ]           = "SMMU_EVT_F_BAD_ATS_TREQ",
 360     [SMMU_EVT_F_STREAM_DISABLED]        = "SMMU_EVT_F_STREAM_DISABLED",
 361     [SMMU_EVT_F_TRANS_FORBIDDEN]        = "SMMU_EVT_F_TRANS_FORBIDDEN",
 362     [SMMU_EVT_C_BAD_SUBSTREAMID]        = "SMMU_EVT_C_BAD_SUBSTREAMID",
 363     [SMMU_EVT_F_CD_FETCH]               = "SMMU_EVT_F_CD_FETCH",
 364     [SMMU_EVT_C_BAD_CD]                 = "SMMU_EVT_C_BAD_CD",
 365     [SMMU_EVT_F_WALK_EABT]              = "SMMU_EVT_F_WALK_EABT",
 366     [SMMU_EVT_F_TRANSLATION]            = "SMMU_EVT_F_TRANSLATION",
 367     [SMMU_EVT_F_ADDR_SIZE]              = "SMMU_EVT_F_ADDR_SIZE",
 368     [SMMU_EVT_F_ACCESS]                 = "SMMU_EVT_F_ACCESS",
 369     [SMMU_EVT_F_PERMISSION]             = "SMMU_EVT_F_PERMISSION",
 370     [SMMU_EVT_F_TLB_CONFLICT]           = "SMMU_EVT_F_TLB_CONFLICT",
 371     [SMMU_EVT_F_CFG_CONFLICT]           = "SMMU_EVT_F_CFG_CONFLICT",
 372     [SMMU_EVT_E_PAGE_REQ]               = "SMMU_EVT_E_PAGE_REQ",
 373 };
 374
 375 static inline const char *smmu_event_string(SMMUEventType type)
 376 {
 377     if (type < ARRAY_SIZE(event_stringify)) {
 378         return event_stringify[type] ? event_stringify[type] : "UNKNOWN";
 379     } else {
 380         return "INVALID";
 381     }
 382 }
 383
 384 /*  Encode an event record */
 385 typedef struct SMMUEventInfo {
 386     SMMUEventType type;
 387     uint32_t sid;
 388     bool recorded;
 389     bool record_trans_faults;
 390     bool inval_ste_allowed;
 391     union {
 392         struct {
 393             uint32_t ssid;
 394             bool ssv;
 395             dma_addr_t addr;
 396             bool rnw;
 397             bool pnu;
 398             bool ind;
 399        } f_uut;
 400        struct SSIDInfo {
 401             uint32_t ssid;
 402             bool ssv;
 403        } c_bad_streamid;
 404        struct SSIDAddrInfo {
 405             uint32_t ssid;
 406             bool ssv;
 407             dma_addr_t addr;
 408        } f_ste_fetch;
 409        struct SSIDInfo c_bad_ste;
 410        struct {
 411             dma_addr_t addr;
 412             bool rnw;
 413        } f_transl_forbidden;
 414        struct {
 415             uint32_t ssid;
 416        } c_bad_substream;
 417        struct SSIDAddrInfo f_cd_fetch;
 418        struct SSIDInfo c_bad_cd;
 419        struct FullInfo {
 420             bool stall;
 421             uint16_t stag;
 422             uint32_t ssid;
 423             bool ssv;
 424             bool s2;
 425             dma_addr_t addr;
 426             bool rnw;
 427             bool pnu;
 428             bool ind;
 429             uint8_t class;
 430             dma_addr_t addr2;
 431        } f_walk_eabt;
 432        struct FullInfo f_translation;
 433        struct FullInfo f_addr_size;
 434        struct FullInfo f_access;
 435        struct FullInfo f_permission;
 436        struct SSIDInfo f_cfg_conflict;
 437        /**
 438         * not supported yet:
 439         * F_BAD_ATS_TREQ
 440         * F_BAD_ATS_TREQ
 441         * F_TLB_CONFLICT
 442         * E_PAGE_REQUEST
 443         * IMPDEF_EVENTn
 444         */
 445     } u;
 446 } SMMUEventInfo;
 447
 448 /* EVTQ fields */
 449
 450 #define EVT_Q_OVERFLOW        (1 << 31)
 451
 452 #define EVT_SET_TYPE(x, v)  ((x)->word[0] = deposit32((x)->word[0], 0 , 8 , v))
 453 #define EVT_SET_SSV(x, v)   ((x)->word[0] = deposit32((x)->word[0], 11, 1 , v))
 454 #define EVT_SET_SSID(x, v)  ((x)->word[0] = deposit32((x)->word[0], 12, 20, v))
 455 #define EVT_SET_SID(x, v)   ((x)->word[1] = v)
 456 #define EVT_SET_STAG(x, v)  ((x)->word[2] = deposit32((x)->word[2], 0 , 16, v))
 457 #define EVT_SET_STALL(x, v) ((x)->word[2] = deposit32((x)->word[2], 31, 1 , v))
 458 #define EVT_SET_PNU(x, v)   ((x)->word[3] = deposit32((x)->word[3], 1 , 1 , v))
 459 #define EVT_SET_IND(x, v)   ((x)->word[3] = deposit32((x)->word[3], 2 , 1 , v))
 460 #define EVT_SET_RNW(x, v)   ((x)->word[3] = deposit32((x)->word[3], 3 , 1 , v))
 461 #define EVT_SET_S2(x, v)    ((x)->word[3] = deposit32((x)->word[3], 7 , 1 , v))
 462 #define EVT_SET_CLASS(x, v) ((x)->word[3] = deposit32((x)->word[3], 8 , 2 , v))
 463 #define EVT_SET_ADDR(x, addr)                             \
 464     do {                                                  \
 465             (x)->word[5] = (uint32_t)(addr >> 32);        \
 466             (x)->word[4] = (uint32_t)(addr & 0xffffffff); \
 467     } while (0)
 468 #define EVT_SET_ADDR2(x, addr)                            \
 469     do {                                                  \
 470             (x)->word[7] = (uint32_t)(addr >> 32);        \
 471             (x)->word[6] = (uint32_t)(addr & 0xffffffff); \
 472     } while (0)
 473
 474 void smmuv3_record_event(SMMUv3State *s, SMMUEventInfo *event);
 475
 476 /* Configuration Data */
 477
 478 /* STE Level 1 Descriptor */
 479 typedef struct STEDesc {
 480     uint32_t word[2];
 481 } STEDesc;
 482
 483 /* CD Level 1 Descriptor */
 484 typedef struct CDDesc {
 485     uint32_t word[2];
 486 } CDDesc;
 487
 488 /* Stream Table Entry(STE) */
 489 typedef struct STE {
 490     uint32_t word[16];
 491 } STE;
 492
 493 /* Context Descriptor(CD) */
 494 typedef struct CD {
 495     uint32_t word[16];
 496 } CD;
 497
 498 /* STE fields */
 499
 500 #define STE_VALID(x)   extract32((x)->word[0], 0, 1)
 501
 502 #define STE_CONFIG(x)  extract32((x)->word[0], 1, 3)
 503 #define STE_CFG_S1_ENABLED(config) (config & 0x1)
 504 #define STE_CFG_S2_ENABLED(config) (config & 0x2)
 505 #define STE_CFG_ABORT(config)      (!(config & 0x4))
 506 #define STE_CFG_BYPASS(config)     (config == 0x4)
 507
 508 #define STE_S1FMT(x)       extract32((x)->word[0], 4 , 2)
 509 #define STE_S1CDMAX(x)     extract32((x)->word[1], 27, 5)
 510 #define STE_S1STALLD(x)    extract32((x)->word[2], 27, 1)
 511 #define STE_EATS(x)        extract32((x)->word[2], 28, 2)
 512 #define STE_STRW(x)        extract32((x)->word[2], 30, 2)
 513 #define STE_S2VMID(x)      extract32((x)->word[4], 0 , 16)
 514 #define STE_S2T0SZ(x)      extract32((x)->word[5], 0 , 6)
 515 #define STE_S2SL0(x)       extract32((x)->word[5], 6 , 2)
 516 #define STE_S2TG(x)        extract32((x)->word[5], 14, 2)
 517 #define STE_S2PS(x)        extract32((x)->word[5], 16, 3)
 518 #define STE_S2AA64(x)      extract32((x)->word[5], 19, 1)
 519 #define STE_S2HD(x)        extract32((x)->word[5], 24, 1)
 520 #define STE_S2HA(x)        extract32((x)->word[5], 25, 1)
 521 #define STE_S2S(x)         extract32((x)->word[5], 26, 1)
 522 #define STE_CTXPTR(x)                                           \
 523     ({                                                          \
 524         unsigned long addr;                                     \
 525         addr = (uint64_t)extract32((x)->word[1], 0, 16) << 32;  \
 526         addr |= (uint64_t)((x)->word[0] & 0xffffffc0);          \
 527         addr;                                                   \
 528     })
 529
 530 #define STE_S2TTB(x)                                            \
 531     ({                                                          \
 532         unsigned long addr;                                     \
 533         addr = (uint64_t)extract32((x)->word[7], 0, 16) << 32;  \
 534         addr |= (uint64_t)((x)->word[6] & 0xfffffff0);          \
 535         addr;                                                   \
 536     })
 537
 538 static inline int oas2bits(int oas_field)
 539 {
 540     switch (oas_field) {
 541     case 0:
 542         return 32;
 543     case 1:
 544         return 36;
 545     case 2:
 546         return 40;
 547     case 3:
 548         return 42;
 549     case 4:
 550         return 44;
 551     case 5:
 552         return 48;
 553     }
 554     return -1;
 555 }
 556
 557 static inline int pa_range(STE *ste)
 558 {
 559     int oas_field = MIN(STE_S2PS(ste), SMMU_IDR5_OAS);
 560
 561     if (!STE_S2AA64(ste)) {
 562         return 40;
 563     }
 564
 565     return oas2bits(oas_field);
 566 }
 567
 568 #define MAX_PA(ste) ((1 << pa_range(ste)) - 1)
 569
 570 /* CD fields */
 571
 572 #define CD_VALID(x)   extract32((x)->word[0], 30, 1)
 573 #define CD_ASID(x)    extract32((x)->word[1], 16, 16)
 574 #define CD_TTB(x, sel)                                      \
 575     ({                                                      \
 576         uint64_t hi, lo;                                    \
 577         hi = extract32((x)->word[(sel) * 2 + 3], 0, 19);    \
 578         hi <<= 32;                                          \
 579         lo = (x)->word[(sel) * 2 + 2] & ~0xfULL;            \
 580         hi | lo;                                            \
 581     })
 582 #define CD_HAD(x, sel)   extract32((x)->word[(sel) * 2 + 2], 1, 1)
 583
 584 #define CD_TSZ(x, sel)   extract32((x)->word[0], (16 * (sel)) + 0, 6)
 585 #define CD_TG(x, sel)    extract32((x)->word[0], (16 * (sel)) + 6, 2)
 586 #define CD_EPD(x, sel)   extract32((x)->word[0], (16 * (sel)) + 14, 1)
 587 #define CD_ENDI(x)       extract32((x)->word[0], 15, 1)
 588 #define CD_IPS(x)        extract32((x)->word[1], 0 , 3)
 589 #define CD_TBI(x)        extract32((x)->word[1], 6 , 2)
 590 #define CD_HD(x)         extract32((x)->word[1], 10 , 1)
 591 #define CD_HA(x)         extract32((x)->word[1], 11 , 1)
 592 #define CD_S(x)          extract32((x)->word[1], 12, 1)
 593 #define CD_R(x)          extract32((x)->word[1], 13, 1)
 594 #define CD_A(x)          extract32((x)->word[1], 14, 1)
 595 #define CD_AARCH64(x)    extract32((x)->word[1], 9 , 1)
 596
 597 #define CDM_VALID(x)    ((x)->word[0] & 0x1)
 598
 599 static inline int is_cd_valid(SMMUv3State *s, STE *ste, CD *cd)
 600 {
 601     return CD_VALID(cd);
 602 }
 603
 604 /**
 605  * tg2granule - Decodes the CD translation granule size field according
 606  * to the ttbr in use
 607  * @bits: TG0/1 fields
 608  * @ttbr: ttbr index in use
 609  */
 610 static inline int tg2granule(int bits, int ttbr)
 611 {
 612     switch (bits) {
 613     case 0:
 614         return ttbr ? 0  : 12;
 615     case 1:
 616         return ttbr ? 14 : 16;
 617     case 2:
 618         return ttbr ? 12 : 14;
 619     case 3:
 620         return ttbr ? 16 :  0;
 621     default:
 622         return 0;
 623     }
 624 }
 625
 626 static inline uint64_t l1std_l2ptr(STEDesc *desc)
 627 {
 628     uint64_t hi, lo;
 629
 630     hi = desc->word[1];
 631     lo = desc->word[0] & ~0x1fULL;
 632     return hi << 32 | lo;
 633 }
 634
 635 #define L1STD_SPAN(stm) (extract32((stm)->word[0], 0, 4))
 636
 637 #endif