SystemTableBuilder.cpp@ 107037

Last change on this file since 107037 was 107037, checked in by vboxsync, 5 months ago
Main/SystemTableBuilder: Start generating the PPI interface for the TPM in the ACPI tables, bufref:10777
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 36.3 KB

Line
1	/* $Id: SystemTableBuilder.cpp 107037 2024-11-19 10:07:33Z 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. */
707	RTAcpiTblMethodStart(m_hAcpiDsdt, "_DSM", 4, RTACPI_METHOD_F_SERIALIZED, 0 /uSyncLvl/);
708
709	/*
710	* Check that the UUID in Arg0 contains the Physical Presence Interface Specification UUID.
711	*/
712	RTAcpiTblIfStart(m_hAcpiDsdt);
713
714	/* Predicate (LEqual(Arg0, ToUUID("3dddfaa6-361b-4eb4-a424-8d10089d1653")))*/
715	RTAcpiTblBinaryOpAppend(m_hAcpiDsdt, kAcpiBinaryOp_LEqual);
716	RTAcpiTblArgOpAppend(m_hAcpiDsdt, 0);
717	RTAcpiTblUuidAppendFromStr(m_hAcpiDsdt, "3dddfaa6-361b-4eb4-a424-8d10089d1653");
718
719	/* Standard _DSM query function. */
720	RTAcpiTblIfStart(m_hAcpiDsdt);
721
722	/* LEqual(Arg2, Zero). */
723	RTAcpiTblBinaryOpAppend(m_hAcpiDsdt, kAcpiBinaryOp_LEqual);
724	RTAcpiTblArgOpAppend(m_hAcpiDsdt, 2);
725	RTAcpiTblIntegerAppend(m_hAcpiDsdt, 0);
726
727	RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Return);
728	uint8_t abDsmQuery[2] = { 0xff, 0x01 };
729	RTAcpiTblBufferAppend(m_hAcpiDsdt, &abDsmQuery[0], sizeof(abDsmQuery));
730
731	RTAcpiTblIfFinalize(m_hAcpiDsdt);
732
733	/* Query supported PPI revision . */
734	RTAcpiTblIfStart(m_hAcpiDsdt);
735
736	/* LEqual(Arg2, Zero). */
737	RTAcpiTblBinaryOpAppend(m_hAcpiDsdt, kAcpiBinaryOp_LEqual);
738	RTAcpiTblArgOpAppend(m_hAcpiDsdt, 2);
739	RTAcpiTblIntegerAppend(m_hAcpiDsdt, 1);
740
741	RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Return);
742	RTAcpiTblStringAppend(m_hAcpiDsdt, "1.3");
743
744	RTAcpiTblIfFinalize(m_hAcpiDsdt);
745
746
747	/* Submit TPM Operation Requested to pre-OS environment. */
748	RTAcpiTblIfStart(m_hAcpiDsdt);
749
750	/* LEqual(Arg2, Zero). */
751	RTAcpiTblBinaryOpAppend(m_hAcpiDsdt, kAcpiBinaryOp_LEqual);
752	RTAcpiTblArgOpAppend(m_hAcpiDsdt, 2);
753	RTAcpiTblIntegerAppend(m_hAcpiDsdt, 2);
754
755	/** @todo */
756
757	RTAcpiTblIfFinalize(m_hAcpiDsdt);
758
759
760	/* Get Pending TPM Operation Requested by the OS. */
761	RTAcpiTblIfStart(m_hAcpiDsdt);
762
763	/* LEqual(Arg2, Zero). */
764	RTAcpiTblBinaryOpAppend(m_hAcpiDsdt, kAcpiBinaryOp_LEqual);
765	RTAcpiTblArgOpAppend(m_hAcpiDsdt, 2);
766	RTAcpiTblIntegerAppend(m_hAcpiDsdt, 3);
767
768	/** @todo */
769
770	RTAcpiTblIfFinalize(m_hAcpiDsdt);
771
772
773	/* Get Platform-specific Action to Transition to Pre-OS Environment. */
774	RTAcpiTblIfStart(m_hAcpiDsdt);
775
776	/* LEqual(Arg2, Zero). */
777	RTAcpiTblBinaryOpAppend(m_hAcpiDsdt, kAcpiBinaryOp_LEqual);
778	RTAcpiTblArgOpAppend(m_hAcpiDsdt, 2);
779	RTAcpiTblIntegerAppend(m_hAcpiDsdt, 4);
780
781	RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Return);
782	RTAcpiTblIntegerAppend(m_hAcpiDsdt, 2); /* Reboot */
783
784	RTAcpiTblIfFinalize(m_hAcpiDsdt);
785
786
787	/* Return TPM Operation Response to OS Environment. */
788	RTAcpiTblIfStart(m_hAcpiDsdt);
789
790	/* LEqual(Arg2, Zero). */
791	RTAcpiTblBinaryOpAppend(m_hAcpiDsdt, kAcpiBinaryOp_LEqual);
792	RTAcpiTblArgOpAppend(m_hAcpiDsdt, 2);
793	RTAcpiTblIntegerAppend(m_hAcpiDsdt, 5);
794
795	/** @todo */
796
797	RTAcpiTblIfFinalize(m_hAcpiDsdt);
798
799
800	/* Submit Preferred user language - deprecated. */
801	RTAcpiTblIfStart(m_hAcpiDsdt);
802
803	/* LEqual(Arg2, Zero). */
804	RTAcpiTblBinaryOpAppend(m_hAcpiDsdt, kAcpiBinaryOp_LEqual);
805	RTAcpiTblArgOpAppend(m_hAcpiDsdt, 2);
806	RTAcpiTblIntegerAppend(m_hAcpiDsdt, 6);
807
808	RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Return);
809	RTAcpiTblIntegerAppend(m_hAcpiDsdt, 3); /* Not implemented */
810
811	RTAcpiTblIfFinalize(m_hAcpiDsdt);
812
813
814	/* Submit TPM Operation Request to Pre-OS Environment 2. */
815	RTAcpiTblIfStart(m_hAcpiDsdt);
816
817	/* LEqual(Arg2, Zero). */
818	RTAcpiTblBinaryOpAppend(m_hAcpiDsdt, kAcpiBinaryOp_LEqual);
819	RTAcpiTblArgOpAppend(m_hAcpiDsdt, 2);
820	RTAcpiTblIntegerAppend(m_hAcpiDsdt, 7);
821
822	/** @todo */
823
824	RTAcpiTblIfFinalize(m_hAcpiDsdt);
825
826
827	/* Get User Confirmation Status for Operation. */
828	RTAcpiTblIfStart(m_hAcpiDsdt);
829
830	/* LEqual(Arg2, Zero). */
831	RTAcpiTblBinaryOpAppend(m_hAcpiDsdt, kAcpiBinaryOp_LEqual);
832	RTAcpiTblArgOpAppend(m_hAcpiDsdt, 2);
833	RTAcpiTblIntegerAppend(m_hAcpiDsdt, 8);
834
835	/** @todo */
836
837	RTAcpiTblIfFinalize(m_hAcpiDsdt);
838
839
840	/* Return Unknown function. */
841	uint8_t bUnkFunc = 0x00;
842	RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Return);
843	RTAcpiTblBufferAppend(m_hAcpiDsdt, &bUnkFunc, sizeof(bUnkFunc));
844
845	RTAcpiTblIfFinalize(m_hAcpiDsdt);
846
847
848	/*
849	* TCG Platform Reset Attack Mitigation Specification interface.
850	*/
851	RTAcpiTblIfStart(m_hAcpiDsdt);
852
853	/* Predicate (LEqual(Arg0, ToUUID("376054ed-cc13-4675-901c-4756d7f2d45d")))*/
854	RTAcpiTblBinaryOpAppend(m_hAcpiDsdt, kAcpiBinaryOp_LEqual);
855	RTAcpiTblArgOpAppend(m_hAcpiDsdt, 0);
856	RTAcpiTblUuidAppendFromStr(m_hAcpiDsdt, "376054ed-cc13-4675-901c-4756d7f2d45d");
857
858	/* Standard _DSM query function. */
859	RTAcpiTblIfStart(m_hAcpiDsdt);
860
861	/* LEqual(Arg2, Zero). */
862	RTAcpiTblBinaryOpAppend(m_hAcpiDsdt, kAcpiBinaryOp_LEqual);
863	RTAcpiTblArgOpAppend(m_hAcpiDsdt, 2);
864	RTAcpiTblIntegerAppend(m_hAcpiDsdt, 0);
865
866	RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Return);
867	uint8_t bBuf = 0x03;
868	RTAcpiTblBufferAppend(m_hAcpiDsdt, &bBuf, sizeof(bBuf));
869
870	RTAcpiTblIfFinalize(m_hAcpiDsdt);
871
872	/* Set Memory Overwrite Request (MOR) bit to specified value. */
873	RTAcpiTblIfStart(m_hAcpiDsdt);
874
875	/* LEqual(Arg2, Zero). */
876	RTAcpiTblBinaryOpAppend(m_hAcpiDsdt, kAcpiBinaryOp_LEqual);
877	RTAcpiTblArgOpAppend(m_hAcpiDsdt, 2);
878	RTAcpiTblIntegerAppend(m_hAcpiDsdt, 1);
879
880	RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Return);
881	RTAcpiTblIntegerAppend(m_hAcpiDsdt, 0); /* Memory always zeroed on reset. */
882
883	RTAcpiTblIfFinalize(m_hAcpiDsdt);
884
885	/* Return Unknown function. */
886	bUnkFunc = 0x00;
887	RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Return);
888	RTAcpiTblBufferAppend(m_hAcpiDsdt, &bUnkFunc, sizeof(bUnkFunc));
889
890	RTAcpiTblIfFinalize(m_hAcpiDsdt);
891
892	/* Return Unknown function. */
893	bUnkFunc = 0x00;
894	RTAcpiTblStmtSimpleAppend(m_hAcpiDsdt, kAcpiStmt_Return);
895	RTAcpiTblBufferAppend(m_hAcpiDsdt, &bUnkFunc, sizeof(bUnkFunc));
896
897	RTAcpiTblMethodFinalize(m_hAcpiDsdt);
898
899	return RTAcpiTblDeviceFinalize(m_hAcpiDsdt);
900	}
901
902
903	int SystemTableBuilder::initInstance(void)
904	{
905	return VERR_NOT_IMPLEMENTED;
906	}
907
908
909	int SystemTableBuilder::finishTables(RTGCPHYS GCPhysTblsStart, RTVFSIOSTREAM hVfsIos,
910	PRTGCPHYS pGCPhysTblRoot, size_t pcbTblRoot, size_t pcbTbls)
911	{
912	RT_NOREF(GCPhysTblsStart, hVfsIos, pGCPhysTblRoot, pcbTblRoot, pcbTbls);
913	return VERR_NOT_IMPLEMENTED;
914	}
915
916
917	int SystemTableBuilder::addCpu(uint32_t idCpu)
918	{
919	RT_NOREF(idCpu);
920	return VERR_NOT_IMPLEMENTED;
921	}
922
923
924	int SystemTableBuilder::addMemory(RTGCPHYS GCPhysStart, RTGCPHYS cbMem)
925	{
926	RT_NOREF(GCPhysStart, cbMem);
927	return VERR_NOT_IMPLEMENTED;
928	}
929
930
931	int SystemTableBuilder::addMmioDeviceNoIrq(const char *pszVBoxName, uint32_t uInstance, RTGCPHYS GCPhysMmio, RTGCPHYS cbMmio)
932	{
933	RT_NOREF(pszVBoxName, uInstance, GCPhysMmio, cbMmio);
934	return VERR_NOT_IMPLEMENTED;
935	}
936
937
938	int SystemTableBuilder::addMmioDevice(const char *pszVBoxName, uint32_t uInstance, RTGCPHYS GCPhysMmio, RTGCPHYS cbMmio, uint32_t u32Irq)
939	{
940	RT_NOREF(pszVBoxName, uInstance, GCPhysMmio, cbMmio, u32Irq);
941	return VERR_NOT_IMPLEMENTED;
942	}
943
944
945	int SystemTableBuilder::configureGic(uint32_t cCpus, RTGCPHYS GCPhysIntcDist, RTGCPHYS cbMmioIntcDist, RTGCPHYS GCPhysIntcReDist,
946	RTGCPHYS cbMmioIntcReDist)
947	{
948	RT_NOREF(cCpus, GCPhysIntcDist, cbMmioIntcDist, GCPhysIntcReDist, cbMmioIntcReDist);
949	return VERR_NOT_IMPLEMENTED;
950	}
951
952
953	int SystemTableBuilder::configureClock(void)
954	{
955	return VERR_NOT_IMPLEMENTED;
956	}
957
958
959	int SystemTableBuilder::configurePcieRootBus(const char *pszVBoxName, uint32_t aPinIrqs[4], RTGCPHYS GCPhysMmioPio, RTGCPHYS GCPhysMmioEcam, size_t cbPciMmioEcam,
960	RTGCPHYS GCPhysPciMmioBase, RTGCPHYS cbPciMmio, RTGCPHYS GCPhysPciMmio32Base, RTGCPHYS cbPciMmio32)
961	{
962	RT_NOREF(pszVBoxName, aPinIrqs, GCPhysMmioPio, GCPhysMmioEcam, cbPciMmioEcam,
963	GCPhysPciMmioBase, cbPciMmio, GCPhysPciMmio32Base, cbPciMmio32);
964	return VERR_NOT_IMPLEMENTED;
965	}
966
967
968	int SystemTableBuilder::configureTpm2(bool fCrb, RTGCPHYS GCPhysMmioStart, RTGCPHYS cbMmio, uint32_t u32Irq)
969	{
970	RT_NOREF(fCrb, GCPhysMmioStart, cbMmio, u32Irq);
971	return VERR_NOT_IMPLEMENTED;
972	}
973
974
975	int SystemTableBuilder::dumpTables(const char *pszFilename)
976	{
977	RT_NOREF(pszFilename);
978	return VERR_NOT_IMPLEMENTED;
979	}
980
981
982	SystemTableBuilder *SystemTableBuilder::createInstance(SYSTEMTABLETYPE enmTableType)
983	{
984	AssertReturn(enmTableType == kSystemTableType_Acpi, NULL);
985
986	SystemTableBuilder *pInstance = new SystemTableBuilderAcpi();
987	Assert(pInstance);
988
989	int vrc = pInstance->initInstance();
990	if (RT_FAILURE(vrc))
991	{
992	delete pInstance;
993	pInstance = NULL;
994	}
995
996	return pInstance;
997	}

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

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

Download in other formats: