SystemTableBuilder.cpp@ 107770

Last change on this file since 107770 was 107770, checked in by vboxsync, 3 weeks ago
Main/src-client/SystemTableBuilder.cpp: Missing error checks, bugref:3409
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 50.4 KB

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

Note: See TracBrowser for help on using the repository browser.

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

Download in other formats: