VirtualBox

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

Last change on this file since 107952 was 107952, checked in by vboxsync, 4 weeks ago

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

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette