acpi.cpp@ 107063

Last change on this file since 107063 was 107063, checked in by vboxsync, 4 months ago
Runtime/RTAcpi*: Some updates to the ACPI code generation, bugref:10733
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 55.9 KB

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

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

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

Download in other formats: