qualcomm/qbox
Loading...
Searching...
No Matches
smmuv3_gen.h
1/*
2 * Copyright (c) Qualcomm Technologies, Inc. and/or its subsidiaries.
3 *
4 * SPDX-License-Identifier: BSD-3-Clause-Clear
5 */
6
7#ifndef SMMUV3_GEN_H
8#define SMMUV3_GEN_H
9
10#include <registers.h>
11#include <reg_model_maker/reg_model_maker.h>
12#include <string>
13#include <vector>
14#include <memory>
15
16namespace gs {
17
18// Backing store for all SMMU MMIO registers. "gs_register" is one 32-bit register and
19// "gs_field" is a named bit-slice within a register. Acronyms are explained the first time they appear.
20class smmuv3_gen
21{
22public:
23 // IDR0..IDR5 = ID Registers: read-only feature/capability bits the driver inspects at boot.
25 gs_field<uint32_t> IDR0_S2P; // S2P = Stage-2 translation Present (i.e. supported)
26 gs_field<uint32_t> IDR0_S1P; // S1P = Stage-1 translation Present
27 gs_field<uint32_t> IDR0_TTF; // TTF = Translation Table Format support (AArch32/AArch64)
28 gs_field<uint32_t> IDR0_COHACC; // COHACC = Coherent ACCess: SMMU's own page-walks are coherent with CPU caches
29 gs_field<uint32_t> IDR0_ASID16; // ASID16 = ASID (Address-Space ID) is 16 bits wide (vs 8)
30 gs_field<uint32_t> IDR0_VMID16; // VMID16 = VMID (Virtual-Machine ID) is 16 bits wide (vs 8)
31 gs_field<uint32_t> IDR0_PRI; // PRI = Page Request Interface (PCIe-style page-fault delivery) supported
33 IDR0_ATOS; // ATOS = Address Translation Operations Support (debug-only translate-this-VA channel)
34 gs_field<uint32_t> IDR0_HTTU; // HTTU = Hardware Translation Table Update (HW updates Access/Dirty bits)
35 gs_field<uint32_t> IDR0_STLEVEL; // STLEVEL = Stream Table LEVEL: 1-level (linear) vs 2-level table support
36 gs_field<uint32_t> IDR0_MSI; // MSI = Message Signalled Interrupts supported (writes-to-address instead of wires)
37 gs_field<uint32_t> IDR0_ATS; // ATS = Address Translation Service (PCIe ATS) supported
38
40 gs_field<uint32_t> IDR1_SIDSIZE; // SIDSIZE = number of bits in a StreamID (selects the device on the upstream side)
41 gs_field<uint32_t> IDR1_EVENTQS; // EVENTQS = Event Queue Size (log2 of max entries)
42 gs_field<uint32_t> IDR1_CMDQS; // CMDQS = Command Queue Size (log2 of max entries)
43
46 gs_field<uint32_t> IDR3_BBML1; // BBML1 = Break-Before-Make Level 1: HW supports level-1 BBM mapping changes
47 gs_field<uint32_t> IDR3_BBML2; // BBML2 = Break-Before-Make Level 2: stronger guarantees on live-mapping changes
48
51 gs_field<uint32_t> IDR5_OAS; // OAS = Output Address Size: how wide the resulting physical address can be
52 gs_field<uint32_t> IDR5_GRAN4K; // GRAN4K = 4 KiB page granule supported
53 gs_field<uint32_t> IDR5_GRAN16K; // GRAN16K = 16 KiB page granule supported
54 gs_field<uint32_t> IDR5_GRAN64K; // GRAN64K = 64 KiB page granule supported
55
56 gs_register<uint32_t> IIDR; // IIDR = Implementation ID Register (vendor/product/revision)
57 gs_register<uint32_t> AIDR; // AIDR = Architecture ID Register (which arch revision this implements)
58
59 // CR = Control Register: writeable knobs the driver uses to configure the SMMU at runtime.
61 gs_field<uint32_t> CR0_SMMUEN; // SMMUEN = SMMU Enable: turn the whole translator on/off
62 gs_field<uint32_t> CR0_PRIQEN; // PRIQEN = Page Request Queue Enable
63 gs_field<uint32_t> CR0_EVENTQEN; // EVENTQEN = Event Queue Enable
64 gs_field<uint32_t> CR0_CMDQEN; // CMDQEN = Command Queue Enable
65 gs_field<uint32_t> CR0_ATSCHK; // ATSCHK = ATS Check: validate that incoming pre-translated transactions are allowed
66 gs_field<uint32_t> CR0_NSCFG; // NSCFG = Non-Secure CFG override (controls how the NS attribute is forced)
67 gs_field<uint32_t> CR0_VMW; // VMW = VMID Wildcard match (for stage-2 invalidations)
68
70 CR0ACK; // ACK = Acknowledge: hardware mirror of CR0 the driver polls to confirm a write took effect
72 // For each of the SMMU's own memory accesses (page-table walks, queue accesses), CR1 fixes
73 // the cache/shareability hints. SH = SHareability, OC = Outer Cacheability, IC = Inner Cacheability.
74 gs_field<uint32_t> CR1_TABLE_SH;
75 gs_field<uint32_t> CR1_TABLE_OC;
76 gs_field<uint32_t> CR1_TABLE_IC;
77 gs_field<uint32_t> CR1_QUEUE_SH;
78 gs_field<uint32_t> CR1_QUEUE_OC;
79 gs_field<uint32_t> CR1_QUEUE_IC;
80
83 CR2_PTM; // PTM = Private TLB Maintenance: invalidations from the CPU are not broadcast to this SMMU
85 CR2_RECINVSID; // RECINVSID = Record INValid SID: log events when a transaction arrives with a bad StreamID
86 gs_field<uint32_t> CR2_E2H; // E2H = EL2 Host bit (matches the CPU-side hypervisor-host extension semantics)
87
88 gs_register<uint32_t> STATUSR; // STATUSR = STATUS Register (general status bits, e.g. quiesced)
90 GBPA; // GBPA = Global ByPass Attributes: how to treat traffic when no Stream Table Entry matches
91 gs_field<uint32_t> GBPA_UPDATE; // UPDATE = self-clearing bit the driver sets to commit a new GBPA value atomically
92 gs_field<uint32_t> GBPA_ABORT; // ABORT = if set, abort un-matched traffic instead of letting it pass through
93
94 gs_register<uint32_t> AGBPA; // AGBPA = Auxiliary GBPA (vendor/implementation-defined extra bypass knobs)
95
97 IRQ_CTRL; // IRQ_CTRL = Interrupt Request Control: master enable bits for the three IRQ sources
99 IRQ_CTRL_GERROR_IRQEN; // IRQEN = IRQ ENable. GERROR = Global ERROR (catastrophic-error interrupt)
100 gs_field<uint32_t> IRQ_CTRL_PRI_IRQEN; // PRI = Page Request Interface interrupt enable
102 IRQ_CTRL_EVENTQ_IRQEN; // EVENTQ = Event Queue interrupt enable (faults/events written to memory queue)
103
104 gs_register<uint32_t> IRQ_CTRL_ACK; // Driver-readable mirror of IRQ_CTRL (write-takes-effect handshake)
105
106 // GERROR holds sticky catastrophic-error bits; the driver clears them by writing the matching
107 // bit into GERRORN. ABT = ABorT (a bus error happened while the SMMU itself was accessing memory).
109 gs_field<uint32_t> GERROR_CMDQ_ERR; // command queue saw a malformed/unsupported command
110 gs_field<uint32_t> GERROR_EVENTQ_ABT_ERR; // bus abort while writing into the event queue
111 gs_field<uint32_t> GERROR_PRIQ_ABT_ERR; // bus abort while writing into the PRI queue
112 gs_field<uint32_t> GERROR_MSI_CMDQ_ABT_ERR; // bus abort while sending the cmd-queue MSI
113 gs_field<uint32_t> GERROR_MSI_EVENTQ_ABT_ERR; // bus abort while sending the event-queue MSI
114 gs_field<uint32_t> GERROR_MSI_PRIQ_ABT_ERR; // bus abort while sending the PRI-queue MSI
115 gs_field<uint32_t> GERROR_MSI_GERROR_ABT_ERR; // bus abort while sending the GERROR MSI itself
116 gs_field<uint32_t> GERROR_SFM_ERR; // SFM = Stream Fault Mode: a fatal stream-walk fault was hit
117
118 gs_register<uint32_t> GERRORN; // GERRORN = GERROR Negate: writing a 1 here clears the matching GERROR bit
119
120 // CFG0_LO/HI = address (low and high halves) the SMMU writes the MSI payload to;
121 // CFG1 = MSI attributes; CFG2 = MSI data word.
122 gs_register<uint32_t> GERROR_IRQ_CFG0_LO;
123 gs_register<uint32_t> GERROR_IRQ_CFG0_HI;
124 gs_register<uint32_t> GERROR_IRQ_CFG1;
125 gs_register<uint32_t> GERROR_IRQ_CFG2;
126
127 // STRTAB = STReam TABle: an in-memory array of Stream Table Entries (STEs); each entry describes
128 // one upstream device (looked up by StreamID). LO/HI hold the 64-bit base address.
129 gs_register<uint32_t> STRTAB_BASE_LO;
130 gs_register<uint32_t> STRTAB_BASE_HI;
131 gs_register<uint32_t> STRTAB_BASE_CFG;
132 gs_field<uint32_t> STRTAB_BASE_CFG_FMT; // FMT = ForMaT: 0 = single-level (linear), other = 2-level
133 gs_field<uint32_t> STRTAB_BASE_CFG_SPLIT; // SPLIT = how many bits of StreamID select the L1 entry (rest selects L2)
134 gs_field<uint32_t> STRTAB_BASE_CFG_LOG2SIZE; // LOG2SIZE = log2 of total number of StreamIDs the table covers
135
136 // CMDQ = CoMmanD Queue: in-memory ring the driver pushes commands into for the SMMU to consume.
137 // PROD = PRODucer index (driver-written); CONS = CONSumer index (SMMU-written).
138 gs_register<uint32_t> CMDQ_BASE_LO;
139 gs_field<uint32_t> CMDQ_BASE_LOG2SIZE; // log2 of queue size in entries (entry = 16 bytes)
140
141 gs_register<uint32_t> CMDQ_BASE_HI;
142 gs_register<uint32_t> CMDQ_PROD;
143 gs_field<uint32_t> CMDQ_PROD_WRP; // WRP = WRaP bit: toggles each time the index passes the end (so empty != full)
144 gs_field<uint32_t> CMDQ_PROD_RD; // RD = ReaD index portion of PROD (next slot to write)
145
146 gs_register<uint32_t> CMDQ_CONS;
147 gs_field<uint32_t> CMDQ_CONS_WRP;
148 gs_field<uint32_t> CMDQ_CONS_RD;
149 gs_field<uint32_t> CMDQ_CONS_ERR; // ERR = consumer-side error code if a command was rejected
150
151 // EVENTQ = EVENT Queue: SMMU pushes fault/event records here for the driver to consume.
152 gs_register<uint32_t> EVENTQ_BASE_LO;
153 gs_field<uint32_t> EVENTQ_BASE_LOG2SIZE;
154
155 gs_register<uint32_t> EVENTQ_BASE_HI;
156 gs_register<uint32_t> EVENTQ_PROD;
157 gs_field<uint32_t> EVENTQ_PROD_WRP;
158 gs_field<uint32_t> EVENTQ_PROD_RD;
159
160 gs_register<uint32_t> EVENTQ_CONS;
161 gs_field<uint32_t> EVENTQ_CONS_WRP;
162 gs_field<uint32_t> EVENTQ_CONS_RD;
163
164 gs_register<uint32_t> EVENTQ_IRQ_CFG0_LO;
165 gs_register<uint32_t> EVENTQ_IRQ_CFG0_HI;
166 gs_register<uint32_t> EVENTQ_IRQ_CFG1;
167 gs_register<uint32_t> EVENTQ_IRQ_CFG2;
168
169 // PRIQ = Page Request Interface Queue: SMMU pushes PCIe page-fault requests here for the OS to handle.
170 gs_register<uint32_t> PRIQ_BASE_LO;
171 gs_field<uint32_t> PRIQ_BASE_LOG2SIZE;
172
173 gs_register<uint32_t> PRIQ_BASE_HI;
174 gs_register<uint32_t> PRIQ_PROD;
175 gs_field<uint32_t> PRIQ_PROD_WRP;
176 gs_field<uint32_t> PRIQ_PROD_RD;
177
178 gs_register<uint32_t> PRIQ_CONS;
179 gs_field<uint32_t> PRIQ_CONS_WRP;
180 gs_field<uint32_t> PRIQ_CONS_RD;
181
182 gs_register<uint32_t> PRIQ_IRQ_CFG0_LO;
183 gs_register<uint32_t> PRIQ_IRQ_CFG0_HI;
184 gs_register<uint32_t> PRIQ_IRQ_CFG1;
185 gs_register<uint32_t> PRIQ_IRQ_CFG2;
186
187 // GATOS = Global Address Translation Operations Support: a debug-only "translate this VA for me"
188 // channel. The driver writes a StreamID + VA, kicks RUN, and reads the resulting PA back from PAR.
189 gs_register<uint32_t> GATOS_CTRL;
190 gs_field<uint32_t> GATOS_CTRL_RUN; // RUN = self-clearing trigger bit; set by driver to start a translation
191 gs_field<uint32_t> GATOS_CTRL_INPRG; // INPRG = IN-PRoGress: SMMU sets this while the translation is happening
192 gs_field<uint32_t> GATOS_CTRL_READ_NWRITE; // READ_NWRITE = 1 means simulate a read access, 0 means a write access
193
194 gs_register<uint32_t> GATOS_SID; // SID = StreamID of the requester to impersonate
195 gs_register<uint32_t> GATOS_ADDR_LO; // input VA, low half
196 gs_register<uint32_t> GATOS_ADDR_HI; // input VA, high half
197 gs_register<uint32_t> GATOS_PAR_LO; // PAR = Physical Address Result (translation output), low half
198 gs_field<uint32_t> GATOS_PAR_F; // F = Fault: 1 if translation failed (then PAR holds fault info, not an address)
199 gs_field<uint32_t> GATOS_PAR_FST; // FST = Fault STatus: encoded reason code when F = 1
200
201 gs_register<uint32_t> GATOS_PAR_HI; // PAR high half
202
203 // IDREGS = block of read-only "PrimeCell" identification registers at the top of the page (vendor/part/revision
204 // IDs)
205 std::vector<std::shared_ptr<gs_register<uint32_t>>> IDREGS;
206
207 // _P1 = Page 1 alias: SMMUv3 exposes a second 64 KiB page that mirrors a few queue pointers,
208 // letting the driver reach them through a separate VMM/EL2 mapping without exposing the whole register file.
209 gs_register<uint32_t> CMDQ_PROD_P1;
210 gs_register<uint32_t> CMDQ_CONS_P1;
211 gs_register<uint32_t> EVENTQ_PROD_P1;
212 gs_register<uint32_t> EVENTQ_CONS_P1;
213 gs_register<uint32_t> PRIQ_PROD_P1;
214 gs_register<uint32_t> PRIQ_CONS_P1;
215
216 // S_ prefix = Secure: a parallel set of registers, only accessible from Secure-world software,
217 // controlling translations for Secure-tagged transactions. Field meanings mirror their non-S_ twins.
223
225 gs_field<uint32_t> S_CR0_SMMUEN;
226 gs_field<uint32_t> S_CR0_EVENTQEN;
227 gs_field<uint32_t> S_CR0_CMDQEN;
228 gs_register<uint32_t> S_CR0ACK;
231 gs_register<uint32_t> S_INIT; // INIT = INITialise: secure-only register the secure firmware uses to reset state
232 gs_field<uint32_t> S_INIT_INV_ALL; // INV_ALL = INValidate ALL caches/TLBs (self-clearing trigger)
234 gs_field<uint32_t> S_GBPA_UPDATE;
235 gs_field<uint32_t> S_GBPA_ABORT;
236 gs_register<uint32_t> S_AGBPA;
237
238 gs_register<uint32_t> S_IRQ_CTRL;
239 gs_field<uint32_t> S_IRQ_CTRL_GERROR_IRQEN;
240 gs_field<uint32_t> S_IRQ_CTRL_EVENTQ_IRQEN;
241 gs_register<uint32_t> S_IRQ_CTRL_ACK;
242
243 gs_register<uint32_t> S_GERROR;
244 gs_field<uint32_t> S_GERROR_CMDQ_ERR;
245 gs_field<uint32_t> S_GERROR_EVENTQ_ABT_ERR;
246 gs_field<uint32_t> S_GERROR_MSI_CMDQ_ABT_ERR;
247 gs_field<uint32_t> S_GERROR_MSI_EVENTQ_ABT_ERR;
248 gs_field<uint32_t> S_GERROR_MSI_GERROR_ABT_ERR;
249 gs_field<uint32_t> S_GERROR_SFM_ERR;
250 gs_register<uint32_t> S_GERRORN;
251
252 gs_register<uint32_t> S_GERROR_IRQ_CFG0_LO;
253 gs_register<uint32_t> S_GERROR_IRQ_CFG0_HI;
254 gs_register<uint32_t> S_GERROR_IRQ_CFG1;
255 gs_register<uint32_t> S_GERROR_IRQ_CFG2;
256
257 gs_register<uint32_t> S_STRTAB_BASE_LO;
258 gs_register<uint32_t> S_STRTAB_BASE_HI;
259 gs_register<uint32_t> S_STRTAB_BASE_CFG;
260 gs_field<uint32_t> S_STRTAB_BASE_CFG_FMT;
261 gs_field<uint32_t> S_STRTAB_BASE_CFG_SPLIT;
262 gs_field<uint32_t> S_STRTAB_BASE_CFG_LOG2SIZE;
263
264 gs_register<uint32_t> S_CMDQ_BASE_LO;
265 gs_field<uint32_t> S_CMDQ_BASE_LOG2SIZE;
266 gs_register<uint32_t> S_CMDQ_BASE_HI;
267 gs_register<uint32_t> S_CMDQ_PROD;
268 gs_field<uint32_t> S_CMDQ_PROD_WRP;
269 gs_field<uint32_t> S_CMDQ_PROD_RD;
270 gs_register<uint32_t> S_CMDQ_CONS;
271 gs_field<uint32_t> S_CMDQ_CONS_WRP;
272 gs_field<uint32_t> S_CMDQ_CONS_RD;
273 gs_field<uint32_t> S_CMDQ_CONS_ERR;
274
275 gs_register<uint32_t> S_EVENTQ_BASE_LO;
276 gs_field<uint32_t> S_EVENTQ_BASE_LOG2SIZE;
277 gs_register<uint32_t> S_EVENTQ_BASE_HI;
278 gs_register<uint32_t> S_EVENTQ_PROD;
279 gs_field<uint32_t> S_EVENTQ_PROD_WRP;
280 gs_field<uint32_t> S_EVENTQ_PROD_RD;
281 gs_register<uint32_t> S_EVENTQ_CONS;
282 gs_field<uint32_t> S_EVENTQ_CONS_WRP;
283 gs_field<uint32_t> S_EVENTQ_CONS_RD;
284
285 gs_register<uint32_t> S_EVENTQ_IRQ_CFG0_LO;
286 gs_register<uint32_t> S_EVENTQ_IRQ_CFG0_HI;
287 gs_register<uint32_t> S_EVENTQ_IRQ_CFG1;
288 gs_register<uint32_t> S_EVENTQ_IRQ_CFG2;
289
290 smmuv3_gen()
291 : IDR0("IDR0", "smmuv3.IDR0", 0x0, 1)
292 , IDR0_S2P(IDR0, "smmuv3.IDR0.S2P", 0, 1)
293 , IDR0_S1P(IDR0, "smmuv3.IDR0.S1P", 1, 1)
294 , IDR0_TTF(IDR0, "smmuv3.IDR0.TTF", 2, 2)
295 , IDR0_COHACC(IDR0, "smmuv3.IDR0.COHACC", 4, 1)
296 , IDR0_ASID16(IDR0, "smmuv3.IDR0.ASID16", 12, 1)
297 , IDR0_VMID16(IDR0, "smmuv3.IDR0.VMID16", 18, 1)
298 , IDR0_PRI(IDR0, "smmuv3.IDR0.PRI", 16, 1)
299 , IDR0_ATOS(IDR0, "smmuv3.IDR0.ATOS", 15, 1)
300 , IDR0_HTTU(IDR0, "smmuv3.IDR0.HTTU", 6, 2)
301 , IDR0_STLEVEL(IDR0, "smmuv3.IDR0.STLEVEL", 27, 2)
302 , IDR0_MSI(IDR0, "smmuv3.IDR0.MSI", 13, 1)
303 , IDR0_ATS(IDR0, "smmuv3.IDR0.ATS", 10, 1)
304 , IDR1("IDR1", "smmuv3.IDR1", 0x4, 1)
305 , IDR1_SIDSIZE(IDR1, "smmuv3.IDR1.SIDSIZE", 0, 6)
306 , IDR1_EVENTQS(IDR1, "smmuv3.IDR1.EVENTQS", 16, 5)
307 , IDR1_CMDQS(IDR1, "smmuv3.IDR1.CMDQS", 21, 5)
308 , IDR2("IDR2", "smmuv3.IDR2", 0x8, 1)
309 , IDR3("IDR3", "smmuv3.IDR3", 0xC, 1)
310 , IDR3_BBML1(IDR3, "smmuv3.IDR3.BBML1", 11, 1)
311 , IDR3_BBML2(IDR3, "smmuv3.IDR3.BBML2", 12, 1)
312 , IDR4("IDR4", "smmuv3.IDR4", 0x10, 1)
313 , IDR5("IDR5", "smmuv3.IDR5", 0x14, 1)
314 , IDR5_OAS(IDR5, "smmuv3.IDR5.OAS", 0, 3)
315 , IDR5_GRAN4K(IDR5, "smmuv3.IDR5.GRAN4K", 4, 1)
316 , IDR5_GRAN16K(IDR5, "smmuv3.IDR5.GRAN16K", 5, 1)
317 , IDR5_GRAN64K(IDR5, "smmuv3.IDR5.GRAN64K", 6, 1)
318 , IIDR("IIDR", "smmuv3.IIDR", 0x18, 1)
319 , AIDR("AIDR", "smmuv3.AIDR", 0x1C, 1)
320 , CR0("CR0", "smmuv3.CR0", 0x20, 1)
321 , CR0_SMMUEN(CR0, "smmuv3.CR0.SMMUEN", 0, 1)
322 , CR0_PRIQEN(CR0, "smmuv3.CR0.PRIQEN", 1, 1)
323 , CR0_EVENTQEN(CR0, "smmuv3.CR0.EVENTQEN", 2, 1)
324 , CR0_CMDQEN(CR0, "smmuv3.CR0.CMDQEN", 3, 1)
325 , CR0_ATSCHK(CR0, "smmuv3.CR0.ATSCHK", 4, 1)
326 , CR0_VMW(CR0, "smmuv3.CR0.VMW", 6, 3)
327 , CR0_NSCFG(CR0, "smmuv3.CR0.NSCFG", 28, 2)
328 , CR0ACK("CR0ACK", "smmuv3.CR0ACK", 0x24, 1)
329 , CR1("CR1", "smmuv3.CR1", 0x28, 1)
330 , CR1_TABLE_SH(CR1, "smmuv3.CR1.TABLE_SH", 10, 2)
331 , CR1_TABLE_OC(CR1, "smmuv3.CR1.TABLE_OC", 8, 2)
332 , CR1_TABLE_IC(CR1, "smmuv3.CR1.TABLE_IC", 6, 2)
333 , CR1_QUEUE_SH(CR1, "smmuv3.CR1.QUEUE_SH", 4, 2)
334 , CR1_QUEUE_OC(CR1, "smmuv3.CR1.QUEUE_OC", 2, 2)
335 , CR1_QUEUE_IC(CR1, "smmuv3.CR1.QUEUE_IC", 0, 2)
336 , CR2("CR2", "smmuv3.CR2", 0x2C, 1)
337 , CR2_PTM(CR2, "smmuv3.CR2.PTM", 2, 1)
338 , CR2_RECINVSID(CR2, "smmuv3.CR2.RECINVSID", 1, 1)
339 , CR2_E2H(CR2, "smmuv3.CR2.E2H", 0, 1)
340 , STATUSR("STATUSR", "smmuv3.STATUSR", 0x40, 1)
341 , GBPA("GBPA", "smmuv3.GBPA", 0x44, 1)
342 , GBPA_UPDATE(GBPA, "smmuv3.GBPA.UPDATE", 31, 1)
343 , GBPA_ABORT(GBPA, "smmuv3.GBPA.ABORT", 20, 1)
344 , AGBPA("AGBPA", "smmuv3.AGBPA", 0x48, 1)
345 , IRQ_CTRL("IRQ_CTRL", "smmuv3.IRQ_CTRL", 0x50, 1)
346 , IRQ_CTRL_GERROR_IRQEN(IRQ_CTRL, "smmuv3.IRQ_CTRL.GERROR_IRQEN", 0, 1)
347 , IRQ_CTRL_PRI_IRQEN(IRQ_CTRL, "smmuv3.IRQ_CTRL.PRI_IRQEN", 1, 1)
348 , IRQ_CTRL_EVENTQ_IRQEN(IRQ_CTRL, "smmuv3.IRQ_CTRL.EVENTQ_IRQEN", 2, 1)
349 , IRQ_CTRL_ACK("IRQ_CTRL_ACK", "smmuv3.IRQ_CTRL_ACK", 0x54, 1)
350 , GERROR("GERROR", "smmuv3.GERROR", 0x60, 1)
351 , GERROR_CMDQ_ERR(GERROR, "smmuv3.GERROR.CMDQ_ERR", 0, 1)
352 , GERROR_EVENTQ_ABT_ERR(GERROR, "smmuv3.GERROR.EVENTQ_ABT_ERR", 2, 1)
353 , GERROR_PRIQ_ABT_ERR(GERROR, "smmuv3.GERROR.PRIQ_ABT_ERR", 3, 1)
354 , GERROR_MSI_CMDQ_ABT_ERR(GERROR, "smmuv3.GERROR.MSI_CMDQ_ABT_ERR", 4, 1)
355 , GERROR_MSI_EVENTQ_ABT_ERR(GERROR, "smmuv3.GERROR.MSI_EVENTQ_ABT_ERR", 5, 1)
356 , GERROR_MSI_PRIQ_ABT_ERR(GERROR, "smmuv3.GERROR.MSI_PRIQ_ABT_ERR", 6, 1)
357 , GERROR_MSI_GERROR_ABT_ERR(GERROR, "smmuv3.GERROR.MSI_GERROR_ABT_ERR", 7, 1)
358 , GERROR_SFM_ERR(GERROR, "smmuv3.GERROR.SFM_ERR", 8, 1)
359 , GERRORN("GERRORN", "smmuv3.GERRORN", 0x64, 1)
360 , GERROR_IRQ_CFG0_LO("GERROR_IRQ_CFG0_LO", "smmuv3.GERROR_IRQ_CFG0_LO", 0x68, 1)
361 , GERROR_IRQ_CFG0_HI("GERROR_IRQ_CFG0_HI", "smmuv3.GERROR_IRQ_CFG0_HI", 0x6C, 1)
362 , GERROR_IRQ_CFG1("GERROR_IRQ_CFG1", "smmuv3.GERROR_IRQ_CFG1", 0x70, 1)
363 , GERROR_IRQ_CFG2("GERROR_IRQ_CFG2", "smmuv3.GERROR_IRQ_CFG2", 0x74, 1)
364 , STRTAB_BASE_LO("STRTAB_BASE_LO", "smmuv3.STRTAB_BASE_LO", 0x80, 1)
365 , STRTAB_BASE_HI("STRTAB_BASE_HI", "smmuv3.STRTAB_BASE_HI", 0x84, 1)
366 , STRTAB_BASE_CFG("STRTAB_BASE_CFG", "smmuv3.STRTAB_BASE_CFG", 0x88, 1)
367 , STRTAB_BASE_CFG_FMT(STRTAB_BASE_CFG, "smmuv3.STRTAB_BASE_CFG.FMT", 16, 2)
368 , STRTAB_BASE_CFG_SPLIT(STRTAB_BASE_CFG, "smmuv3.STRTAB_BASE_CFG.SPLIT", 6, 5)
369 , STRTAB_BASE_CFG_LOG2SIZE(STRTAB_BASE_CFG, "smmuv3.STRTAB_BASE_CFG.LOG2SIZE", 0, 6)
370 , CMDQ_BASE_LO("CMDQ_BASE_LO", "smmuv3.CMDQ_BASE_LO", 0x90, 1)
371 , CMDQ_BASE_LOG2SIZE(CMDQ_BASE_LO, "smmuv3.CMDQ_BASE_LO.LOG2SIZE", 0, 5)
372 , CMDQ_BASE_HI("CMDQ_BASE_HI", "smmuv3.CMDQ_BASE_HI", 0x94, 1)
373 , CMDQ_PROD("CMDQ_PROD", "smmuv3.CMDQ_PROD", 0x98, 1)
374 , CMDQ_PROD_WRP(CMDQ_PROD, "smmuv3.CMDQ_PROD.WRP", 19, 1)
375 , CMDQ_PROD_RD(CMDQ_PROD, "smmuv3.CMDQ_PROD.RD", 0, 19)
376 , CMDQ_CONS("CMDQ_CONS", "smmuv3.CMDQ_CONS", 0x9C, 1)
377 , CMDQ_CONS_WRP(CMDQ_CONS, "smmuv3.CMDQ_CONS.WRP", 19, 1)
378 , CMDQ_CONS_RD(CMDQ_CONS, "smmuv3.CMDQ_CONS.RD", 0, 19)
379 , CMDQ_CONS_ERR(CMDQ_CONS, "smmuv3.CMDQ_CONS.ERR", 23, 7)
380 , EVENTQ_BASE_LO("EVENTQ_BASE_LO", "smmuv3.EVENTQ_BASE_LO", 0xA0, 1)
381 , EVENTQ_BASE_LOG2SIZE(EVENTQ_BASE_LO, "smmuv3.EVENTQ_BASE_LO.LOG2SIZE", 0, 5)
382 , EVENTQ_BASE_HI("EVENTQ_BASE_HI", "smmuv3.EVENTQ_BASE_HI", 0xA4, 1)
383 , EVENTQ_PROD("EVENTQ_PROD", "smmuv3.EVENTQ_PROD", 0xA8, 1)
384 , EVENTQ_PROD_WRP(EVENTQ_PROD, "smmuv3.EVENTQ_PROD.WRP", 19, 1)
385 , EVENTQ_PROD_RD(EVENTQ_PROD, "smmuv3.EVENTQ_PROD.RD", 0, 19)
386 , EVENTQ_CONS("EVENTQ_CONS", "smmuv3.EVENTQ_CONS", 0xAC, 1)
387 , EVENTQ_CONS_WRP(EVENTQ_CONS, "smmuv3.EVENTQ_CONS.WRP", 19, 1)
388 , EVENTQ_CONS_RD(EVENTQ_CONS, "smmuv3.EVENTQ_CONS.RD", 0, 19)
389 , EVENTQ_IRQ_CFG0_LO("EVENTQ_IRQ_CFG0_LO", "smmuv3.EVENTQ_IRQ_CFG0_LO", 0xB0, 1)
390 , EVENTQ_IRQ_CFG0_HI("EVENTQ_IRQ_CFG0_HI", "smmuv3.EVENTQ_IRQ_CFG0_HI", 0xB4, 1)
391 , EVENTQ_IRQ_CFG1("EVENTQ_IRQ_CFG1", "smmuv3.EVENTQ_IRQ_CFG1", 0xB8, 1)
392 , EVENTQ_IRQ_CFG2("EVENTQ_IRQ_CFG2", "smmuv3.EVENTQ_IRQ_CFG2", 0xBC, 1)
393 , PRIQ_BASE_LO("PRIQ_BASE_LO", "smmuv3.PRIQ_BASE_LO", 0xC0, 1)
394 , PRIQ_BASE_LOG2SIZE(PRIQ_BASE_LO, "smmuv3.PRIQ_BASE_LO.LOG2SIZE", 0, 5)
395 , PRIQ_BASE_HI("PRIQ_BASE_HI", "smmuv3.PRIQ_BASE_HI", 0xC4, 1)
396 , PRIQ_PROD("PRIQ_PROD", "smmuv3.PRIQ_PROD", 0xC8, 1)
397 , PRIQ_PROD_WRP(PRIQ_PROD, "smmuv3.PRIQ_PROD.WRP", 19, 1)
398 , PRIQ_PROD_RD(PRIQ_PROD, "smmuv3.PRIQ_PROD.RD", 0, 19)
399 , PRIQ_CONS("PRIQ_CONS", "smmuv3.PRIQ_CONS", 0xCC, 1)
400 , PRIQ_CONS_WRP(PRIQ_CONS, "smmuv3.PRIQ_CONS.WRP", 19, 1)
401 , PRIQ_CONS_RD(PRIQ_CONS, "smmuv3.PRIQ_CONS.RD", 0, 19)
402 , PRIQ_IRQ_CFG0_LO("PRIQ_IRQ_CFG0_LO", "smmuv3.PRIQ_IRQ_CFG0_LO", 0xD0, 1)
403 , PRIQ_IRQ_CFG0_HI("PRIQ_IRQ_CFG0_HI", "smmuv3.PRIQ_IRQ_CFG0_HI", 0xD4, 1)
404 , PRIQ_IRQ_CFG1("PRIQ_IRQ_CFG1", "smmuv3.PRIQ_IRQ_CFG1", 0xD8, 1)
405 , PRIQ_IRQ_CFG2("PRIQ_IRQ_CFG2", "smmuv3.PRIQ_IRQ_CFG2", 0xDC, 1)
406 , GATOS_CTRL("GATOS_CTRL", "smmuv3.GATOS_CTRL", 0x100, 1)
407 , GATOS_CTRL_RUN(GATOS_CTRL, "smmuv3.GATOS_CTRL.RUN", 0, 1)
408 , GATOS_CTRL_INPRG(GATOS_CTRL, "smmuv3.GATOS_CTRL.INPRG", 1, 1)
409 , GATOS_CTRL_READ_NWRITE(GATOS_CTRL, "smmuv3.GATOS_CTRL.READ_NWRITE", 8, 1)
410 , GATOS_SID("GATOS_SID", "smmuv3.GATOS_SID", 0x108, 1)
411 , GATOS_ADDR_LO("GATOS_ADDR_LO", "smmuv3.GATOS_ADDR_LO", 0x110, 1)
412 , GATOS_ADDR_HI("GATOS_ADDR_HI", "smmuv3.GATOS_ADDR_HI", 0x114, 1)
413 , GATOS_PAR_LO("GATOS_PAR_LO", "smmuv3.GATOS_PAR_LO", 0x118, 1)
414 , GATOS_PAR_F(GATOS_PAR_LO, "smmuv3.GATOS_PAR_LO.F", 0, 1)
415 , GATOS_PAR_FST(GATOS_PAR_LO, "smmuv3.GATOS_PAR_LO.FST", 1, 7)
416 , GATOS_PAR_HI("GATOS_PAR_HI", "smmuv3.GATOS_PAR_HI", 0x11C, 1)
417 , IDREGS(12)
418 , CMDQ_PROD_P1("CMDQ_PROD_P1", "smmuv3.CMDQ_PROD_P1", 0x10098, 1)
419 , CMDQ_CONS_P1("CMDQ_CONS_P1", "smmuv3.CMDQ_CONS_P1", 0x1009C, 1)
420 , S_IDR0("S_IDR0", "smmuv3.S_IDR0", 0x8000, 1)
421 , S_IDR1("S_IDR1", "smmuv3.S_IDR1", 0x8004, 1)
422 , S_IDR2("S_IDR2", "smmuv3.S_IDR2", 0x8008, 1)
423 , S_IDR3("S_IDR3", "smmuv3.S_IDR3", 0x800C, 1)
424 , S_IDR4("S_IDR4", "smmuv3.S_IDR4", 0x8010, 1)
425 , S_CR0("S_CR0", "smmuv3.S_CR0", 0x8020, 1)
426 , S_CR0_SMMUEN(S_CR0, "smmuv3.S_CR0.SMMUEN", 0, 1)
427 , S_CR0_EVENTQEN(S_CR0, "smmuv3.S_CR0.EVENTQEN", 2, 1)
428 , S_CR0_CMDQEN(S_CR0, "smmuv3.S_CR0.CMDQEN", 3, 1)
429 , S_CR0ACK("S_CR0ACK", "smmuv3.S_CR0ACK", 0x8024, 1)
430 , S_CR1("S_CR1", "smmuv3.S_CR1", 0x8028, 1)
431 , S_CR2("S_CR2", "smmuv3.S_CR2", 0x802C, 1)
432 , S_INIT("S_INIT", "smmuv3.S_INIT", 0x803C, 1)
433 , S_INIT_INV_ALL(S_INIT, "smmuv3.S_INIT.INV_ALL", 0, 1)
434 , S_GBPA("S_GBPA", "smmuv3.S_GBPA", 0x8044, 1)
435 , S_GBPA_UPDATE(S_GBPA, "smmuv3.S_GBPA.UPDATE", 31, 1)
436 , S_GBPA_ABORT(S_GBPA, "smmuv3.S_GBPA.ABORT", 20, 1)
437 , S_AGBPA("S_AGBPA", "smmuv3.S_AGBPA", 0x8048, 1)
438 , S_IRQ_CTRL("S_IRQ_CTRL", "smmuv3.S_IRQ_CTRL", 0x8050, 1)
439 , S_IRQ_CTRL_GERROR_IRQEN(S_IRQ_CTRL, "smmuv3.S_IRQ_CTRL.GERROR_IRQEN", 0, 1)
440 , S_IRQ_CTRL_EVENTQ_IRQEN(S_IRQ_CTRL, "smmuv3.S_IRQ_CTRL.EVENTQ_IRQEN", 2, 1)
441 , S_IRQ_CTRL_ACK("S_IRQ_CTRL_ACK", "smmuv3.S_IRQ_CTRL_ACK", 0x8054, 1)
442 , S_GERROR("S_GERROR", "smmuv3.S_GERROR", 0x8060, 1)
443 , S_GERROR_CMDQ_ERR(S_GERROR, "smmuv3.S_GERROR.CMDQ_ERR", 0, 1)
444 , S_GERROR_EVENTQ_ABT_ERR(S_GERROR, "smmuv3.S_GERROR.EVENTQ_ABT_ERR", 2, 1)
445 , S_GERROR_MSI_CMDQ_ABT_ERR(S_GERROR, "smmuv3.S_GERROR.MSI_CMDQ_ABT_ERR", 4, 1)
446 , S_GERROR_MSI_EVENTQ_ABT_ERR(S_GERROR, "smmuv3.S_GERROR.MSI_EVENTQ_ABT_ERR", 5, 1)
447 , S_GERROR_MSI_GERROR_ABT_ERR(S_GERROR, "smmuv3.S_GERROR.MSI_GERROR_ABT_ERR", 7, 1)
448 , S_GERROR_SFM_ERR(S_GERROR, "smmuv3.S_GERROR.SFM_ERR", 8, 1)
449 , S_GERRORN("S_GERRORN", "smmuv3.S_GERRORN", 0x8064, 1)
450 , S_GERROR_IRQ_CFG0_LO("S_GERROR_IRQ_CFG0_LO", "smmuv3.S_GERROR_IRQ_CFG0_LO", 0x8068, 1)
451 , S_GERROR_IRQ_CFG0_HI("S_GERROR_IRQ_CFG0_HI", "smmuv3.S_GERROR_IRQ_CFG0_HI", 0x806C, 1)
452 , S_GERROR_IRQ_CFG1("S_GERROR_IRQ_CFG1", "smmuv3.S_GERROR_IRQ_CFG1", 0x8070, 1)
453 , S_GERROR_IRQ_CFG2("S_GERROR_IRQ_CFG2", "smmuv3.S_GERROR_IRQ_CFG2", 0x8074, 1)
454 , S_STRTAB_BASE_LO("S_STRTAB_BASE_LO", "smmuv3.S_STRTAB_BASE_LO", 0x8080, 1)
455 , S_STRTAB_BASE_HI("S_STRTAB_BASE_HI", "smmuv3.S_STRTAB_BASE_HI", 0x8084, 1)
456 , S_STRTAB_BASE_CFG("S_STRTAB_BASE_CFG", "smmuv3.S_STRTAB_BASE_CFG", 0x8088, 1)
457 , S_STRTAB_BASE_CFG_FMT(S_STRTAB_BASE_CFG, "smmuv3.S_STRTAB_BASE_CFG.FMT", 16, 2)
458 , S_STRTAB_BASE_CFG_SPLIT(S_STRTAB_BASE_CFG, "smmuv3.S_STRTAB_BASE_CFG.SPLIT", 6, 5)
459 , S_STRTAB_BASE_CFG_LOG2SIZE(S_STRTAB_BASE_CFG, "smmuv3.S_STRTAB_BASE_CFG.LOG2SIZE", 0, 6)
460 , S_CMDQ_BASE_LO("S_CMDQ_BASE_LO", "smmuv3.S_CMDQ_BASE_LO", 0x8090, 1)
461 , S_CMDQ_BASE_LOG2SIZE(S_CMDQ_BASE_LO, "smmuv3.S_CMDQ_BASE_LO.LOG2SIZE", 0, 5)
462 , S_CMDQ_BASE_HI("S_CMDQ_BASE_HI", "smmuv3.S_CMDQ_BASE_HI", 0x8094, 1)
463 , S_CMDQ_PROD("S_CMDQ_PROD", "smmuv3.S_CMDQ_PROD", 0x8098, 1)
464 , S_CMDQ_PROD_WRP(S_CMDQ_PROD, "smmuv3.S_CMDQ_PROD.WRP", 19, 1)
465 , S_CMDQ_PROD_RD(S_CMDQ_PROD, "smmuv3.S_CMDQ_PROD.RD", 0, 19)
466 , S_CMDQ_CONS("S_CMDQ_CONS", "smmuv3.S_CMDQ_CONS", 0x809C, 1)
467 , S_CMDQ_CONS_WRP(S_CMDQ_CONS, "smmuv3.S_CMDQ_CONS.WRP", 19, 1)
468 , S_CMDQ_CONS_RD(S_CMDQ_CONS, "smmuv3.S_CMDQ_CONS.RD", 0, 19)
469 , S_CMDQ_CONS_ERR(S_CMDQ_CONS, "smmuv3.S_CMDQ_CONS.ERR", 23, 7)
470 , S_EVENTQ_BASE_LO("S_EVENTQ_BASE_LO", "smmuv3.S_EVENTQ_BASE_LO", 0x80A0, 1)
471 , S_EVENTQ_BASE_LOG2SIZE(S_EVENTQ_BASE_LO, "smmuv3.S_EVENTQ_BASE_LO.LOG2SIZE", 0, 5)
472 , S_EVENTQ_BASE_HI("S_EVENTQ_BASE_HI", "smmuv3.S_EVENTQ_BASE_HI", 0x80A4, 1)
473 , S_EVENTQ_PROD("S_EVENTQ_PROD", "smmuv3.S_EVENTQ_PROD", 0x80A8, 1)
474 , S_EVENTQ_PROD_WRP(S_EVENTQ_PROD, "smmuv3.S_EVENTQ_PROD.WRP", 19, 1)
475 , S_EVENTQ_PROD_RD(S_EVENTQ_PROD, "smmuv3.S_EVENTQ_PROD.RD", 0, 19)
476 , S_EVENTQ_CONS("S_EVENTQ_CONS", "smmuv3.S_EVENTQ_CONS", 0x80AC, 1)
477 , S_EVENTQ_CONS_WRP(S_EVENTQ_CONS, "smmuv3.S_EVENTQ_CONS.WRP", 19, 1)
478 , S_EVENTQ_CONS_RD(S_EVENTQ_CONS, "smmuv3.S_EVENTQ_CONS.RD", 0, 19)
479 , S_EVENTQ_IRQ_CFG0_LO("S_EVENTQ_IRQ_CFG0_LO", "smmuv3.S_EVENTQ_IRQ_CFG0_LO", 0x80B0, 1)
480 , S_EVENTQ_IRQ_CFG0_HI("S_EVENTQ_IRQ_CFG0_HI", "smmuv3.S_EVENTQ_IRQ_CFG0_HI", 0x80B4, 1)
481 , S_EVENTQ_IRQ_CFG1("S_EVENTQ_IRQ_CFG1", "smmuv3.S_EVENTQ_IRQ_CFG1", 0x80B8, 1)
482 , S_EVENTQ_IRQ_CFG2("S_EVENTQ_IRQ_CFG2", "smmuv3.S_EVENTQ_IRQ_CFG2", 0x80BC, 1)
483 , EVENTQ_PROD_P1("EVENTQ_PROD_P1", "smmuv3.EVENTQ_PROD_P1", 0x100A8, 1)
484 , EVENTQ_CONS_P1("EVENTQ_CONS_P1", "smmuv3.EVENTQ_CONS_P1", 0x100AC, 1)
485 , PRIQ_PROD_P1("PRIQ_PROD_P1", "smmuv3.PRIQ_PROD_P1", 0x100C8, 1)
486 , PRIQ_CONS_P1("PRIQ_CONS_P1", "smmuv3.PRIQ_CONS_P1", 0x100CC, 1)
487 {
488 for (uint32_t i = 0; i < 12; i++) {
489 IDREGS[i] = std::make_shared<gs_register<uint32_t>>("IDREG" + std::to_string(i),
490 "smmuv3.IDREG" + std::to_string(i), 0xFD0 + (i * 4), 1);
491 }
492 }
493
494 void bind_regs(gs::json_module& jm)
495 {
496 jm.bind_reg(IDR0);
497 jm.bind_reg(IDR1);
498 jm.bind_reg(IDR2);
499 jm.bind_reg(IDR3);
500 jm.bind_reg(IDR4);
501 jm.bind_reg(IDR5);
502 jm.bind_reg(IIDR);
503 jm.bind_reg(AIDR);
504 jm.bind_reg(CR0);
505 jm.bind_reg(CR0ACK);
506 jm.bind_reg(CR1);
507 jm.bind_reg(CR2);
508 jm.bind_reg(STATUSR);
509 jm.bind_reg(GBPA);
510 jm.bind_reg(AGBPA);
511 jm.bind_reg(IRQ_CTRL);
512 jm.bind_reg(IRQ_CTRL_ACK);
513 jm.bind_reg(GERROR);
514 jm.bind_reg(GERRORN);
515 jm.bind_reg(GERROR_IRQ_CFG0_LO);
516 jm.bind_reg(GERROR_IRQ_CFG0_HI);
517 jm.bind_reg(GERROR_IRQ_CFG1);
518 jm.bind_reg(GERROR_IRQ_CFG2);
519 jm.bind_reg(STRTAB_BASE_LO);
520 jm.bind_reg(STRTAB_BASE_HI);
521 jm.bind_reg(STRTAB_BASE_CFG);
522 jm.bind_reg(CMDQ_BASE_LO);
523 jm.bind_reg(CMDQ_BASE_HI);
524 jm.bind_reg(CMDQ_PROD);
525 jm.bind_reg(CMDQ_CONS);
526 jm.bind_reg(EVENTQ_BASE_LO);
527 jm.bind_reg(EVENTQ_BASE_HI);
528 jm.bind_reg(EVENTQ_PROD);
529 jm.bind_reg(EVENTQ_CONS);
530 jm.bind_reg(EVENTQ_IRQ_CFG0_LO);
531 jm.bind_reg(EVENTQ_IRQ_CFG0_HI);
532 jm.bind_reg(EVENTQ_IRQ_CFG1);
533 jm.bind_reg(EVENTQ_IRQ_CFG2);
534 jm.bind_reg(PRIQ_BASE_LO);
535 jm.bind_reg(PRIQ_BASE_HI);
536 jm.bind_reg(PRIQ_PROD);
537 jm.bind_reg(PRIQ_CONS);
538 jm.bind_reg(PRIQ_IRQ_CFG0_LO);
539 jm.bind_reg(PRIQ_IRQ_CFG0_HI);
540 jm.bind_reg(PRIQ_IRQ_CFG1);
541 jm.bind_reg(PRIQ_IRQ_CFG2);
542 jm.bind_reg(GATOS_CTRL);
543 jm.bind_reg(GATOS_SID);
544 jm.bind_reg(GATOS_ADDR_LO);
545 jm.bind_reg(GATOS_ADDR_HI);
546 jm.bind_reg(GATOS_PAR_LO);
547 jm.bind_reg(GATOS_PAR_HI);
548
549 for (auto& reg : IDREGS) {
550 jm.bind_reg(*reg);
551 }
552
553 jm.bind_reg(CMDQ_PROD_P1);
554 jm.bind_reg(CMDQ_CONS_P1);
555 jm.bind_reg(EVENTQ_PROD_P1);
556 jm.bind_reg(EVENTQ_CONS_P1);
557 jm.bind_reg(PRIQ_PROD_P1);
558 jm.bind_reg(PRIQ_CONS_P1);
559
560 jm.bind_reg(S_IDR0);
561 jm.bind_reg(S_IDR1);
562 jm.bind_reg(S_IDR2);
563 jm.bind_reg(S_IDR3);
564 jm.bind_reg(S_IDR4);
565 jm.bind_reg(S_CR0);
566 jm.bind_reg(S_CR0ACK);
567 jm.bind_reg(S_CR1);
568 jm.bind_reg(S_CR2);
569 jm.bind_reg(S_INIT);
570 jm.bind_reg(S_GBPA);
571 jm.bind_reg(S_AGBPA);
572 jm.bind_reg(S_IRQ_CTRL);
573 jm.bind_reg(S_IRQ_CTRL_ACK);
574 jm.bind_reg(S_GERROR);
575 jm.bind_reg(S_GERRORN);
576 jm.bind_reg(S_GERROR_IRQ_CFG0_LO);
577 jm.bind_reg(S_GERROR_IRQ_CFG0_HI);
578 jm.bind_reg(S_GERROR_IRQ_CFG1);
579 jm.bind_reg(S_GERROR_IRQ_CFG2);
580 jm.bind_reg(S_STRTAB_BASE_LO);
581 jm.bind_reg(S_STRTAB_BASE_HI);
582 jm.bind_reg(S_STRTAB_BASE_CFG);
583 jm.bind_reg(S_CMDQ_BASE_LO);
584 jm.bind_reg(S_CMDQ_BASE_HI);
585 jm.bind_reg(S_CMDQ_PROD);
586 jm.bind_reg(S_CMDQ_CONS);
587 jm.bind_reg(S_EVENTQ_BASE_LO);
588 jm.bind_reg(S_EVENTQ_BASE_HI);
589 jm.bind_reg(S_EVENTQ_PROD);
590 jm.bind_reg(S_EVENTQ_CONS);
591 jm.bind_reg(S_EVENTQ_IRQ_CFG0_LO);
592 jm.bind_reg(S_EVENTQ_IRQ_CFG0_HI);
593 jm.bind_reg(S_EVENTQ_IRQ_CFG1);
594 jm.bind_reg(S_EVENTQ_IRQ_CFG2);
595
596 jm.log_end_of_binding_msg("smmuv3_gen");
597 }
598};
599
600} // namespace gs
601
602#endif
fields within registered encapsulated using a bitfield proxy. This field is constructed from a specif...
Definition registers.h:716
Class that encapsulates a 'register' that proxies it's data via a tlm interface, and uses callbacks (...
Definition registers.h:556
Definition reg_model_maker.h:457
Tool which reads a Lua configuration file and sets parameters.
Definition biflow.cc:10