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	*/
57	typedef 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;
65	typedef SYSTEMTABLEDEVICE *PSYSTEMTABLEDEVICE;
66	typedef const SYSTEMTABLEDEVICE *PCSYSTEMTABLEDEVICE;
67
68
69	/*********************************************************************************************************************************
70	* Global Variables *
71	*********************************************************************************************************************************/
72	static 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
81	static 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
91	static 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
121	static 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
144	int 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
159	int 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
275	int 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
289	int SystemTableBuilderAcpi::addMemory(RTGCPHYS GCPhysStart, RTGCPHYS cbMem)
290	{
291	RT_NOREF(GCPhysStart, cbMem);
292	return VINF_SUCCESS;
293	}
294
295
296	int 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
317	int 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
339	int 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
351	int SystemTableBuilderAcpi::configureClock(void)
352	{
353	return VINF_SUCCESS;
354	}
355
356
357	int 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
468	int SystemTableBuilderAcpi::dumpTables(const char *pszFilename)
469	{
470	return RTAcpiTblDumpToFile(m_hAcpiDsdt, RTACPITBLTYPE_AML, pszFilename);
471	}
472
473
474	int 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
536	int 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
571	int 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
626	int 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
654	int 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
682	int 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
1192	int SystemTableBuilder::initInstance(void)
1193	{
1194	return VERR_NOT_IMPLEMENTED;
1195	}
1196
1197
1198	int 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
1206	int SystemTableBuilder::addCpu(uint32_t idCpu)
1207	{
1208	RT_NOREF(idCpu);
1209	return VERR_NOT_IMPLEMENTED;
1210	}
1211
1212
1213	int SystemTableBuilder::addMemory(RTGCPHYS GCPhysStart, RTGCPHYS cbMem)
1214	{
1215	RT_NOREF(GCPhysStart, cbMem);
1216	return VERR_NOT_IMPLEMENTED;
1217	}
1218
1219
1220	int 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
1227	int 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
1234	int 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
1242	int SystemTableBuilder::configureClock(void)
1243	{
1244	return VERR_NOT_IMPLEMENTED;
1245	}
1246
1247
1248	int 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
1257	int 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
1264	int SystemTableBuilder::dumpTables(const char *pszFilename)
1265	{
1266	RT_NOREF(pszFilename);
1267	return VERR_NOT_IMPLEMENTED;
1268	}
1269
1270
1271	SystemTableBuilder *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.

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

Download in other formats: