acpi.cpp@ 107455

Last change on this file since 107455 was 107064, checked in by vboxsync, 2 months ago
Runtime/RTAcpi*: Support more statements, an extended variant of the Region() API, bugref:10733
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 57.5 KB

Line
1	/* $Id: acpi.cpp 107064 2024-11-20 20:21:23Z 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) RTAcpiTblNullNameAppend(RTACPITBL hAcpiTbl)
753	{
754	PRTACPITBLINT pThis = hAcpiTbl;
755	AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
756
757	rtAcpiTblAppendByte(pThis, 0x00);
758	return pThis->rcErr;
759	}
760
761
762	RTDECL(int) RTAcpiTblNameStringAppend(RTACPITBL hAcpiTbl, const char *pszName)
763	{
764	PRTACPITBLINT pThis = hAcpiTbl;
765	AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
766
767	rtAcpiTblAppendNameString(pThis, pszName);
768	return pThis->rcErr;
769	}
770
771
772	RTDECL(int) RTAcpiTblStringAppend(RTACPITBL hAcpiTbl, const char *psz)
773	{
774	PRTACPITBLINT pThis = hAcpiTbl;
775	AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
776
777	rtAcpiTblAppendByte(pThis, ACPI_AML_BYTE_CODE_PREFIX_STRING);
778	rtAcpiTblAppendData(pThis, psz, (uint32_t)strlen(psz) + 1);
779	return pThis->rcErr;
780	}
781
782
783	RTDECL(int) RTAcpiTblIntegerAppend(RTACPITBL hAcpiTbl, uint64_t u64)
784	{
785	PRTACPITBLINT pThis = hAcpiTbl;
786	AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
787
788	if (!u64)
789	rtAcpiTblAppendByte(pThis, ACPI_AML_BYTE_CODE_OP_ZERO);
790	else if (u64 == 1)
791	rtAcpiTblAppendByte(pThis, ACPI_AML_BYTE_CODE_OP_ONE);
792	else if (u64 <= UINT8_MAX)
793	{
794	rtAcpiTblAppendByte(pThis, ACPI_AML_BYTE_CODE_PREFIX_BYTE);
795	rtAcpiTblAppendByte(pThis, (uint8_t)u64);
796	}
797	else if (u64 <= UINT16_MAX)
798	{
799	rtAcpiTblAppendByte(pThis, ACPI_AML_BYTE_CODE_PREFIX_WORD);
800	rtAcpiTblAppendByte(pThis, (uint8_t)u64);
801	rtAcpiTblAppendByte(pThis, (uint8_t)(u64 >> 8));
802	}
803	else if (u64 <= UINT32_MAX)
804	{
805	rtAcpiTblAppendByte(pThis, ACPI_AML_BYTE_CODE_PREFIX_DWORD);
806	rtAcpiTblAppendByte(pThis, (uint8_t)u64);
807	rtAcpiTblAppendByte(pThis, (uint8_t)(u64 >> 8));
808	rtAcpiTblAppendByte(pThis, (uint8_t)(u64 >> 16));
809	rtAcpiTblAppendByte(pThis, (uint8_t)(u64 >> 24));
810	}
811	else
812	{
813	rtAcpiTblAppendByte(pThis, ACPI_AML_BYTE_CODE_PREFIX_QWORD);
814	rtAcpiTblAppendByte(pThis, (uint8_t)u64);
815	rtAcpiTblAppendByte(pThis, (uint8_t)(u64 >> 8));
816	rtAcpiTblAppendByte(pThis, (uint8_t)(u64 >> 16));
817	rtAcpiTblAppendByte(pThis, (uint8_t)(u64 >> 24));
818	rtAcpiTblAppendByte(pThis, (uint8_t)(u64 >> 32));
819	rtAcpiTblAppendByte(pThis, (uint8_t)(u64 >> 40));
820	rtAcpiTblAppendByte(pThis, (uint8_t)(u64 >> 48));
821	rtAcpiTblAppendByte(pThis, (uint8_t)(u64 >> 56));
822	}
823	return pThis->rcErr;
824	}
825
826
827	RTDECL(int) RTAcpiTblBufferAppend(RTACPITBL hAcpiTbl, const void *pvBuf, size_t cbBuf)
828	{
829	PRTACPITBLINT pThis = hAcpiTbl;
830	AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
831	AssertReturn(!cbBuf \|\| RT_VALID_PTR(pvBuf), VERR_INVALID_PARAMETER);
832	AssertReturn(cbBuf <= UINT32_MAX, VERR_BUFFER_OVERFLOW);
833
834	rtAcpiTblPkgStart(pThis, ACPI_AML_BYTE_CODE_OP_BUFFER);
835	RTAcpiTblIntegerAppend(hAcpiTbl, cbBuf);
836	if (pvBuf)
837	rtAcpiTblAppendData(pThis, pvBuf, (uint32_t)cbBuf);
838	return rtAcpiTblPkgFinish(pThis, ACPI_AML_BYTE_CODE_OP_BUFFER);
839	}
840
841
842	RTDECL(int) RTAcpiTblResourceAppend(RTACPITBL hAcpiTbl, RTACPIRES hAcpiRes)
843	{
844	PRTACPITBLINT pThis = hAcpiTbl;
845	AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
846	AssertRCReturn(pThis->rcErr, pThis->rcErr);
847
848	const void *pvRes = NULL;
849	size_t cbRes = 0;
850	int rc = RTAcpiResourceQueryBuffer(hAcpiRes, &pvRes, &cbRes);
851	if (RT_SUCCESS(rc))
852	rc = RTAcpiTblBufferAppend(pThis, pvRes, cbRes);
853
854	return rc;
855	}
856
857
858	RTDECL(int) RTAcpiTblStmtSimpleAppend(RTACPITBL hAcpiTbl, RTACPISTMT enmStmt)
859	{
860	PRTACPITBLINT pThis = hAcpiTbl;
861	AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
862
863	uint8_t bOp;
864	switch (enmStmt)
865	{
866	case kAcpiStmt_Return: bOp = ACPI_AML_BYTE_CODE_OP_RETURN; break;
867	case kAcpiStmt_Breakpoint: bOp = ACPI_AML_BYTE_CODE_OP_BREAK_POINT; break;
868	case kAcpiStmt_Nop: bOp = ACPI_AML_BYTE_CODE_OP_NOOP; break;
869	case kAcpiStmt_Break: bOp = ACPI_AML_BYTE_CODE_OP_BREAK; break;
870	case kAcpiStmt_Continue: bOp = ACPI_AML_BYTE_CODE_OP_CONTINUE; break;
871	case kAcpiStmt_Add: bOp = ACPI_AML_BYTE_CODE_OP_ADD; break;
872	case kAcpiStmt_Subtract: bOp = ACPI_AML_BYTE_CODE_OP_SUBTRACT; break;
873	case kAcpiStmt_And: bOp = ACPI_AML_BYTE_CODE_OP_AND; break;
874	case kAcpiStmt_Nand: bOp = ACPI_AML_BYTE_CODE_OP_NAND; break;
875	case kAcpiStmt_Or: bOp = ACPI_AML_BYTE_CODE_OP_OR; break;
876	case kAcpiStmt_Xor: bOp = ACPI_AML_BYTE_CODE_OP_XOR; break;
877	case kAcpiStmt_Not: bOp = ACPI_AML_BYTE_CODE_OP_NOT; break;
878	case kAcpiStmt_Store: bOp = ACPI_AML_BYTE_CODE_OP_STORE; break;
879	case kAcpiStmt_Index: bOp = ACPI_AML_BYTE_CODE_OP_INDEX; break;
880	case kAcpiStmt_DerefOf: bOp = ACPI_AML_BYTE_CODE_OP_DEREF_OF; break;
881	default:
882	AssertFailedReturn(VERR_INVALID_PARAMETER);
883	}
884	rtAcpiTblAppendByte(pThis, bOp);
885	return pThis->rcErr;
886	}
887
888
889	RTDECL(int) RTAcpiTblIfStart(RTACPITBL hAcpiTbl)
890	{
891	PRTACPITBLINT pThis = hAcpiTbl;
892	AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
893
894	rtAcpiTblPkgStart(pThis, ACPI_AML_BYTE_CODE_OP_IF);
895	return pThis->rcErr;
896	}
897
898
899	RTDECL(int) RTAcpiTblIfFinalize(RTACPITBL hAcpiTbl)
900	{
901	PRTACPITBLINT pThis = hAcpiTbl;
902	AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
903
904	return rtAcpiTblPkgFinish(pThis, ACPI_AML_BYTE_CODE_OP_IF);
905	}
906
907
908	RTDECL(int) RTAcpiTblElseStart(RTACPITBL hAcpiTbl)
909	{
910	PRTACPITBLINT pThis = hAcpiTbl;
911	AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
912
913	/* Makes only sense inside an IfOp package. */
914	AssertReturn(pThis->paPkgStack[pThis->idxPkgStackElem].bOp == ACPI_AML_BYTE_CODE_OP_IF, VERR_INVALID_STATE);
915
916	rtAcpiTblPkgStartExt(pThis, ACPI_AML_BYTE_CODE_OP_ELSE);
917	return pThis->rcErr;
918	}
919
920
921	RTDECL(int) RTAcpiTblElseFinalize(RTACPITBL hAcpiTbl)
922	{
923	PRTACPITBLINT pThis = hAcpiTbl;
924	AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
925
926	return rtAcpiTblPkgFinish(pThis, ACPI_AML_BYTE_CODE_OP_ELSE);
927	}
928
929
930	RTDECL(int) RTAcpiTblBinaryOpAppend(RTACPITBL hAcpiTbl, RTACPIBINARYOP enmBinaryOp)
931	{
932	PRTACPITBLINT pThis = hAcpiTbl;
933	AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
934
935	uint8_t bOp;
936	switch (enmBinaryOp)
937	{
938	case kAcpiBinaryOp_LAnd: bOp = ACPI_AML_BYTE_CODE_OP_LAND; break;
939	case kAcpiBinaryOp_LEqual: bOp = ACPI_AML_BYTE_CODE_OP_LEQUAL; break;
940	case kAcpiBinaryOp_LGreater: bOp = ACPI_AML_BYTE_CODE_OP_LGREATER; break;
941	case kAcpiBinaryOp_LLess: bOp = ACPI_AML_BYTE_CODE_OP_LLESS; break;
942	case kAcpiBinaryOp_LGreaterEqual:
943	case kAcpiBinaryOp_LLessEqual:
944	case kAcpiBinaryOp_LNotEqual:
945	bOp = ACPI_AML_BYTE_CODE_OP_LNOT;
946	break;
947	default:
948	AssertFailedReturn(VERR_INVALID_PARAMETER);
949	}
950	rtAcpiTblAppendByte(pThis, bOp);
951	switch (enmBinaryOp)
952	{
953	case kAcpiBinaryOp_LGreaterEqual: bOp = ACPI_AML_BYTE_CODE_OP_LLESS; break;
954	case kAcpiBinaryOp_LLessEqual: bOp = ACPI_AML_BYTE_CODE_OP_LGREATER; break;
955	case kAcpiBinaryOp_LNotEqual: bOp = ACPI_AML_BYTE_CODE_OP_LEQUAL; break;
956	default:
957	bOp = 0x00;
958	}
959	if (bOp != 0x00)
960	rtAcpiTblAppendByte(pThis, bOp);
961	return pThis->rcErr;
962	}
963
964
965	RTDECL(int) RTAcpiTblArgOpAppend(RTACPITBL hAcpiTbl, uint8_t idArg)
966	{
967	PRTACPITBLINT pThis = hAcpiTbl;
968	AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
969	AssertReturn(idArg <= 6, VERR_INVALID_PARAMETER);
970
971	rtAcpiTblAppendByte(pThis, ACPI_AML_BYTE_CODE_OP_ARG_0 + idArg);
972	return pThis->rcErr;
973	}
974
975
976	RTDECL(int) RTAcpiTblLocalOpAppend(RTACPITBL hAcpiTbl, uint8_t idLocal)
977	{
978	PRTACPITBLINT pThis = hAcpiTbl;
979	AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
980	AssertReturn(idLocal <= 7, VERR_INVALID_PARAMETER);
981
982	rtAcpiTblAppendByte(pThis, ACPI_AML_BYTE_CODE_OP_LOCAL_0 + idLocal);
983	return pThis->rcErr;
984	}
985
986
987	RTDECL(int) RTAcpiTblUuidAppend(RTACPITBL hAcpiTbl, PCRTUUID pUuid)
988	{
989	/* UUIDs are stored as a buffer object. */
990	/** @todo Needs conversion on big endian machines. */
991	return RTAcpiTblBufferAppend(hAcpiTbl, &pUuid->au8[0], sizeof(*pUuid));
992	}
993
994
995	RTDECL(int) RTAcpiTblUuidAppendFromStr(RTACPITBL hAcpiTbl, const char *pszUuid)
996	{
997	PRTACPITBLINT pThis = hAcpiTbl;
998	AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
999
1000	RTUUID Uuid;
1001	pThis->rcErr = RTUuidFromStr(&Uuid, pszUuid);
1002	if (RT_SUCCESS(pThis->rcErr))
1003	return RTAcpiTblUuidAppend(pThis, &Uuid);
1004
1005	return pThis->rcErr;
1006	}
1007
1008
1009	RTDECL(int) RTAcpiTblOpRegionAppendEx(RTACPITBL hAcpiTbl, const char *pszName, RTACPIOPREGIONSPACE enmSpace)
1010	{
1011	PRTACPITBLINT pThis = hAcpiTbl;
1012	AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
1013
1014	uint8_t abOp[2] = { ACPI_AML_BYTE_CODE_PREFIX_EXT_OP, ACPI_AML_BYTE_CODE_EXT_OP_OP_REGION };
1015	rtAcpiTblAppendData(pThis, &abOp[0], sizeof(abOp));
1016	rtAcpiTblAppendNameString(pThis, pszName);
1017
1018	uint8_t bRegionSpace = 0xff;
1019	switch (enmSpace)
1020	{
1021	case kAcpiOperationRegionSpace_SystemMemory: bRegionSpace = 0x00; break;
1022	case kAcpiOperationRegionSpace_SystemIo: bRegionSpace = 0x01; break;
1023	case kAcpiOperationRegionSpace_PciConfig: bRegionSpace = 0x02; break;
1024	case kAcpiOperationRegionSpace_EmbeddedControl: bRegionSpace = 0x03; break;
1025	case kAcpiOperationRegionSpace_SmBus: bRegionSpace = 0x04; break;
1026	case kAcpiOperationRegionSpace_SystemCmos: bRegionSpace = 0x05; break;
1027	case kAcpiOperationRegionSpace_PciBarTarget: bRegionSpace = 0x06; break;
1028	case kAcpiOperationRegionSpace_Ipmi: bRegionSpace = 0x07; break;
1029	case kAcpiOperationRegionSpace_Gpio: bRegionSpace = 0x08; break;
1030	case kAcpiOperationRegionSpace_GenericSerialBus: bRegionSpace = 0x09; break;
1031	case kAcpiOperationRegionSpace_Pcc: bRegionSpace = 0x0a; break;
1032	default:
1033	pThis->rcErr = VERR_INVALID_PARAMETER;
1034	AssertFailedReturn(pThis->rcErr);
1035	}
1036	rtAcpiTblAppendByte(pThis, bRegionSpace);
1037	return pThis->rcErr;
1038	}
1039
1040
1041	RTDECL(int) RTAcpiTblOpRegionAppend(RTACPITBL hAcpiTbl, const char *pszName, RTACPIOPREGIONSPACE enmSpace,
1042	uint64_t offRegion, uint64_t cbRegion)
1043	{
1044	PRTACPITBLINT pThis = hAcpiTbl;
1045	AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
1046
1047	int rc = RTAcpiTblOpRegionAppendEx(pThis, pszName, enmSpace);
1048	if (RT_FAILURE(rc))
1049	return rc;
1050
1051	RTAcpiTblIntegerAppend(pThis, offRegion);
1052	RTAcpiTblIntegerAppend(pThis, cbRegion);
1053	return pThis->rcErr;
1054	}
1055
1056
1057	RTDECL(int) RTAcpiTblFieldAppend(RTACPITBL hAcpiTbl, const char *pszNameRef, RTACPIFIELDACC enmAcc,
1058	bool fLock, RTACPIFIELDUPDATE enmUpdate, PCRTACPIFIELDENTRY paFields,
1059	uint32_t cFields)
1060	{
1061	PRTACPITBLINT pThis = hAcpiTbl;
1062	AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
1063
1064	rtAcpiTblPkgStartExt(pThis, ACPI_AML_BYTE_CODE_EXT_OP_FIELD);
1065	rtAcpiTblAppendNameString(pThis, pszNameRef);
1066
1067	uint8_t fFlags = 0;
1068	switch (enmAcc)
1069	{
1070	case kAcpiFieldAcc_Any: fFlags = 0; break;
1071	case kAcpiFieldAcc_Byte: fFlags = 1; break;
1072	case kAcpiFieldAcc_Word: fFlags = 2; break;
1073	case kAcpiFieldAcc_DWord: fFlags = 3; break;
1074	case kAcpiFieldAcc_QWord: fFlags = 4; break;
1075	case kAcpiFieldAcc_Buffer: fFlags = 5; break;
1076	default:
1077	pThis->rcErr = VERR_INVALID_PARAMETER;
1078	AssertFailedReturn(pThis->rcErr);
1079	}
1080	if (fLock)
1081	fFlags \|= RT_BIT(4);
1082	switch (enmUpdate)
1083	{
1084	case kAcpiFieldUpdate_Preserve: fFlags \|= 0 << 5; break;
1085	case kAcpiFieldUpdate_WriteAsOnes: fFlags \|= 1 << 5; break;
1086	case kAcpiFieldUpdate_WriteAsZeroes: fFlags \|= 2 << 5; break;
1087	default:
1088	pThis->rcErr = VERR_INVALID_PARAMETER;
1089	AssertFailedReturn(pThis->rcErr);
1090	}
1091	rtAcpiTblAppendByte(pThis, fFlags);
1092
1093	for (uint32_t i = 0; i < cFields; i++)
1094	{
1095	rtAcpiTblAppendNameString(pThis, paFields[i].pszName);
1096	rtAcpiTblEncodePkgLength(pThis, paFields[i].cBits);
1097	}
1098
1099	rtAcpiTblPkgFinish(pThis, ACPI_AML_BYTE_CODE_EXT_OP_FIELD);
1100	return pThis->rcErr;
1101	}
1102
1103
1104	/**
1105	* Ensures there is at least the given amount of space in the given ACPI resource.
1106	*
1107	* @returns Pointer to the free buffer space or NULL if out of memory.
1108	* @param pThis The ACPI resource instance.
1109	* @param cbReq Number of free bytes required.
1110	*/
1111	static uint8_t *rtAcpiResBufEnsureSpace(PRTACPIRESINT pThis, uint32_t cbReq)
1112	{
1113	if (RT_LIKELY(pThis->cbResBuf - pThis->offResBuf >= cbReq))
1114	{
1115	uint8_t *pb = &pThis->pbResBuf[pThis->offResBuf];
1116	pThis->offResBuf += cbReq;
1117	return pb;
1118	}
1119
1120	size_t const cbNew = RT_ALIGN_Z(pThis->cbResBuf + cbReq, _4K);
1121	uint8_t pbNew = (uint8_t )RTMemRealloc(pThis->pbResBuf, cbNew);
1122	if (RT_UNLIKELY(!pbNew))
1123	{
1124	pThis->rcErr = VERR_NO_MEMORY;
1125	return NULL;
1126	}
1127
1128	pThis->pbResBuf = pbNew;
1129	pThis->cbResBuf = cbNew;
1130
1131	uint8_t *pb = &pThis->pbResBuf[pThis->offResBuf];
1132	pThis->offResBuf += cbReq;
1133	return pb;
1134	}
1135
1136
1137	/**
1138	* Encodes an ACPI 16-bit integer in the given byte buffer.
1139	*
1140	* @returns Pointer to after the encoded integer.
1141	* @param pb Where to encode the integer into.
1142	* @param u16 The 16-bit unsigned integere to encode.
1143	*/
1144	DECLINLINE(uint8_t ) rtAcpiResEncode16BitInteger(uint8_t pb, uint16_t u16)
1145	{
1146	*pb++ = (uint8_t)u16;
1147	*pb++ = (uint8_t)(u16 >> 8);
1148	return pb;
1149	}
1150
1151
1152	/**
1153	* Encodes an ACPI 32-bit integer in the given byte buffer.
1154	*
1155	* @returns Pointer to after the encoded integer.
1156	* @param pb Where to encode the integer into.
1157	* @param u32 The 32-bit unsigned integere to encode.
1158	*/
1159	DECLINLINE(uint8_t ) rtAcpiResEncode32BitInteger(uint8_t pb, uint32_t u32)
1160	{
1161	*pb++ = (uint8_t)u32;
1162	*pb++ = (uint8_t)(u32 >> 8);
1163	*pb++ = (uint8_t)(u32 >> 16);
1164	*pb++ = (uint8_t)(u32 >> 24);
1165	return pb;
1166	}
1167
1168	/**
1169	* Encodes an ACPI 64-bit integer in the given byte buffer.
1170	*
1171	* @returns Pointer to after the encoded integer.
1172	* @param pb Where to encode the integer into.
1173	* @param u64 The 64-bit unsigned integere to encode.
1174	*/
1175
1176	DECLINLINE(uint8_t ) rtAcpiResEncode64BitInteger(uint8_t pb, uint64_t u64)
1177	{
1178	*pb++ = (uint8_t)u64;
1179	*pb++ = (uint8_t)(u64 >> 8);
1180	*pb++ = (uint8_t)(u64 >> 16);
1181	*pb++ = (uint8_t)(u64 >> 24);
1182	*pb++ = (uint8_t)(u64 >> 32);
1183	*pb++ = (uint8_t)(u64 >> 40);
1184	*pb++ = (uint8_t)(u64 >> 48);
1185	*pb++ = (uint8_t)(u64 >> 56);
1186	return pb;
1187	}
1188
1189
1190	RTDECL(int) RTAcpiResourceCreate(PRTACPIRES phAcpiRes)
1191	{
1192	AssertPtrReturn(phAcpiRes, VERR_INVALID_POINTER);
1193
1194	PRTACPIRESINT pThis = (PRTACPIRESINT)RTMemAllocZ(sizeof(*pThis));
1195	if (pThis)
1196	{
1197	pThis->pbResBuf = (uint8_t *)RTMemAlloc(64);
1198	if (pThis->pbResBuf)
1199	{
1200	pThis->offResBuf = 0;
1201	pThis->cbResBuf = 64;
1202	pThis->fSealed = false;
1203	pThis->rcErr = VINF_SUCCESS;
1204
1205	*phAcpiRes = pThis;
1206	return VINF_SUCCESS;
1207	}
1208
1209	RTMemFree(pThis);
1210	}
1211
1212	return VERR_NO_MEMORY;
1213	}
1214
1215
1216	RTDECL(void) RTAcpiResourceDestroy(RTACPIRES hAcpiRes)
1217	{
1218	PRTACPIRESINT pThis = hAcpiRes;
1219	AssertPtrReturnVoid(pThis);
1220
1221	RTMemFree(pThis->pbResBuf);
1222	pThis->pbResBuf = NULL;
1223	pThis->cbResBuf = 0;
1224	pThis->offResBuf = 0;
1225	RTMemFree(pThis);
1226	}
1227
1228
1229	RTDECL(void) RTAcpiResourceReset(RTACPIRES hAcpiRes)
1230	{
1231	PRTACPIRESINT pThis = hAcpiRes;
1232	AssertPtrReturnVoid(pThis);
1233
1234	pThis->offResBuf = 0;
1235	pThis->fSealed = false;
1236	pThis->rcErr = VINF_SUCCESS;
1237	}
1238
1239
1240	RTDECL(int) RTAcpiResourceSeal(RTACPIRES hAcpiRes)
1241	{
1242	PRTACPIRESINT pThis = hAcpiRes;
1243	AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
1244	AssertReturn(!pThis->fSealed, VERR_INVALID_STATE);
1245	AssertRCReturn(pThis->rcErr, pThis->rcErr);
1246
1247	/* Add the end tag. */
1248	uint8_t *pb = rtAcpiResBufEnsureSpace(pThis, 2);
1249	if (!pb)
1250	return VERR_NO_MEMORY;
1251
1252	*pb++ = ACPI_RSRCS_TAG_END;
1253	/*
1254	* Generate checksum, we could just write 0 here which will be treated as checksum operation succeeded,
1255	* but having this might catch some bugs.
1256	*
1257	* Checksum algorithm is the same as with the ACPI tables.
1258	*/
1259	pb = RTAcpiChecksumGenerate(pThis->pbResBuf, pThis->offResBuf - 1); / Exclude the checksum field. */
1260
1261	pThis->fSealed = true;
1262	return VINF_SUCCESS;
1263	}
1264
1265
1266	RTDECL(int) RTAcpiResourceQueryBuffer(RTACPIRES hAcpiRes, const void *ppvRes, size_t pcbRes)
1267	{
1268	PRTACPIRESINT pThis = hAcpiRes;
1269	AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
1270	AssertReturn(pThis->fSealed, VERR_INVALID_STATE);
1271	AssertRCReturn(pThis->rcErr, pThis->rcErr);
1272
1273	*ppvRes = pThis->pbResBuf;
1274	*pcbRes = pThis->offResBuf;
1275	return VINF_SUCCESS;
1276	}
1277
1278
1279	RTDECL(int) RTAcpiResourceAdd32BitFixedMemoryRange(RTACPIRES hAcpiRes, uint32_t u32AddrBase, uint32_t cbRange,
1280	bool fRw)
1281	{
1282	PRTACPIRESINT pThis = hAcpiRes;
1283	AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
1284	AssertReturn(!pThis->fSealed, VERR_INVALID_STATE);
1285	AssertRCReturn(pThis->rcErr, pThis->rcErr);
1286
1287	uint8_t *pb = rtAcpiResBufEnsureSpace(pThis, 12);
1288	if (!pb)
1289	return VERR_NO_MEMORY;
1290
1291	pb[0] = ACPI_RSRCS_LARGE_TYPE \| ACPI_RSRCS_ITEM_32BIT_FIXED_MEMORY_RANGE; /* Tag */
1292	pb[1] = 9; /* Length[7:0] */
1293	pb[2] = 0; /* Length[15:8] */
1294	pb[3] = fRw ? 1 : 0; /* Information */
1295	rtAcpiResEncode32BitInteger(&pb[4], u32AddrBase);
1296	rtAcpiResEncode32BitInteger(&pb[8], cbRange);
1297	return VINF_SUCCESS;
1298	}
1299
1300
1301	RTDECL(int) RTAcpiResourceAddExtendedInterrupt(RTACPIRES hAcpiRes, bool fConsumer, bool fEdgeTriggered, bool fActiveLow, bool fShared,
1302	bool fWakeCapable, uint8_t cIntrs, uint32_t *pau32Intrs)
1303	{
1304	PRTACPIRESINT pThis = hAcpiRes;
1305	AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
1306	AssertReturn(!pThis->fSealed, VERR_INVALID_STATE);
1307	AssertRCReturn(pThis->rcErr, pThis->rcErr);
1308
1309	uint8_t pb = rtAcpiResBufEnsureSpace(pThis, 3 + 2 + cIntrs sizeof(uint32_t));
1310	if (!pb)
1311	return VERR_NO_MEMORY;
1312
1313	pb[0] = ACPI_RSRCS_LARGE_TYPE \| ACPI_RSRCS_ITEM_EXTENDED_INTERRUPT; /* Tag */
1314	rtAcpiResEncode16BitInteger(&pb[1], 2 + cIntrs * sizeof(uint32_t)); /* Length[15:0] */
1315	pb[3] = (fConsumer ? ACPI_RSRCS_EXT_INTR_VEC_F_CONSUMER : ACPI_RSRCS_EXT_INTR_VEC_F_PRODUCER)
1316	\| (fEdgeTriggered ? ACPI_RSRCS_EXT_INTR_VEC_F_EDGE_TRIGGERED : ACPI_RSRCS_EXT_INTR_VEC_F_LEVEL_TRIGGERED)
1317	\| (fActiveLow ? ACPI_RSRCS_EXT_INTR_VEC_F_ACTIVE_LOW : ACPI_RSRCS_EXT_INTR_VEC_F_ACTIVE_HIGH)
1318	\| (fShared ? ACPI_RSRCS_EXT_INTR_VEC_F_SHARED : ACPI_RSRCS_EXT_INTR_VEC_F_EXCLUSIVE)
1319	\| (fWakeCapable ? ACPI_RSRCS_EXT_INTR_VEC_F_WAKE_CAP : ACPI_RSRCS_EXT_INTR_VEC_F_NOT_WAKE_CAP);
1320	pb[4] = cIntrs;
1321	pb = &pb[5];
1322	for (uint32_t i = 0; i < cIntrs; i++)
1323	pb = rtAcpiResEncode32BitInteger(pb, pau32Intrs[i]);
1324
1325	return VINF_SUCCESS;
1326	}
1327
1328
1329	/**
1330	* Common worker for encoding a new quad word (64-bit) address range.
1331	*
1332	* @returns IPRT status code
1333	* @retval VERR_NO_MEMORY if not enough memory could be reserved in the ACPI resource descriptor.
1334	* @param pThis The ACPI resource instance.
1335	* @param bType The ACPI address range type.
1336	* @param fAddrSpace Combination of RTACPI_RESOURCE_ADDR_RANGE_F_XXX.
1337	* @param fType The range flags returned from rtAcpiResourceMemoryRangeToTypeFlags().
1338	* @param u64AddrMin The start address of the memory range.
1339	* @param u64AddrMax Last valid address of the range.
1340	* @param u64OffTrans Translation offset being applied to the address (for a PCIe bridge or IOMMU for example).
1341	* @param u64Granularity The access granularity of the range in bytes.
1342	* @param u64Length Length of the memory range in bytes.
1343	*/
1344	static int rtAcpiResourceAddQWordAddressRange(PRTACPIRESINT pThis, uint8_t bType, uint32_t fAddrSpace, uint8_t fType,
1345	uint64_t u64AddrMin, uint64_t u64AddrMax, uint64_t u64OffTrans,
1346	uint64_t u64Granularity, uint64_t u64Length)
1347	{
1348	uint8_t *pb = rtAcpiResBufEnsureSpace(pThis, 3 + 43);
1349	if (!pb)
1350	return VERR_NO_MEMORY;
1351
1352	pb[0] = ACPI_RSRCS_LARGE_TYPE \| ACPI_RSRCS_ITEM_QWORD_ADDR_SPACE; /* Tag */
1353	pb[1] = 43; /* Length[7:0] */
1354	pb[2] = 0; /* Length[15:8] */
1355	pb[3] = bType;
1356	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)
1357	\| (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)
1358	\| (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);
1359	pb[5] = fType;
1360
1361	pb = rtAcpiResEncode64BitInteger(&pb[6], u64Granularity);
1362	pb = rtAcpiResEncode64BitInteger(pb, u64AddrMin);
1363	pb = rtAcpiResEncode64BitInteger(pb, u64AddrMax);
1364	pb = rtAcpiResEncode64BitInteger(pb, u64OffTrans);
1365	rtAcpiResEncode64BitInteger(pb, u64Length);
1366	return VINF_SUCCESS;
1367	}
1368
1369
1370	/**
1371	* Common worker for encoding a new double word (32-bit) address range.
1372	*
1373	* @returns IPRT status code
1374	* @retval VERR_NO_MEMORY if not enough memory could be reserved in the ACPI resource descriptor.
1375	* @param pThis The ACPI resource instance.
1376	* @param bType The ACPI address range type.
1377	* @param fAddrSpace Combination of RTACPI_RESOURCE_ADDR_RANGE_F_XXX.
1378	* @param fType The range flags returned from rtAcpiResourceMemoryRangeToTypeFlags().
1379	* @param u32AddrMin The start address of the memory range.
1380	* @param u32AddrMax Last valid address of the range.
1381	* @param u32OffTrans Translation offset being applied to the address (for a PCIe bridge or IOMMU for example).
1382	* @param u32Granularity The access granularity of the range in bytes.
1383	* @param u32Length Length of the memory range in bytes.
1384	*/
1385	static int rtAcpiResourceAddDWordAddressRange(PRTACPIRESINT pThis, uint8_t bType, uint32_t fAddrSpace, uint8_t fType,
1386	uint32_t u32AddrMin, uint32_t u32AddrMax, uint32_t u32OffTrans,
1387	uint32_t u32Granularity, uint32_t u32Length)
1388	{
1389	uint8_t *pb = rtAcpiResBufEnsureSpace(pThis, 3 + 23);
1390	if (!pb)
1391	return VERR_NO_MEMORY;
1392
1393	pb[0] = ACPI_RSRCS_LARGE_TYPE \| ACPI_RSRCS_ITEM_DWORD_ADDR_SPACE; /* Tag */
1394	pb[1] = 23; /* Length[7:0] */
1395	pb[2] = 0; /* Length[15:8] */
1396	pb[3] = bType;
1397	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)
1398	\| (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)
1399	\| (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);
1400	pb[5] = fType;
1401
1402	pb = rtAcpiResEncode32BitInteger(&pb[6], u32Granularity);
1403	pb = rtAcpiResEncode32BitInteger(pb, u32AddrMin);
1404	pb = rtAcpiResEncode32BitInteger(pb, u32AddrMax);
1405	pb = rtAcpiResEncode32BitInteger(pb, u32OffTrans);
1406	rtAcpiResEncode32BitInteger(pb, u32Length);
1407	return VINF_SUCCESS;
1408	}
1409
1410
1411	/**
1412	* Converts the given cacheability, range type and R/W flag to the ACPI resource flags.
1413	*
1414	* @returns Converted ACPI resource flags.
1415	* @param enmCacheability The cacheability enum to convert.
1416	* @param enmType THe memory range type enum to convert.
1417	* @param fRw The read/write flag.
1418	*/
1419	DECLINLINE(uint8_t) rtAcpiResourceMemoryRangeToTypeFlags(RTACPIRESMEMRANGECACHEABILITY enmCacheability, RTACPIRESMEMRANGETYPE enmType,
1420	bool fRw)
1421	{
1422	uint8_t fType = fRw ? ACPI_RSRCS_ADDR_SPACE_MEM_F_RW : ACPI_RSRCS_ADDR_SPACE_MEM_F_RO;
1423
1424	switch (enmCacheability)
1425	{
1426	case kAcpiResMemRangeCacheability_NonCacheable:
1427	fType \|= ACPI_RSRCS_ADDR_SPACE_MEM_F_CACHE_NON_CACHEABLE;
1428	break;
1429	case kAcpiResMemRangeCacheability_Cacheable:
1430	fType \|= ACPI_RSRCS_ADDR_SPACE_MEM_F_CACHE_CACHEABLE;
1431	break;
1432	case kAcpiResMemRangeCacheability_CacheableWriteCombining:
1433	fType \|= ACPI_RSRCS_ADDR_SPACE_MEM_F_CACHE_CACHEABLE_WR_COMB;
1434	break;
1435	case kAcpiResMemRangeCacheability_CacheablePrefetchable:
1436	fType \|= ACPI_RSRCS_ADDR_SPACE_MEM_F_CACHE_CACHEABLE_PREFETCHABLE;
1437	break;
1438	case kAcpiResMemRangeCacheability_Invalid:
1439	default:
1440	AssertFailedReturn(0);
1441	}
1442
1443	switch (enmType)
1444	{
1445	case kAcpiResMemType_Memory:
1446	fType \|= ACPI_RSRCS_ADDR_SPACE_MEM_F_ATTR_MEMORY;
1447	break;
1448	case kAcpiResMemType_Reserved:
1449	fType \|= ACPI_RSRCS_ADDR_SPACE_MEM_F_ATTR_RESERVED;
1450	break;
1451	case kAcpiResMemType_Acpi:
1452	fType \|= ACPI_RSRCS_ADDR_SPACE_MEM_F_ATTR_ACPI;
1453	break;
1454	case kAcpiResMemType_Nvs:
1455	fType \|= ACPI_RSRCS_ADDR_SPACE_MEM_F_ATTR_NVS;
1456	break;
1457	case kAcpiResMemType_Invalid:
1458	default:
1459	AssertFailedReturn(0);
1460	}
1461
1462	return fType;
1463	}
1464
1465
1466	RTDECL(int) RTAcpiResourceAddQWordMemoryRange(RTACPIRES hAcpiRes, RTACPIRESMEMRANGECACHEABILITY enmCacheability,
1467	RTACPIRESMEMRANGETYPE enmType, bool fRw, uint32_t fAddrSpace,
1468	uint64_t u64AddrMin, uint64_t u64AddrMax, uint64_t u64OffTrans,
1469	uint64_t u64Granularity, uint64_t u64Length)
1470	{
1471	PRTACPIRESINT pThis = hAcpiRes;
1472	AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
1473	AssertReturn(enmCacheability != kAcpiResMemRangeCacheability_Invalid, VERR_INVALID_PARAMETER);
1474	AssertReturn(enmType != kAcpiResMemType_Invalid, VERR_INVALID_PARAMETER);
1475	AssertReturn(!(fAddrSpace & ~RTACPI_RESOURCE_ADDR_RANGE_F_VALID_MASK), VERR_INVALID_PARAMETER);
1476	AssertReturn(!pThis->fSealed, VERR_INVALID_STATE);
1477	AssertRCReturn(pThis->rcErr, pThis->rcErr);
1478
1479	uint8_t fType = rtAcpiResourceMemoryRangeToTypeFlags(enmCacheability, enmType, fRw);
1480	return rtAcpiResourceAddQWordAddressRange(pThis, ACPI_RSRCS_ADDR_SPACE_TYPE_MEMORY, fAddrSpace, fType,
1481	u64AddrMin, u64AddrMax, u64OffTrans, u64Granularity, u64Length);
1482	}
1483
1484
1485	RTDECL(int) RTAcpiResourceAddDWordMemoryRange(RTACPIRES hAcpiRes, RTACPIRESMEMRANGECACHEABILITY enmCacheability,
1486	RTACPIRESMEMRANGETYPE enmType, bool fRw, uint32_t fAddrSpace,
1487	uint32_t u32AddrMin, uint32_t u32AddrMax, uint32_t u32OffTrans,
1488	uint32_t u32Granularity, uint32_t u32Length)
1489	{
1490	PRTACPIRESINT pThis = hAcpiRes;
1491	AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
1492	AssertReturn(enmCacheability != kAcpiResMemRangeCacheability_Invalid, VERR_INVALID_PARAMETER);
1493	AssertReturn(enmType != kAcpiResMemType_Invalid, VERR_INVALID_PARAMETER);
1494	AssertReturn(!(fAddrSpace & ~RTACPI_RESOURCE_ADDR_RANGE_F_VALID_MASK), VERR_INVALID_PARAMETER);
1495	AssertReturn(!pThis->fSealed, VERR_INVALID_STATE);
1496	AssertRCReturn(pThis->rcErr, pThis->rcErr);
1497
1498	uint8_t fType = rtAcpiResourceMemoryRangeToTypeFlags(enmCacheability, enmType, fRw);
1499	return rtAcpiResourceAddDWordAddressRange(pThis, ACPI_RSRCS_ADDR_SPACE_TYPE_MEMORY, fAddrSpace, fType,
1500	u32AddrMin, u32AddrMax, u32OffTrans, u32Granularity, u32Length);
1501	}
1502
1503
1504	RTDECL(int) RTAcpiResourceAddQWordIoRange(RTACPIRES hAcpiRes, RTACPIRESIORANGETYPE enmIoType, RTACPIRESIORANGE enmIoRange,
1505	uint32_t fAddrSpace, uint64_t u64AddrMin, uint64_t u64AddrMax, uint64_t u64OffTrans,
1506	uint64_t u64Granularity, uint64_t u64Length)
1507	{
1508	PRTACPIRESINT pThis = hAcpiRes;
1509	AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
1510	AssertReturn(enmIoType != kAcpiResIoRangeType_Invalid, VERR_INVALID_PARAMETER);
1511	AssertReturn(enmIoRange != kAcpiResIoRange_Invalid, VERR_INVALID_PARAMETER);
1512	AssertReturn(!(fAddrSpace & ~RTACPI_RESOURCE_ADDR_RANGE_F_VALID_MASK), VERR_INVALID_PARAMETER);
1513	AssertReturn(!pThis->fSealed, VERR_INVALID_STATE);
1514	AssertRCReturn(pThis->rcErr, pThis->rcErr);
1515
1516	uint8_t fType = 0;
1517	switch (enmIoType)
1518	{
1519	case kAcpiResIoRangeType_Static:
1520	fType = ACPI_RSRCS_ADDR_SPACE_IO_F_TYPE_STATIC;
1521	break;
1522	case kAcpiResIoRangeType_Translation_Sparse:
1523	fType = ACPI_RSRCS_ADDR_SPACE_IO_F_TYPE_TRANSLATION \| ACPI_RSRCS_ADDR_SPACE_IO_F_TRANSLATION_SPARSE;
1524	break;
1525	case kAcpiResIoRangeType_Translation_Dense:
1526	fType = ACPI_RSRCS_ADDR_SPACE_IO_F_TYPE_TRANSLATION \| ACPI_RSRCS_ADDR_SPACE_IO_F_TRANSLATION_DENSE;
1527	break;
1528	case kAcpiResIoRangeType_Invalid:
1529	default:
1530	AssertFailedReturn(VERR_INVALID_PARAMETER);
1531	}
1532
1533	switch (enmIoRange)
1534	{
1535	case kAcpiResIoRange_NonIsaOnly:
1536	fType \|= ACPI_RSRCS_ADDR_SPACE_IO_F_RANGE_NON_ISA_ONLY;
1537	break;
1538	case kAcpiResIoRange_IsaOnly:
1539	fType \|= ACPI_RSRCS_ADDR_SPACE_IO_F_RANGE_ISA_ONLY;
1540	break;
1541	case kAcpiResIoRange_Whole:
1542	fType \|= ACPI_RSRCS_ADDR_SPACE_IO_F_RANGE_WHOLE;
1543	break;
1544	case kAcpiResIoRange_Invalid:
1545	default:
1546	AssertFailedReturn(VERR_INVALID_PARAMETER);
1547	}
1548
1549	return rtAcpiResourceAddQWordAddressRange(pThis, ACPI_RSRCS_ADDR_SPACE_TYPE_IO, fAddrSpace, fType,
1550	u64AddrMin, u64AddrMax, u64OffTrans, u64Granularity, u64Length);
1551	}
1552
1553
1554	RTDECL(int) RTAcpiResourceAddWordBusNumber(RTACPIRES hAcpiRes, uint32_t fAddrSpace, uint16_t u16BusMin, uint16_t u16BusMax,
1555	uint16_t u16OffTrans, uint16_t u16Granularity, uint16_t u16Length)
1556	{
1557	PRTACPIRESINT pThis = hAcpiRes;
1558	AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
1559	AssertReturn(!(fAddrSpace & ~RTACPI_RESOURCE_ADDR_RANGE_F_VALID_MASK), VERR_INVALID_PARAMETER);
1560	AssertReturn(!pThis->fSealed, VERR_INVALID_STATE);
1561	AssertRCReturn(pThis->rcErr, pThis->rcErr);
1562
1563	uint8_t *pb = rtAcpiResBufEnsureSpace(pThis, 3 + 13);
1564	if (!pb)
1565	return VERR_NO_MEMORY;
1566
1567	pb[0] = ACPI_RSRCS_LARGE_TYPE \| ACPI_RSRCS_ITEM_WORD_ADDR_SPACE; /* Tag */
1568	pb[1] = 13; /* Length[7:0] */
1569	pb[2] = 0; /* Length[15:8] */
1570	pb[3] = ACPI_RSRCS_ADDR_SPACE_TYPE_BUS_NUM_RANGE;
1571	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)
1572	\| (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)
1573	\| (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);
1574	pb[5] = 0;
1575
1576	pb = rtAcpiResEncode16BitInteger(&pb[6], u16Granularity);
1577	pb = rtAcpiResEncode16BitInteger(pb, u16BusMin);
1578	pb = rtAcpiResEncode16BitInteger(pb, u16BusMax);
1579	pb = rtAcpiResEncode16BitInteger(pb, u16OffTrans);
1580	rtAcpiResEncode16BitInteger(pb, u16Length);
1581	return VINF_SUCCESS;
1582
1583	}

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

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

Download in other formats: