Changeset 107063 in vbox

Timestamp:

Nov 20, 2024 5:22:16 PM (6 months ago)

Author:

vboxsync

svn:sync-xref-src-repo-rev:

166017

Message:

Runtime/RTAcpi*: Some updates to the ACPI code generation, bugref:10733

Location:

trunk

Files:

• include/iprt/acpi.h (modified) (1 diff)
• include/iprt/mangling.h (modified) (2 diffs)
• src/VBox/Runtime/common/misc/acpi.cpp (modified) (2 diffs)

trunk/include/iprt/acpi.h

@@ -445 +445 @@
 
 
+/**
+ * Known operation region space types.
+ */
+typedef enum RTACPIOPREGIONSPACE
+{
+    /** Invalid region space type. */
+    kAcpiOperationRegionSpace_Invalid = 0,
+    /** Region is in system memory space. */
+    kAcpiOperationRegionSpace_SystemMemory,
+    /** Region is in system I/O space. */
+    kAcpiOperationRegionSpace_SystemIo,
+    /** Region is in PCI config space. */
+    kAcpiOperationRegionSpace_PciConfig,
+    /** Region is in embedded control space. */
+    kAcpiOperationRegionSpace_EmbeddedControl,
+    /** Region is in SMBUS space. */
+    kAcpiOperationRegionSpace_SmBus,
+    /** Region is in system CMOS space. */
+    kAcpiOperationRegionSpace_SystemCmos,
+    /** Region is a PCI bar target. */
+    kAcpiOperationRegionSpace_PciBarTarget,
+    /** Region is in IPMI space. */
+    kAcpiOperationRegionSpace_Ipmi,
+    /** Region is in GPIO space. */
+    kAcpiOperationRegionSpace_Gpio,
+    /** Region is in generic serial bus space. */
+    kAcpiOperationRegionSpace_GenericSerialBus,
+    /** Region is in platform communications channel (PCC) space. */
+    kAcpiOperationRegionSpace_Pcc,
+    /** 32bit hack. */
+    kAcpiOperationRegionSpace_32bit_Hack = 0x7fffffff
+} RTACPIOPREGIONSPACE;
+
+
+/**
+ * Appends a new OperationRegion() to the given ACPI table.
+ *
+ * @returns IPRT status code.
+ * @param   hAcpiTbl            The ACPI table handle.
+ * @param   pszName             The name of the operation region.
+ * @param   enmSpace            The operation region space type.
+ * @param   offRegion           Offset of the region.
+ * @param   cbRegion            Size of the region in bytes.
+ */
+RTDECL(int) RTAcpiTblOpRegionAppend(RTACPITBL hAcpiTbl, const char *pszName, RTACPIOPREGIONSPACE enmSpace,
+                                    uint64_t offRegion, uint64_t cbRegion);
+
+
+/**
+ * Field access type.
+ */
+typedef enum RTACPIFIELDACC
+{
+    /** Invalid access type. */
+    kAcpiFieldAcc_Invalid = 0,
+    /** Any access width is okay. */
+    kAcpiFieldAcc_Any,
+    /** Byte (8-bit) access. */
+    kAcpiFieldAcc_Byte,
+    /** Word (16-bit) access. */
+    kAcpiFieldAcc_Word,
+    /** Double word (32-bit) access. */
+    kAcpiFieldAcc_DWord,
+    /** Quad word (64-bit) access. */
+    kAcpiFieldAcc_QWord,
+    /** Buffer like access. */
+    kAcpiFieldAcc_Buffer
+} RTACPIFIELDACC;
+
+
+/**
+ * Field update rule.
+ */
+typedef enum RTACPIFIELDUPDATE
+{
+    /** Invalid upadte rule. */
+    kAcpiFieldUpdate_Invalid = 0,
+    /** Preserve content not being accessed. */
+    kAcpiFieldUpdate_Preserve,
+    /** Write as ones. */
+    kAcpiFieldUpdate_WriteAsOnes,
+    /** Write as zeroes. */
+    kAcpiFieldUpdate_WriteAsZeroes
+} RTACPIFIELDUPDATE;
+
+
+/**
+ * Field entry.
+ */
+typedef struct RTACPIFIELDENTRY
+{
+    /** The field name. */
+    const char              *pszName;
+    /** Number of bits of the field. */
+    uint64_t                cBits;
+} RTACPIFIELDENTRY;
+/** Pointer to a field entry. */
+typedef RTACPIFIELDENTRY *PRTACPIFIELDENTRY;
+/** Pointer to a const field entry. */
+typedef const RTACPIFIELDENTRY *PCRTACPIFIELDENTRY;
+
+
+/**
+ * Appends a new field descriptor to the given ACPI table.
+ *
+ * @returns IPRT status code.
+ * @param   hAcpiTbl            The ACPI table handle.
+ * @param   pszNameRef          The region/buffer the field describes.
+ * @param   enmAcc              The access type,
+ * @param   fLock               Flag whether access must happen under a lock.
+ * @param   enmUpdate           The update rule.
+ * @param   paFields            Pointer to the field descriptors.
+ * @param   cFields             Number of entries in the array.
+ */
+RTDECL(int) RTAcpiTblFieldAppend(RTACPITBL hAcpiTbl, const char *pszNameRef, RTACPIFIELDACC enmAcc,
+                                 bool fLock, RTACPIFIELDUPDATE enmUpdate, PCRTACPIFIELDENTRY paFields,
+                                 uint32_t cFields);
+
+
+
 /** @name ACPI resource builder related API.
  * @{ */

trunk/include/iprt/mangling.h

@@ -401 +401 @@
 # define RTAcpiTblElseFinalize                          RT_MANGLER(RTAcpiTblElseFinalize)
 # define RTAcpiTblElseStart                             RT_MANGLER(RTAcpiTblElseStart)
+# define RTAcpiTblFieldAppend                           RT_MANGLER(RTAcpiTblFieldAppend)
 # define RTAcpiTblFinalize                              RT_MANGLER(RTAcpiTblFinalize)
 # define RTAcpiTblGetSize                               RT_MANGLER(RTAcpiTblGetSize)
@@ -411 +412 @@
 # define RTAcpiTblMethodFinalize                        RT_MANGLER(RTAcpiTblMethodFinalize)
 # define RTAcpiTblNameAppend                            RT_MANGLER(RTAcpiTblNameAppend)
+# define RTAcpiTblOpRegionAppend                        RT_MANGLER(RTAcpiTblOpRegionAppend)
 # define RTAcpiTblPackageStart                          RT_MANGLER(RTAcpiTblPackageStart)
 # define RTAcpiTblPackageFinalize                       RT_MANGLER(RTAcpiTblPackageFinalize)

trunk/src/VBox/Runtime/common/misc/acpi.cpp

@@ -431 +431 @@
 
 
+/**
+ * Encodes a PkgLength item for the given number.
+ *
+ * @returns IPRT status code.
+ * @param pThis                 The ACPI table instance.
+ * @param u64Length             The length to encode.
+ */
+DECLINLINE(int) rtAcpiTblEncodePkgLength(PRTACPITBLINT pThis, uint64_t u64Length)
+{
+    AssertReturn(u64Length < RT_BIT_32(28), VERR_BUFFER_OVERFLOW);
+
+    if (u64Length <= 63)
+    {
+        /* PkgLength only consists of the package lead byte. */
+        rtAcpiTblAppendByte(pThis, (u64Length & 0x3f));
+    }
+    else if (u64Length < RT_BIT_32(12))
+    {
+        uint8_t abData[2];
+        abData[0] = (1 << 6) | (u64Length & 0xf);
+        abData[1] = (u64Length >> 4) & 0xff;
+        rtAcpiTblAppendData(pThis, &abData[0], sizeof(abData));
+    }
+    else if (u64Length < RT_BIT_32(20))
+    {
+        uint8_t abData[3];
+        abData[0] = (1 << 6) | (u64Length & 0xf);
+        abData[1] = (u64Length >> 4)  & 0xff;
+        abData[2] = (u64Length >> 12) & 0xff;
+        rtAcpiTblAppendData(pThis, &abData[0], sizeof(abData));
+    }
+    else if (u64Length < RT_BIT_32(28))
+    {
+        uint8_t abData[4];
+        abData[0] = (1 << 6) | (u64Length & 0xf);
+        abData[1] = (u64Length >> 4)  & 0xff;
+        abData[2] = (u64Length >> 12) & 0xff;
+        abData[3] = (u64Length >> 20) & 0xff;
+        rtAcpiTblAppendData(pThis, &abData[0], sizeof(abData));
+    }
+    else
+        AssertReleaseFailed();
+
+    return VINF_SUCCESS;
+}
+
+
 RTDECL(uint8_t) RTAcpiChecksumGenerate(const void *pvData, size_t cbData)
 {
@@ -926 +973 @@
         return RTAcpiTblUuidAppend(pThis, &Uuid);
 
+    return pThis->rcErr;
+}
+
+
+RTDECL(int) RTAcpiTblOpRegionAppend(RTACPITBL hAcpiTbl, const char *pszName, RTACPIOPREGIONSPACE enmSpace,
+                                    uint64_t offRegion, uint64_t cbRegion)
+{
+    PRTACPITBLINT pThis = hAcpiTbl;
+    AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
+
+    uint8_t abOp[2] = { ACPI_AML_BYTE_CODE_PREFIX_EXT_OP, ACPI_AML_BYTE_CODE_EXT_OP_OP_REGION };
+    rtAcpiTblAppendData(pThis, &abOp[0], sizeof(abOp));
+    rtAcpiTblAppendNameString(pThis, pszName);
+
+    uint8_t bRegionSpace = 0xff;
+    switch (enmSpace)
+    {
+        case kAcpiOperationRegionSpace_SystemMemory:        bRegionSpace = 0x00; break;
+        case kAcpiOperationRegionSpace_SystemIo:            bRegionSpace = 0x01; break;
+        case kAcpiOperationRegionSpace_PciConfig:           bRegionSpace = 0x02; break;
+        case kAcpiOperationRegionSpace_EmbeddedControl:     bRegionSpace = 0x03; break;
+        case kAcpiOperationRegionSpace_SmBus:               bRegionSpace = 0x04; break;
+        case kAcpiOperationRegionSpace_SystemCmos:          bRegionSpace = 0x05; break;
+        case kAcpiOperationRegionSpace_PciBarTarget:        bRegionSpace = 0x06; break;
+        case kAcpiOperationRegionSpace_Ipmi:                bRegionSpace = 0x07; break;
+        case kAcpiOperationRegionSpace_Gpio:                bRegionSpace = 0x08; break;
+        case kAcpiOperationRegionSpace_GenericSerialBus:    bRegionSpace = 0x09; break;
+        case kAcpiOperationRegionSpace_Pcc:                 bRegionSpace = 0x0a; break;
+        default:
+            pThis->rcErr = VERR_INVALID_PARAMETER;
+            AssertFailedReturn(pThis->rcErr);
+    }
+    rtAcpiTblAppendByte(pThis, bRegionSpace);
+    RTAcpiTblIntegerAppend(pThis, offRegion);
+    RTAcpiTblIntegerAppend(pThis, cbRegion);
+    return pThis->rcErr;
+}
+
+
+RTDECL(int) RTAcpiTblFieldAppend(RTACPITBL hAcpiTbl, const char *pszNameRef, RTACPIFIELDACC enmAcc,
+                                 bool fLock, RTACPIFIELDUPDATE enmUpdate, PCRTACPIFIELDENTRY paFields,
+                                 uint32_t cFields)
+{
+    PRTACPITBLINT pThis = hAcpiTbl;
+    AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
+
+    rtAcpiTblPkgStartExt(pThis, ACPI_AML_BYTE_CODE_EXT_OP_FIELD);
+    rtAcpiTblAppendNameString(pThis, pszNameRef);
+
+    uint8_t fFlags = 0;
+    switch (enmAcc)
+    {
+        case kAcpiFieldAcc_Any:    fFlags = 0; break;
+        case kAcpiFieldAcc_Byte:   fFlags = 1; break;
+        case kAcpiFieldAcc_Word:   fFlags = 2; break;
+        case kAcpiFieldAcc_DWord:  fFlags = 3; break;
+        case kAcpiFieldAcc_QWord:  fFlags = 4; break;
+        case kAcpiFieldAcc_Buffer: fFlags = 5; break;
+        default:
+            pThis->rcErr = VERR_INVALID_PARAMETER;
+            AssertFailedReturn(pThis->rcErr);
+    }
+    if (fLock)
+        fFlags |= RT_BIT(4);
+    switch (enmUpdate)
+    {
+        case kAcpiFieldUpdate_Preserve:      fFlags |= 0 << 5; break;
+        case kAcpiFieldUpdate_WriteAsOnes:   fFlags |= 1 << 5; break;
+        case kAcpiFieldUpdate_WriteAsZeroes: fFlags |= 2 << 5; break;
+        default:
+            pThis->rcErr = VERR_INVALID_PARAMETER;
+            AssertFailedReturn(pThis->rcErr);
+    }
+    rtAcpiTblAppendByte(pThis, fFlags);
+
+    for (uint32_t i = 0; i < cFields; i++)
+    {
+        rtAcpiTblAppendNameString(pThis, paFields[i].pszName);
+        rtAcpiTblEncodePkgLength(pThis, paFields[i].cBits);
+    }
+
+    rtAcpiTblPkgFinish(pThis, ACPI_AML_BYTE_CODE_EXT_OP_FIELD);
     return pThis->rcErr;
 }