SystemTableBuilder.cpp@ 108346

Last change on this file since 108346 was 108346, checked in by vboxsync, 3 weeks ago
Main/src-client/SystemTableBuilder.cpp: Use Eisa IDs where appropriate, bugref:10733
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 50.9 KB

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

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

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

Download in other formats: