VirtualBox

source: vbox/trunk/src/VBox/Main/src-client/SystemTableBuilder.cpp@ 108292

Last change on this file since 108292 was 108292, checked in by vboxsync, 4 weeks ago

Main/SystemTableBuilder.cpp: Fix address space flags to make guests work again after r167500, bugref:10733

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 50.7 KB
Line 
1/* $Id: SystemTableBuilder.cpp 108292 2025-02-19 13:38:01Z vboxsync $ */
2/** @file
3 * VirtualBox bus slots assignment manager
4 */
5
6/*
7 * Copyright (C) 2010-2024 Oracle and/or its affiliates.
8 *
9 * This file is part of VirtualBox base platform packages, as
10 * available from https://www.virtualbox.org.
11 *
12 * This program is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU General Public License
14 * as published by the Free Software Foundation, in version 3 of the
15 * License.
16 *
17 * This program is distributed in the hope that it will be useful, but
18 * WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20 * General Public License for more details.
21 *
22 * You should have received a copy of the GNU General Public License
23 * along with this program; if not, see <https://www.gnu.org/licenses>.
24 *
25 * SPDX-License-Identifier: GPL-3.0-only
26 */
27
28
29/*********************************************************************************************************************************
30* Header Files *
31*********************************************************************************************************************************/
32#define LOG_GROUP LOG_GROUP_MAIN
33#include "LoggingNew.h"
34
35#include "SystemTableBuilder.h"
36
37#include <VBox/gic.h>
38
39#include <iprt/asm.h>
40#include <iprt/string.h>
41
42
43/*********************************************************************************************************************************
44* Defined Constants And Macros *
45*********************************************************************************************************************************/
46
47/** Locality CRB request register. */
48#define TPM_CRB_LOCALITY_REG_CTRL_REQ 0x40
49
50
51/*********************************************************************************************************************************
52* Structures and Typedefs *
53*********************************************************************************************************************************/
54/**
55 * A system table device.
56 */
57typedef struct SYSTEMTABLEDEVICE
58{
59 const char *pszVBoxName;
60 const char *pszFdtName;
61 const char *pszFdtCompatible;
62 const char *pszAcpiName;
63 const char *pszAcpiHid;
64} SYSTEMTABLEDEVICE;
65typedef SYSTEMTABLEDEVICE *PSYSTEMTABLEDEVICE;
66typedef const SYSTEMTABLEDEVICE *PCSYSTEMTABLEDEVICE;
67
68
69/*********************************************************************************************************************************
70* Global Variables *
71*********************************************************************************************************************************/
72static const SYSTEMTABLEDEVICE g_aSysTblDevices[] =
73{
74 { "qemu-fw-cfg", "fw-cfg", "qemu,fw-cfg-mmio", "FWC", "QEMU0002" },
75 { "arm-pl011", "pl011", "arm,pl011", "SRL", "ARMH0011" },
76 { "arm-pl061-gpio", "pl061", "arm,pl061", "GPI", "ARMH0061" },
77 { "pci-generic-ecam", "pcie", "pci-host-ecam-generic", "PCI", "PNP0A08" },
78};
79
80
81static PCSYSTEMTABLEDEVICE systemTableVBoxDevName2SysTblDevice(const char *pszVBoxName)
82{
83 for (uint32_t i = 0; i < RT_ELEMENTS(g_aSysTblDevices); i++)
84 if (!strcmp(pszVBoxName, g_aSysTblDevices[i].pszVBoxName))
85 return &g_aSysTblDevices[i];
86
87 return NULL;
88}
89
90
91static int systemTableAcpiMmioDevResource(RTACPITBL hDsdt, RTACPIRES hAcpiRes, uint64_t u64AddrBase,
92 uint64_t cbMmio, uint32_t uIrq)
93{
94 uint32_t const fAddrSpace = RTACPI_RESOURCE_ADDR_RANGE_F_DECODE_TYPE_POS
95 | RTACPI_RESOURCE_ADDR_RANGE_F_MIN_ADDR_FIXED
96 | RTACPI_RESOURCE_ADDR_RANGE_F_MAX_ADDR_FIXED
97 | RTACPI_RESOURCE_ADDR_RANGE_F_PRODUCER;
98
99 RTAcpiResourceReset(hAcpiRes);
100 int vrc;
101 if (u64AddrBase + cbMmio <= _4G)
102 vrc = RTAcpiResourceAdd32BitFixedMemoryRange(hAcpiRes, u64AddrBase, cbMmio, true /*fRw*/);
103 else
104 vrc = RTAcpiResourceAddQWordMemoryRange(hAcpiRes, kAcpiResMemRangeCacheability_NonCacheable, kAcpiResMemType_Memory, true /*fRw*/,
105 fAddrSpace, u64AddrBase, u64AddrBase + cbMmio - 1, 0 /*u64OffTrans*/, 0 /*u64Granularity*/,
106 cbMmio);
107 if (RT_SUCCESS(vrc))
108 vrc = RTAcpiResourceAddExtendedInterrupt(hAcpiRes, true /*fConsumer*/, false /*fEdgeTriggered*/, false /*fActiveLow*/,
109 false /*fShared*/, false /*fWakeCapable*/, 1, &uIrq);
110 if (RT_SUCCESS(vrc))
111 {
112 vrc = RTAcpiResourceSeal(hAcpiRes);
113 if (RT_SUCCESS(vrc))
114 vrc = RTAcpiTblResourceAppend(hDsdt, hAcpiRes);
115 }
116
117 return vrc;
118}
119
120
121static int systemTableAcpiMmioDevResourceNoIrq(RTACPITBL hDsdt, RTACPIRES hAcpiRes, uint64_t u64AddrBase,
122 uint64_t cbMmio)
123{
124 uint32_t const fAddrSpace = RTACPI_RESOURCE_ADDR_RANGE_F_DECODE_TYPE_POS
125 | RTACPI_RESOURCE_ADDR_RANGE_F_MIN_ADDR_FIXED
126 | RTACPI_RESOURCE_ADDR_RANGE_F_MAX_ADDR_FIXED
127 | RTACPI_RESOURCE_ADDR_RANGE_F_PRODUCER;
128
129 RTAcpiResourceReset(hAcpiRes);
130 int vrc = RTAcpiResourceAddQWordMemoryRange(hAcpiRes, kAcpiResMemRangeCacheability_NonCacheable, kAcpiResMemType_Memory, true /*fRw*/,
131 fAddrSpace, u64AddrBase, u64AddrBase + cbMmio - 1, 0 /*u64OffTrans*/, 0 /*u64Granularity*/,
132 cbMmio);
133 if (RT_SUCCESS(vrc))
134 {
135 vrc = RTAcpiResourceSeal(hAcpiRes);
136 if (RT_SUCCESS(vrc))
137 vrc = RTAcpiTblResourceAppend(hDsdt, hAcpiRes);
138 }
139
140 return vrc;
141}
142
143
144int SystemTableBuilderAcpi::initInstance(void)
145{
146 m_fTpm20 = false;
147
148 int vrc = RTAcpiTblCreate(&m_hAcpiDsdt, ACPI_TABLE_HDR_SIGNATURE_DSDT, 6, "ORCL ", "VBOXDSDT", 1, "VBOX", 1);
149 AssertRCReturn(vrc, vrc);
150
151 vrc = RTAcpiResourceCreate(&m_hAcpiRes);
152 AssertRCReturn(vrc, vrc);
153
154 /* Append _SB Scope. */
155 return RTAcpiTblScopeStart(m_hAcpiDsdt, "\\_SB");
156}
157
158
159int SystemTableBuilderAcpi::finishTables(RTGCPHYS GCPhysTblsStart, RTVFSIOSTREAM hVfsIos,
160 PRTGCPHYS pGCPhysTblRoot, size_t *pcbTblRoot, size_t *pcbTbls)
161{
162 int vrc = RTAcpiTblScopeFinalize(m_hAcpiDsdt); /* End \_SB scope */
163 AssertRCReturn(vrc, vrc);
164
165 vrc = RTAcpiTblFinalize(m_hAcpiDsdt);
166 AssertRCReturn(vrc, vrc);
167
168 RTGCPHYS GCPhysDsdt = GCPhysTblsStart;
169
170 size_t cbAcpiTbls = RTAcpiTblGetSize(m_hAcpiDsdt);
171 Assert(cbAcpiTbls);
172
173 /* Write the DSDT. */
174 vrc = RTAcpiTblDumpToVfsIoStrm(m_hAcpiDsdt, RTACPITBLTYPE_AML, hVfsIos);
175 AssertRCReturn(vrc, vrc);
176
177 GCPhysTblsStart += cbAcpiTbls;
178
179 uint32_t cTbls = 0;
180 uint8_t abXsdt[36 + 32 * sizeof(uint64_t)]; RT_ZERO(abXsdt);
181 PACPIXSDT pXsdt = (PACPIXSDT)&abXsdt[0];
182
183 /* Build the FADT. */
184 size_t cbTbl = 0;
185 vrc = buildFadt(hVfsIos, GCPhysDsdt, &cbTbl);
186 AssertRCReturn(vrc, vrc);
187
188 pXsdt->au64AddrTbl[cTbls++] = GCPhysTblsStart;
189 cbAcpiTbls += cbTbl;
190 GCPhysTblsStart += cbTbl;
191
192 /* Build the GTDT. */
193 vrc = buildGtdt(hVfsIos, &cbTbl);
194 AssertRCReturn(vrc, vrc);
195
196 pXsdt->au64AddrTbl[cTbls++] = GCPhysTblsStart;
197 cbAcpiTbls += cbTbl;
198 GCPhysTblsStart += cbTbl;
199
200 /* Build the MADT. */
201 vrc = buildMadt(hVfsIos, &cbTbl);
202 AssertRCReturn(vrc, vrc);
203
204 pXsdt->au64AddrTbl[cTbls++] = GCPhysTblsStart;
205 cbAcpiTbls += cbTbl;
206 GCPhysTblsStart += cbTbl;
207
208 /* Build the MCFG. */
209 vrc = buildMcfg(hVfsIos, &cbTbl);
210 AssertRCReturn(vrc, vrc);
211
212 pXsdt->au64AddrTbl[cTbls++] = GCPhysTblsStart;
213 cbAcpiTbls += cbTbl;
214 GCPhysTblsStart += cbTbl;
215
216 /* Build TPM2 table if configured. */
217 if (m_fTpm20)
218 {
219 vrc = buildTpm20(hVfsIos, &cbTbl);
220 AssertRCReturn(vrc, vrc);
221
222 pXsdt->au64AddrTbl[cTbls++] = GCPhysTblsStart;
223 cbAcpiTbls += cbTbl;
224 GCPhysTblsStart += cbTbl;
225 }
226
227 /* Build XSDT. */
228 RTGCPHYS GCPhysXsdt = GCPhysTblsStart;
229 size_t const cbXsdt = RT_UOFFSETOF_DYN(ACPIXSDT, au64AddrTbl[cTbls]);
230 pXsdt->Hdr.u32Signature = ACPI_TABLE_HDR_SIGNATURE_XSDT;
231 pXsdt->Hdr.cbTbl = RT_UOFFSETOF_DYN(ACPIXSDT, au64AddrTbl[cTbls]);
232 pXsdt->Hdr.bRevision = 6;
233 pXsdt->Hdr.bChkSum = 0;
234 pXsdt->Hdr.u32OemRevision = 1;
235 pXsdt->Hdr.u32CreatorRevision = 1;
236
237 memcpy(&pXsdt->Hdr.abOemId[0], "ORCLVB", 6);
238 memcpy(&pXsdt->Hdr.abOemTblId[0], "ORCL", 4);
239 memcpy(&pXsdt->Hdr.abOemTblId[4], &pXsdt->Hdr.u32Signature, 4);
240 memcpy(&pXsdt->Hdr.abCreatorId[0], "ORCL", 4);
241 RTAcpiTblHdrChecksumGenerate(&pXsdt->Hdr, cbXsdt);
242 vrc = RTVfsIoStrmWrite(hVfsIos, &abXsdt[0], cbXsdt, true /*fBlocking*/, NULL /*pcbWritten*/);
243 AssertRCReturn(vrc, vrc);
244
245 GCPhysTblsStart += cbXsdt;
246 cbAcpiTbls += cbXsdt;
247
248 /* Build XSDP */
249 ACPIRSDP Xsdp; RT_ZERO(Xsdp);
250
251 /* ACPI 1.0 part (RSDP) */
252 memcpy(Xsdp.abSignature, "RSD PTR ", 8);
253 memcpy(Xsdp.abOemId, "ORCLVB", 6);
254 Xsdp.bRevision = 3;
255 Xsdp.u32AddrRsdt = 0;
256 Xsdp.bChkSum = RTAcpiChecksumGenerate(&Xsdp, RT_OFFSETOF(ACPIRSDP, cbRsdp));
257
258 /* ACPI 2.0 part (XSDP) */
259 Xsdp.cbRsdp = RT_H2LE_U32(sizeof(ACPIRSDP));
260 Xsdp.u64AddrXsdt = RT_H2LE_U64(GCPhysXsdt);
261 Xsdp.bExtChkSum = RTAcpiChecksumGenerate(&Xsdp, sizeof(ACPIRSDP));
262
263 vrc = RTVfsIoStrmWrite(hVfsIos, &Xsdp, sizeof(Xsdp), true /*fBlocking*/, NULL /*pcbWritten*/);
264 AssertRCReturn(vrc, vrc);
265 cbAcpiTbls += sizeof(Xsdp);
266
267 *pGCPhysTblRoot = GCPhysTblsStart;
268 *pcbTblRoot = sizeof(Xsdp);
269 *pcbTbls = cbAcpiTbls;
270
271 return VINF_SUCCESS;
272}
273
274
275int SystemTableBuilderAcpi::addCpu(uint32_t idCpu)
276{
277 RTAcpiTblDeviceStartF(m_hAcpiDsdt, "CP%02RX32", idCpu);
278
279 RTAcpiTblNameAppend(m_hAcpiDsdt, "_HID");
280 RTAcpiTblStringAppend(m_hAcpiDsdt, "ACPI0007");
281
282 RTAcpiTblNameAppend(m_hAcpiDsdt, "_UID");
283 RTAcpiTblIntegerAppend(m_hAcpiDsdt, idCpu);
284
285 return RTAcpiTblDeviceFinalize(m_hAcpiDsdt);
286}
287
288
289int SystemTableBuilderAcpi::addMemory(RTGCPHYS GCPhysStart, RTGCPHYS cbMem)
290{
291 RT_NOREF(GCPhysStart, cbMem);
292 return VINF_SUCCESS;
293}
294
295
296int SystemTableBuilderAcpi::addMmioDeviceNoIrq(const char *pszVBoxName, uint32_t uInstance, RTGCPHYS GCPhysMmio, RTGCPHYS cbMmio)
297{
298 PCSYSTEMTABLEDEVICE pSysTblDev = systemTableVBoxDevName2SysTblDevice(pszVBoxName);
299 AssertPtrReturn(pSysTblDev, VERR_NOT_FOUND);
300
301 RTAcpiTblDeviceStartF(m_hAcpiDsdt, "%s%RX32", pSysTblDev->pszAcpiName, uInstance);
302
303 RTAcpiTblNameAppend(m_hAcpiDsdt, "_HID");
304 RTAcpiTblStringAppend(m_hAcpiDsdt, pSysTblDev->pszAcpiHid);
305
306 RTAcpiTblNameAppend(m_hAcpiDsdt, "_UID");
307 RTAcpiTblIntegerAppend(m_hAcpiDsdt, uInstance);
308
309 RTAcpiTblNameAppend(m_hAcpiDsdt, "_CRS");
310 int vrc = systemTableAcpiMmioDevResourceNoIrq(m_hAcpiDsdt, m_hAcpiRes, GCPhysMmio, cbMmio);
311 AssertRCReturn(vrc, vrc);
312
313 return RTAcpiTblDeviceFinalize(m_hAcpiDsdt);
314}
315
316
317int SystemTableBuilderAcpi::addMmioDevice(const char *pszVBoxName, uint32_t uInstance, RTGCPHYS GCPhysMmio, RTGCPHYS cbMmio,
318 uint32_t u32Irq)
319{
320 PCSYSTEMTABLEDEVICE pSysTblDev = systemTableVBoxDevName2SysTblDevice(pszVBoxName);
321 AssertPtrReturn(pSysTblDev, VERR_NOT_FOUND);
322
323 RTAcpiTblDeviceStartF(m_hAcpiDsdt, "%s%RX32", pSysTblDev->pszAcpiName, uInstance);
324
325 RTAcpiTblNameAppend(m_hAcpiDsdt, "_HID");
326 RTAcpiTblStringAppend(m_hAcpiDsdt, pSysTblDev->pszAcpiHid);
327
328 RTAcpiTblNameAppend(m_hAcpiDsdt, "_UID");
329 RTAcpiTblIntegerAppend(m_hAcpiDsdt, uInstance);
330
331 RTAcpiTblNameAppend(m_hAcpiDsdt, "_CRS");
332 int vrc = systemTableAcpiMmioDevResource(m_hAcpiDsdt, m_hAcpiRes, GCPhysMmio, cbMmio, u32Irq + GIC_INTID_RANGE_SPI_START);
333 AssertRCReturn(vrc, vrc);
334
335 return RTAcpiTblDeviceFinalize(m_hAcpiDsdt);
336}
337
338
339int SystemTableBuilderAcpi::configureGic(uint32_t cCpus, RTGCPHYS GCPhysIntcDist, RTGCPHYS cbMmioIntcDist, RTGCPHYS GCPhysIntcReDist,
340 RTGCPHYS cbMmioIntcReDist)
341{
342 m_cCpus = cCpus;
343 m_GCPhysIntcDist = GCPhysIntcDist;
344 m_cbMmioIntcDist = cbMmioIntcDist;
345 m_GCPhysIntcReDist = GCPhysIntcReDist;
346 m_cbMmioIntcReDist = cbMmioIntcReDist;
347 return VINF_SUCCESS;
348}
349
350
351int SystemTableBuilderAcpi::configureClock(void)
352{
353 return VINF_SUCCESS;
354}
355
356
357int SystemTableBuilderAcpi::configurePcieRootBus(const char *pszVBoxName, uint32_t aPinIrqs[4], RTGCPHYS GCPhysMmioPio, RTGCPHYS GCPhysMmioEcam, size_t cbPciMmioEcam,
358 RTGCPHYS GCPhysPciMmioBase, RTGCPHYS cbPciMmio, RTGCPHYS GCPhysPciMmio32Base, RTGCPHYS cbPciMmio32)
359{
360 PCSYSTEMTABLEDEVICE pSysTblDev = systemTableVBoxDevName2SysTblDevice(pszVBoxName);
361 AssertPtrReturn(pSysTblDev, VERR_NOT_FOUND);
362
363 m_GCPhysPciMmioEcam = GCPhysMmioEcam; /* Need that for MCFG later. */
364 m_bPciBusMax = 15; /** @todo Make parameter. */
365
366 RTAcpiTblDeviceStartF(m_hAcpiDsdt, "%s%RX32", pSysTblDev->pszAcpiName, 0);
367
368 RTAcpiTblNameAppend(m_hAcpiDsdt, "_HID");
369 RTAcpiTblStringAppend(m_hAcpiDsdt, pSysTblDev->pszAcpiHid);
370
371 RTAcpiTblNameAppend(m_hAcpiDsdt, "_CID");
372 RTAcpiTblStringAppend(m_hAcpiDsdt, "PNP0A03"); /** @todo */
373
374 RTAcpiTblNameAppend(m_hAcpiDsdt, "_UID");
375 RTAcpiTblIntegerAppend(m_hAcpiDsdt, 0);
376
377 RTAcpiTblNameAppend(m_hAcpiDsdt, "_CCA"); /* Cache coherency attribute. */
378 RTAcpiTblIntegerAppend(m_hAcpiDsdt, 1);
379
380 RTAcpiTblNameAppend(m_hAcpiDsdt, "_CRS");
381
382 uint32_t const fAddrSpace = RTACPI_RESOURCE_ADDR_RANGE_F_DECODE_TYPE_POS
383 | RTACPI_RESOURCE_ADDR_RANGE_F_MIN_ADDR_FIXED
384 | RTACPI_RESOURCE_ADDR_RANGE_F_MAX_ADDR_FIXED
385 | RTACPI_RESOURCE_ADDR_RANGE_F_PRODUCER;
386
387 RTAcpiResourceReset(m_hAcpiRes);
388 int vrc = RTAcpiResourceAddWordBusNumber(m_hAcpiRes, fAddrSpace, 0 /*u16BusMin*/, m_bPciBusMax /*u16BusMax*/,
389 0 /*u16OffTrans*/, 0 /*u16Granularity*/, m_bPciBusMax + 1 /*u16Length*/);
390 AssertRCReturn(vrc, vrc);
391
392 vrc = RTAcpiResourceAddQWordIoRange(m_hAcpiRes, kAcpiResIoRangeType_Translation_Dense, kAcpiResIoRange_Whole,
393 fAddrSpace, 0 /*u64AddrMin*/, UINT16_MAX /*u64AddrMax*/, GCPhysMmioPio,
394 0 /*u64Granularity*/, _64K);
395 AssertRCReturn(vrc, vrc);
396
397 vrc = RTAcpiResourceAddDWordMemoryRange(m_hAcpiRes, kAcpiResMemRangeCacheability_NonCacheable, kAcpiResMemType_Memory, true /*fRw*/,
398 fAddrSpace, (uint32_t)GCPhysPciMmio32Base, (uint32_t)(GCPhysPciMmio32Base + cbPciMmio32 - 1),
399 0 /*u32OffTrans*/, 0 /*u32Granularity*/, (uint32_t)cbPciMmio32);
400 AssertRCReturn(vrc, vrc);
401
402 vrc = RTAcpiResourceAddQWordMemoryRange(m_hAcpiRes, kAcpiResMemRangeCacheability_NonCacheable, kAcpiResMemType_Memory, true /*fRw*/,
403 fAddrSpace, GCPhysPciMmioBase, GCPhysPciMmioBase + cbPciMmio - 1,
404 0 /*u64OffTrans*/, 0 /*u64Granularity*/, cbPciMmio);
405 if (RT_SUCCESS(vrc))
406 {
407 vrc = RTAcpiResourceSeal(m_hAcpiRes);
408 if (RT_SUCCESS(vrc))
409 vrc = RTAcpiTblResourceAppend(m_hAcpiDsdt, m_hAcpiRes);
410 }
411 AssertRCReturn(vrc, vrc);
412
413 /* For the ECAM base we need to define a new device with a new resource template inside the PCI device. */
414 RTAcpiTblDeviceStart(m_hAcpiDsdt, "RES0");
415
416 RTAcpiTblNameAppend(m_hAcpiDsdt, "_HID");
417 RTAcpiTblStringAppend(m_hAcpiDsdt, "PNP0C02");
418
419 RTAcpiTblNameAppend(m_hAcpiDsdt, "_CRS");
420 RTAcpiResourceReset(m_hAcpiRes);
421 vrc = RTAcpiResourceAddQWordMemoryRange(m_hAcpiRes, kAcpiResMemRangeCacheability_NonCacheable, kAcpiResMemType_Memory, true /*fRw*/,
422 fAddrSpace, GCPhysMmioEcam, GCPhysMmioEcam + cbPciMmioEcam - 1,
423 0 /*u64OffTrans*/, 0 /*u64Granularity*/, cbPciMmioEcam);
424 if (RT_SUCCESS(vrc))
425 {
426 vrc = RTAcpiResourceSeal(m_hAcpiRes);
427 if (RT_SUCCESS(vrc))
428 vrc = RTAcpiTblResourceAppend(m_hAcpiDsdt, m_hAcpiRes);
429 }
430 AssertRCReturn(vrc, vrc);
431
432 /* Finish RES0 device. */
433 vrc = RTAcpiTblDeviceFinalize(m_hAcpiDsdt);
434 AssertRCReturn(vrc, vrc);
435
436 /* Build the PCI interrupt routing table (_PRT). */
437 RTAcpiTblNameAppend(m_hAcpiDsdt, "_PRT");
438 RTAcpiTblPackageStart(m_hAcpiDsdt, 32 * 4);
439
440 uint32_t iIrqPinSwizzle = 0;
441
442 for (uint32_t i = 0; i < 32; i++)
443 {
444 for (uint32_t iIrqPin = 0; iIrqPin < 4; iIrqPin++)
445 {
446 RTAcpiTblPackageStart(m_hAcpiDsdt, 4);
447 RTAcpiTblIntegerAppend(m_hAcpiDsdt, (i << 16) | 0xffff); /* ACPI PCI address. */
448 RTAcpiTblIntegerAppend(m_hAcpiDsdt, iIrqPin); /* Interrupt pin (INTA, INTB, ...). */
449 RTAcpiTblIntegerAppend(m_hAcpiDsdt, 0); /* Interrupt destination, unused. */
450 RTAcpiTblIntegerAppend(m_hAcpiDsdt, GIC_INTID_RANGE_SPI_START
451 + aPinIrqs[(iIrqPinSwizzle + iIrqPin) % 4]); /* GSI of the interrupt. */
452 RTAcpiTblPackageFinalize(m_hAcpiDsdt);
453 }
454
455 iIrqPinSwizzle++;
456 }
457
458 RTAcpiTblPackageFinalize(m_hAcpiDsdt);
459
460 /* Create _CBA for the ECAM base. */
461 RTAcpiTblNameAppend(m_hAcpiDsdt, "_CBA");
462 RTAcpiTblIntegerAppend(m_hAcpiDsdt, GCPhysMmioEcam);
463
464 return RTAcpiTblDeviceFinalize(m_hAcpiDsdt);
465}
466
467
468int SystemTableBuilderAcpi::dumpTables(const char *pszFilename)
469{
470 return RTAcpiTblDumpToFile(m_hAcpiDsdt, RTACPITBLTYPE_AML, pszFilename);
471}
472
473
474int SystemTableBuilderAcpi::buildMadt(RTVFSIOSTREAM hVfsIos, size_t *pcbMadt)
475{
476 uint8_t abMadt[_4K];
477 uint32_t cbMadt = 0;
478
479 RT_ZERO(abMadt);
480
481 PACPIMADT pMadt = (PACPIMADT)&abMadt[0];
482 PACPIMADTGICC pGicc = (PACPIMADTGICC)(pMadt + 1);
483
484 cbMadt += sizeof(*pMadt);
485
486 /* Include a GIC CPU interface for each CPU. */
487 for (uint32_t i = 0; i < m_cCpus; i++)
488 {
489 pGicc->bType = ACPI_MADT_INTR_CTRL_TYPE_GICC;
490 pGicc->cbThis = sizeof(*pGicc);
491 pGicc->u32CpuId = i;
492 pGicc->u32AcpiCpuUid = i;
493 pGicc->fGicc = ACPI_MADT_GICC_F_ENABLED;
494 pGicc->u64Mpidr = i;
495
496 cbMadt += sizeof(*pGicc);
497 pGicc++;
498 }
499
500 /* Build the GICD. */
501 PACPIMADTGICD pGicd = (PACPIMADTGICD)pGicc;
502 pGicd->bType = ACPI_MADT_INTR_CTRL_TYPE_GICD;
503 pGicd->cbThis = sizeof(*pGicd);
504 pGicd->u64PhysAddrBase = m_GCPhysIntcDist;
505 pGicd->bGicVersion = ACPI_MADT_GICD_VERSION_GICv3;
506
507 cbMadt += sizeof(*pGicd);
508
509 /* Build the GICR. */
510 PACPIMADTGICR pGicr = (PACPIMADTGICR)(pGicd + 1);
511 pGicr->bType = ACPI_MADT_INTR_CTRL_TYPE_GICR;
512 pGicr->cbThis = sizeof(*pGicr);
513 pGicr->u64PhysAddrGicrRangeBase = m_GCPhysIntcReDist;
514 pGicr->cbGicrRange = m_cbMmioIntcReDist;
515
516 cbMadt += sizeof(*pGicr);
517
518 /* Finalize the MADT. */
519 pMadt->Hdr.u32Signature = ACPI_TABLE_HDR_SIGNATURE_APIC;
520 pMadt->Hdr.cbTbl = cbMadt;
521 pMadt->Hdr.bRevision = 6;
522 pMadt->Hdr.bChkSum = 0;
523 pMadt->Hdr.u32OemRevision = 1;
524 pMadt->Hdr.u32CreatorRevision = 1;
525
526 memcpy(&pMadt->Hdr.abOemId[0], "ORCLVB", 6);
527 memcpy(&pMadt->Hdr.abOemTblId[0], "ORCL", 4);
528 memcpy(&pMadt->Hdr.abOemTblId[4], &pMadt->Hdr.u32Signature, 4);
529 memcpy(&pMadt->Hdr.abCreatorId[0], "ORCL", 4);
530 RTAcpiTblHdrChecksumGenerate(&pMadt->Hdr, cbMadt);
531 *pcbMadt = cbMadt;
532 return RTVfsIoStrmWrite(hVfsIos, pMadt, cbMadt, true /*fBlocking*/, NULL /*pcbWritten*/);
533}
534
535
536int SystemTableBuilderAcpi::buildMcfg(RTVFSIOSTREAM hVfsIos, size_t *pcbMcfg)
537{
538 uint8_t abMcfg[_1K];
539 uint32_t cbMcfg = 0;
540
541 RT_ZERO(abMcfg);
542
543 PACPIMCFG pMcfg = (PACPIMCFG)&abMcfg[0];
544 PACPIMCFGALLOC pAlloc = (PACPIMCFGALLOC)(pMcfg + 1);
545
546 cbMcfg += sizeof(*pMcfg) + sizeof(*pAlloc);
547
548 pAlloc->u64PhysAddrBase = m_GCPhysPciMmioEcam;
549 pAlloc->u16PciSegGrpNr = 0;
550 pAlloc->bPciBusFirst = 0;
551 pAlloc->bPciBusLast = m_bPciBusMax;
552
553 /* Finalize the MADT. */
554 pMcfg->Hdr.u32Signature = ACPI_TABLE_HDR_SIGNATURE_RSVD_MCFG;
555 pMcfg->Hdr.cbTbl = cbMcfg;
556 pMcfg->Hdr.bRevision = 6;
557 pMcfg->Hdr.bChkSum = 0;
558 pMcfg->Hdr.u32OemRevision = 1;
559 pMcfg->Hdr.u32CreatorRevision = 1;
560
561 memcpy(&pMcfg->Hdr.abOemId[0], "ORCLVB", 6);
562 memcpy(&pMcfg->Hdr.abOemTblId[0], "ORCL", 4);
563 memcpy(&pMcfg->Hdr.abOemTblId[4], &pMcfg->Hdr.u32Signature, 4);
564 memcpy(&pMcfg->Hdr.abCreatorId[0], "ORCL", 4);
565 RTAcpiTblHdrChecksumGenerate(&pMcfg->Hdr, cbMcfg);
566 *pcbMcfg = cbMcfg;
567 return RTVfsIoStrmWrite(hVfsIos, pMcfg, cbMcfg, true /*fBlocking*/, NULL /*pcbWritten*/);
568}
569
570
571int SystemTableBuilderAcpi::buildGtdt(RTVFSIOSTREAM hVfsIos, size_t *pcbGtdt)
572{
573 ACPIGTDT Gtdt; RT_ZERO(Gtdt);
574
575#if 1
576 Gtdt.u64PhysAddrCntControlBase = UINT64_MAX;
577 Gtdt.u32Rsvd = 0;
578 Gtdt.u32El1SecTimerGsiv = 0;
579 Gtdt.fEl1SecTimer = 0;
580 Gtdt.u32El1NonSecTimerGsiv = 0x1a; /** @todo */
581 Gtdt.fEl1NonSecTimer = ACPI_GTDT_TIMER_F_INTR_MODE_LEVEL | ACPI_GTDT_TIMER_F_INTR_POLARITY_ACTIVE_HIGH | ACPI_GTDT_TIMER_F_ALWAYS_ON_CAP;
582 Gtdt.u32El1VirtTimerGsiv = 0x1b; /** @todo */
583 Gtdt.fEl1VirtTimer = ACPI_GTDT_TIMER_F_INTR_MODE_LEVEL | ACPI_GTDT_TIMER_F_INTR_POLARITY_ACTIVE_HIGH;
584 Gtdt.u32El2TimerGsiv = 0x1e;
585 Gtdt.fEl2Timer = ACPI_GTDT_TIMER_F_INTR_MODE_LEVEL | ACPI_GTDT_TIMER_F_INTR_POLARITY_ACTIVE_HIGH;
586 Gtdt.u64PhysAddrCndReadBase = UINT64_MAX;
587 Gtdt.cPlatformTimers = 0;
588 Gtdt.offPlatformTimers = 0;
589 Gtdt.u32El2VirtTimerGsiv = 0;
590 Gtdt.fEl2VirtTimer = 0;
591#else /* Nested virt config on AppleSilicon. */
592 Gtdt.u64PhysAddrCntControlBase = UINT64_MAX;
593 Gtdt.u32Rsvd = 0;
594 Gtdt.u32El1SecTimerGsiv = 0;
595 Gtdt.fEl1SecTimer = 0;
596 Gtdt.u32El1NonSecTimerGsiv = 0x1e; /** @todo */
597 Gtdt.fEl1NonSecTimer = ACPI_GTDT_TIMER_F_INTR_MODE_LEVEL | ACPI_GTDT_TIMER_F_INTR_POLARITY_ACTIVE_HIGH | ACPI_GTDT_TIMER_F_ALWAYS_ON_CAP;
598 Gtdt.u32El1VirtTimerGsiv = 0x1b; /** @todo */
599 Gtdt.fEl1VirtTimer = ACPI_GTDT_TIMER_F_INTR_MODE_LEVEL | ACPI_GTDT_TIMER_F_INTR_POLARITY_ACTIVE_HIGH;
600 Gtdt.u32El2TimerGsiv = 0x1a;
601 Gtdt.fEl2Timer = ACPI_GTDT_TIMER_F_INTR_MODE_LEVEL | ACPI_GTDT_TIMER_F_INTR_POLARITY_ACTIVE_HIGH;
602 Gtdt.u64PhysAddrCndReadBase = UINT64_MAX;
603 Gtdt.cPlatformTimers = 0;
604 Gtdt.offPlatformTimers = 0;
605 Gtdt.u32El2VirtTimerGsiv = 0;
606 Gtdt.fEl2VirtTimer = 0;
607#endif
608
609 Gtdt.Hdr.u32Signature = ACPI_TABLE_HDR_SIGNATURE_GTDT;
610 Gtdt.Hdr.cbTbl = sizeof(Gtdt);
611 Gtdt.Hdr.bRevision = 6;
612 Gtdt.Hdr.bChkSum = 0;
613 Gtdt.Hdr.u32OemRevision = 1;
614 Gtdt.Hdr.u32CreatorRevision = 1;
615
616 memcpy(&Gtdt.Hdr.abOemId[0], "ORCLVB", 6);
617 memcpy(&Gtdt.Hdr.abOemTblId[0], "ORCL", 4);
618 memcpy(&Gtdt.Hdr.abOemTblId[4], &Gtdt.Hdr.u32Signature, 4);
619 memcpy(&Gtdt.Hdr.abCreatorId[0], "ORCL", 4);
620 RTAcpiTblHdrChecksumGenerate(&Gtdt.Hdr, sizeof(Gtdt));
621 *pcbGtdt = sizeof(Gtdt);
622 return RTVfsIoStrmWrite(hVfsIos, &Gtdt, sizeof(Gtdt), true /*fBlocking*/, NULL /*pcbWritten*/);
623}
624
625
626int SystemTableBuilderAcpi::buildFadt(RTVFSIOSTREAM hVfsIos, RTGCPHYS GCPhysXDsdt, size_t *pcbFadt)
627{
628 /* Build FADT. */
629 ACPIFADT Fadt; RT_ZERO(Fadt);
630
631 Fadt.fFeatures = ACPI_FADT_F_HW_REDUCED_ACPI;
632 Fadt.fArmBootArch = ACPI_FADT_ARM_BOOT_ARCH_F_PSCI_COMP
633 | ACPI_FADT_ARM_BOOT_ARCH_F_PSCI_USE_HVC;
634 Fadt.bFadtVersionMinor = 3;
635 Fadt.u64AddrXDsdt = GCPhysXDsdt;
636
637 Fadt.Hdr.u32Signature = ACPI_TABLE_HDR_SIGNATURE_FACP;
638 Fadt.Hdr.cbTbl = sizeof(Fadt);
639 Fadt.Hdr.bRevision = 6;
640 Fadt.Hdr.bChkSum = 0;
641 Fadt.Hdr.u32OemRevision = 1;
642 Fadt.Hdr.u32CreatorRevision = 1;
643
644 memcpy(&Fadt.Hdr.abOemId[0], "ORCLVB", 6);
645 memcpy(&Fadt.Hdr.abOemTblId[0], "ORCL", 4);
646 memcpy(&Fadt.Hdr.abOemTblId[4], &Fadt.Hdr.u32Signature, 4);
647 memcpy(&Fadt.Hdr.abCreatorId[0], "ORCL", 4);
648 RTAcpiTblHdrChecksumGenerate(&Fadt.Hdr, sizeof(Fadt));
649 *pcbFadt = sizeof(Fadt);
650 return RTVfsIoStrmWrite(hVfsIos, &Fadt, sizeof(Fadt), true /*fBlocking*/, NULL /*pcbWritten*/);
651}
652
653
654int SystemTableBuilderAcpi::buildTpm20(RTVFSIOSTREAM hVfsIos, size_t *pcbTpm20)
655{
656 Assert(m_fTpm20);
657
658 ACPITPM20 Tpm2;
659 RT_ZERO(Tpm2);
660
661 Tpm2.u32StartMethod = m_fCrb ? ACPITBL_TPM20_START_METHOD_CRB : ACPITBL_TPM20_START_METHOD_TIS12;
662 Tpm2.u64BaseAddrCrbOrFifo = m_fCrb ? m_GCPhysTpm20Mmio + TPM_CRB_LOCALITY_REG_CTRL_REQ : m_GCPhysTpm20Mmio;
663 Tpm2.u16PlatCls = ACPITBL_TPM20_PLAT_CLS_CLIENT;
664
665 Tpm2.Hdr.u32Signature = ACPI_TABLE_HDR_SIGNATURE_RSVD_TPM2;
666 Tpm2.Hdr.cbTbl = sizeof(Tpm2);
667 Tpm2.Hdr.bRevision = ACPI_TPM20_REVISION;
668 Tpm2.Hdr.bChkSum = 0;
669 Tpm2.Hdr.u32OemRevision = 1;
670 Tpm2.Hdr.u32CreatorRevision = 1;
671
672 memcpy(&Tpm2.Hdr.abOemId[0], "ORCLVB", 6);
673 memcpy(&Tpm2.Hdr.abOemTblId[0], "ORCL", 4);
674 memcpy(&Tpm2.Hdr.abOemTblId[4], &Tpm2.Hdr.u32Signature, 4);
675 memcpy(&Tpm2.Hdr.abCreatorId[0], "ORCL", 4);
676 RTAcpiTblHdrChecksumGenerate(&Tpm2.Hdr, sizeof(Tpm2));
677 *pcbTpm20 = sizeof(Tpm2);
678 return RTVfsIoStrmWrite(hVfsIos, &Tpm2, sizeof(Tpm2), true /*fBlocking*/, NULL /*pcbWritten*/);
679}
680
681
682int SystemTableBuilderAcpi::configureTpm2(bool fCrb, RTGCPHYS GCPhysMmioStart, RTGCPHYS cbMmio, uint32_t u32Irq)
683{
684 m_fTpm20 = true;
685 m_fCrb = fCrb;
686 m_GCPhysTpm20Mmio = GCPhysMmioStart;
687
688 RTAcpiTblDeviceStartF(m_hAcpiDsdt, "TPM0");
689
690 RTAcpiTblNameAppend(m_hAcpiDsdt, "_HID");
691 RTAcpiTblStringAppend(m_hAcpiDsdt, "MSFT0101");
692
693 RTAcpiTblNameAppend(m_hAcpiDsdt, "_CID");
694 RTAcpiTblStringAppend(m_hAcpiDsdt, "MSFT0101");
695
696 RTAcpiTblNameAppend(m_hAcpiDsdt, "_STR");
697 RTAcpiTblStringAppend(m_hAcpiDsdt, "TPM 2.0 Device");
698
699 RTAcpiTblNameAppend(m_hAcpiDsdt, "_UID");
700 RTAcpiTblIntegerAppend(m_hAcpiDsdt, 0);
701
702 RTAcpiTblNameAppend(m_hAcpiDsdt, "_CRS");
703 int vrc = systemTableAcpiMmioDevResource(m_hAcpiDsdt, m_hAcpiRes, GCPhysMmioStart, cbMmio, u32Irq + GIC_INTID_RANGE_SPI_START);
704 AssertRCReturn(vrc, vrc);
705
706 RTAcpiTblMethodStart(m_hAcpiDsdt, "_STA", 0, RTACPI_METHOD_F_NOT_SERIALIZED, 0 /*uSyncLvl*/);
707 RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Return);
708 RTAcpiTblIntegerAppend(m_hAcpiDsdt, 0x0f);
709 RTAcpiTblMethodFinalize(m_hAcpiDsdt);
710
711 /* Build the PPI interface (this is as a verbatim translation from src/VBox/Devices/PC/vbox-tpm.dsl as possible). */
712 RTAcpiTblMethodStart(m_hAcpiDsdt, "TPFS", 1, RTACPI_METHOD_F_SERIALIZED, 0 /*uSyncLvl*/);
713
714 RTAcpiTblIfStart(m_hAcpiDsdt);
715 /* LGreaterEqual(Arg0, 0x100). */
716 RTAcpiTblBinaryOpAppend(m_hAcpiDsdt, kAcpiBinaryOp_LGreaterEqual);
717 RTAcpiTblArgOpAppend(m_hAcpiDsdt, 0);
718 RTAcpiTblIntegerAppend(m_hAcpiDsdt, 0x100);
719
720 RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Return);
721 RTAcpiTblIntegerAppend(m_hAcpiDsdt, 0);
722 RTAcpiTblIfFinalize(m_hAcpiDsdt);
723
724 RTAcpiTblOpRegionAppendEx(m_hAcpiDsdt, "TPP1", kAcpiOperationRegionSpace_SystemMemory);
725 RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Add); /* Region offset */
726 RTAcpiTblIntegerAppend(m_hAcpiDsdt, m_GCPhysTpm20Mmio + 0x5000);
727 RTAcpiTblArgOpAppend(m_hAcpiDsdt, 0); /* Arg0 */
728 RTAcpiTblNullNameAppend(m_hAcpiDsdt); /* Target -> NullName */
729 RTAcpiTblIntegerAppend(m_hAcpiDsdt, 1); /* Region size */
730
731 /* Define the field accessor. */
732 const RTACPIFIELDENTRY aPpiTpp1Fields[] =
733 {
734 { "TPPF", 8 },
735 };
736 RTAcpiTblFieldAppend(m_hAcpiDsdt, "TPP1", kAcpiFieldAcc_Any, false /*fLock*/, kAcpiFieldUpdate_Preserve,
737 &aPpiTpp1Fields[0], RT_ELEMENTS(aPpiTpp1Fields));
738 RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Return);
739 RTAcpiTblNameStringAppend(m_hAcpiDsdt, "TPPF");
740
741 RTAcpiTblMethodFinalize(m_hAcpiDsdt);
742
743
744 /* Device specific method. */
745 RTAcpiTblMethodStart(m_hAcpiDsdt, "_DSM", 4, RTACPI_METHOD_F_SERIALIZED, 0 /*uSyncLvl*/);
746
747 /* Define the MMIO region for the PPI interface. */
748 RTAcpiTblOpRegionAppend(m_hAcpiDsdt, "TPMP", kAcpiOperationRegionSpace_SystemMemory,
749 m_GCPhysTpm20Mmio + 0x5100, 0x5a /*cbRegion*/);
750
751 /* Define the field accessors for the PPI interface. */
752 const RTACPIFIELDENTRY aPpiFields[] =
753 {
754 { "PPIN", 8 },
755 { "PPIP", 32 },
756 { "PPRP", 32 },
757 { "PPRQ", 32 },
758 { "PPRM", 32 },
759 { "LPPR", 32 }
760 };
761 RTAcpiTblFieldAppend(m_hAcpiDsdt, "TPMP", kAcpiFieldAcc_Any, false /*fLock*/, kAcpiFieldUpdate_Preserve,
762 &aPpiFields[0], RT_ELEMENTS(aPpiFields));
763
764 /* Define some packages we need later on. */
765 RTAcpiTblNameAppend(m_hAcpiDsdt, "TPB2");
766 RTAcpiTblPackageStart(m_hAcpiDsdt, 2 /*cElements*/);
767 RTAcpiTblIntegerAppend(m_hAcpiDsdt, 0);
768 RTAcpiTblIntegerAppend(m_hAcpiDsdt, 0);
769 RTAcpiTblPackageFinalize(m_hAcpiDsdt);
770
771 RTAcpiTblNameAppend(m_hAcpiDsdt, "TPB3");
772 RTAcpiTblPackageStart(m_hAcpiDsdt, 3 /*cElements*/);
773 RTAcpiTblIntegerAppend(m_hAcpiDsdt, 0);
774 RTAcpiTblIntegerAppend(m_hAcpiDsdt, 0);
775 RTAcpiTblIntegerAppend(m_hAcpiDsdt, 0);
776 RTAcpiTblPackageFinalize(m_hAcpiDsdt);
777
778
779 /*
780 * Check that the UUID in Arg0 contains the Physical Presence Interface Specification UUID.
781 */
782 RTAcpiTblIfStart(m_hAcpiDsdt);
783
784 /* Predicate (LEqual(Arg0, ToUUID("3dddfaa6-361b-4eb4-a424-8d10089d1653")))*/
785 RTAcpiTblBinaryOpAppend(m_hAcpiDsdt, kAcpiBinaryOp_LEqual);
786 RTAcpiTblArgOpAppend(m_hAcpiDsdt, 0);
787 RTAcpiTblUuidAppendFromStr(m_hAcpiDsdt, "3dddfaa6-361b-4eb4-a424-8d10089d1653");
788
789 /* Standard _DSM query function. */
790 RTAcpiTblIfStart(m_hAcpiDsdt);
791
792 /* LEqual(Arg2, Zero). */
793 RTAcpiTblBinaryOpAppend(m_hAcpiDsdt, kAcpiBinaryOp_LEqual);
794 RTAcpiTblArgOpAppend(m_hAcpiDsdt, 2);
795 RTAcpiTblIntegerAppend(m_hAcpiDsdt, 0);
796
797 RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Return);
798 uint8_t abDsmQuery[2] = { 0xff, 0x01 };
799 RTAcpiTblBufferAppend(m_hAcpiDsdt, &abDsmQuery[0], sizeof(abDsmQuery));
800
801 RTAcpiTblIfFinalize(m_hAcpiDsdt);
802
803 /* Query supported PPI revision . */
804 RTAcpiTblIfStart(m_hAcpiDsdt);
805
806 /* LEqual(Arg2, Zero). */
807 RTAcpiTblBinaryOpAppend(m_hAcpiDsdt, kAcpiBinaryOp_LEqual);
808 RTAcpiTblArgOpAppend(m_hAcpiDsdt, 2);
809 RTAcpiTblIntegerAppend(m_hAcpiDsdt, 1);
810
811 RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Return);
812 RTAcpiTblStringAppend(m_hAcpiDsdt, "1.3");
813
814 RTAcpiTblIfFinalize(m_hAcpiDsdt);
815
816
817 /* Submit TPM Operation Requested to pre-OS environment. */
818 RTAcpiTblIfStart(m_hAcpiDsdt);
819
820 /* LEqual(Arg2, Zero). */
821 RTAcpiTblBinaryOpAppend(m_hAcpiDsdt, kAcpiBinaryOp_LEqual);
822 RTAcpiTblArgOpAppend(m_hAcpiDsdt, 2);
823 RTAcpiTblIntegerAppend(m_hAcpiDsdt, 2);
824
825 /* Store(DerefOf(Index(Arg3, Zero)), Local0) */
826 RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Store);
827 RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_DerefOf);
828 RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Index);
829 RTAcpiTblArgOpAppend(m_hAcpiDsdt, 3); /* Arg3 */
830 RTAcpiTblIntegerAppend(m_hAcpiDsdt, 0); /* Zero */
831 RTAcpiTblNullNameAppend(m_hAcpiDsdt); /* Target -> NullName */
832 RTAcpiTblLocalOpAppend(m_hAcpiDsdt, 0); /* Local0 */
833
834 /* Store (TPFS (Local0), Local1) */
835 RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Store);
836 RTAcpiTblNameStringAppend(m_hAcpiDsdt, "TPFS");
837 RTAcpiTblLocalOpAppend(m_hAcpiDsdt, 0); /* Local0 */
838 RTAcpiTblLocalOpAppend(m_hAcpiDsdt, 1); /* Local1 */
839
840 /* If (LEqual (And (Local1, 0x07), Zero)) */
841 RTAcpiTblIfStart(m_hAcpiDsdt);
842 RTAcpiTblBinaryOpAppend(m_hAcpiDsdt, kAcpiBinaryOp_LEqual);
843 RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_And);
844 RTAcpiTblLocalOpAppend(m_hAcpiDsdt, 1); /* Local1 */
845 RTAcpiTblIntegerAppend(m_hAcpiDsdt, 0x7);
846 RTAcpiTblNullNameAppend(m_hAcpiDsdt); /* Target -> NullName */
847 RTAcpiTblIntegerAppend(m_hAcpiDsdt, 0);
848
849 RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Return);
850 RTAcpiTblIntegerAppend(m_hAcpiDsdt, 1);
851
852 RTAcpiTblIfFinalize(m_hAcpiDsdt);
853
854 /* Store (Local0, PPRQ) */
855 RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Store);
856 RTAcpiTblLocalOpAppend(m_hAcpiDsdt, 0); /* Local0 */
857 RTAcpiTblNameStringAppend(m_hAcpiDsdt, "PPRQ");
858 /* Store (Zero, PPRM) */
859 RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Store);
860 RTAcpiTblIntegerAppend(m_hAcpiDsdt, 0);
861 RTAcpiTblNameStringAppend(m_hAcpiDsdt, "PPRM");
862
863 RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Return);
864 RTAcpiTblIntegerAppend(m_hAcpiDsdt, 0);
865
866 RTAcpiTblIfFinalize(m_hAcpiDsdt);
867
868
869 /* Get Pending TPM Operation Requested by the OS. */
870 RTAcpiTblIfStart(m_hAcpiDsdt);
871
872 /* LEqual(Arg2, Zero). */
873 RTAcpiTblBinaryOpAppend(m_hAcpiDsdt, kAcpiBinaryOp_LEqual);
874 RTAcpiTblArgOpAppend(m_hAcpiDsdt, 2);
875 RTAcpiTblIntegerAppend(m_hAcpiDsdt, 3);
876
877 RTAcpiTblIfStart(m_hAcpiDsdt);
878
879 /* LEqual(Arg1, One). */
880 RTAcpiTblBinaryOpAppend(m_hAcpiDsdt, kAcpiBinaryOp_LEqual);
881 RTAcpiTblArgOpAppend(m_hAcpiDsdt, 1);
882 RTAcpiTblIntegerAppend(m_hAcpiDsdt, 1);
883
884 /* Store (PPRQ, Index(TPB2, One) */
885 RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Store);
886 RTAcpiTblNameStringAppend(m_hAcpiDsdt, "PPRQ");
887 RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Index);
888 RTAcpiTblNameStringAppend(m_hAcpiDsdt, "TPB2");
889 RTAcpiTblIntegerAppend(m_hAcpiDsdt, 1);
890 RTAcpiTblNullNameAppend(m_hAcpiDsdt); /* Target -> NullName */
891
892 RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Return);
893 RTAcpiTblNameStringAppend(m_hAcpiDsdt, "TPB2");
894
895 RTAcpiTblIfFinalize(m_hAcpiDsdt);
896
897 RTAcpiTblIfStart(m_hAcpiDsdt);
898
899 /* LEqual(Arg1, 0x02). */
900 RTAcpiTblBinaryOpAppend(m_hAcpiDsdt, kAcpiBinaryOp_LEqual);
901 RTAcpiTblArgOpAppend(m_hAcpiDsdt, 1);
902 RTAcpiTblIntegerAppend(m_hAcpiDsdt, 2);
903
904 /* Store (PPRQ, Index(TPB3, One) */
905 RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Store);
906 RTAcpiTblNameStringAppend(m_hAcpiDsdt, "PPRQ");
907 RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Index);
908 RTAcpiTblNameStringAppend(m_hAcpiDsdt, "TPB3");
909 RTAcpiTblIntegerAppend(m_hAcpiDsdt, 1);
910 RTAcpiTblNullNameAppend(m_hAcpiDsdt); /* Target -> NullName */
911
912 /* Store (PPRM, Index(TPB3, 0x2) */
913 RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Store);
914 RTAcpiTblNameStringAppend(m_hAcpiDsdt, "PPRM");
915 RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Index);
916 RTAcpiTblNameStringAppend(m_hAcpiDsdt, "TPB3");
917 RTAcpiTblIntegerAppend(m_hAcpiDsdt, 2);
918 RTAcpiTblNullNameAppend(m_hAcpiDsdt); /* Target -> NullName */
919
920 RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Return);
921 RTAcpiTblNameStringAppend(m_hAcpiDsdt, "TPB2");
922
923 RTAcpiTblIfFinalize(m_hAcpiDsdt);
924
925 RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Return);
926 RTAcpiTblNameStringAppend(m_hAcpiDsdt, "TPB3");
927
928 RTAcpiTblIfFinalize(m_hAcpiDsdt);
929
930
931 /* Get Platform-specific Action to Transition to Pre-OS Environment. */
932 RTAcpiTblIfStart(m_hAcpiDsdt);
933
934 /* LEqual(Arg2, Zero). */
935 RTAcpiTblBinaryOpAppend(m_hAcpiDsdt, kAcpiBinaryOp_LEqual);
936 RTAcpiTblArgOpAppend(m_hAcpiDsdt, 2);
937 RTAcpiTblIntegerAppend(m_hAcpiDsdt, 4);
938
939 RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Return);
940 RTAcpiTblIntegerAppend(m_hAcpiDsdt, 2); /* Reboot */
941
942 RTAcpiTblIfFinalize(m_hAcpiDsdt);
943
944
945 /* Return TPM Operation Response to OS Environment. */
946 RTAcpiTblIfStart(m_hAcpiDsdt);
947
948 /* LEqual(Arg2, Zero). */
949 RTAcpiTblBinaryOpAppend(m_hAcpiDsdt, kAcpiBinaryOp_LEqual);
950 RTAcpiTblArgOpAppend(m_hAcpiDsdt, 2);
951 RTAcpiTblIntegerAppend(m_hAcpiDsdt, 5);
952
953 /* Store (LPPR, Index(TPB3, One) */
954 RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Store);
955 RTAcpiTblNameStringAppend(m_hAcpiDsdt, "LPPR");
956 RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Index);
957 RTAcpiTblNameStringAppend(m_hAcpiDsdt, "TPB3");
958 RTAcpiTblIntegerAppend(m_hAcpiDsdt, 1);
959 RTAcpiTblNullNameAppend(m_hAcpiDsdt); /* Target -> NullName */
960
961 /* Store (PPRP, Index(TPB3, 0x2) */
962 RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Store);
963 RTAcpiTblNameStringAppend(m_hAcpiDsdt, "PPRP");
964 RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Index);
965 RTAcpiTblNameStringAppend(m_hAcpiDsdt, "TPB3");
966 RTAcpiTblIntegerAppend(m_hAcpiDsdt, 2);
967 RTAcpiTblNullNameAppend(m_hAcpiDsdt); /* Target -> NullName */
968
969 RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Return);
970 RTAcpiTblNameStringAppend(m_hAcpiDsdt, "TPB3");
971
972 RTAcpiTblIfFinalize(m_hAcpiDsdt);
973
974
975 /* Submit Preferred user language - deprecated. */
976 RTAcpiTblIfStart(m_hAcpiDsdt);
977
978 /* LEqual(Arg2, Zero). */
979 RTAcpiTblBinaryOpAppend(m_hAcpiDsdt, kAcpiBinaryOp_LEqual);
980 RTAcpiTblArgOpAppend(m_hAcpiDsdt, 2);
981 RTAcpiTblIntegerAppend(m_hAcpiDsdt, 6);
982
983 RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Return);
984 RTAcpiTblIntegerAppend(m_hAcpiDsdt, 3); /* Not implemented */
985
986 RTAcpiTblIfFinalize(m_hAcpiDsdt);
987
988
989 /* Submit TPM Operation Request to Pre-OS Environment 2. */
990 RTAcpiTblIfStart(m_hAcpiDsdt);
991
992 /* LEqual(Arg2, Zero). */
993 RTAcpiTblBinaryOpAppend(m_hAcpiDsdt, kAcpiBinaryOp_LEqual);
994 RTAcpiTblArgOpAppend(m_hAcpiDsdt, 2);
995 RTAcpiTblIntegerAppend(m_hAcpiDsdt, 7);
996
997 /* Store(DerefOf(Index(Arg3, Zero)), Local0) */
998 RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Store);
999 RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_DerefOf);
1000 RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Index);
1001 RTAcpiTblArgOpAppend(m_hAcpiDsdt, 3); /* Arg3 */
1002 RTAcpiTblIntegerAppend(m_hAcpiDsdt, 0); /* Zero */
1003 RTAcpiTblNullNameAppend(m_hAcpiDsdt); /* Target -> NullName */
1004 RTAcpiTblLocalOpAppend(m_hAcpiDsdt, 0); /* Local0 */
1005
1006 /* Store (TPFS (Local0), Local1) */
1007 RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Store);
1008 RTAcpiTblNameStringAppend(m_hAcpiDsdt, "TPFS");
1009 RTAcpiTblLocalOpAppend(m_hAcpiDsdt, 0); /* Local0 */
1010 RTAcpiTblLocalOpAppend(m_hAcpiDsdt, 1); /* Local1 */
1011
1012 /* Store(And(Local1, 0x07), Local1) */
1013 RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Store);
1014 RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_And);
1015 RTAcpiTblLocalOpAppend(m_hAcpiDsdt, 1); /* Local1 */
1016 RTAcpiTblIntegerAppend(m_hAcpiDsdt, 0x7);
1017 RTAcpiTblNullNameAppend(m_hAcpiDsdt); /* Target -> NullName */
1018 RTAcpiTblLocalOpAppend(m_hAcpiDsdt, 1); /* Local1 */
1019
1020 /* LEqual(Local1, Zero) */
1021 RTAcpiTblIfStart(m_hAcpiDsdt);
1022
1023 RTAcpiTblBinaryOpAppend(m_hAcpiDsdt, kAcpiBinaryOp_LEqual);
1024 RTAcpiTblLocalOpAppend(m_hAcpiDsdt, 1);
1025 RTAcpiTblIntegerAppend(m_hAcpiDsdt, 0);
1026
1027 RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Return);
1028 RTAcpiTblIntegerAppend(m_hAcpiDsdt, 1);
1029
1030 RTAcpiTblIfFinalize(m_hAcpiDsdt);
1031
1032 /* LEqual(Local1, 2) */
1033 RTAcpiTblIfStart(m_hAcpiDsdt);
1034
1035 RTAcpiTblBinaryOpAppend(m_hAcpiDsdt, kAcpiBinaryOp_LEqual);
1036 RTAcpiTblLocalOpAppend(m_hAcpiDsdt, 1);
1037 RTAcpiTblIntegerAppend(m_hAcpiDsdt, 2);
1038
1039 RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Return);
1040 RTAcpiTblIntegerAppend(m_hAcpiDsdt, 3);
1041
1042 RTAcpiTblIfFinalize(m_hAcpiDsdt);
1043
1044 /* LEqual(Arg1, One) */
1045 RTAcpiTblIfStart(m_hAcpiDsdt);
1046
1047 RTAcpiTblBinaryOpAppend(m_hAcpiDsdt, kAcpiBinaryOp_LEqual);
1048 RTAcpiTblArgOpAppend(m_hAcpiDsdt, 1);
1049 RTAcpiTblIntegerAppend(m_hAcpiDsdt, 1);
1050
1051 /* Store(Local0, PPRQ) */
1052 RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Store);
1053 RTAcpiTblLocalOpAppend(m_hAcpiDsdt, 0);
1054 RTAcpiTblNameStringAppend(m_hAcpiDsdt, "PPRQ");
1055
1056 /* Store(Zero, PPRM) */
1057 RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Store);
1058 RTAcpiTblIntegerAppend(m_hAcpiDsdt, 0);
1059 RTAcpiTblNameStringAppend(m_hAcpiDsdt, "PPRM");
1060
1061 RTAcpiTblIfFinalize(m_hAcpiDsdt);
1062
1063 /* LEqual(Arg1, 2) */
1064 RTAcpiTblIfStart(m_hAcpiDsdt);
1065
1066 RTAcpiTblBinaryOpAppend(m_hAcpiDsdt, kAcpiBinaryOp_LEqual);
1067 RTAcpiTblArgOpAppend(m_hAcpiDsdt, 1);
1068 RTAcpiTblIntegerAppend(m_hAcpiDsdt, 2);
1069
1070 /* Store(DerefOf(Index(Arg3, One)), Local2) */
1071 RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Store);
1072 RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_DerefOf);
1073 RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Index);
1074 RTAcpiTblArgOpAppend(m_hAcpiDsdt, 3); /* Arg3 */
1075 RTAcpiTblIntegerAppend(m_hAcpiDsdt, 1); /* ONe */
1076 RTAcpiTblNullNameAppend(m_hAcpiDsdt); /* Target -> NullName */
1077 RTAcpiTblLocalOpAppend(m_hAcpiDsdt, 2); /* Local2 */
1078
1079 /* Store(Local0, PPRQ) */
1080 RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Store);
1081 RTAcpiTblLocalOpAppend(m_hAcpiDsdt, 0);
1082 RTAcpiTblNameStringAppend(m_hAcpiDsdt, "PPRQ");
1083
1084 /* Store(Local2, PPRM) */
1085 RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Store);
1086 RTAcpiTblLocalOpAppend(m_hAcpiDsdt, 2);
1087 RTAcpiTblNameStringAppend(m_hAcpiDsdt, "PPRM");
1088
1089 RTAcpiTblIfFinalize(m_hAcpiDsdt);
1090
1091 RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Return);
1092 RTAcpiTblIntegerAppend(m_hAcpiDsdt, 0);
1093
1094 RTAcpiTblIfFinalize(m_hAcpiDsdt);
1095
1096
1097 /* Get User Confirmation Status for Operation. */
1098 RTAcpiTblIfStart(m_hAcpiDsdt);
1099
1100 /* LEqual(Arg2, Zero). */
1101 RTAcpiTblBinaryOpAppend(m_hAcpiDsdt, kAcpiBinaryOp_LEqual);
1102 RTAcpiTblArgOpAppend(m_hAcpiDsdt, 2);
1103 RTAcpiTblIntegerAppend(m_hAcpiDsdt, 8);
1104
1105 /* Store(DerefOf(Index(Arg3, Zero)), Local0) */
1106 RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Store);
1107 RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_DerefOf);
1108 RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Index);
1109 RTAcpiTblArgOpAppend(m_hAcpiDsdt, 3); /* Arg3 */
1110 RTAcpiTblIntegerAppend(m_hAcpiDsdt, 0); /* Zero */
1111 RTAcpiTblNullNameAppend(m_hAcpiDsdt); /* Target -> NullName */
1112 RTAcpiTblLocalOpAppend(m_hAcpiDsdt, 0); /* Local0 */
1113
1114 /* Store (TPFS (Local0), Local1) */
1115 RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Store);
1116 RTAcpiTblNameStringAppend(m_hAcpiDsdt, "TPFS");
1117 RTAcpiTblLocalOpAppend(m_hAcpiDsdt, 0); /* Local0 */
1118 RTAcpiTblLocalOpAppend(m_hAcpiDsdt, 1); /* Local1 */
1119
1120 RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Return);
1121 RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_And);
1122 RTAcpiTblLocalOpAppend(m_hAcpiDsdt, 1); /* Local1 */
1123 RTAcpiTblIntegerAppend(m_hAcpiDsdt, 0x7);
1124 RTAcpiTblNullNameAppend(m_hAcpiDsdt); /* Target -> NullName */
1125
1126 RTAcpiTblIfFinalize(m_hAcpiDsdt);
1127
1128
1129 /* Return Unknown function. */
1130 uint8_t bUnkFunc = 0x00;
1131 RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Return);
1132 RTAcpiTblBufferAppend(m_hAcpiDsdt, &bUnkFunc, sizeof(bUnkFunc));
1133
1134 RTAcpiTblIfFinalize(m_hAcpiDsdt);
1135
1136
1137 /*
1138 * TCG Platform Reset Attack Mitigation Specification interface.
1139 */
1140 RTAcpiTblIfStart(m_hAcpiDsdt);
1141
1142 /* Predicate (LEqual(Arg0, ToUUID("376054ed-cc13-4675-901c-4756d7f2d45d")))*/
1143 RTAcpiTblBinaryOpAppend(m_hAcpiDsdt, kAcpiBinaryOp_LEqual);
1144 RTAcpiTblArgOpAppend(m_hAcpiDsdt, 0);
1145 RTAcpiTblUuidAppendFromStr(m_hAcpiDsdt, "376054ed-cc13-4675-901c-4756d7f2d45d");
1146
1147 /* Standard _DSM query function. */
1148 RTAcpiTblIfStart(m_hAcpiDsdt);
1149
1150 /* LEqual(Arg2, Zero). */
1151 RTAcpiTblBinaryOpAppend(m_hAcpiDsdt, kAcpiBinaryOp_LEqual);
1152 RTAcpiTblArgOpAppend(m_hAcpiDsdt, 2);
1153 RTAcpiTblIntegerAppend(m_hAcpiDsdt, 0);
1154
1155 RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Return);
1156 uint8_t bBuf = 0x03;
1157 RTAcpiTblBufferAppend(m_hAcpiDsdt, &bBuf, sizeof(bBuf));
1158
1159 RTAcpiTblIfFinalize(m_hAcpiDsdt);
1160
1161 /* Set Memory Overwrite Request (MOR) bit to specified value. */
1162 RTAcpiTblIfStart(m_hAcpiDsdt);
1163
1164 /* LEqual(Arg2, Zero). */
1165 RTAcpiTblBinaryOpAppend(m_hAcpiDsdt, kAcpiBinaryOp_LEqual);
1166 RTAcpiTblArgOpAppend(m_hAcpiDsdt, 2);
1167 RTAcpiTblIntegerAppend(m_hAcpiDsdt, 1);
1168
1169 RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Return);
1170 RTAcpiTblIntegerAppend(m_hAcpiDsdt, 0); /* Memory always zeroed on reset. */
1171
1172 RTAcpiTblIfFinalize(m_hAcpiDsdt);
1173
1174 /* Return Unknown function. */
1175 bUnkFunc = 0x00;
1176 RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Return);
1177 RTAcpiTblBufferAppend(m_hAcpiDsdt, &bUnkFunc, sizeof(bUnkFunc));
1178
1179 RTAcpiTblIfFinalize(m_hAcpiDsdt);
1180
1181 /* Return Unknown function. */
1182 bUnkFunc = 0x00;
1183 RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Return);
1184 RTAcpiTblBufferAppend(m_hAcpiDsdt, &bUnkFunc, sizeof(bUnkFunc));
1185
1186 RTAcpiTblMethodFinalize(m_hAcpiDsdt);
1187
1188 return RTAcpiTblDeviceFinalize(m_hAcpiDsdt);
1189}
1190
1191
1192int SystemTableBuilder::initInstance(void)
1193{
1194 return VERR_NOT_IMPLEMENTED;
1195}
1196
1197
1198int SystemTableBuilder::finishTables(RTGCPHYS GCPhysTblsStart, RTVFSIOSTREAM hVfsIos,
1199 PRTGCPHYS pGCPhysTblRoot, size_t *pcbTblRoot, size_t *pcbTbls)
1200{
1201 RT_NOREF(GCPhysTblsStart, hVfsIos, pGCPhysTblRoot, pcbTblRoot, pcbTbls);
1202 return VERR_NOT_IMPLEMENTED;
1203}
1204
1205
1206int SystemTableBuilder::addCpu(uint32_t idCpu)
1207{
1208 RT_NOREF(idCpu);
1209 return VERR_NOT_IMPLEMENTED;
1210}
1211
1212
1213int SystemTableBuilder::addMemory(RTGCPHYS GCPhysStart, RTGCPHYS cbMem)
1214{
1215 RT_NOREF(GCPhysStart, cbMem);
1216 return VERR_NOT_IMPLEMENTED;
1217}
1218
1219
1220int SystemTableBuilder::addMmioDeviceNoIrq(const char *pszVBoxName, uint32_t uInstance, RTGCPHYS GCPhysMmio, RTGCPHYS cbMmio)
1221{
1222 RT_NOREF(pszVBoxName, uInstance, GCPhysMmio, cbMmio);
1223 return VERR_NOT_IMPLEMENTED;
1224}
1225
1226
1227int SystemTableBuilder::addMmioDevice(const char *pszVBoxName, uint32_t uInstance, RTGCPHYS GCPhysMmio, RTGCPHYS cbMmio, uint32_t u32Irq)
1228{
1229 RT_NOREF(pszVBoxName, uInstance, GCPhysMmio, cbMmio, u32Irq);
1230 return VERR_NOT_IMPLEMENTED;
1231}
1232
1233
1234int SystemTableBuilder::configureGic(uint32_t cCpus, RTGCPHYS GCPhysIntcDist, RTGCPHYS cbMmioIntcDist, RTGCPHYS GCPhysIntcReDist,
1235 RTGCPHYS cbMmioIntcReDist)
1236{
1237 RT_NOREF(cCpus, GCPhysIntcDist, cbMmioIntcDist, GCPhysIntcReDist, cbMmioIntcReDist);
1238 return VERR_NOT_IMPLEMENTED;
1239}
1240
1241
1242int SystemTableBuilder::configureClock(void)
1243{
1244 return VERR_NOT_IMPLEMENTED;
1245}
1246
1247
1248int SystemTableBuilder::configurePcieRootBus(const char *pszVBoxName, uint32_t aPinIrqs[4], RTGCPHYS GCPhysMmioPio, RTGCPHYS GCPhysMmioEcam, size_t cbPciMmioEcam,
1249 RTGCPHYS GCPhysPciMmioBase, RTGCPHYS cbPciMmio, RTGCPHYS GCPhysPciMmio32Base, RTGCPHYS cbPciMmio32)
1250{
1251 RT_NOREF(pszVBoxName, aPinIrqs, GCPhysMmioPio, GCPhysMmioEcam, cbPciMmioEcam,
1252 GCPhysPciMmioBase, cbPciMmio, GCPhysPciMmio32Base, cbPciMmio32);
1253 return VERR_NOT_IMPLEMENTED;
1254}
1255
1256
1257int SystemTableBuilder::configureTpm2(bool fCrb, RTGCPHYS GCPhysMmioStart, RTGCPHYS cbMmio, uint32_t u32Irq)
1258{
1259 RT_NOREF(fCrb, GCPhysMmioStart, cbMmio, u32Irq);
1260 return VERR_NOT_IMPLEMENTED;
1261}
1262
1263
1264int SystemTableBuilder::dumpTables(const char *pszFilename)
1265{
1266 RT_NOREF(pszFilename);
1267 return VERR_NOT_IMPLEMENTED;
1268}
1269
1270
1271SystemTableBuilder *SystemTableBuilder::createInstance(SYSTEMTABLETYPE enmTableType)
1272{
1273 AssertReturn(enmTableType == kSystemTableType_Acpi, NULL);
1274
1275 SystemTableBuilder *pInstance = new SystemTableBuilderAcpi();
1276 Assert(pInstance);
1277
1278 int vrc = pInstance->initInstance();
1279 if (RT_FAILURE(vrc))
1280 {
1281 delete pInstance;
1282 pInstance = NULL;
1283 }
1284
1285 return pInstance;
1286}
Note: See TracBrowser for help on using the repository browser.

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette