acpi.cpp@ 106486

Last change on this file since 106486 was 106486, checked in by vboxsync, 5 months ago
Runtime/acpi.cpp: Hopefully fix building on sparc64, bugref:10733
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 47.6 KB

Line
1	/* $Id: acpi.cpp 106486 2024-10-18 16:42:19Z vboxsync $ */
2	/** @file
3	* IPRT - Advanced Configuration and Power Interface (ACPI) Table generation API.
4	*/
5
6	/*
7	* Copyright (C) 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	* The contents of this file may alternatively be used under the terms
26	* of the Common Development and Distribution License Version 1.0
27	* (CDDL), a copy of it is provided in the "COPYING.CDDL" file included
28	* in the VirtualBox distribution, in which case the provisions of the
29	* CDDL are applicable instead of those of the GPL.
30	*
31	* You may elect to license modified versions of this file under the
32	* terms and conditions of either the GPL or the CDDL or both.
33	*
34	* SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0
35	*/
36
37
38	/*********************************************************************************************************************************
39	* Header Files *
40	*********************************************************************************************************************************/
41	#define LOG_GROUP RTLOGGROUP_ACPI
42	#include <iprt/acpi.h>
43	#include <iprt/asm.h>
44	#include <iprt/file.h>
45	#include <iprt/mem.h>
46	#include <iprt/string.h>
47
48	#include <iprt/formats/acpi-aml.h>
49	#include <iprt/formats/acpi-resources.h>
50
51
52	/*********************************************************************************************************************************
53	* Defined Constants And Macros *
54	*********************************************************************************************************************************/
55
56
57
58	/*********************************************************************************************************************************
59	* Structures and Typedefs *
60	*********************************************************************************************************************************/
61
62	/**
63	* Package stack element.
64	*/
65	typedef struct RTACPITBLSTACKELEM
66	{
67	/** Pointer to the table buffer memory where the PkgLength object starts. */
68	uint8_t *pbPkgLength;
69	/** Current size of the package in bytes, without the PkgLength object. */
70	uint32_t cbPkg;
71	/** The operator creating the package, UINT8_MAX denotes the special root operator. */
72	uint8_t bOp;
73	} RTACPITBLSTACKELEM;
74	/** Pointer to a package stack element. */
75	typedef RTACPITBLSTACKELEM *PRTACPITBLSTACKELEM;
76	/** Pointer to a const package stack element. */
77	typedef const RTACPITBLSTACKELEM *PCRTACPITBLSTACKELEM;
78
79
80	/**
81	* ACPI table generator instance.
82	*/
83	typedef struct RTACPITBLINT
84	{
85	/** Pointer to the ACPI table header, needed when finalizing the table. */
86	PACPITBLHDR pHdr;
87	/** Byte buffer holding the actual table. */
88	uint8_t *pbTblBuf;
89	/** Size of the table buffer. */
90	uint32_t cbTblBuf;
91	/** Current offset into the table buffer. */
92	uint32_t offTblBuf;
93	/** Flag whether the table is finalized. */
94	bool fFinalized;
95	/** First error code encountered. */
96	int rcErr;
97	/** Pointer to the package element stack. */
98	PRTACPITBLSTACKELEM paPkgStack;
99	/** Number of elements the package stack can hold. */
100	uint32_t cPkgStackElems;
101	/** Index of the current package in the package stack. */
102	uint32_t idxPkgStackElem;
103	} RTACPITBLINT;
104	/** Pointer to an ACPI table generator instance. */
105	typedef RTACPITBLINT *PRTACPITBLINT;
106
107
108	/**
109	* ACPI resource builder instance.
110	*/
111	typedef struct RTACPIRESINT
112	{
113	/** Byte buffer holding the resource. */
114	uint8_t *pbResBuf;
115	/** Size of the resource buffer. */
116	size_t cbResBuf;
117	/** Current offset into the resource buffer. */
118	uint32_t offResBuf;
119	/** Flag whether the resource is sealed. */
120	bool fSealed;
121	/** First error code encountered. */
122	int rcErr;
123	} RTACPIRESINT;
124	/** Pointer to an ACPI resource builder instance. */
125	typedef RTACPIRESINT *PRTACPIRESINT;
126
127
128	/*********************************************************************************************************************************
129	* Global Variables *
130	*********************************************************************************************************************************/
131
132
133	/*********************************************************************************************************************************
134	* Internal Functions *
135	*********************************************************************************************************************************/
136
137
138	/**
139	* Copies the given string into the given buffer padding the remainder with the given character.
140	*
141	* @param pbId The destination to copy the string to.
142	* @param cbId Size of the buffer in bytes.
143	* @param pszStr The string to copy.
144	* @param chPad The character to pad with.
145	*/
146	static void rtAcpiTblCopyStringPadWith(uint8_t pbId, size_t cbId, const char pszStr, char chPad)
147	{
148	Assert(strlen(pszStr) <= cbId);
149
150	uint32_t idx = 0;
151	while (*pszStr != '\0')
152	pbId[idx++] = (uint8_t)*pszStr++;
153
154	while (idx < cbId)
155	pbId[idx++] = chPad;
156	}
157
158
159	/**
160	* Updates the package length of the current package in the stack
161	*
162	* @param pThis The ACPI table instance.
163	* @param cbAdd How many bytes to add to the package length.
164	*/
165	DECL_FORCE_INLINE(void) rtAcpiTblUpdatePkgLength(PRTACPITBLINT pThis, uint32_t cbAdd)
166	{
167	PRTACPITBLSTACKELEM pPkgElem = &pThis->paPkgStack[pThis->idxPkgStackElem];
168	pPkgElem->cbPkg += cbAdd;
169	}
170
171
172	/**
173	* Ensures there is the given amount of room in the ACPI table buffer returning the pointer.
174	*
175	* @returns The pointer to the free space on success or NULL if out of memory.
176	* @param pThis The ACPI table instance.
177	* @param cbReq Amount of bytes requested.
178	*/
179	static uint8_t *rtAcpiTblBufEnsureSpace(PRTACPITBLINT pThis, uint32_t cbReq)
180	{
181	if (RT_LIKELY(pThis->cbTblBuf - pThis->offTblBuf >= cbReq))
182	{
183	uint8_t *pb = &pThis->pbTblBuf[pThis->offTblBuf];
184	pThis->offTblBuf += cbReq;
185	return pb;
186	}
187
188	uint32_t const cbNew = RT_ALIGN_32(pThis->cbTblBuf + cbReq, _4K);
189	uint8_t pbNew = (uint8_t )RTMemRealloc(pThis->pbTblBuf, cbNew);
190	if (RT_UNLIKELY(!pbNew))
191	{
192	pThis->rcErr = VERR_NO_MEMORY;
193	return NULL;
194	}
195
196	pThis->pbTblBuf = pbNew;
197	pThis->cbTblBuf = cbNew;
198
199	uint8_t *pb = &pThis->pbTblBuf[pThis->offTblBuf];
200	pThis->offTblBuf += cbReq;
201	return pb;
202	}
203
204
205	/**
206	* Appends a new package in the given ACPI table instance package stack.
207	*
208	* @returns IPRT status code.
209	* @retval VERR_NO_MEMORY if allocating additional resources to hold the new package failed.
210	* @param pThis The ACPI table instance.
211	* @param bOp The opcode byte the package starts with (for verification purposes when finalizing the package).
212	* @param pbPkgBuf The Start of the package buffer.
213	*/
214	static int rtAcpiTblPkgAppendEx(PRTACPITBLINT pThis, uint8_t bOp, uint8_t *pbPkgBuf)
215	{
216	/* Get a new stack element. */
217	if (pThis->idxPkgStackElem + 1 == pThis->cPkgStackElems)
218	{
219	uint32_t const cPkgElemsNew = pThis->cPkgStackElems + 8;
220	PRTACPITBLSTACKELEM paPkgStackNew = (PRTACPITBLSTACKELEM)RTMemRealloc(pThis->paPkgStack, cPkgElemsNew * sizeof(*paPkgStackNew));
221	if (!paPkgStackNew)
222	{
223	pThis->rcErr = VERR_NO_MEMORY;
224	return VERR_NO_MEMORY;
225	}
226
227	pThis->paPkgStack = paPkgStackNew;
228	pThis->cPkgStackElems = cPkgElemsNew;
229	}
230
231	PRTACPITBLSTACKELEM pStackElem = &pThis->paPkgStack[++pThis->idxPkgStackElem];
232	pStackElem->pbPkgLength = pbPkgBuf;
233	pStackElem->cbPkg = 0;
234	pStackElem->bOp = bOp;
235	return VINF_SUCCESS;
236	}
237
238
239	/**
240	* Starts a new ACPI package in the given ACPI table instance.
241	*
242	* @returns IPRT status code.
243	* @retval VERR_NO_MEMORY if allocating additional resources to hold the new package failed.
244	* @param pThis The ACPI table instance.
245	* @param bOp The opcode byte identifying the package content.
246	*/
247	static int rtAcpiTblPkgStart(PRTACPITBLINT pThis, uint8_t bOp)
248	{
249	/*
250	* Allocate 1 byte for opcode + always 4 bytes for the PkgLength, as we don't know how much we will need upfront.
251	* This will be corrected when the package is finalized.
252	*/
253	uint8_t *pbPkg = rtAcpiTblBufEnsureSpace(pThis, 5);
254	if (!pbPkg)
255	{
256	pThis->rcErr = VERR_NO_MEMORY;
257	return VERR_NO_MEMORY;
258	}
259
260	*pbPkg = bOp;
261	/*
262	* Update the package length of the outer package for the opcode,
263	* the PkgLength object's final length will be added in rtAcpiTblPkgFinish().
264	*/
265	rtAcpiTblUpdatePkgLength(pThis, sizeof(bOp));
266	return rtAcpiTblPkgAppendEx(pThis, bOp, pbPkg + 1);
267	}
268
269
270	/**
271	* Starts a new ACPI package in the given ACPI table instance. This is for opcodes prefixed with
272	* ACPI_AML_BYTE_CODE_PREFIX_EXT_O, which will be added automatically.
273	*
274	* @returns IPRT status code.
275	* @retval VERR_NO_MEMORY if allocating additional resources to hold the new package failed.
276	* @param pThis The ACPI table instance.
277	* @param bOp The opcode byte identifying the package content.
278	*/
279	static int rtAcpiTblPkgStartExt(PRTACPITBLINT pThis, uint8_t bOp)
280	{
281	/*
282	* Allocate 2 bytes for ExtOpPrefix opcode + always 4 bytes for the PkgLength, as we don't know how much we will need upfront.
283	* This will be corrected when the package is finalized.
284	*/
285	uint8_t *pbPkg = rtAcpiTblBufEnsureSpace(pThis, 6);
286	if (!pbPkg)
287	{
288	pThis->rcErr = VERR_NO_MEMORY;
289	return VERR_NO_MEMORY;
290	}
291
292	pbPkg[0] = ACPI_AML_BYTE_CODE_PREFIX_EXT_OP;
293	pbPkg[1] = bOp;
294
295	/*
296	* Update the package length of the outer package for the opcode,
297	* the PkgLength object's final length will be added in rtAcpiTblPkgFinish().
298	*/
299	rtAcpiTblUpdatePkgLength(pThis, sizeof(uint8_t) + sizeof(bOp));
300	return rtAcpiTblPkgAppendEx(pThis, bOp, pbPkg + 2);
301	}
302
303
304	/**
305	* Finishes the current package on the top of the package stack, setting the
306	* package length accordingly.
307	*
308	* @returns IPRT status code.
309	* @retval VERR_INVALID_STATE if bOp doesn't match the opcode the package was started with (asserted in debug builds).
310	* @retval VERR_BUFFER_OVERFLOW if the package length exceeds what can be encoded in the package length field.
311	* @param pThis The ACPI table instance.
312	* @param bOp The opcode byte identifying the package content the package was started with.
313	*/
314	static int rtAcpiTblPkgFinish(PRTACPITBLINT pThis, uint8_t bOp)
315	{
316	/* Ensure the op matches what is current on the top of the stack. */
317	AssertReturn(pThis->paPkgStack[pThis->idxPkgStackElem].bOp == bOp, VERR_INVALID_STATE);
318
319	/* Pop the topmost stack element from the stack. */
320	PRTACPITBLSTACKELEM pPkgElem = &pThis->paPkgStack[pThis->idxPkgStackElem--];
321
322	/*
323	* Determine how many bytes we actually need for the PkgLength and re-arrange the ACPI table.
324	*
325	* Note! PkgLength will also include its own length.
326	*/
327	uint8_t *pbPkgLength = pPkgElem->pbPkgLength;
328	uint32_t cbThisPkg = pPkgElem->cbPkg;
329	if (cbThisPkg + 1 <= 63)
330	{
331	/* Remove the gap. */
332	memmove(pbPkgLength + 1, pbPkgLength + 4, cbThisPkg);
333	pThis->offTblBuf -= 3;
334
335	/* PkgLength only consists of the package lead byte. */
336	cbThisPkg += 1;
337	*pbPkgLength = (cbThisPkg & 0x3f);
338	}
339	else if (cbThisPkg + 2 < RT_BIT_32(12))
340	{
341	/* Remove the gap. */
342	memmove(pbPkgLength + 2, pbPkgLength + 4, cbThisPkg);
343	pThis->offTblBuf -= 2;
344
345	cbThisPkg += 2;
346	pbPkgLength[0] = (1 << 6) \| (cbThisPkg & 0xf);
347	pbPkgLength[1] = (cbThisPkg >> 4) & 0xff;
348	}
349	else if (cbThisPkg + 3 < RT_BIT_32(20))
350	{
351	/* Remove the gap. */
352	memmove(pbPkgLength + 3, pbPkgLength + 4, cbThisPkg);
353	pThis->offTblBuf -= 1;
354
355	cbThisPkg += 3;
356	pbPkgLength[0] = (2 << 6) \| (cbThisPkg & 0xf);
357	pbPkgLength[1] = (cbThisPkg >> 4) & 0xff;
358	pbPkgLength[2] = (cbThisPkg >> 12) & 0xff;
359	}
360	else if (cbThisPkg + 4 < RT_BIT_32(28))
361	{
362	cbThisPkg += 4;
363	pbPkgLength[0] = (3 << 6) \| (cbThisPkg & 0xf);
364	pbPkgLength[1] = (cbThisPkg >> 4) & 0xff;
365	pbPkgLength[2] = (cbThisPkg >> 12) & 0xff;
366	pbPkgLength[3] = (cbThisPkg >> 20) & 0xff;
367	}
368	else
369	return VERR_BUFFER_OVERFLOW;
370
371	/* Update the size of the outer package. */
372	pThis->paPkgStack[pThis->idxPkgStackElem].cbPkg += cbThisPkg;
373
374	return VINF_SUCCESS;
375	}
376
377
378	/**
379	* Appends the given byte to the ACPI table, updating the package length of the current package.
380	*
381	* @param pThis The ACPI table instance.
382	* @param bData The byte data to append.
383	*/
384	DECLINLINE(void) rtAcpiTblAppendByte(PRTACPITBLINT pThis, uint8_t bData)
385	{
386	uint8_t *pb = rtAcpiTblBufEnsureSpace(pThis, sizeof(bData));
387	if (pb)
388	{
389	*pb = bData;
390	rtAcpiTblUpdatePkgLength(pThis, sizeof(bData));
391	}
392	}
393
394
395	/**
396	* Appends the given date to the ACPI table, updating the package length of the current package.
397	*
398	* @param pThis The ACPI table instance.
399	* @param pvData The data to append.
400	* @param cbData Size of the data in bytes.
401	*/
402	DECLINLINE(void) rtAcpiTblAppendData(PRTACPITBLINT pThis, const void *pvData, uint32_t cbData)
403	{
404	uint8_t *pb = rtAcpiTblBufEnsureSpace(pThis, cbData);
405	if (pb)
406	{
407	memcpy(pb, pvData, cbData);
408	rtAcpiTblUpdatePkgLength(pThis, cbData);
409	}
410	}
411
412
413	/**
414	* Appends the given namestring to the ACPI table, updating the package length of the current package
415	* and padding the name with _ if too short.
416	*
417	* @param pThis The ACPI table instance.
418	* @param pszName The name to append, maximum is 4 bytes (or 5 if \\ is the first character).
419	*/
420	DECLINLINE(void) rtAcpiTblAppendNameString(PRTACPITBLINT pThis, const char *pszName)
421	{
422	uint32_t cbName = *pszName == '\\' ? 5 : 4;
423	uint8_t *pb = rtAcpiTblBufEnsureSpace(pThis, cbName);
424	if (pb)
425	{
426	rtAcpiTblCopyStringPadWith(pb, cbName, pszName, '_');
427	rtAcpiTblUpdatePkgLength(pThis, cbName);
428	}
429	}
430
431
432	RTDECL(uint8_t) RTAcpiChecksumGenerate(const void *pvData, size_t cbData)
433	{
434	uint8_t const pbSrc = (uint8_t const )pvData;
435	uint8_t bSum = 0;
436	for (size_t i = 0; i < cbData; ++i)
437	bSum += pbSrc[i];
438
439	return -bSum;
440	}
441
442
443	RTDECL(void) RTAcpiTblHdrChecksumGenerate(PACPITBLHDR pTbl, size_t cbTbl)
444	{
445	pTbl->bChkSum = 0;
446	pTbl->bChkSum = RTAcpiChecksumGenerate(pTbl, cbTbl);
447	}
448
449
450	RTDECL(int) RTAcpiTblCreate(PRTACPITBL phAcpiTbl, uint32_t u32TblSig, uint8_t bRevision, const char *pszOemId,
451	const char pszOemTblId, uint32_t u32OemRevision, const char pszCreatorId,
452	uint32_t u32CreatorRevision)
453	{
454	AssertPtrReturn(phAcpiTbl, VERR_INVALID_POINTER);
455	AssertPtrReturn(pszOemId, VERR_INVALID_POINTER);
456	AssertPtrReturn(pszOemTblId, VERR_INVALID_POINTER);
457	AssertReturn(strlen(pszOemId) <= 6, VERR_INVALID_PARAMETER);
458	AssertReturn(strlen(pszOemTblId) <= 8, VERR_INVALID_PARAMETER);
459	AssertReturn(!pszCreatorId \|\| strlen(pszCreatorId) <= 4, VERR_INVALID_PARAMETER);
460
461	PRTACPITBLINT pThis = (PRTACPITBLINT)RTMemAllocZ(sizeof(*pThis));
462	if (pThis)
463	{
464	pThis->pbTblBuf = (uint8_t *)RTMemAlloc(_4K);
465	if (pThis->pbTblBuf)
466	{
467	pThis->pHdr = (PACPITBLHDR)pThis->pbTblBuf;
468	pThis->offTblBuf = sizeof(*pThis->pHdr);
469	pThis->cbTblBuf = _4K;
470	pThis->fFinalized = false;
471	pThis->rcErr = VINF_SUCCESS;
472	pThis->paPkgStack = NULL;
473	pThis->cPkgStackElems = 0;
474	pThis->idxPkgStackElem = 0;
475
476	/* Add the root stack element for the table, aka DefinitionBlock() in ASL. */
477	uint32_t const cPkgElemsInitial = 8;
478	pThis->paPkgStack = (PRTACPITBLSTACKELEM)RTMemAlloc(cPkgElemsInitial * sizeof(*pThis->paPkgStack));
479	if (pThis->paPkgStack)
480	{
481	pThis->cPkgStackElems = cPkgElemsInitial;
482
483	PRTACPITBLSTACKELEM pStackElem = &pThis->paPkgStack[pThis->idxPkgStackElem];
484	pStackElem->pbPkgLength = pThis->pbTblBuf; /* Starts with the header. */
485	pStackElem->cbPkg = sizeof(*pThis->pHdr);
486	pStackElem->bOp = UINT8_MAX;
487
488	/* Init the table header with static things. */
489	pThis->pHdr->u32Signature = u32TblSig;
490	pThis->pHdr->bRevision = bRevision;
491	pThis->pHdr->u32OemRevision = RT_H2LE_U32(u32OemRevision);
492	pThis->pHdr->u32CreatorRevision = RT_H2LE_U32(u32CreatorRevision);
493
494	rtAcpiTblCopyStringPadWith(&pThis->pHdr->abOemId[0], sizeof(pThis->pHdr->abOemId), pszOemId, ' ');
495	rtAcpiTblCopyStringPadWith(&pThis->pHdr->abOemTblId[0], sizeof(pThis->pHdr->abOemTblId), pszOemTblId, ' ');
496	rtAcpiTblCopyStringPadWith(&pThis->pHdr->abCreatorId[0], sizeof(pThis->pHdr->abCreatorId),
497	pszCreatorId ? pszCreatorId : "IPRT", ' ');
498
499	*phAcpiTbl = pThis;
500	return VINF_SUCCESS;
501	}
502
503	RTMemFree(pThis->pbTblBuf);
504	}
505
506	RTMemFree(pThis);
507	}
508
509	return VERR_NO_MEMORY;
510	}
511
512
513	RTDECL(void) RTAcpiTblDestroy(RTACPITBL hAcpiTbl)
514	{
515	PRTACPITBLINT pThis = hAcpiTbl;
516	AssertPtrReturnVoid(pThis);
517
518	RTMemFree(pThis->paPkgStack);
519	RTMemFree(pThis->pbTblBuf);
520	pThis->pHdr = NULL;
521	pThis->pbTblBuf = NULL;
522	pThis->cbTblBuf = 0;
523	pThis->offTblBuf = 0;
524	pThis->paPkgStack = NULL;
525	pThis->cPkgStackElems = 0;
526	pThis->idxPkgStackElem = 0;
527	RTMemFree(pThis);
528	}
529
530
531	RTDECL(int) RTAcpiTblFinalize(RTACPITBL hAcpiTbl)
532	{
533	PRTACPITBLINT pThis = hAcpiTbl;
534	AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
535	AssertRCReturn(pThis->rcErr, pThis->rcErr);
536	AssertReturn(!pThis->fFinalized, VERR_INVALID_PARAMETER);
537	AssertReturn(pThis->idxPkgStackElem == 0, VERR_INVALID_STATE); /** @todo Better status code. */
538	AssertReturn(pThis->paPkgStack[0].bOp == UINT8_MAX, VERR_INVALID_STATE);
539
540	pThis->pHdr->cbTbl = RT_H2LE_U32(pThis->paPkgStack[0].cbPkg);
541	RTAcpiTblHdrChecksumGenerate(pThis->pHdr, pThis->paPkgStack[0].cbPkg);
542
543	pThis->fFinalized = true;
544	return VINF_SUCCESS;
545	}
546
547
548	RTDECL(uint32_t) RTAcpiTblGetSize(RTACPITBL hAcpiTbl)
549	{
550	PRTACPITBLINT pThis = hAcpiTbl;
551	AssertPtrReturn(pThis, 0);
552	AssertRCReturn(pThis->rcErr, 0);
553	AssertReturn(pThis->fFinalized, 0);
554
555	return pThis->paPkgStack[0].cbPkg;
556	}
557
558
559	RTDECL(int) RTAcpiTblDumpToVfsIoStrm(RTACPITBL hAcpiTbl, RTVFSIOSTREAM hVfsIos)
560	{
561	PRTACPITBLINT pThis = hAcpiTbl;
562	AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
563	AssertRCReturn(pThis->rcErr, 0);
564
565	return RTVfsIoStrmWrite(hVfsIos, pThis->pbTblBuf, pThis->paPkgStack[0].cbPkg,
566	true /fBlocking/, NULL /pcbWritten/);
567	}
568
569
570	RTDECL(int) RTAcpiTblDumpToFile(RTACPITBL hAcpiTbl, const char *pszFilename)
571	{
572	RTVFSIOSTREAM hVfsIos = NIL_RTVFSIOSTREAM;
573	int rc = RTVfsChainOpenIoStream(pszFilename, RTFILE_O_WRITE \| RTFILE_O_CREATE \| RTFILE_O_DENY_NONE,
574	&hVfsIos, NULL /poffError/, NULL);
575	if (RT_FAILURE(rc))
576	return rc;
577
578	rc = RTAcpiTblDumpToVfsIoStrm(hAcpiTbl, hVfsIos);
579	RTVfsIoStrmRelease(hVfsIos);
580	return rc;
581	}
582
583
584	RTDECL(int) RTAcpiTblScopeFinalize(RTACPITBL hAcpiTbl)
585	{
586	PRTACPITBLINT pThis = hAcpiTbl;
587	AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
588
589	return rtAcpiTblPkgFinish(pThis, ACPI_AML_BYTE_CODE_OP_SCOPE);
590	}
591
592
593	RTDECL(int) RTAcpiTblScopeStart(RTACPITBL hAcpiTbl, const char *pszName)
594	{
595	PRTACPITBLINT pThis = hAcpiTbl;
596	AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
597
598	rtAcpiTblPkgStart(pThis, ACPI_AML_BYTE_CODE_OP_SCOPE);
599	rtAcpiTblAppendNameString(pThis, pszName);
600	return pThis->rcErr;
601	}
602
603
604	RTDECL(int) RTAcpiTblPackageStart(RTACPITBL hAcpiTbl, uint8_t cElements)
605	{
606	PRTACPITBLINT pThis = hAcpiTbl;
607	AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
608
609	rtAcpiTblPkgStart(pThis, ACPI_AML_BYTE_CODE_OP_PACKAGE);
610	rtAcpiTblAppendByte(pThis, cElements);
611	return pThis->rcErr;
612	}
613
614
615	RTDECL(int) RTAcpiTblPackageFinalize(RTACPITBL hAcpiTbl)
616	{
617	PRTACPITBLINT pThis = hAcpiTbl;
618	AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
619
620	return rtAcpiTblPkgFinish(pThis, ACPI_AML_BYTE_CODE_OP_PACKAGE);
621	}
622
623
624	RTDECL(int) RTAcpiTblDeviceStart(RTACPITBL hAcpiTbl, const char *pszName)
625	{
626	PRTACPITBLINT pThis = hAcpiTbl;
627	AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
628
629	rtAcpiTblPkgStartExt(pThis, ACPI_AML_BYTE_CODE_EXT_OP_DEVICE);
630	rtAcpiTblAppendNameString(pThis, pszName);
631	return pThis->rcErr;
632	}
633
634
635	RTDECL(int) RTAcpiTblDeviceStartF(RTACPITBL hAcpiTbl, const char *pszNameFmt, ...)
636	{
637	va_list va;
638	va_start(va, pszNameFmt);
639	int rc = RTAcpiTblDeviceStartV(hAcpiTbl, pszNameFmt, va);
640	va_end(va);
641	return rc;
642	}
643
644
645	RTDECL(int) RTAcpiTblDeviceStartV(RTACPITBL hAcpiTbl, const char *pszNameFmt, va_list va)
646	{
647	char szName[5];
648	ssize_t cch = RTStrPrintf2V(&szName[0], sizeof(szName), pszNameFmt, va);
649	if (cch <= 0)
650	return VERR_BUFFER_OVERFLOW;
651
652	return RTAcpiTblDeviceStart(hAcpiTbl, &szName[0]);
653	}
654
655
656	RTDECL(int) RTAcpiTblDeviceFinalize(RTACPITBL hAcpiTbl)
657	{
658	PRTACPITBLINT pThis = hAcpiTbl;
659	AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
660
661	return rtAcpiTblPkgFinish(pThis, ACPI_AML_BYTE_CODE_EXT_OP_DEVICE);
662	}
663
664
665	RTDECL(int) RTAcpiTblMethodStart(RTACPITBL hAcpiTbl, const char *pszName, uint8_t cArgs, uint32_t fFlags, uint8_t uSyncLvl)
666	{
667	PRTACPITBLINT pThis = hAcpiTbl;
668	AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
669	AssertReturn(cArgs < 8, VERR_INVALID_PARAMETER);
670	AssertReturn(uSyncLvl < 0x10, VERR_INVALID_PARAMETER);
671
672	rtAcpiTblPkgStart(pThis, ACPI_AML_BYTE_CODE_OP_METHOD);
673	rtAcpiTblAppendNameString(pThis, pszName);
674
675	uint8_t bFlags = cArgs;
676	bFlags \|= fFlags & RTACPI_METHOD_F_SERIALIZED ? RT_BIT(3) : 0;
677	bFlags \|= uSyncLvl << 4;
678
679	rtAcpiTblAppendByte(pThis, bFlags);
680	return pThis->rcErr;
681	}
682
683
684	RTDECL(int) RTAcpiTblMethodFinalize(RTACPITBL hAcpiTbl)
685	{
686	PRTACPITBLINT pThis = hAcpiTbl;
687	AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
688
689	return rtAcpiTblPkgFinish(pThis, ACPI_AML_BYTE_CODE_OP_METHOD);
690	}
691
692
693	RTDECL(int) RTAcpiTblNameAppend(RTACPITBL hAcpiTbl, const char *pszName)
694	{
695	PRTACPITBLINT pThis = hAcpiTbl;
696	AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
697
698	rtAcpiTblAppendByte(pThis, ACPI_AML_BYTE_CODE_OP_NAME);
699	rtAcpiTblAppendNameString(pThis, pszName);
700	return pThis->rcErr;
701	}
702
703
704	RTDECL(int) RTAcpiTblStringAppend(RTACPITBL hAcpiTbl, const char *psz)
705	{
706	PRTACPITBLINT pThis = hAcpiTbl;
707	AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
708
709	rtAcpiTblAppendByte(pThis, ACPI_AML_BYTE_CODE_PREFIX_STRING);
710	rtAcpiTblAppendData(pThis, psz, (uint32_t)strlen(psz) + 1);
711	return pThis->rcErr;
712	}
713
714
715	RTDECL(int) RTAcpiTblIntegerAppend(RTACPITBL hAcpiTbl, uint64_t u64)
716	{
717	PRTACPITBLINT pThis = hAcpiTbl;
718	AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
719
720	if (!u64)
721	rtAcpiTblAppendByte(pThis, ACPI_AML_BYTE_CODE_OP_ZERO);
722	else if (u64 == 1)
723	rtAcpiTblAppendByte(pThis, ACPI_AML_BYTE_CODE_OP_ONE);
724	else if (u64 <= UINT8_MAX)
725	{
726	rtAcpiTblAppendByte(pThis, ACPI_AML_BYTE_CODE_PREFIX_BYTE);
727	rtAcpiTblAppendByte(pThis, (uint8_t)u64);
728	}
729	else if (u64 <= UINT16_MAX)
730	{
731	rtAcpiTblAppendByte(pThis, ACPI_AML_BYTE_CODE_PREFIX_WORD);
732	rtAcpiTblAppendByte(pThis, (uint8_t)u64);
733	rtAcpiTblAppendByte(pThis, (uint8_t)(u64 >> 8));
734	}
735	else if (u64 <= UINT32_MAX)
736	{
737	rtAcpiTblAppendByte(pThis, ACPI_AML_BYTE_CODE_PREFIX_DWORD);
738	rtAcpiTblAppendByte(pThis, (uint8_t)u64);
739	rtAcpiTblAppendByte(pThis, (uint8_t)(u64 >> 8));
740	rtAcpiTblAppendByte(pThis, (uint8_t)(u64 >> 16));
741	rtAcpiTblAppendByte(pThis, (uint8_t)(u64 >> 24));
742	}
743	else
744	{
745	rtAcpiTblAppendByte(pThis, ACPI_AML_BYTE_CODE_PREFIX_QWORD);
746	rtAcpiTblAppendByte(pThis, (uint8_t)u64);
747	rtAcpiTblAppendByte(pThis, (uint8_t)(u64 >> 8));
748	rtAcpiTblAppendByte(pThis, (uint8_t)(u64 >> 16));
749	rtAcpiTblAppendByte(pThis, (uint8_t)(u64 >> 24));
750	rtAcpiTblAppendByte(pThis, (uint8_t)(u64 >> 32));
751	rtAcpiTblAppendByte(pThis, (uint8_t)(u64 >> 40));
752	rtAcpiTblAppendByte(pThis, (uint8_t)(u64 >> 48));
753	rtAcpiTblAppendByte(pThis, (uint8_t)(u64 >> 56));
754	}
755	return pThis->rcErr;
756	}
757
758
759	RTDECL(int) RTAcpiTblBufferAppend(RTACPITBL hAcpiTbl, const void *pvBuf, size_t cbBuf)
760	{
761	PRTACPITBLINT pThis = hAcpiTbl;
762	AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
763	AssertReturn(!cbBuf \|\| RT_VALID_PTR(pvBuf), VERR_INVALID_PARAMETER);
764	AssertReturn(cbBuf <= UINT32_MAX, VERR_BUFFER_OVERFLOW);
765
766	rtAcpiTblPkgStart(pThis, ACPI_AML_BYTE_CODE_OP_BUFFER);
767	RTAcpiTblIntegerAppend(hAcpiTbl, cbBuf);
768	if (pvBuf)
769	rtAcpiTblAppendData(pThis, pvBuf, (uint32_t)cbBuf);
770	return rtAcpiTblPkgFinish(pThis, ACPI_AML_BYTE_CODE_OP_BUFFER);
771	}
772
773
774	RTDECL(int) RTAcpiTblResourceAppend(RTACPITBL hAcpiTbl, RTACPIRES hAcpiRes)
775	{
776	PRTACPITBLINT pThis = hAcpiTbl;
777	AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
778	AssertRCReturn(pThis->rcErr, pThis->rcErr);
779
780	const void *pvRes = NULL;
781	size_t cbRes = 0;
782	int rc = RTAcpiResourceQueryBuffer(hAcpiRes, &pvRes, &cbRes);
783	if (RT_SUCCESS(rc))
784	rc = RTAcpiTblBufferAppend(pThis, pvRes, cbRes);
785
786	return rc;
787	}
788
789
790	RTDECL(int) RTAcpiTblStmtSimpleAppend(RTACPITBL hAcpiTbl, RTACPISTMT enmStmt)
791	{
792	PRTACPITBLINT pThis = hAcpiTbl;
793	AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
794
795	uint8_t bOp;
796	switch (enmStmt)
797	{
798	case kAcpiStmt_Return: bOp = ACPI_AML_BYTE_CODE_OP_RETURN; break;
799	case kAcpiStmt_Breakpoint: bOp = ACPI_AML_BYTE_CODE_OP_BREAK_POINT; break;
800	case kAcpiStmt_Nop: bOp = ACPI_AML_BYTE_CODE_OP_NOOP; break;
801	case kAcpiStmt_Break: bOp = ACPI_AML_BYTE_CODE_OP_BREAK; break;
802	case kAcpiStmt_Continue: bOp = ACPI_AML_BYTE_CODE_OP_CONTINUE; break;
803	default:
804	AssertFailedReturn(VERR_INVALID_PARAMETER);
805	}
806	rtAcpiTblAppendByte(pThis, bOp);
807	return pThis->rcErr;
808	}
809
810
811	/**
812	* Ensures there is at least the given amount of space in the given ACPI resource.
813	*
814	* @returns Pointer to the free buffer space or NULL if out of memory.
815	* @param pThis The ACPI resource instance.
816	* @param cbReq Number of free bytes required.
817	*/
818	static uint8_t *rtAcpiResBufEnsureSpace(PRTACPIRESINT pThis, uint32_t cbReq)
819	{
820	if (RT_LIKELY(pThis->cbResBuf - pThis->offResBuf >= cbReq))
821	{
822	uint8_t *pb = &pThis->pbResBuf[pThis->offResBuf];
823	pThis->offResBuf += cbReq;
824	return pb;
825	}
826
827	size_t const cbNew = RT_ALIGN_Z(pThis->cbResBuf + cbReq, _4K);
828	uint8_t pbNew = (uint8_t )RTMemRealloc(pThis->pbResBuf, cbNew);
829	if (RT_UNLIKELY(!pbNew))
830	{
831	pThis->rcErr = VERR_NO_MEMORY;
832	return NULL;
833	}
834
835	pThis->pbResBuf = pbNew;
836	pThis->cbResBuf = cbNew;
837
838	uint8_t *pb = &pThis->pbResBuf[pThis->offResBuf];
839	pThis->offResBuf += cbReq;
840	return pb;
841	}
842
843
844	/**
845	* Encodes an ACPI 16-bit integer in the given byte buffer.
846	*
847	* @returns Pointer to after the encoded integer.
848	* @param pb Where to encode the integer into.
849	* @param u16 The 16-bit unsigned integere to encode.
850	*/
851	DECLINLINE(uint8_t ) rtAcpiResEncode16BitInteger(uint8_t pb, uint16_t u16)
852	{
853	*pb++ = (uint8_t)u16;
854	*pb++ = (uint8_t)(u16 >> 8);
855	return pb;
856	}
857
858
859	/**
860	* Encodes an ACPI 32-bit integer in the given byte buffer.
861	*
862	* @returns Pointer to after the encoded integer.
863	* @param pb Where to encode the integer into.
864	* @param u32 The 32-bit unsigned integere to encode.
865	*/
866	DECLINLINE(uint8_t ) rtAcpiResEncode32BitInteger(uint8_t pb, uint32_t u32)
867	{
868	*pb++ = (uint8_t)u32;
869	*pb++ = (uint8_t)(u32 >> 8);
870	*pb++ = (uint8_t)(u32 >> 16);
871	*pb++ = (uint8_t)(u32 >> 24);
872	return pb;
873	}
874
875	/**
876	* Encodes an ACPI 64-bit integer in the given byte buffer.
877	*
878	* @returns Pointer to after the encoded integer.
879	* @param pb Where to encode the integer into.
880	* @param u64 The 64-bit unsigned integere to encode.
881	*/
882
883	DECLINLINE(uint8_t ) rtAcpiResEncode64BitInteger(uint8_t pb, uint64_t u64)
884	{
885	*pb++ = (uint8_t)u64;
886	*pb++ = (uint8_t)(u64 >> 8);
887	*pb++ = (uint8_t)(u64 >> 16);
888	*pb++ = (uint8_t)(u64 >> 24);
889	*pb++ = (uint8_t)(u64 >> 32);
890	*pb++ = (uint8_t)(u64 >> 40);
891	*pb++ = (uint8_t)(u64 >> 48);
892	*pb++ = (uint8_t)(u64 >> 56);
893	return pb;
894	}
895
896
897	RTDECL(int) RTAcpiResourceCreate(PRTACPIRES phAcpiRes)
898	{
899	AssertPtrReturn(phAcpiRes, VERR_INVALID_POINTER);
900
901	PRTACPIRESINT pThis = (PRTACPIRESINT)RTMemAllocZ(sizeof(*pThis));
902	if (pThis)
903	{
904	pThis->pbResBuf = (uint8_t *)RTMemAlloc(64);
905	if (pThis->pbResBuf)
906	{
907	pThis->offResBuf = 0;
908	pThis->cbResBuf = 64;
909	pThis->fSealed = false;
910	pThis->rcErr = VINF_SUCCESS;
911
912	*phAcpiRes = pThis;
913	return VINF_SUCCESS;
914	}
915
916	RTMemFree(pThis);
917	}
918
919	return VERR_NO_MEMORY;
920	}
921
922
923	RTDECL(void) RTAcpiResourceDestroy(RTACPIRES hAcpiRes)
924	{
925	PRTACPIRESINT pThis = hAcpiRes;
926	AssertPtrReturnVoid(pThis);
927
928	RTMemFree(pThis->pbResBuf);
929	pThis->pbResBuf = NULL;
930	pThis->cbResBuf = 0;
931	pThis->offResBuf = 0;
932	RTMemFree(pThis);
933	}
934
935
936	RTDECL(void) RTAcpiResourceReset(RTACPIRES hAcpiRes)
937	{
938	PRTACPIRESINT pThis = hAcpiRes;
939	AssertPtrReturnVoid(pThis);
940
941	pThis->offResBuf = 0;
942	pThis->fSealed = false;
943	pThis->rcErr = VINF_SUCCESS;
944	}
945
946
947	RTDECL(int) RTAcpiResourceSeal(RTACPIRES hAcpiRes)
948	{
949	PRTACPIRESINT pThis = hAcpiRes;
950	AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
951	AssertReturn(!pThis->fSealed, VERR_INVALID_STATE);
952	AssertRCReturn(pThis->rcErr, pThis->rcErr);
953
954	/* Add the end tag. */
955	uint8_t *pb = rtAcpiResBufEnsureSpace(pThis, 2);
956	if (!pb)
957	return VERR_NO_MEMORY;
958
959	*pb++ = ACPI_RSRCS_TAG_END;
960	/*
961	* Generate checksum, we could just write 0 here which will be treated as checksum operation succeeded,
962	* but having this might catch some bugs.
963	*
964	* Checksum algorithm is the same as with the ACPI tables.
965	*/
966	pb = RTAcpiChecksumGenerate(pThis->pbResBuf, pThis->offResBuf - 1); / Exclude the checksum field. */
967
968	pThis->fSealed = true;
969	return VINF_SUCCESS;
970	}
971
972
973	RTDECL(int) RTAcpiResourceQueryBuffer(RTACPIRES hAcpiRes, const void *ppvRes, size_t pcbRes)
974	{
975	PRTACPIRESINT pThis = hAcpiRes;
976	AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
977	AssertReturn(pThis->fSealed, VERR_INVALID_STATE);
978	AssertRCReturn(pThis->rcErr, pThis->rcErr);
979
980	*ppvRes = pThis->pbResBuf;
981	*pcbRes = pThis->offResBuf;
982	return VINF_SUCCESS;
983	}
984
985
986	RTDECL(int) RTAcpiResourceAdd32BitFixedMemoryRange(RTACPIRES hAcpiRes, uint32_t u32AddrBase, uint32_t cbRange,
987	bool fRw)
988	{
989	PRTACPIRESINT pThis = hAcpiRes;
990	AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
991	AssertReturn(!pThis->fSealed, VERR_INVALID_STATE);
992	AssertRCReturn(pThis->rcErr, pThis->rcErr);
993
994	uint8_t *pb = rtAcpiResBufEnsureSpace(pThis, 12);
995	if (!pb)
996	return VERR_NO_MEMORY;
997
998	pb[0] = ACPI_RSRCS_LARGE_TYPE \| ACPI_RSRCS_ITEM_32BIT_FIXED_MEMORY_RANGE; /* Tag */
999	pb[1] = 9; /* Length[7:0] */
1000	pb[2] = 0; /* Length[15:8] */
1001	pb[3] = fRw ? 1 : 0; /* Information */
1002	rtAcpiResEncode32BitInteger(&pb[4], u32AddrBase);
1003	rtAcpiResEncode32BitInteger(&pb[8], cbRange);
1004	return VINF_SUCCESS;
1005	}
1006
1007
1008	RTDECL(int) RTAcpiResourceAddExtendedInterrupt(RTACPIRES hAcpiRes, bool fConsumer, bool fEdgeTriggered, bool fActiveLow, bool fShared,
1009	bool fWakeCapable, uint8_t cIntrs, uint32_t *pau32Intrs)
1010	{
1011	PRTACPIRESINT pThis = hAcpiRes;
1012	AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
1013	AssertReturn(!pThis->fSealed, VERR_INVALID_STATE);
1014	AssertRCReturn(pThis->rcErr, pThis->rcErr);
1015
1016	uint8_t pb = rtAcpiResBufEnsureSpace(pThis, 3 + 2 + cIntrs sizeof(uint32_t));
1017	if (!pb)
1018	return VERR_NO_MEMORY;
1019
1020	pb[0] = ACPI_RSRCS_LARGE_TYPE \| ACPI_RSRCS_ITEM_EXTENDED_INTERRUPT; /* Tag */
1021	rtAcpiResEncode16BitInteger(&pb[1], 2 + cIntrs * sizeof(uint32_t)); /* Length[15:0] */
1022	pb[3] = (fConsumer ? ACPI_RSRCS_EXT_INTR_VEC_F_CONSUMER : ACPI_RSRCS_EXT_INTR_VEC_F_PRODUCER)
1023	\| (fEdgeTriggered ? ACPI_RSRCS_EXT_INTR_VEC_F_EDGE_TRIGGERED : ACPI_RSRCS_EXT_INTR_VEC_F_LEVEL_TRIGGERED)
1024	\| (fActiveLow ? ACPI_RSRCS_EXT_INTR_VEC_F_ACTIVE_LOW : ACPI_RSRCS_EXT_INTR_VEC_F_ACTIVE_HIGH)
1025	\| (fShared ? ACPI_RSRCS_EXT_INTR_VEC_F_SHARED : ACPI_RSRCS_EXT_INTR_VEC_F_EXCLUSIVE)
1026	\| (fWakeCapable ? ACPI_RSRCS_EXT_INTR_VEC_F_WAKE_CAP : ACPI_RSRCS_EXT_INTR_VEC_F_NOT_WAKE_CAP);
1027	pb[4] = cIntrs;
1028	pb = &pb[5];
1029	for (uint32_t i = 0; i < cIntrs; i++)
1030	pb = rtAcpiResEncode32BitInteger(pb, pau32Intrs[i]);
1031
1032	return VINF_SUCCESS;
1033	}
1034
1035
1036	/**
1037	* Common worker for encoding a new quad word (64-bit) address range.
1038	*
1039	* @returns IPRT status code
1040	* @retval VERR_NO_MEMORY if not enough memory could be reserved in the ACPI resource descriptor.
1041	* @param pThis The ACPI resource instance.
1042	* @param bType The ACPI address range type.
1043	* @param fAddrSpace Combination of RTACPI_RESOURCE_ADDR_RANGE_F_XXX.
1044	* @param fType The range flags returned from rtAcpiResourceMemoryRangeToTypeFlags().
1045	* @param u64AddrMin The start address of the memory range.
1046	* @param u64AddrMax Last valid address of the range.
1047	* @param u64OffTrans Translation offset being applied to the address (for a PCIe bridge or IOMMU for example).
1048	* @param u64Granularity The access granularity of the range in bytes.
1049	* @param u64Length Length of the memory range in bytes.
1050	*/
1051	static int rtAcpiResourceAddQWordAddressRange(PRTACPIRESINT pThis, uint8_t bType, uint32_t fAddrSpace, uint8_t fType,
1052	uint64_t u64AddrMin, uint64_t u64AddrMax, uint64_t u64OffTrans,
1053	uint64_t u64Granularity, uint64_t u64Length)
1054	{
1055	uint8_t *pb = rtAcpiResBufEnsureSpace(pThis, 3 + 43);
1056	if (!pb)
1057	return VERR_NO_MEMORY;
1058
1059	pb[0] = ACPI_RSRCS_LARGE_TYPE \| ACPI_RSRCS_ITEM_QWORD_ADDR_SPACE; /* Tag */
1060	pb[1] = 43; /* Length[7:0] */
1061	pb[2] = 0; /* Length[15:8] */
1062	pb[3] = bType;
1063	pb[4] = (fAddrSpace & RTACPI_RESOURCE_ADDR_RANGE_F_DECODE_TYPE_SUB ? ACPI_RSRCS_ADDR_SPACE_F_DECODE_TYPE_SUB : ACPI_RSRCS_ADDR_SPACE_F_DECODE_TYPE_POS)
1064	\| (fAddrSpace & RTACPI_RESOURCE_ADDR_RANGE_F_MIN_ADDR_FIXED ? ACPI_RSRCS_ADDR_SPACE_F_MIN_ADDR_FIXED : ACPI_RSRCS_ADDR_SPACE_F_MIN_ADDR_CHANGEABLE)
1065	\| (fAddrSpace & RTACPI_RESOURCE_ADDR_RANGE_F_MAX_ADDR_FIXED ? ACPI_RSRCS_ADDR_SPACE_F_MAX_ADDR_FIXED : ACPI_RSRCS_ADDR_SPACE_F_MAX_ADDR_CHANGEABLE);
1066	pb[5] = fType;
1067
1068	pb = rtAcpiResEncode64BitInteger(&pb[6], u64Granularity);
1069	pb = rtAcpiResEncode64BitInteger(pb, u64AddrMin);
1070	pb = rtAcpiResEncode64BitInteger(pb, u64AddrMax);
1071	pb = rtAcpiResEncode64BitInteger(pb, u64OffTrans);
1072	rtAcpiResEncode64BitInteger(pb, u64Length);
1073	return VINF_SUCCESS;
1074	}
1075
1076
1077	/**
1078	* Common worker for encoding a new double word (32-bit) address range.
1079	*
1080	* @returns IPRT status code
1081	* @retval VERR_NO_MEMORY if not enough memory could be reserved in the ACPI resource descriptor.
1082	* @param pThis The ACPI resource instance.
1083	* @param bType The ACPI address range type.
1084	* @param fAddrSpace Combination of RTACPI_RESOURCE_ADDR_RANGE_F_XXX.
1085	* @param fType The range flags returned from rtAcpiResourceMemoryRangeToTypeFlags().
1086	* @param u32AddrMin The start address of the memory range.
1087	* @param u32AddrMax Last valid address of the range.
1088	* @param u32OffTrans Translation offset being applied to the address (for a PCIe bridge or IOMMU for example).
1089	* @param u32Granularity The access granularity of the range in bytes.
1090	* @param u32Length Length of the memory range in bytes.
1091	*/
1092	static int rtAcpiResourceAddDWordAddressRange(PRTACPIRESINT pThis, uint8_t bType, uint32_t fAddrSpace, uint8_t fType,
1093	uint32_t u32AddrMin, uint32_t u32AddrMax, uint32_t u32OffTrans,
1094	uint32_t u32Granularity, uint32_t u32Length)
1095	{
1096	uint8_t *pb = rtAcpiResBufEnsureSpace(pThis, 3 + 23);
1097	if (!pb)
1098	return VERR_NO_MEMORY;
1099
1100	pb[0] = ACPI_RSRCS_LARGE_TYPE \| ACPI_RSRCS_ITEM_DWORD_ADDR_SPACE; /* Tag */
1101	pb[1] = 23; /* Length[7:0] */
1102	pb[2] = 0; /* Length[15:8] */
1103	pb[3] = bType;
1104	pb[4] = (fAddrSpace & RTACPI_RESOURCE_ADDR_RANGE_F_DECODE_TYPE_SUB ? ACPI_RSRCS_ADDR_SPACE_F_DECODE_TYPE_SUB : ACPI_RSRCS_ADDR_SPACE_F_DECODE_TYPE_POS)
1105	\| (fAddrSpace & RTACPI_RESOURCE_ADDR_RANGE_F_MIN_ADDR_FIXED ? ACPI_RSRCS_ADDR_SPACE_F_MIN_ADDR_FIXED : ACPI_RSRCS_ADDR_SPACE_F_MIN_ADDR_CHANGEABLE)
1106	\| (fAddrSpace & RTACPI_RESOURCE_ADDR_RANGE_F_MAX_ADDR_FIXED ? ACPI_RSRCS_ADDR_SPACE_F_MAX_ADDR_FIXED : ACPI_RSRCS_ADDR_SPACE_F_MAX_ADDR_CHANGEABLE);
1107	pb[5] = fType;
1108
1109	pb = rtAcpiResEncode32BitInteger(&pb[6], u32Granularity);
1110	pb = rtAcpiResEncode32BitInteger(pb, u32AddrMin);
1111	pb = rtAcpiResEncode32BitInteger(pb, u32AddrMax);
1112	pb = rtAcpiResEncode32BitInteger(pb, u32OffTrans);
1113	rtAcpiResEncode32BitInteger(pb, u32Length);
1114	return VINF_SUCCESS;
1115	}
1116
1117
1118	/**
1119	* Converts the given cacheability, range type and R/W flag to the ACPI resource flags.
1120	*
1121	* @returns Converted ACPI resource flags.
1122	* @param enmCacheability The cacheability enum to convert.
1123	* @param enmType THe memory range type enum to convert.
1124	* @param fRw The read/write flag.
1125	*/
1126	DECLINLINE(uint8_t) rtAcpiResourceMemoryRangeToTypeFlags(RTACPIRESMEMRANGECACHEABILITY enmCacheability, RTACPIRESMEMRANGETYPE enmType,
1127	bool fRw)
1128	{
1129	uint8_t fType = fRw ? ACPI_RSRCS_ADDR_SPACE_MEM_F_RW : ACPI_RSRCS_ADDR_SPACE_MEM_F_RO;
1130
1131	switch (enmCacheability)
1132	{
1133	case kAcpiResMemRangeCacheability_NonCacheable:
1134	fType \|= ACPI_RSRCS_ADDR_SPACE_MEM_F_CACHE_NON_CACHEABLE;
1135	break;
1136	case kAcpiResMemRangeCacheability_Cacheable:
1137	fType \|= ACPI_RSRCS_ADDR_SPACE_MEM_F_CACHE_CACHEABLE;
1138	break;
1139	case kAcpiResMemRangeCacheability_CacheableWriteCombining:
1140	fType \|= ACPI_RSRCS_ADDR_SPACE_MEM_F_CACHE_CACHEABLE_WR_COMB;
1141	break;
1142	case kAcpiResMemRangeCacheability_CacheablePrefetchable:
1143	fType \|= ACPI_RSRCS_ADDR_SPACE_MEM_F_CACHE_CACHEABLE_PREFETCHABLE;
1144	break;
1145	case kAcpiResMemRangeCacheability_Invalid:
1146	default:
1147	AssertFailedReturn(0);
1148	}
1149
1150	switch (enmType)
1151	{
1152	case kAcpiResMemType_Memory:
1153	fType \|= ACPI_RSRCS_ADDR_SPACE_MEM_F_ATTR_MEMORY;
1154	break;
1155	case kAcpiResMemType_Reserved:
1156	fType \|= ACPI_RSRCS_ADDR_SPACE_MEM_F_ATTR_RESERVED;
1157	break;
1158	case kAcpiResMemType_Acpi:
1159	fType \|= ACPI_RSRCS_ADDR_SPACE_MEM_F_ATTR_ACPI;
1160	break;
1161	case kAcpiResMemType_Nvs:
1162	fType \|= ACPI_RSRCS_ADDR_SPACE_MEM_F_ATTR_NVS;
1163	break;
1164	case kAcpiResMemType_Invalid:
1165	default:
1166	AssertFailedReturn(0);
1167	}
1168
1169	return fType;
1170	}
1171
1172
1173	RTDECL(int) RTAcpiResourceAddQWordMemoryRange(RTACPIRES hAcpiRes, RTACPIRESMEMRANGECACHEABILITY enmCacheability,
1174	RTACPIRESMEMRANGETYPE enmType, bool fRw, uint32_t fAddrSpace,
1175	uint64_t u64AddrMin, uint64_t u64AddrMax, uint64_t u64OffTrans,
1176	uint64_t u64Granularity, uint64_t u64Length)
1177	{
1178	PRTACPIRESINT pThis = hAcpiRes;
1179	AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
1180	AssertReturn(enmCacheability != kAcpiResMemRangeCacheability_Invalid, VERR_INVALID_PARAMETER);
1181	AssertReturn(enmType != kAcpiResMemType_Invalid, VERR_INVALID_PARAMETER);
1182	AssertReturn(!(fAddrSpace & ~RTACPI_RESOURCE_ADDR_RANGE_F_VALID_MASK), VERR_INVALID_PARAMETER);
1183	AssertReturn(!pThis->fSealed, VERR_INVALID_STATE);
1184	AssertRCReturn(pThis->rcErr, pThis->rcErr);
1185
1186	uint8_t fType = rtAcpiResourceMemoryRangeToTypeFlags(enmCacheability, enmType, fRw);
1187	return rtAcpiResourceAddQWordAddressRange(pThis, ACPI_RSRCS_ADDR_SPACE_TYPE_MEMORY, fAddrSpace, fType,
1188	u64AddrMin, u64AddrMax, u64OffTrans, u64Granularity, u64Length);
1189	}
1190
1191
1192	RTDECL(int) RTAcpiResourceAddDWordMemoryRange(RTACPIRES hAcpiRes, RTACPIRESMEMRANGECACHEABILITY enmCacheability,
1193	RTACPIRESMEMRANGETYPE enmType, bool fRw, uint32_t fAddrSpace,
1194	uint32_t u32AddrMin, uint32_t u32AddrMax, uint32_t u32OffTrans,
1195	uint32_t u32Granularity, uint32_t u32Length)
1196	{
1197	PRTACPIRESINT pThis = hAcpiRes;
1198	AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
1199	AssertReturn(enmCacheability != kAcpiResMemRangeCacheability_Invalid, VERR_INVALID_PARAMETER);
1200	AssertReturn(enmType != kAcpiResMemType_Invalid, VERR_INVALID_PARAMETER);
1201	AssertReturn(!(fAddrSpace & ~RTACPI_RESOURCE_ADDR_RANGE_F_VALID_MASK), VERR_INVALID_PARAMETER);
1202	AssertReturn(!pThis->fSealed, VERR_INVALID_STATE);
1203	AssertRCReturn(pThis->rcErr, pThis->rcErr);
1204
1205	uint8_t fType = rtAcpiResourceMemoryRangeToTypeFlags(enmCacheability, enmType, fRw);
1206	return rtAcpiResourceAddDWordAddressRange(pThis, ACPI_RSRCS_ADDR_SPACE_TYPE_MEMORY, fAddrSpace, fType,
1207	u32AddrMin, u32AddrMax, u32OffTrans, u32Granularity, u32Length);
1208	}
1209
1210
1211	RTDECL(int) RTAcpiResourceAddQWordIoRange(RTACPIRES hAcpiRes, RTACPIRESIORANGETYPE enmIoType, RTACPIRESIORANGE enmIoRange,
1212	uint32_t fAddrSpace, uint64_t u64AddrMin, uint64_t u64AddrMax, uint64_t u64OffTrans,
1213	uint64_t u64Granularity, uint64_t u64Length)
1214	{
1215	PRTACPIRESINT pThis = hAcpiRes;
1216	AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
1217	AssertReturn(enmIoType != kAcpiResIoRangeType_Invalid, VERR_INVALID_PARAMETER);
1218	AssertReturn(enmIoRange != kAcpiResIoRange_Invalid, VERR_INVALID_PARAMETER);
1219	AssertReturn(!(fAddrSpace & ~RTACPI_RESOURCE_ADDR_RANGE_F_VALID_MASK), VERR_INVALID_PARAMETER);
1220	AssertReturn(!pThis->fSealed, VERR_INVALID_STATE);
1221	AssertRCReturn(pThis->rcErr, pThis->rcErr);
1222
1223	uint8_t fType = 0;
1224	switch (enmIoType)
1225	{
1226	case kAcpiResIoRangeType_Static:
1227	fType = ACPI_RSRCS_ADDR_SPACE_IO_F_TYPE_STATIC;
1228	break;
1229	case kAcpiResIoRangeType_Translation_Sparse:
1230	fType = ACPI_RSRCS_ADDR_SPACE_IO_F_TYPE_TRANSLATION \| ACPI_RSRCS_ADDR_SPACE_IO_F_TRANSLATION_SPARSE;
1231	break;
1232	case kAcpiResIoRangeType_Translation_Dense:
1233	fType = ACPI_RSRCS_ADDR_SPACE_IO_F_TYPE_TRANSLATION \| ACPI_RSRCS_ADDR_SPACE_IO_F_TRANSLATION_DENSE;
1234	break;
1235	case kAcpiResIoRangeType_Invalid:
1236	default:
1237	AssertFailedReturn(VERR_INVALID_PARAMETER);
1238	}
1239
1240	switch (enmIoRange)
1241	{
1242	case kAcpiResIoRange_NonIsaOnly:
1243	fType \|= ACPI_RSRCS_ADDR_SPACE_IO_F_RANGE_NON_ISA_ONLY;
1244	break;
1245	case kAcpiResIoRange_IsaOnly:
1246	fType \|= ACPI_RSRCS_ADDR_SPACE_IO_F_RANGE_ISA_ONLY;
1247	break;
1248	case kAcpiResIoRange_Whole:
1249	fType \|= ACPI_RSRCS_ADDR_SPACE_IO_F_RANGE_WHOLE;
1250	break;
1251	case kAcpiResIoRange_Invalid:
1252	default:
1253	AssertFailedReturn(VERR_INVALID_PARAMETER);
1254	}
1255
1256	return rtAcpiResourceAddQWordAddressRange(pThis, ACPI_RSRCS_ADDR_SPACE_TYPE_IO, fAddrSpace, fType,
1257	u64AddrMin, u64AddrMax, u64OffTrans, u64Granularity, u64Length);
1258	}
1259
1260
1261	RTDECL(int) RTAcpiResourceAddWordBusNumber(RTACPIRES hAcpiRes, uint32_t fAddrSpace, uint16_t u16BusMin, uint16_t u16BusMax,
1262	uint16_t u16OffTrans, uint16_t u16Granularity, uint16_t u16Length)
1263	{
1264	PRTACPIRESINT pThis = hAcpiRes;
1265	AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
1266	AssertReturn(!(fAddrSpace & ~RTACPI_RESOURCE_ADDR_RANGE_F_VALID_MASK), VERR_INVALID_PARAMETER);
1267	AssertReturn(!pThis->fSealed, VERR_INVALID_STATE);
1268	AssertRCReturn(pThis->rcErr, pThis->rcErr);
1269
1270	uint8_t *pb = rtAcpiResBufEnsureSpace(pThis, 3 + 13);
1271	if (!pb)
1272	return VERR_NO_MEMORY;
1273
1274	pb[0] = ACPI_RSRCS_LARGE_TYPE \| ACPI_RSRCS_ITEM_WORD_ADDR_SPACE; /* Tag */
1275	pb[1] = 13; /* Length[7:0] */
1276	pb[2] = 0; /* Length[15:8] */
1277	pb[3] = ACPI_RSRCS_ADDR_SPACE_TYPE_BUS_NUM_RANGE;
1278	pb[4] = (fAddrSpace & RTACPI_RESOURCE_ADDR_RANGE_F_DECODE_TYPE_SUB ? ACPI_RSRCS_ADDR_SPACE_F_DECODE_TYPE_SUB : ACPI_RSRCS_ADDR_SPACE_F_DECODE_TYPE_POS)
1279	\| (fAddrSpace & RTACPI_RESOURCE_ADDR_RANGE_F_MIN_ADDR_FIXED ? ACPI_RSRCS_ADDR_SPACE_F_MIN_ADDR_FIXED : ACPI_RSRCS_ADDR_SPACE_F_MIN_ADDR_CHANGEABLE)
1280	\| (fAddrSpace & RTACPI_RESOURCE_ADDR_RANGE_F_MAX_ADDR_FIXED ? ACPI_RSRCS_ADDR_SPACE_F_MAX_ADDR_FIXED : ACPI_RSRCS_ADDR_SPACE_F_MAX_ADDR_CHANGEABLE);
1281	pb[5] = 0;
1282
1283	pb = rtAcpiResEncode16BitInteger(&pb[6], u16Granularity);
1284	pb = rtAcpiResEncode16BitInteger(pb, u16BusMin);
1285	pb = rtAcpiResEncode16BitInteger(pb, u16BusMax);
1286	pb = rtAcpiResEncode16BitInteger(pb, u16OffTrans);
1287	rtAcpiResEncode16BitInteger(pb, u16Length);
1288	return VINF_SUCCESS;
1289
1290	}

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

source: vbox/trunk/src/VBox/Runtime/common/misc/acpi.cpp@ 106486

Download in other formats: