acpi.cpp@ 108015

Last change on this file since 108015 was 108015, checked in by vboxsync, 3 weeks ago
Runtime/acpi: Some re-arrangement and start with an ASL compiler, bugref:10733
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 59.3 KB

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

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

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

Download in other formats: