SystemTableBuilder.cpp@ 107491

Last change on this file since 107491 was 107065, checked in by vboxsync, 2 months ago
Main/SystemTableBuilder: Finish generating the TPM PPI ACPI bytecode, bugref:10777
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 107065 2024-11-20 20:22:49Z 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
409	/* For the ECAM base we need to define a new device with a new resource template inside the PCI device. */
410	RTAcpiTblDeviceStart(m_hAcpiDsdt, "RES0");
411
412	RTAcpiTblNameAppend(m_hAcpiDsdt, "_HID");
413	RTAcpiTblStringAppend(m_hAcpiDsdt, "PNP0C02");
414
415	RTAcpiTblNameAppend(m_hAcpiDsdt, "_CRS");
416	RTAcpiResourceReset(m_hAcpiRes);
417	vrc = RTAcpiResourceAddQWordMemoryRange(m_hAcpiRes, kAcpiResMemRangeCacheability_NonCacheable, kAcpiResMemType_Memory, true /fRw/,
418	fAddrSpace, GCPhysMmioEcam, GCPhysMmioEcam + cbPciMmioEcam - 1,
419	0 /u64OffTrans/, 0 /u64Granularity/, cbPciMmioEcam);
420	if (RT_SUCCESS(vrc))
421	{
422	vrc = RTAcpiResourceSeal(m_hAcpiRes);
423	if (RT_SUCCESS(vrc))
424	vrc = RTAcpiTblResourceAppend(m_hAcpiDsdt, m_hAcpiRes);
425	}
426
427	/* Finish RES0 device. */
428	vrc = RTAcpiTblDeviceFinalize(m_hAcpiDsdt);
429	AssertRCReturn(vrc, vrc);
430
431	/* Build the PCI interrupt routing table (_PRT). */
432	RTAcpiTblNameAppend(m_hAcpiDsdt, "_PRT");
433	RTAcpiTblPackageStart(m_hAcpiDsdt, 32 * 4);
434
435	uint32_t iIrqPinSwizzle = 0;
436
437	for (uint32_t i = 0; i < 32; i++)
438	{
439	for (uint32_t iIrqPin = 0; iIrqPin < 4; iIrqPin++)
440	{
441	RTAcpiTblPackageStart(m_hAcpiDsdt, 4);
442	RTAcpiTblIntegerAppend(m_hAcpiDsdt, (i << 16) \| 0xffff); /* ACPI PCI address. */
443	RTAcpiTblIntegerAppend(m_hAcpiDsdt, iIrqPin); /* Interrupt pin (INTA, INTB, ...). */
444	RTAcpiTblIntegerAppend(m_hAcpiDsdt, 0); /* Interrupt destination, unused. */
445	RTAcpiTblIntegerAppend(m_hAcpiDsdt, GIC_INTID_RANGE_SPI_START
446	+ aPinIrqs[(iIrqPinSwizzle + iIrqPin) % 4]); /* GSI of the interrupt. */
447	RTAcpiTblPackageFinalize(m_hAcpiDsdt);
448	}
449
450	iIrqPinSwizzle++;
451	}
452
453	RTAcpiTblPackageFinalize(m_hAcpiDsdt);
454
455	/* Create _CBA for the ECAM base. */
456	RTAcpiTblNameAppend(m_hAcpiDsdt, "_CBA");
457	RTAcpiTblIntegerAppend(m_hAcpiDsdt, GCPhysMmioEcam);
458
459	return RTAcpiTblDeviceFinalize(m_hAcpiDsdt);
460	}
461
462
463	int SystemTableBuilderAcpi::dumpTables(const char *pszFilename)
464	{
465	return RTAcpiTblDumpToFile(m_hAcpiDsdt, pszFilename);
466	}
467
468
469	int SystemTableBuilderAcpi::buildMadt(RTVFSIOSTREAM hVfsIos, size_t *pcbMadt)
470	{
471	uint8_t abMadt[_4K];
472	uint32_t cbMadt = 0;
473
474	RT_ZERO(abMadt);
475
476	PACPIMADT pMadt = (PACPIMADT)&abMadt[0];
477	PACPIMADTGICC pGicc = (PACPIMADTGICC)(pMadt + 1);
478
479	cbMadt += sizeof(*pMadt);
480
481	/* Include a GIC CPU interface for each CPU. */
482	for (uint32_t i = 0; i < m_cCpus; i++)
483	{
484	pGicc->bType = ACPI_MADT_INTR_CTRL_TYPE_GICC;
485	pGicc->cbThis = sizeof(*pGicc);
486	pGicc->u32CpuId = i;
487	pGicc->u32AcpiCpuUid = i;
488	pGicc->fGicc = ACPI_MADT_GICC_F_ENABLED;
489	pGicc->u64Mpidr = i;
490
491	cbMadt += sizeof(*pGicc);
492	pGicc++;
493	}
494
495	/* Build the GICD. */
496	PACPIMADTGICD pGicd = (PACPIMADTGICD)pGicc;
497	pGicd->bType = ACPI_MADT_INTR_CTRL_TYPE_GICD;
498	pGicd->cbThis = sizeof(*pGicd);
499	pGicd->u64PhysAddrBase = m_GCPhysIntcDist;
500	pGicd->bGicVersion = ACPI_MADT_GICD_VERSION_GICv3;
501
502	cbMadt += sizeof(*pGicd);
503
504	/* Build the GICR. */
505	PACPIMADTGICR pGicr = (PACPIMADTGICR)(pGicd + 1);
506	pGicr->bType = ACPI_MADT_INTR_CTRL_TYPE_GICR;
507	pGicr->cbThis = sizeof(*pGicr);
508	pGicr->u64PhysAddrGicrRangeBase = m_GCPhysIntcReDist;
509	pGicr->cbGicrRange = m_cbMmioIntcReDist;
510
511	cbMadt += sizeof(*pGicr);
512
513	/* Finalize the MADT. */
514	pMadt->Hdr.u32Signature = ACPI_TABLE_HDR_SIGNATURE_APIC;
515	pMadt->Hdr.cbTbl = cbMadt;
516	pMadt->Hdr.bRevision = 6;
517	pMadt->Hdr.bChkSum = 0;
518	pMadt->Hdr.u32OemRevision = 1;
519	pMadt->Hdr.u32CreatorRevision = 1;
520
521	memcpy(&pMadt->Hdr.abOemId[0], "ORCLVB", 6);
522	memcpy(&pMadt->Hdr.abOemTblId[0], "ORCL", 4);
523	memcpy(&pMadt->Hdr.abOemTblId[4], &pMadt->Hdr.u32Signature, 4);
524	memcpy(&pMadt->Hdr.abCreatorId[0], "ORCL", 4);
525	RTAcpiTblHdrChecksumGenerate(&pMadt->Hdr, cbMadt);
526	*pcbMadt = cbMadt;
527	return RTVfsIoStrmWrite(hVfsIos, pMadt, cbMadt, true /fBlocking/, NULL /pcbWritten/);
528	}
529
530
531	int SystemTableBuilderAcpi::buildMcfg(RTVFSIOSTREAM hVfsIos, size_t *pcbMcfg)
532	{
533	uint8_t abMcfg[_1K];
534	uint32_t cbMcfg = 0;
535
536	RT_ZERO(abMcfg);
537
538	PACPIMCFG pMcfg = (PACPIMCFG)&abMcfg[0];
539	PACPIMCFGALLOC pAlloc = (PACPIMCFGALLOC)(pMcfg + 1);
540
541	cbMcfg += sizeof(pMcfg) + sizeof(pAlloc);
542
543	pAlloc->u64PhysAddrBase = m_GCPhysPciMmioEcam;
544	pAlloc->u16PciSegGrpNr = 0;
545	pAlloc->bPciBusFirst = 0;
546	pAlloc->bPciBusLast = m_bPciBusMax;
547
548	/* Finalize the MADT. */
549	pMcfg->Hdr.u32Signature = ACPI_TABLE_HDR_SIGNATURE_RSVD_MCFG;
550	pMcfg->Hdr.cbTbl = cbMcfg;
551	pMcfg->Hdr.bRevision = 6;
552	pMcfg->Hdr.bChkSum = 0;
553	pMcfg->Hdr.u32OemRevision = 1;
554	pMcfg->Hdr.u32CreatorRevision = 1;
555
556	memcpy(&pMcfg->Hdr.abOemId[0], "ORCLVB", 6);
557	memcpy(&pMcfg->Hdr.abOemTblId[0], "ORCL", 4);
558	memcpy(&pMcfg->Hdr.abOemTblId[4], &pMcfg->Hdr.u32Signature, 4);
559	memcpy(&pMcfg->Hdr.abCreatorId[0], "ORCL", 4);
560	RTAcpiTblHdrChecksumGenerate(&pMcfg->Hdr, cbMcfg);
561	*pcbMcfg = cbMcfg;
562	return RTVfsIoStrmWrite(hVfsIos, pMcfg, cbMcfg, true /fBlocking/, NULL /pcbWritten/);
563	}
564
565
566	int SystemTableBuilderAcpi::buildGtdt(RTVFSIOSTREAM hVfsIos, size_t *pcbGtdt)
567	{
568	ACPIGTDT Gtdt; RT_ZERO(Gtdt);
569
570	#if 1
571	Gtdt.u64PhysAddrCntControlBase = UINT64_MAX;
572	Gtdt.u32Rsvd = 0;
573	Gtdt.u32El1SecTimerGsiv = 0;
574	Gtdt.fEl1SecTimer = 0;
575	Gtdt.u32El1NonSecTimerGsiv = 0x1a; /** @todo */
576	Gtdt.fEl1NonSecTimer = ACPI_GTDT_TIMER_F_INTR_MODE_LEVEL \| ACPI_GTDT_TIMER_F_INTR_POLARITY_ACTIVE_HIGH \| ACPI_GTDT_TIMER_F_ALWAYS_ON_CAP;
577	Gtdt.u32El1VirtTimerGsiv = 0x1b; /** @todo */
578	Gtdt.fEl1VirtTimer = ACPI_GTDT_TIMER_F_INTR_MODE_LEVEL \| ACPI_GTDT_TIMER_F_INTR_POLARITY_ACTIVE_HIGH;
579	Gtdt.u32El2TimerGsiv = 0x1e;
580	Gtdt.fEl2Timer = ACPI_GTDT_TIMER_F_INTR_MODE_LEVEL \| ACPI_GTDT_TIMER_F_INTR_POLARITY_ACTIVE_HIGH;
581	Gtdt.u64PhysAddrCndReadBase = UINT64_MAX;
582	Gtdt.cPlatformTimers = 0;
583	Gtdt.offPlatformTimers = 0;
584	Gtdt.u32El2VirtTimerGsiv = 0;
585	Gtdt.fEl2VirtTimer = 0;
586	#else /* Nested virt config on AppleSilicon. */
587	Gtdt.u64PhysAddrCntControlBase = UINT64_MAX;
588	Gtdt.u32Rsvd = 0;
589	Gtdt.u32El1SecTimerGsiv = 0;
590	Gtdt.fEl1SecTimer = 0;
591	Gtdt.u32El1NonSecTimerGsiv = 0x1e; /** @todo */
592	Gtdt.fEl1NonSecTimer = ACPI_GTDT_TIMER_F_INTR_MODE_LEVEL \| ACPI_GTDT_TIMER_F_INTR_POLARITY_ACTIVE_HIGH \| ACPI_GTDT_TIMER_F_ALWAYS_ON_CAP;
593	Gtdt.u32El1VirtTimerGsiv = 0x1b; /** @todo */
594	Gtdt.fEl1VirtTimer = ACPI_GTDT_TIMER_F_INTR_MODE_LEVEL \| ACPI_GTDT_TIMER_F_INTR_POLARITY_ACTIVE_HIGH;
595	Gtdt.u32El2TimerGsiv = 0x1a;
596	Gtdt.fEl2Timer = ACPI_GTDT_TIMER_F_INTR_MODE_LEVEL \| ACPI_GTDT_TIMER_F_INTR_POLARITY_ACTIVE_HIGH;
597	Gtdt.u64PhysAddrCndReadBase = UINT64_MAX;
598	Gtdt.cPlatformTimers = 0;
599	Gtdt.offPlatformTimers = 0;
600	Gtdt.u32El2VirtTimerGsiv = 0;
601	Gtdt.fEl2VirtTimer = 0;
602	#endif
603
604	Gtdt.Hdr.u32Signature = ACPI_TABLE_HDR_SIGNATURE_GTDT;
605	Gtdt.Hdr.cbTbl = sizeof(Gtdt);
606	Gtdt.Hdr.bRevision = 6;
607	Gtdt.Hdr.bChkSum = 0;
608	Gtdt.Hdr.u32OemRevision = 1;
609	Gtdt.Hdr.u32CreatorRevision = 1;
610
611	memcpy(&Gtdt.Hdr.abOemId[0], "ORCLVB", 6);
612	memcpy(&Gtdt.Hdr.abOemTblId[0], "ORCL", 4);
613	memcpy(&Gtdt.Hdr.abOemTblId[4], &Gtdt.Hdr.u32Signature, 4);
614	memcpy(&Gtdt.Hdr.abCreatorId[0], "ORCL", 4);
615	RTAcpiTblHdrChecksumGenerate(&Gtdt.Hdr, sizeof(Gtdt));
616	*pcbGtdt = sizeof(Gtdt);
617	return RTVfsIoStrmWrite(hVfsIos, &Gtdt, sizeof(Gtdt), true /fBlocking/, NULL /pcbWritten/);
618	}
619
620
621	int SystemTableBuilderAcpi::buildFadt(RTVFSIOSTREAM hVfsIos, RTGCPHYS GCPhysXDsdt, size_t *pcbFadt)
622	{
623	/* Build FADT. */
624	ACPIFADT Fadt; RT_ZERO(Fadt);
625
626	Fadt.fFeatures = ACPI_FADT_F_HW_REDUCED_ACPI;
627	Fadt.fArmBootArch = ACPI_FADT_ARM_BOOT_ARCH_F_PSCI_COMP
628	\| ACPI_FADT_ARM_BOOT_ARCH_F_PSCI_USE_HVC;
629	Fadt.bFadtVersionMinor = 3;
630	Fadt.u64AddrXDsdt = GCPhysXDsdt;
631
632	Fadt.Hdr.u32Signature = ACPI_TABLE_HDR_SIGNATURE_FACP;
633	Fadt.Hdr.cbTbl = sizeof(Fadt);
634	Fadt.Hdr.bRevision = 6;
635	Fadt.Hdr.bChkSum = 0;
636	Fadt.Hdr.u32OemRevision = 1;
637	Fadt.Hdr.u32CreatorRevision = 1;
638
639	memcpy(&Fadt.Hdr.abOemId[0], "ORCLVB", 6);
640	memcpy(&Fadt.Hdr.abOemTblId[0], "ORCL", 4);
641	memcpy(&Fadt.Hdr.abOemTblId[4], &Fadt.Hdr.u32Signature, 4);
642	memcpy(&Fadt.Hdr.abCreatorId[0], "ORCL", 4);
643	RTAcpiTblHdrChecksumGenerate(&Fadt.Hdr, sizeof(Fadt));
644	*pcbFadt = sizeof(Fadt);
645	return RTVfsIoStrmWrite(hVfsIos, &Fadt, sizeof(Fadt), true /fBlocking/, NULL /pcbWritten/);
646	}
647
648
649	int SystemTableBuilderAcpi::buildTpm20(RTVFSIOSTREAM hVfsIos, size_t *pcbTpm20)
650	{
651	Assert(m_fTpm20);
652
653	ACPITPM20 Tpm2;
654	RT_ZERO(Tpm2);
655
656	Tpm2.u32StartMethod = m_fCrb ? ACPITBL_TPM20_START_METHOD_CRB : ACPITBL_TPM20_START_METHOD_TIS12;
657	Tpm2.u64BaseAddrCrbOrFifo = m_fCrb ? m_GCPhysTpm20Mmio + TPM_CRB_LOCALITY_REG_CTRL_REQ : m_GCPhysTpm20Mmio;
658	Tpm2.u16PlatCls = ACPITBL_TPM20_PLAT_CLS_CLIENT;
659
660	Tpm2.Hdr.u32Signature = ACPI_TABLE_HDR_SIGNATURE_RSVD_TPM2;
661	Tpm2.Hdr.cbTbl = sizeof(Tpm2);
662	Tpm2.Hdr.bRevision = ACPI_TPM20_REVISION;
663	Tpm2.Hdr.bChkSum = 0;
664	Tpm2.Hdr.u32OemRevision = 1;
665	Tpm2.Hdr.u32CreatorRevision = 1;
666
667	memcpy(&Tpm2.Hdr.abOemId[0], "ORCLVB", 6);
668	memcpy(&Tpm2.Hdr.abOemTblId[0], "ORCL", 4);
669	memcpy(&Tpm2.Hdr.abOemTblId[4], &Tpm2.Hdr.u32Signature, 4);
670	memcpy(&Tpm2.Hdr.abCreatorId[0], "ORCL", 4);
671	RTAcpiTblHdrChecksumGenerate(&Tpm2.Hdr, sizeof(Tpm2));
672	*pcbTpm20 = sizeof(Tpm2);
673	return RTVfsIoStrmWrite(hVfsIos, &Tpm2, sizeof(Tpm2), true /fBlocking/, NULL /pcbWritten/);
674	}
675
676
677	int SystemTableBuilderAcpi::configureTpm2(bool fCrb, RTGCPHYS GCPhysMmioStart, RTGCPHYS cbMmio, uint32_t u32Irq)
678	{
679	m_fTpm20 = true;
680	m_fCrb = fCrb;
681	m_GCPhysTpm20Mmio = GCPhysMmioStart;
682
683	RTAcpiTblDeviceStartF(m_hAcpiDsdt, "TPM0");
684
685	RTAcpiTblNameAppend(m_hAcpiDsdt, "_HID");
686	RTAcpiTblStringAppend(m_hAcpiDsdt, "MSFT0101");
687
688	RTAcpiTblNameAppend(m_hAcpiDsdt, "_CID");
689	RTAcpiTblStringAppend(m_hAcpiDsdt, "MSFT0101");
690
691	RTAcpiTblNameAppend(m_hAcpiDsdt, "_STR");
692	RTAcpiTblStringAppend(m_hAcpiDsdt, "TPM 2.0 Device");
693
694	RTAcpiTblNameAppend(m_hAcpiDsdt, "_UID");
695	RTAcpiTblIntegerAppend(m_hAcpiDsdt, 0);
696
697	RTAcpiTblNameAppend(m_hAcpiDsdt, "_CRS");
698	int vrc = systemTableAcpiMmioDevResource(m_hAcpiDsdt, m_hAcpiRes, GCPhysMmioStart, cbMmio, u32Irq + GIC_INTID_RANGE_SPI_START);
699	AssertRCReturn(vrc, vrc);
700
701	RTAcpiTblMethodStart(m_hAcpiDsdt, "_STA", 0, RTACPI_METHOD_F_NOT_SERIALIZED, 0 /uSyncLvl/);
702	RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Return);
703	RTAcpiTblIntegerAppend(m_hAcpiDsdt, 0x0f);
704	RTAcpiTblMethodFinalize(m_hAcpiDsdt);
705
706	/* Build the PPI interface (this is as a verbatim translation from src/VBox/Devices/PC/vbox-tpm.dsl as possible). */
707	RTAcpiTblMethodStart(m_hAcpiDsdt, "TPFS", 1, RTACPI_METHOD_F_SERIALIZED, 0 /uSyncLvl/);
708
709	RTAcpiTblIfStart(m_hAcpiDsdt);
710	/* LGreaterEqual(Arg0, 0x100). */
711	RTAcpiTblBinaryOpAppend(m_hAcpiDsdt, kAcpiBinaryOp_LGreaterEqual);
712	RTAcpiTblArgOpAppend(m_hAcpiDsdt, 0);
713	RTAcpiTblIntegerAppend(m_hAcpiDsdt, 0x100);
714
715	RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Return);
716	RTAcpiTblIntegerAppend(m_hAcpiDsdt, 0);
717	RTAcpiTblIfFinalize(m_hAcpiDsdt);
718
719	RTAcpiTblOpRegionAppendEx(m_hAcpiDsdt, "TPP1", kAcpiOperationRegionSpace_SystemMemory);
720	RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Add); /* Region offset */
721	RTAcpiTblIntegerAppend(m_hAcpiDsdt, m_GCPhysTpm20Mmio + 0x5000);
722	RTAcpiTblArgOpAppend(m_hAcpiDsdt, 0); /* Arg0 */
723	RTAcpiTblNullNameAppend(m_hAcpiDsdt); /* Target -> NullName */
724	RTAcpiTblIntegerAppend(m_hAcpiDsdt, 1); /* Region size */
725
726	/* Define the field accessor. */
727	const RTACPIFIELDENTRY aPpiTpp1Fields[] =
728	{
729	{ "TPPF", 8 },
730	};
731	RTAcpiTblFieldAppend(m_hAcpiDsdt, "TPP1", kAcpiFieldAcc_Any, false /fLock/, kAcpiFieldUpdate_Preserve,
732	&aPpiTpp1Fields[0], RT_ELEMENTS(aPpiTpp1Fields));
733	RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Return);
734	RTAcpiTblNameStringAppend(m_hAcpiDsdt, "TPPF");
735
736	RTAcpiTblMethodFinalize(m_hAcpiDsdt);
737
738
739	/* Device specific method. */
740	RTAcpiTblMethodStart(m_hAcpiDsdt, "_DSM", 4, RTACPI_METHOD_F_SERIALIZED, 0 /uSyncLvl/);
741
742	/* Define the MMIO region for the PPI interface. */
743	RTAcpiTblOpRegionAppend(m_hAcpiDsdt, "TPMP", kAcpiOperationRegionSpace_SystemMemory,
744	m_GCPhysTpm20Mmio + 0x5100, 0x5a /cbRegion/);
745
746	/* Define the field accessors for the PPI interface. */
747	const RTACPIFIELDENTRY aPpiFields[] =
748	{
749	{ "PPIN", 8 },
750	{ "PPIP", 32 },
751	{ "PPRP", 32 },
752	{ "PPRQ", 32 },
753	{ "PPRM", 32 },
754	{ "LPPR", 32 }
755	};
756	RTAcpiTblFieldAppend(m_hAcpiDsdt, "TPMP", kAcpiFieldAcc_Any, false /fLock/, kAcpiFieldUpdate_Preserve,
757	&aPpiFields[0], RT_ELEMENTS(aPpiFields));
758
759	/* Define some packages we need later on. */
760	RTAcpiTblNameAppend(m_hAcpiDsdt, "TPB2");
761	RTAcpiTblPackageStart(m_hAcpiDsdt, 2 /cElements/);
762	RTAcpiTblIntegerAppend(m_hAcpiDsdt, 0);
763	RTAcpiTblIntegerAppend(m_hAcpiDsdt, 0);
764	RTAcpiTblPackageFinalize(m_hAcpiDsdt);
765
766	RTAcpiTblNameAppend(m_hAcpiDsdt, "TPB3");
767	RTAcpiTblPackageStart(m_hAcpiDsdt, 3 /cElements/);
768	RTAcpiTblIntegerAppend(m_hAcpiDsdt, 0);
769	RTAcpiTblIntegerAppend(m_hAcpiDsdt, 0);
770	RTAcpiTblIntegerAppend(m_hAcpiDsdt, 0);
771	RTAcpiTblPackageFinalize(m_hAcpiDsdt);
772
773
774	/*
775	* Check that the UUID in Arg0 contains the Physical Presence Interface Specification UUID.
776	*/
777	RTAcpiTblIfStart(m_hAcpiDsdt);
778
779	/* Predicate (LEqual(Arg0, ToUUID("3dddfaa6-361b-4eb4-a424-8d10089d1653")))*/
780	RTAcpiTblBinaryOpAppend(m_hAcpiDsdt, kAcpiBinaryOp_LEqual);
781	RTAcpiTblArgOpAppend(m_hAcpiDsdt, 0);
782	RTAcpiTblUuidAppendFromStr(m_hAcpiDsdt, "3dddfaa6-361b-4eb4-a424-8d10089d1653");
783
784	/* Standard _DSM query function. */
785	RTAcpiTblIfStart(m_hAcpiDsdt);
786
787	/* LEqual(Arg2, Zero). */
788	RTAcpiTblBinaryOpAppend(m_hAcpiDsdt, kAcpiBinaryOp_LEqual);
789	RTAcpiTblArgOpAppend(m_hAcpiDsdt, 2);
790	RTAcpiTblIntegerAppend(m_hAcpiDsdt, 0);
791
792	RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Return);
793	uint8_t abDsmQuery[2] = { 0xff, 0x01 };
794	RTAcpiTblBufferAppend(m_hAcpiDsdt, &abDsmQuery[0], sizeof(abDsmQuery));
795
796	RTAcpiTblIfFinalize(m_hAcpiDsdt);
797
798	/* Query supported PPI revision . */
799	RTAcpiTblIfStart(m_hAcpiDsdt);
800
801	/* LEqual(Arg2, Zero). */
802	RTAcpiTblBinaryOpAppend(m_hAcpiDsdt, kAcpiBinaryOp_LEqual);
803	RTAcpiTblArgOpAppend(m_hAcpiDsdt, 2);
804	RTAcpiTblIntegerAppend(m_hAcpiDsdt, 1);
805
806	RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Return);
807	RTAcpiTblStringAppend(m_hAcpiDsdt, "1.3");
808
809	RTAcpiTblIfFinalize(m_hAcpiDsdt);
810
811
812	/* Submit TPM Operation Requested to pre-OS environment. */
813	RTAcpiTblIfStart(m_hAcpiDsdt);
814
815	/* LEqual(Arg2, Zero). */
816	RTAcpiTblBinaryOpAppend(m_hAcpiDsdt, kAcpiBinaryOp_LEqual);
817	RTAcpiTblArgOpAppend(m_hAcpiDsdt, 2);
818	RTAcpiTblIntegerAppend(m_hAcpiDsdt, 2);
819
820	/* Store(DerefOf(Index(Arg3, Zero)), Local0) */
821	RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Store);
822	RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_DerefOf);
823	RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Index);
824	RTAcpiTblArgOpAppend(m_hAcpiDsdt, 3); /* Arg3 */
825	RTAcpiTblIntegerAppend(m_hAcpiDsdt, 0); /* Zero */
826	RTAcpiTblNullNameAppend(m_hAcpiDsdt); /* Target -> NullName */
827	RTAcpiTblLocalOpAppend(m_hAcpiDsdt, 0); /* Local0 */
828
829	/* Store (TPFS (Local0), Local1) */
830	RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Store);
831	RTAcpiTblNameStringAppend(m_hAcpiDsdt, "TPFS");
832	RTAcpiTblLocalOpAppend(m_hAcpiDsdt, 0); /* Local0 */
833	RTAcpiTblLocalOpAppend(m_hAcpiDsdt, 1); /* Local1 */
834
835	/* If (LEqual (And (Local1, 0x07), Zero)) */
836	RTAcpiTblIfStart(m_hAcpiDsdt);
837	RTAcpiTblBinaryOpAppend(m_hAcpiDsdt, kAcpiBinaryOp_LEqual);
838	RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_And);
839	RTAcpiTblLocalOpAppend(m_hAcpiDsdt, 1); /* Local1 */
840	RTAcpiTblIntegerAppend(m_hAcpiDsdt, 0x7);
841	RTAcpiTblNullNameAppend(m_hAcpiDsdt); /* Target -> NullName */
842	RTAcpiTblIntegerAppend(m_hAcpiDsdt, 0);
843
844	RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Return);
845	RTAcpiTblIntegerAppend(m_hAcpiDsdt, 1);
846
847	RTAcpiTblIfFinalize(m_hAcpiDsdt);
848
849	/* Store (Local0, PPRQ) */
850	RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Store);
851	RTAcpiTblLocalOpAppend(m_hAcpiDsdt, 0); /* Local0 */
852	RTAcpiTblNameStringAppend(m_hAcpiDsdt, "PPRQ");
853	/* Store (Zero, PPRM) */
854	RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Store);
855	RTAcpiTblIntegerAppend(m_hAcpiDsdt, 0);
856	RTAcpiTblNameStringAppend(m_hAcpiDsdt, "PPRM");
857
858	RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Return);
859	RTAcpiTblIntegerAppend(m_hAcpiDsdt, 0);
860
861	RTAcpiTblIfFinalize(m_hAcpiDsdt);
862
863
864	/* Get Pending TPM Operation Requested by the OS. */
865	RTAcpiTblIfStart(m_hAcpiDsdt);
866
867	/* LEqual(Arg2, Zero). */
868	RTAcpiTblBinaryOpAppend(m_hAcpiDsdt, kAcpiBinaryOp_LEqual);
869	RTAcpiTblArgOpAppend(m_hAcpiDsdt, 2);
870	RTAcpiTblIntegerAppend(m_hAcpiDsdt, 3);
871
872	RTAcpiTblIfStart(m_hAcpiDsdt);
873
874	/* LEqual(Arg1, One). */
875	RTAcpiTblBinaryOpAppend(m_hAcpiDsdt, kAcpiBinaryOp_LEqual);
876	RTAcpiTblArgOpAppend(m_hAcpiDsdt, 1);
877	RTAcpiTblIntegerAppend(m_hAcpiDsdt, 1);
878
879	/* Store (PPRQ, Index(TPB2, One) */
880	RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Store);
881	RTAcpiTblNameStringAppend(m_hAcpiDsdt, "PPRQ");
882	RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Index);
883	RTAcpiTblNameStringAppend(m_hAcpiDsdt, "TPB2");
884	RTAcpiTblIntegerAppend(m_hAcpiDsdt, 1);
885	RTAcpiTblNullNameAppend(m_hAcpiDsdt); /* Target -> NullName */
886
887	RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Return);
888	RTAcpiTblNameStringAppend(m_hAcpiDsdt, "TPB2");
889
890	RTAcpiTblIfFinalize(m_hAcpiDsdt);
891
892	RTAcpiTblIfStart(m_hAcpiDsdt);
893
894	/* LEqual(Arg1, 0x02). */
895	RTAcpiTblBinaryOpAppend(m_hAcpiDsdt, kAcpiBinaryOp_LEqual);
896	RTAcpiTblArgOpAppend(m_hAcpiDsdt, 1);
897	RTAcpiTblIntegerAppend(m_hAcpiDsdt, 2);
898
899	/* Store (PPRQ, Index(TPB3, One) */
900	RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Store);
901	RTAcpiTblNameStringAppend(m_hAcpiDsdt, "PPRQ");
902	RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Index);
903	RTAcpiTblNameStringAppend(m_hAcpiDsdt, "TPB3");
904	RTAcpiTblIntegerAppend(m_hAcpiDsdt, 1);
905	RTAcpiTblNullNameAppend(m_hAcpiDsdt); /* Target -> NullName */
906
907	/* Store (PPRM, Index(TPB3, 0x2) */
908	RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Store);
909	RTAcpiTblNameStringAppend(m_hAcpiDsdt, "PPRM");
910	RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Index);
911	RTAcpiTblNameStringAppend(m_hAcpiDsdt, "TPB3");
912	RTAcpiTblIntegerAppend(m_hAcpiDsdt, 2);
913	RTAcpiTblNullNameAppend(m_hAcpiDsdt); /* Target -> NullName */
914
915	RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Return);
916	RTAcpiTblNameStringAppend(m_hAcpiDsdt, "TPB2");
917
918	RTAcpiTblIfFinalize(m_hAcpiDsdt);
919
920	RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Return);
921	RTAcpiTblNameStringAppend(m_hAcpiDsdt, "TPB3");
922
923	RTAcpiTblIfFinalize(m_hAcpiDsdt);
924
925
926	/* Get Platform-specific Action to Transition to Pre-OS Environment. */
927	RTAcpiTblIfStart(m_hAcpiDsdt);
928
929	/* LEqual(Arg2, Zero). */
930	RTAcpiTblBinaryOpAppend(m_hAcpiDsdt, kAcpiBinaryOp_LEqual);
931	RTAcpiTblArgOpAppend(m_hAcpiDsdt, 2);
932	RTAcpiTblIntegerAppend(m_hAcpiDsdt, 4);
933
934	RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Return);
935	RTAcpiTblIntegerAppend(m_hAcpiDsdt, 2); /* Reboot */
936
937	RTAcpiTblIfFinalize(m_hAcpiDsdt);
938
939
940	/* Return TPM Operation Response to OS Environment. */
941	RTAcpiTblIfStart(m_hAcpiDsdt);
942
943	/* LEqual(Arg2, Zero). */
944	RTAcpiTblBinaryOpAppend(m_hAcpiDsdt, kAcpiBinaryOp_LEqual);
945	RTAcpiTblArgOpAppend(m_hAcpiDsdt, 2);
946	RTAcpiTblIntegerAppend(m_hAcpiDsdt, 5);
947
948	/* Store (LPPR, Index(TPB3, One) */
949	RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Store);
950	RTAcpiTblNameStringAppend(m_hAcpiDsdt, "LPPR");
951	RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Index);
952	RTAcpiTblNameStringAppend(m_hAcpiDsdt, "TPB3");
953	RTAcpiTblIntegerAppend(m_hAcpiDsdt, 1);
954	RTAcpiTblNullNameAppend(m_hAcpiDsdt); /* Target -> NullName */
955
956	/* Store (PPRP, Index(TPB3, 0x2) */
957	RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Store);
958	RTAcpiTblNameStringAppend(m_hAcpiDsdt, "PPRP");
959	RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Index);
960	RTAcpiTblNameStringAppend(m_hAcpiDsdt, "TPB3");
961	RTAcpiTblIntegerAppend(m_hAcpiDsdt, 2);
962	RTAcpiTblNullNameAppend(m_hAcpiDsdt); /* Target -> NullName */
963
964	RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Return);
965	RTAcpiTblNameStringAppend(m_hAcpiDsdt, "TPB3");
966
967	RTAcpiTblIfFinalize(m_hAcpiDsdt);
968
969
970	/* Submit Preferred user language - deprecated. */
971	RTAcpiTblIfStart(m_hAcpiDsdt);
972
973	/* LEqual(Arg2, Zero). */
974	RTAcpiTblBinaryOpAppend(m_hAcpiDsdt, kAcpiBinaryOp_LEqual);
975	RTAcpiTblArgOpAppend(m_hAcpiDsdt, 2);
976	RTAcpiTblIntegerAppend(m_hAcpiDsdt, 6);
977
978	RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Return);
979	RTAcpiTblIntegerAppend(m_hAcpiDsdt, 3); /* Not implemented */
980
981	RTAcpiTblIfFinalize(m_hAcpiDsdt);
982
983
984	/* Submit TPM Operation Request to Pre-OS Environment 2. */
985	RTAcpiTblIfStart(m_hAcpiDsdt);
986
987	/* LEqual(Arg2, Zero). */
988	RTAcpiTblBinaryOpAppend(m_hAcpiDsdt, kAcpiBinaryOp_LEqual);
989	RTAcpiTblArgOpAppend(m_hAcpiDsdt, 2);
990	RTAcpiTblIntegerAppend(m_hAcpiDsdt, 7);
991
992	/* Store(DerefOf(Index(Arg3, Zero)), Local0) */
993	RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Store);
994	RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_DerefOf);
995	RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Index);
996	RTAcpiTblArgOpAppend(m_hAcpiDsdt, 3); /* Arg3 */
997	RTAcpiTblIntegerAppend(m_hAcpiDsdt, 0); /* Zero */
998	RTAcpiTblNullNameAppend(m_hAcpiDsdt); /* Target -> NullName */
999	RTAcpiTblLocalOpAppend(m_hAcpiDsdt, 0); /* Local0 */
1000
1001	/* Store (TPFS (Local0), Local1) */
1002	RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Store);
1003	RTAcpiTblNameStringAppend(m_hAcpiDsdt, "TPFS");
1004	RTAcpiTblLocalOpAppend(m_hAcpiDsdt, 0); /* Local0 */
1005	RTAcpiTblLocalOpAppend(m_hAcpiDsdt, 1); /* Local1 */
1006
1007	/* Store(And(Local1, 0x07), Local1) */
1008	RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Store);
1009	RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_And);
1010	RTAcpiTblLocalOpAppend(m_hAcpiDsdt, 1); /* Local1 */
1011	RTAcpiTblIntegerAppend(m_hAcpiDsdt, 0x7);
1012	RTAcpiTblNullNameAppend(m_hAcpiDsdt); /* Target -> NullName */
1013	RTAcpiTblLocalOpAppend(m_hAcpiDsdt, 1); /* Local1 */
1014
1015	/* LEqual(Local1, Zero) */
1016	RTAcpiTblIfStart(m_hAcpiDsdt);
1017
1018	RTAcpiTblBinaryOpAppend(m_hAcpiDsdt, kAcpiBinaryOp_LEqual);
1019	RTAcpiTblLocalOpAppend(m_hAcpiDsdt, 1);
1020	RTAcpiTblIntegerAppend(m_hAcpiDsdt, 0);
1021
1022	RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Return);
1023	RTAcpiTblIntegerAppend(m_hAcpiDsdt, 1);
1024
1025	RTAcpiTblIfFinalize(m_hAcpiDsdt);
1026
1027	/* LEqual(Local1, 2) */
1028	RTAcpiTblIfStart(m_hAcpiDsdt);
1029
1030	RTAcpiTblBinaryOpAppend(m_hAcpiDsdt, kAcpiBinaryOp_LEqual);
1031	RTAcpiTblLocalOpAppend(m_hAcpiDsdt, 1);
1032	RTAcpiTblIntegerAppend(m_hAcpiDsdt, 2);
1033
1034	RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Return);
1035	RTAcpiTblIntegerAppend(m_hAcpiDsdt, 3);
1036
1037	RTAcpiTblIfFinalize(m_hAcpiDsdt);
1038
1039	/* LEqual(Arg1, One) */
1040	RTAcpiTblIfStart(m_hAcpiDsdt);
1041
1042	RTAcpiTblBinaryOpAppend(m_hAcpiDsdt, kAcpiBinaryOp_LEqual);
1043	RTAcpiTblArgOpAppend(m_hAcpiDsdt, 1);
1044	RTAcpiTblIntegerAppend(m_hAcpiDsdt, 1);
1045
1046	/* Store(Local0, PPRQ) */
1047	RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Store);
1048	RTAcpiTblLocalOpAppend(m_hAcpiDsdt, 0);
1049	RTAcpiTblNameStringAppend(m_hAcpiDsdt, "PPRQ");
1050
1051	/* Store(Zero, PPRM) */
1052	RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Store);
1053	RTAcpiTblIntegerAppend(m_hAcpiDsdt, 0);
1054	RTAcpiTblNameStringAppend(m_hAcpiDsdt, "PPRM");
1055
1056	RTAcpiTblIfFinalize(m_hAcpiDsdt);
1057
1058	/* LEqual(Arg1, 2) */
1059	RTAcpiTblIfStart(m_hAcpiDsdt);
1060
1061	RTAcpiTblBinaryOpAppend(m_hAcpiDsdt, kAcpiBinaryOp_LEqual);
1062	RTAcpiTblArgOpAppend(m_hAcpiDsdt, 1);
1063	RTAcpiTblIntegerAppend(m_hAcpiDsdt, 2);
1064
1065	/* Store(DerefOf(Index(Arg3, One)), Local2) */
1066	RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Store);
1067	RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_DerefOf);
1068	RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Index);
1069	RTAcpiTblArgOpAppend(m_hAcpiDsdt, 3); /* Arg3 */
1070	RTAcpiTblIntegerAppend(m_hAcpiDsdt, 1); /* ONe */
1071	RTAcpiTblNullNameAppend(m_hAcpiDsdt); /* Target -> NullName */
1072	RTAcpiTblLocalOpAppend(m_hAcpiDsdt, 2); /* Local2 */
1073
1074	/* Store(Local0, PPRQ) */
1075	RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Store);
1076	RTAcpiTblLocalOpAppend(m_hAcpiDsdt, 0);
1077	RTAcpiTblNameStringAppend(m_hAcpiDsdt, "PPRQ");
1078
1079	/* Store(Local2, PPRM) */
1080	RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Store);
1081	RTAcpiTblLocalOpAppend(m_hAcpiDsdt, 2);
1082	RTAcpiTblNameStringAppend(m_hAcpiDsdt, "PPRM");
1083
1084	RTAcpiTblIfFinalize(m_hAcpiDsdt);
1085
1086	RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Return);
1087	RTAcpiTblIntegerAppend(m_hAcpiDsdt, 0);
1088
1089	RTAcpiTblIfFinalize(m_hAcpiDsdt);
1090
1091
1092	/* Get User Confirmation Status for Operation. */
1093	RTAcpiTblIfStart(m_hAcpiDsdt);
1094
1095	/* LEqual(Arg2, Zero). */
1096	RTAcpiTblBinaryOpAppend(m_hAcpiDsdt, kAcpiBinaryOp_LEqual);
1097	RTAcpiTblArgOpAppend(m_hAcpiDsdt, 2);
1098	RTAcpiTblIntegerAppend(m_hAcpiDsdt, 8);
1099
1100	/* Store(DerefOf(Index(Arg3, Zero)), Local0) */
1101	RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Store);
1102	RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_DerefOf);
1103	RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Index);
1104	RTAcpiTblArgOpAppend(m_hAcpiDsdt, 3); /* Arg3 */
1105	RTAcpiTblIntegerAppend(m_hAcpiDsdt, 0); /* Zero */
1106	RTAcpiTblNullNameAppend(m_hAcpiDsdt); /* Target -> NullName */
1107	RTAcpiTblLocalOpAppend(m_hAcpiDsdt, 0); /* Local0 */
1108
1109	/* Store (TPFS (Local0), Local1) */
1110	RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Store);
1111	RTAcpiTblNameStringAppend(m_hAcpiDsdt, "TPFS");
1112	RTAcpiTblLocalOpAppend(m_hAcpiDsdt, 0); /* Local0 */
1113	RTAcpiTblLocalOpAppend(m_hAcpiDsdt, 1); /* Local1 */
1114
1115	RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Return);
1116	RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_And);
1117	RTAcpiTblLocalOpAppend(m_hAcpiDsdt, 1); /* Local1 */
1118	RTAcpiTblIntegerAppend(m_hAcpiDsdt, 0x7);
1119	RTAcpiTblNullNameAppend(m_hAcpiDsdt); /* Target -> NullName */
1120
1121	RTAcpiTblIfFinalize(m_hAcpiDsdt);
1122
1123
1124	/* Return Unknown function. */
1125	uint8_t bUnkFunc = 0x00;
1126	RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Return);
1127	RTAcpiTblBufferAppend(m_hAcpiDsdt, &bUnkFunc, sizeof(bUnkFunc));
1128
1129	RTAcpiTblIfFinalize(m_hAcpiDsdt);
1130
1131
1132	/*
1133	* TCG Platform Reset Attack Mitigation Specification interface.
1134	*/
1135	RTAcpiTblIfStart(m_hAcpiDsdt);
1136
1137	/* Predicate (LEqual(Arg0, ToUUID("376054ed-cc13-4675-901c-4756d7f2d45d")))*/
1138	RTAcpiTblBinaryOpAppend(m_hAcpiDsdt, kAcpiBinaryOp_LEqual);
1139	RTAcpiTblArgOpAppend(m_hAcpiDsdt, 0);
1140	RTAcpiTblUuidAppendFromStr(m_hAcpiDsdt, "376054ed-cc13-4675-901c-4756d7f2d45d");
1141
1142	/* Standard _DSM query function. */
1143	RTAcpiTblIfStart(m_hAcpiDsdt);
1144
1145	/* LEqual(Arg2, Zero). */
1146	RTAcpiTblBinaryOpAppend(m_hAcpiDsdt, kAcpiBinaryOp_LEqual);
1147	RTAcpiTblArgOpAppend(m_hAcpiDsdt, 2);
1148	RTAcpiTblIntegerAppend(m_hAcpiDsdt, 0);
1149
1150	RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Return);
1151	uint8_t bBuf = 0x03;
1152	RTAcpiTblBufferAppend(m_hAcpiDsdt, &bBuf, sizeof(bBuf));
1153
1154	RTAcpiTblIfFinalize(m_hAcpiDsdt);
1155
1156	/* Set Memory Overwrite Request (MOR) bit to specified value. */
1157	RTAcpiTblIfStart(m_hAcpiDsdt);
1158
1159	/* LEqual(Arg2, Zero). */
1160	RTAcpiTblBinaryOpAppend(m_hAcpiDsdt, kAcpiBinaryOp_LEqual);
1161	RTAcpiTblArgOpAppend(m_hAcpiDsdt, 2);
1162	RTAcpiTblIntegerAppend(m_hAcpiDsdt, 1);
1163
1164	RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Return);
1165	RTAcpiTblIntegerAppend(m_hAcpiDsdt, 0); /* Memory always zeroed on reset. */
1166
1167	RTAcpiTblIfFinalize(m_hAcpiDsdt);
1168
1169	/* Return Unknown function. */
1170	bUnkFunc = 0x00;
1171	RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Return);
1172	RTAcpiTblBufferAppend(m_hAcpiDsdt, &bUnkFunc, sizeof(bUnkFunc));
1173
1174	RTAcpiTblIfFinalize(m_hAcpiDsdt);
1175
1176	/* Return Unknown function. */
1177	bUnkFunc = 0x00;
1178	RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Return);
1179	RTAcpiTblBufferAppend(m_hAcpiDsdt, &bUnkFunc, sizeof(bUnkFunc));
1180
1181	RTAcpiTblMethodFinalize(m_hAcpiDsdt);
1182
1183	return RTAcpiTblDeviceFinalize(m_hAcpiDsdt);
1184	}
1185
1186
1187	int SystemTableBuilder::initInstance(void)
1188	{
1189	return VERR_NOT_IMPLEMENTED;
1190	}
1191
1192
1193	int SystemTableBuilder::finishTables(RTGCPHYS GCPhysTblsStart, RTVFSIOSTREAM hVfsIos,
1194	PRTGCPHYS pGCPhysTblRoot, size_t pcbTblRoot, size_t pcbTbls)
1195	{
1196	RT_NOREF(GCPhysTblsStart, hVfsIos, pGCPhysTblRoot, pcbTblRoot, pcbTbls);
1197	return VERR_NOT_IMPLEMENTED;
1198	}
1199
1200
1201	int SystemTableBuilder::addCpu(uint32_t idCpu)
1202	{
1203	RT_NOREF(idCpu);
1204	return VERR_NOT_IMPLEMENTED;
1205	}
1206
1207
1208	int SystemTableBuilder::addMemory(RTGCPHYS GCPhysStart, RTGCPHYS cbMem)
1209	{
1210	RT_NOREF(GCPhysStart, cbMem);
1211	return VERR_NOT_IMPLEMENTED;
1212	}
1213
1214
1215	int SystemTableBuilder::addMmioDeviceNoIrq(const char *pszVBoxName, uint32_t uInstance, RTGCPHYS GCPhysMmio, RTGCPHYS cbMmio)
1216	{
1217	RT_NOREF(pszVBoxName, uInstance, GCPhysMmio, cbMmio);
1218	return VERR_NOT_IMPLEMENTED;
1219	}
1220
1221
1222	int SystemTableBuilder::addMmioDevice(const char *pszVBoxName, uint32_t uInstance, RTGCPHYS GCPhysMmio, RTGCPHYS cbMmio, uint32_t u32Irq)
1223	{
1224	RT_NOREF(pszVBoxName, uInstance, GCPhysMmio, cbMmio, u32Irq);
1225	return VERR_NOT_IMPLEMENTED;
1226	}
1227
1228
1229	int SystemTableBuilder::configureGic(uint32_t cCpus, RTGCPHYS GCPhysIntcDist, RTGCPHYS cbMmioIntcDist, RTGCPHYS GCPhysIntcReDist,
1230	RTGCPHYS cbMmioIntcReDist)
1231	{
1232	RT_NOREF(cCpus, GCPhysIntcDist, cbMmioIntcDist, GCPhysIntcReDist, cbMmioIntcReDist);
1233	return VERR_NOT_IMPLEMENTED;
1234	}
1235
1236
1237	int SystemTableBuilder::configureClock(void)
1238	{
1239	return VERR_NOT_IMPLEMENTED;
1240	}
1241
1242
1243	int SystemTableBuilder::configurePcieRootBus(const char *pszVBoxName, uint32_t aPinIrqs[4], RTGCPHYS GCPhysMmioPio, RTGCPHYS GCPhysMmioEcam, size_t cbPciMmioEcam,
1244	RTGCPHYS GCPhysPciMmioBase, RTGCPHYS cbPciMmio, RTGCPHYS GCPhysPciMmio32Base, RTGCPHYS cbPciMmio32)
1245	{
1246	RT_NOREF(pszVBoxName, aPinIrqs, GCPhysMmioPio, GCPhysMmioEcam, cbPciMmioEcam,
1247	GCPhysPciMmioBase, cbPciMmio, GCPhysPciMmio32Base, cbPciMmio32);
1248	return VERR_NOT_IMPLEMENTED;
1249	}
1250
1251
1252	int SystemTableBuilder::configureTpm2(bool fCrb, RTGCPHYS GCPhysMmioStart, RTGCPHYS cbMmio, uint32_t u32Irq)
1253	{
1254	RT_NOREF(fCrb, GCPhysMmioStart, cbMmio, u32Irq);
1255	return VERR_NOT_IMPLEMENTED;
1256	}
1257
1258
1259	int SystemTableBuilder::dumpTables(const char *pszFilename)
1260	{
1261	RT_NOREF(pszFilename);
1262	return VERR_NOT_IMPLEMENTED;
1263	}
1264
1265
1266	SystemTableBuilder *SystemTableBuilder::createInstance(SYSTEMTABLETYPE enmTableType)
1267	{
1268	AssertReturn(enmTableType == kSystemTableType_Acpi, NULL);
1269
1270	SystemTableBuilder *pInstance = new SystemTableBuilderAcpi();
1271	Assert(pInstance);
1272
1273	int vrc = pInstance->initInstance();
1274	if (RT_FAILURE(vrc))
1275	{
1276	delete pInstance;
1277	pInstance = NULL;
1278	}
1279
1280	return pInstance;
1281	}

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

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

Download in other formats: