VirtualBox

Changeset 108184 in vbox for trunk/src


Ignore:
Timestamp:
Feb 12, 2025 3:27:06 PM (3 months ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
167500
Message:

Runtime/RTAcpi*: Parser updates, the code is now able to parse vbox.dsl successfully and generate an AST, bugref:10733

Location:
trunk/src/VBox/Runtime
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Runtime/common/acpi/acpi-compiler.cpp

    r108170 r108184  
    152152    RTACPIASLTERMINAL_KEYWORD_TRANSFER_16,
    153153    RTACPIASLTERMINAL_KEYWORD_TRANSFER_8_16,
     154
     155    RTACPIASLTERMINAL_KEYWORD_WORD_BUS_NUMBER,
     156    RTACPIASLTERMINAL_KEYWORD_MIN_FIXED,
     157    RTACPIASLTERMINAL_KEYWORD_MIN_NOT_FIXED,
     158    RTACPIASLTERMINAL_KEYWORD_MAX_FIXED,
     159    RTACPIASLTERMINAL_KEYWORD_MAX_NOT_FIXED,
     160    RTACPIASLTERMINAL_KEYWORD_RESOURCE_CONSUMER,
     161    RTACPIASLTERMINAL_KEYWORD_RESOURCE_PRODUCER,
     162    RTACPIASLTERMINAL_KEYWORD_POS_DECODE,
     163    RTACPIASLTERMINAL_KEYWORD_SUB_DECODE,
     164
     165    RTACPIASLTERMINAL_KEYWORD_WORD_IO,
     166    RTACPIASLTERMINAL_KEYWORD_ISA_ONLY,
     167    RTACPIASLTERMINAL_KEYWORD_NON_ISA_ONLY,
     168    RTACPIASLTERMINAL_KEYWORD_ENTIRE_RANGE,
     169    RTACPIASLTERMINAL_KEYWORD_TYPE_TRANSLATION,
     170    RTACPIASLTERMINAL_KEYWORD_TYPE_STATIC,
     171    RTACPIASLTERMINAL_KEYWORD_SPARSE_TRANSLATION,
     172    RTACPIASLTERMINAL_KEYWORD_DENSE_TRANSLATION,
     173
     174    RTACPIASLTERMINAL_KEYWORD_DWORD_MEMORY,
     175    RTACPIASLTERMINAL_KEYWORD_QWORD_MEMORY,
     176    RTACPIASLTERMINAL_KEYWORD_CACHEABLE,
     177    RTACPIASLTERMINAL_KEYWORD_WRITE_COMBINING,
     178    RTACPIASLTERMINAL_KEYWORD_PREFETCHABLE,
     179    RTACPIASLTERMINAL_KEYWORD_NON_CACHEABLE,
     180    RTACPIASLTERMINAL_KEYWORD_ADDRESS_RANGE_MEMORY,
     181    RTACPIASLTERMINAL_KEYWORD_ADDRESS_RANGE_NVS,
     182    RTACPIASLTERMINAL_KEYWORD_ADDRESS_RANGE_ACPI,
     183    RTACPIASLTERMINAL_KEYWORD_ADDRESS_RANGE_RESERVED,
    154184
    155185    RTACPIASLTERMINAL_PUNCTUATOR_COMMA,
    … …  
    312342    { RT_STR_TUPLE("ADD"),                      RTSCRIPTLEXTOKTYPE_KEYWORD,    true,  kAcpiAstNodeOp_Add                               },
    313343    { RT_STR_TUPLE("SUBTRACT"),                 RTSCRIPTLEXTOKTYPE_KEYWORD,    true,  kAcpiAstNodeOp_Subtract                          },
     344    { RT_STR_TUPLE("MULTIPLY"),                 RTSCRIPTLEXTOKTYPE_KEYWORD,    true,  kAcpiAstNodeOp_Multiply                          },
    314345    { RT_STR_TUPLE("AND"),                      RTSCRIPTLEXTOKTYPE_KEYWORD,    true,  kAcpiAstNodeOp_And                               },
    315346    { RT_STR_TUPLE("NAND"),                     RTSCRIPTLEXTOKTYPE_KEYWORD,    true,  kAcpiAstNodeOp_Nand                              },
    … …  
    317348    { RT_STR_TUPLE("XOR"),                      RTSCRIPTLEXTOKTYPE_KEYWORD,    true,  kAcpiAstNodeOp_Xor                               },
    318349    { RT_STR_TUPLE("NOT"),                      RTSCRIPTLEXTOKTYPE_KEYWORD,    true,  kAcpiAstNodeOp_Not                               },
     350    { RT_STR_TUPLE("SHIFTLEFT"),                RTSCRIPTLEXTOKTYPE_KEYWORD,    true,  kAcpiAstNodeOp_ShiftLeft                         },
     351    { RT_STR_TUPLE("SHIFTRIGHT"),               RTSCRIPTLEXTOKTYPE_KEYWORD,    true,  kAcpiAstNodeOp_ShiftRight                        },
    319352    { RT_STR_TUPLE("NOTIFY"),                   RTSCRIPTLEXTOKTYPE_KEYWORD,    true,  kAcpiAstNodeOp_Notify                            },
    320353    { RT_STR_TUPLE("SIZEOF"),                   RTSCRIPTLEXTOKTYPE_KEYWORD,    true,  kAcpiAstNodeOp_SizeOf                            },
    … …  
    331364    { RT_STR_TUPLE("CREATEDWORDFIELD"),         RTSCRIPTLEXTOKTYPE_KEYWORD,    true,  kAcpiAstNodeOp_CreateDWordField                  },
    332365    { RT_STR_TUPLE("CREATEQWORDFIELD"),         RTSCRIPTLEXTOKTYPE_KEYWORD,    true,  kAcpiAstNodeOp_CreateQWordField                  },
     366    { RT_STR_TUPLE("CONCATENATERESTEMPLATE"),   RTSCRIPTLEXTOKTYPE_KEYWORD,    true,  kAcpiAstNodeOp_ConcatenateResTemplate            },
    333367
    334368    /* Keywords not in the operation parser table. */
    … …  
    411445    { RT_STR_TUPLE("TRANSFER16"),               RTSCRIPTLEXTOKTYPE_KEYWORD,    true,  RTACPIASLTERMINAL_KEYWORD_TRANSFER_16            },
    412446    { RT_STR_TUPLE("TRANSFER8_16"),             RTSCRIPTLEXTOKTYPE_KEYWORD,    true,  RTACPIASLTERMINAL_KEYWORD_TRANSFER_8_16          },
     447
     448    { RT_STR_TUPLE("WORDBUSNUMBER"),            RTSCRIPTLEXTOKTYPE_KEYWORD,    true,  RTACPIASLTERMINAL_KEYWORD_WORD_BUS_NUMBER        },
     449    { RT_STR_TUPLE("MINFIXED"),                 RTSCRIPTLEXTOKTYPE_KEYWORD,    true,  RTACPIASLTERMINAL_KEYWORD_MIN_FIXED              },
     450    { RT_STR_TUPLE("MINNOTFIXED"),              RTSCRIPTLEXTOKTYPE_KEYWORD,    true,  RTACPIASLTERMINAL_KEYWORD_MIN_NOT_FIXED          },
     451    { RT_STR_TUPLE("MAXFIXED"),                 RTSCRIPTLEXTOKTYPE_KEYWORD,    true,  RTACPIASLTERMINAL_KEYWORD_MAX_FIXED              },
     452    { RT_STR_TUPLE("MAXNOTFIXED"),              RTSCRIPTLEXTOKTYPE_KEYWORD,    true,  RTACPIASLTERMINAL_KEYWORD_MAX_NOT_FIXED          },
     453    { RT_STR_TUPLE("RESOURCECONSUMER"),         RTSCRIPTLEXTOKTYPE_KEYWORD,    true,  RTACPIASLTERMINAL_KEYWORD_RESOURCE_CONSUMER      },
     454    { RT_STR_TUPLE("RESOURCEPRODUCER"),         RTSCRIPTLEXTOKTYPE_KEYWORD,    true,  RTACPIASLTERMINAL_KEYWORD_RESOURCE_PRODUCER      },
     455    { RT_STR_TUPLE("POSDECODE"),                RTSCRIPTLEXTOKTYPE_KEYWORD,    true,  RTACPIASLTERMINAL_KEYWORD_POS_DECODE             },
     456    { RT_STR_TUPLE("SUBDECODE"),                RTSCRIPTLEXTOKTYPE_KEYWORD,    true,  RTACPIASLTERMINAL_KEYWORD_SUB_DECODE             },
     457
     458    { RT_STR_TUPLE("WORDIO"),                   RTSCRIPTLEXTOKTYPE_KEYWORD,    true,  RTACPIASLTERMINAL_KEYWORD_WORD_IO                },
     459    { RT_STR_TUPLE("ISAONLY"),                  RTSCRIPTLEXTOKTYPE_KEYWORD,    true,  RTACPIASLTERMINAL_KEYWORD_ISA_ONLY               },
     460    { RT_STR_TUPLE("NONISAONLY"),               RTSCRIPTLEXTOKTYPE_KEYWORD,    true,  RTACPIASLTERMINAL_KEYWORD_NON_ISA_ONLY           },
     461    { RT_STR_TUPLE("ENTIRERANGE"),              RTSCRIPTLEXTOKTYPE_KEYWORD,    true,  RTACPIASLTERMINAL_KEYWORD_ENTIRE_RANGE           },
     462    { RT_STR_TUPLE("TYPETRANSLATION"),          RTSCRIPTLEXTOKTYPE_KEYWORD,    true,  RTACPIASLTERMINAL_KEYWORD_TYPE_TRANSLATION       },
     463    { RT_STR_TUPLE("TYPESTATIC"),               RTSCRIPTLEXTOKTYPE_KEYWORD,    true,  RTACPIASLTERMINAL_KEYWORD_TYPE_STATIC            },
     464    { RT_STR_TUPLE("SPARSETRANSLATION"),        RTSCRIPTLEXTOKTYPE_KEYWORD,    true,  RTACPIASLTERMINAL_KEYWORD_SPARSE_TRANSLATION     },
     465    { RT_STR_TUPLE("DENSETRANSLATION"),         RTSCRIPTLEXTOKTYPE_KEYWORD,    true,  RTACPIASLTERMINAL_KEYWORD_DENSE_TRANSLATION      },
     466
     467    { RT_STR_TUPLE("DWORDMEMORY"),              RTSCRIPTLEXTOKTYPE_KEYWORD,    true,  RTACPIASLTERMINAL_KEYWORD_DWORD_MEMORY           },
     468    { RT_STR_TUPLE("QWORDMEMORY"),              RTSCRIPTLEXTOKTYPE_KEYWORD,    true,  RTACPIASLTERMINAL_KEYWORD_QWORD_MEMORY           },
     469    { RT_STR_TUPLE("CACHEABLE"),                RTSCRIPTLEXTOKTYPE_KEYWORD,    true,  RTACPIASLTERMINAL_KEYWORD_CACHEABLE              },
     470    { RT_STR_TUPLE("WRITECOMBINING"),           RTSCRIPTLEXTOKTYPE_KEYWORD,    true,  RTACPIASLTERMINAL_KEYWORD_WRITE_COMBINING        },
     471    { RT_STR_TUPLE("PREFETCHABLE"),             RTSCRIPTLEXTOKTYPE_KEYWORD,    true,  RTACPIASLTERMINAL_KEYWORD_PREFETCHABLE           },
     472    { RT_STR_TUPLE("NONCACHEABLE"),             RTSCRIPTLEXTOKTYPE_KEYWORD,    true,  RTACPIASLTERMINAL_KEYWORD_NON_CACHEABLE          },
     473    { RT_STR_TUPLE("ADDRESSRANGEMEMORY"),       RTSCRIPTLEXTOKTYPE_KEYWORD,    true,  RTACPIASLTERMINAL_KEYWORD_ADDRESS_RANGE_MEMORY   },
     474    { RT_STR_TUPLE("ADDRESSRANGENVS"),          RTSCRIPTLEXTOKTYPE_KEYWORD,    true,  RTACPIASLTERMINAL_KEYWORD_ADDRESS_RANGE_NVS      },
     475    { RT_STR_TUPLE("ADDRESSRANGEACPI"),         RTSCRIPTLEXTOKTYPE_KEYWORD,    true,  RTACPIASLTERMINAL_KEYWORD_ADDRESS_RANGE_ACPI     },
     476    { RT_STR_TUPLE("ADDRESSRANGERESERVED"),     RTSCRIPTLEXTOKTYPE_KEYWORD,    true,  RTACPIASLTERMINAL_KEYWORD_ADDRESS_RANGE_RESERVED },
    413477
    414478    /* Punctuators */
    … …  
    769833
    770834#define RTACPIASL_PARSE_OPTIONAL_KEYWORD_LIST(a_enmKeyword, a_aenmKeywordList, a_enmDefault) \
    771     RTACPIASLTERMINAL a_enmKeyword = a_enmDefault; \
     835    RTACPIASLTERMINAL a_enmKeyword; \
    772836    do { \
    773837        int rc2 = rtAcpiAslLexerConsumeIfKeywordInList(pThis, a_aenmKeywordList, &a_enmKeyword); \
    774838        if (RT_FAILURE(rc2)) \
    775839            return rc2; \
     840        if (a_enmKeyword == RTACPIASLTERMINAL_INVALID) \
     841            a_enmKeyword = a_enmDefault; \
    776842    } while(0)
    777843
    … …  
    831897        if (!fConsumed2) \
    832898            return RTErrInfoSetF(pThis->pErrInfo, VERR_INVALID_PARAMETER, "Parser: Expected a natural number"); \
     899    } while(0)
     900
     901#define RTACPIASL_PARSE_OPTIONAL_NATURAL(a_u64, a_u64Def) \
     902    uint64_t a_u64 = a_u64Def; \
     903    do { \
     904        bool fConsumed2 = false; \
     905        int rc2 = rtAcpiAslLexerConsumeIfNatural(pThis, &a_u64, &fConsumed2); \
     906        if (RT_FAILURE(rc2)) \
     907            return rc2; \
     908        RT_NOREF(fConsumed2); \
    833909    } while(0)
    834910
    … …  
    12481324
    12491325
     1326/**
     1327 * Resource template namespace entry.
     1328 */
     1329typedef struct RTACPIRSRCNSENTRY
     1330{
     1331    /** Name of the namespace entry - NULL marks the end of the list. */
     1332    const char              *pszName;
     1333    /** Bit offset from the start of the resource. */
     1334    uint32_t                offBits;
     1335    /** Number of bits this field has. */
     1336    uint32_t                cBits;
     1337} RTACPIRSRCNSENTRY;
     1338/** Pointer to a resource template namespace entry. */
     1339typedef RTACPIRSRCNSENTRY *PRTACPIRSRCNSENTRY;
     1340/** Pointer to a constant resource template namespace entry. */
     1341typedef const RTACPIRSRCNSENTRY *PCRTACPIRSRCNSENTRY;
     1342
     1343
     1344static int rtAcpiTblParseResourceNsCreateEntries(PRTACPIASLCU pThis, RTACPIRES hAcpiRes, PRTACPIASTNODE pAstNd,
     1345                                                 const char *pszRsrcName, const char *pszName, PCRTACPIRSRCNSENTRY paNsEntries)
     1346{
     1347    AssertReturn(pszName, VINF_SUCCESS);
     1348
     1349    uint32_t const offResource = RTAcpiResourceGetOffset(hAcpiRes) * 8;
     1350    int rc = rtAcpiNsAddEntryAstNode(pThis->pNs, pszName, pAstNd, true /*fSwitchTo*/);
     1351    if (RT_FAILURE(rc))
     1352            return RTErrInfoSetF(pThis->pErrInfo, rc, "Failed to add %s() to namespace as '%s'",
     1353                                 pszRsrcName, pszName);
     1354
     1355    uint32_t idxRsrc = 0;
     1356    for (;;)
     1357    {
     1358        if (paNsEntries[idxRsrc].pszName == NULL)
     1359        {
     1360            rtAcpiNsPop(pThis->pNs);
     1361            return VINF_SUCCESS;
     1362        }
     1363
     1364        rc = rtAcpiNsAddEntryRsrcField(pThis->pNs, paNsEntries[idxRsrc].pszName, offResource + paNsEntries[idxRsrc].offBits, paNsEntries[idxRsrc].cBits);
     1365        if (RT_FAILURE(rc))
     1366            return RTErrInfoSetF(pThis->pErrInfo, rc, "Failed to add '%s.%s' to namespace", pszName, paNsEntries[idxRsrc].pszName);
     1367
     1368        idxRsrc++;
     1369    }
     1370}
     1371
     1372
    12501373static int rtAcpiTblParseResourceMemory32Fixed(PRTACPIASLCU pThis, RTACPIRES hAcpiRes, PRTACPIASTNODE pAstNd)
    12511374{
    … …  
    12711394    if (pszName)
    12721395    {
    1273         /* Create namespace entries. */
    1274         uint32_t const offResource = RTAcpiResourceGetOffset(hAcpiRes);
    1275         int rc = rtAcpiNsAddEntryAstNode(pThis->pNs, pszName, pAstNd, true /*fSwitchTo*/);
    1276         if (RT_SUCCESS(rc))
    1277         {
    1278             rc = rtAcpiNsAddEntryU64(pThis->pNs, "_BAS", offResource + 4, false /*fSwitchTo*/);
    1279             if (RT_FAILURE(rc))
    1280                 return RTErrInfoSetF(pThis->pErrInfo, rc, "Failed to add '%s._BAS' to namespace",
    1281                                      pszName);
    1282 
    1283             rc = rtAcpiNsAddEntryU64(pThis->pNs, "_LEN", offResource + 8, false /*fSwitchTo*/);
    1284             if (RT_FAILURE(rc))
    1285                 return RTErrInfoSetF(pThis->pErrInfo, rc, "Failed to add '%s._LEN' to namespace",
    1286                                      pszName);
    1287 
    1288             rtAcpiNsPop(pThis->pNs);
    1289         }
    1290         else
    1291             return RTErrInfoSetF(pThis->pErrInfo, rc,
    1292                                  "Failed to add Memory32Fixed(, %#RX64 Size=%#RX64, %s) to namespace",
    1293                                  u64PhysAddrStart, cbRegion, pszName);
     1396        static const RTACPIRSRCNSENTRY s_aRsrcNs[] =
     1397        {
     1398            { "_BAS", 4 * 8, 32 },
     1399            { "_LEN", 8 * 8, 32 },
     1400            { NULL,       0,  0 }
     1401        };
     1402        int rc = rtAcpiTblParseResourceNsCreateEntries(pThis, hAcpiRes, pAstNd, "Memory32Fixed", pszName, &s_aRsrcNs[0]);
     1403        if (RT_FAILURE(rc))
     1404            return rc;
    12941405    }
    12951406
    … …  
    13601471    if (pszName)
    13611472    {
    1362         /* Create namespace entries. */
    1363         uint32_t const offResource = RTAcpiResourceGetOffset(hAcpiRes);
    1364         rc = rtAcpiNsAddEntryAstNode(pThis->pNs, pszName, pAstNd, true /*fSwitchTo*/);
    1365         if (RT_SUCCESS(rc))
    1366         {
    1367             rc = rtAcpiNsAddEntryU64(pThis->pNs, "_HE", offResource, false /*fSwitchTo*/); /** @todo */
    1368             if (RT_FAILURE(rc))
    1369                 return RTErrInfoSetF(pThis->pErrInfo, rc, "Failed to add '%s._HE' to namespace",
    1370                                      pszName);
    1371 
    1372             rc = rtAcpiNsAddEntryU64(pThis->pNs, "_LL", offResource, false /*fSwitchTo*/); /** @todo */
    1373             if (RT_FAILURE(rc))
    1374                 return RTErrInfoSetF(pThis->pErrInfo, rc, "Failed to add '%s._LL' to namespace",
    1375                                      pszName);
    1376 
    1377             rtAcpiNsPop(pThis->pNs);
    1378         }
    1379         else
    1380             return RTErrInfoSetF(pThis->pErrInfo, rc, "Failed to add IRQ(,,,,, %s) to namespace", pszName);
     1473        static const RTACPIRSRCNSENTRY s_aRsrcNs[] =
     1474        {
     1475            { "_INT", 1 * 8,     16 },
     1476            { "_HE_", 3 * 8,      1 },
     1477            { "_LL_", 3 * 8 + 3,  1 },
     1478            { "_SHR", 3 * 8 + 4,  1 },
     1479            { "_WKC", 3 * 8 + 5,  1 },
     1480            { NULL,       0,  0 }
     1481        };
     1482        rc = rtAcpiTblParseResourceNsCreateEntries(pThis, hAcpiRes, pAstNd, "IRQ", pszName, &s_aRsrcNs[0]);
     1483        if (RT_FAILURE(rc))
     1484            return rc;
    13811485    }
    13821486
    … …  
    14081512    if (pszName)
    14091513    {
    1410         /* Create namespace entries. */
    1411         uint32_t const offResource = RTAcpiResourceGetOffset(hAcpiRes); RT_NOREF(offResource);
    1412         rc = rtAcpiNsAddEntryAstNode(pThis->pNs, pszName, pAstNd, false /*fSwitchTo*/);
     1514        static const RTACPIRSRCNSENTRY s_aRsrcNs[] =
     1515        {
     1516            { NULL, 0,  0 }
     1517        };
     1518        rc = rtAcpiTblParseResourceNsCreateEntries(pThis, hAcpiRes, pAstNd, "IRQNoFlags", pszName, &s_aRsrcNs[0]);
    14131519        if (RT_FAILURE(rc))
    1414             return RTErrInfoSetF(pThis->pErrInfo, rc, "Failed to add IRQNoFlags(%s) to namespace", pszName);
     1520            return rc;
    14151521    }
    14161522
    … …  
    14521558    if (pszName)
    14531559    {
    1454         /* Create namespace entries. */
    1455         uint32_t const offResource = RTAcpiResourceGetOffset(hAcpiRes);
    1456         int rc = rtAcpiNsAddEntryAstNode(pThis->pNs, pszName, pAstNd, true /*fSwitchTo*/);
    1457         if (RT_SUCCESS(rc))
    1458         {
    1459             rc = rtAcpiNsAddEntryU64(pThis->pNs, "_DEC", offResource, false /*fSwitchTo*/); /** @todo */
    1460             if (RT_FAILURE(rc))
    1461                 return RTErrInfoSetF(pThis->pErrInfo, rc, "Failed to add '%s._DEC' to namespace",
    1462                                      pszName);
    1463 
    1464             rc = rtAcpiNsAddEntryU64(pThis->pNs, "_MIN", offResource + 2, false /*fSwitchTo*/);
    1465             if (RT_FAILURE(rc))
    1466                 return RTErrInfoSetF(pThis->pErrInfo, rc, "Failed to add '%s._MIN' to namespace",
    1467                                      pszName);
    1468 
    1469             rc = rtAcpiNsAddEntryU64(pThis->pNs, "_MAX", offResource + 4, false /*fSwitchTo*/);
    1470             if (RT_FAILURE(rc))
    1471                 return RTErrInfoSetF(pThis->pErrInfo, rc, "Failed to add '%s._MAX' to namespace",
    1472                                      pszName);
    1473 
    1474             rc = rtAcpiNsAddEntryU64(pThis->pNs, "_ALN", offResource + 6, false /*fSwitchTo*/);
    1475             if (RT_FAILURE(rc))
    1476                 return RTErrInfoSetF(pThis->pErrInfo, rc, "Failed to add '%s._ALN' to namespace",
    1477                                      pszName);
    1478 
    1479             rc = rtAcpiNsAddEntryU64(pThis->pNs, "_LEN", offResource + 7, false /*fSwitchTo*/);
    1480             if (RT_FAILURE(rc))
    1481                 return RTErrInfoSetF(pThis->pErrInfo, rc, "Failed to add '%s._LEN' to namespace",
    1482                                      pszName);
    1483 
    1484             rtAcpiNsPop(pThis->pNs);
    1485         }
    1486         else
    1487             return RTErrInfoSetF(pThis->pErrInfo, rc, "Failed to add IO(,,,,, %s) to namespace", pszName);
     1560        static const RTACPIRSRCNSENTRY s_aRsrcNs[] =
     1561        {
     1562            { "_DEC", 1 * 8,  1 },
     1563            { "_MIN", 2 * 8, 16 },
     1564            { "_MAX", 4 * 8, 16 },
     1565            { "_ALN", 6 * 8,  8 },
     1566            { "_LEN", 7 * 8,  8 },
     1567            { NULL,       0,  0 }
     1568        };
     1569        int rc = rtAcpiTblParseResourceNsCreateEntries(pThis, hAcpiRes, pAstNd, "IO", pszName, &s_aRsrcNs[0]);
     1570        if (RT_FAILURE(rc))
     1571            return rc;
    14881572    }
    14891573
    … …  
    15281612        if (u64DmaChannel > 7)
    15291613            return RTErrInfoSetF(pThis->pErrInfo, VERR_INVALID_PARAMETER,
    1530                                  "DM channel number is out of range [0..7]: %RU64",
     1614                                 "DMA channel number is out of range [0..7]: %RU64",
    15311615                                 u64DmaChannel);
    15321616        if (bmDmaChannels & RT_BIT(u64DmaChannel))
    … …  
    15451629    if (pszName)
    15461630    {
    1547         /* Create namespace entries. */
    1548         uint32_t const offResource = RTAcpiResourceGetOffset(hAcpiRes);
    1549         int rc = rtAcpiNsAddEntryAstNode(pThis->pNs, pszName, pAstNd, true /*fSwitchTo*/);
    1550         if (RT_SUCCESS(rc))
    1551         {
    1552             rc = rtAcpiNsAddEntryU64(pThis->pNs, "_TYP", offResource, false /*fSwitchTo*/); /** @todo */
    1553             if (RT_FAILURE(rc))
    1554                 return RTErrInfoSetF(pThis->pErrInfo, rc, "Failed to add '%s._TYP' to namespace",
    1555                                      pszName);
    1556 
    1557             rc = rtAcpiNsAddEntryU64(pThis->pNs, "_BM", offResource, false /*fSwitchTo*/); /** @todo */
    1558             if (RT_FAILURE(rc))
    1559                 return RTErrInfoSetF(pThis->pErrInfo, rc, "Failed to add '%s._BM' to namespace",
    1560                                      pszName);
    1561 
    1562             rc = rtAcpiNsAddEntryU64(pThis->pNs, "_SIZ", offResource, false /*fSwitchTo*/); /** @todo */
    1563             if (RT_FAILURE(rc))
    1564                 return RTErrInfoSetF(pThis->pErrInfo, rc, "Failed to add '%s._SIZ' to namespace",
    1565                                      pszName);
    1566 
    1567             rtAcpiNsPop(pThis->pNs);
    1568         }
    1569         else
    1570             return RTErrInfoSetF(pThis->pErrInfo, rc, "Failed to add DMA(,,,,, %s) to namespace", pszName);
    1571     }
    1572 
    1573 #if 0
    1574     int rc = RTAcpiResourceAddIo(hAcpiRes, enmDecode == RTACPIASLTERMINAL_KEYWORD_DECODE_10 ? kAcpiResIoDecodeType_Decode10 : kAcpiResIoDecodeType_Decode16,
    1575                                  (uint16_t)u64AddrMin, (uint16_t)u64AddrMax, (uint8_t)u64AddrAlignment, (uint8_t)u64RangeLength);
     1631        static const RTACPIRSRCNSENTRY s_aRsrcNs[] =
     1632        {
     1633            { "_DMA", 1 * 8,      8 },
     1634            { "_SIZ", 2 * 8,      2 },
     1635            { "_BM_", 2 * 8 + 2,  1 },
     1636            { "_TYP", 2 * 8 + 3,  2 },
     1637            { NULL,       0,      0 }
     1638        };
     1639        int rc = rtAcpiTblParseResourceNsCreateEntries(pThis, hAcpiRes, pAstNd, "DMA", pszName, &s_aRsrcNs[0]);
     1640        if (RT_FAILURE(rc))
     1641            return rc;
     1642    }
     1643
     1644    RTACPIRESDMACHANSPEED enmChanSpeed = kAcpiResDmaChanSpeed_Invalid;
     1645    switch (enmDmaType)
     1646    {
     1647        case RTACPIASLTERMINAL_KEYWORD_COMPATIBILITY: enmChanSpeed = kAcpiResDmaChanSpeed_Compatibility; break;
     1648        case RTACPIASLTERMINAL_KEYWORD_TYPE_A:        enmChanSpeed = kAcpiResDmaChanSpeed_TypeA;         break;
     1649        case RTACPIASLTERMINAL_KEYWORD_TYPE_B:        enmChanSpeed = kAcpiResDmaChanSpeed_TypeB;         break;
     1650        case RTACPIASLTERMINAL_KEYWORD_TYPE_F:        enmChanSpeed = kAcpiResDmaChanSpeed_TypeF;         break;
     1651        default:
     1652            AssertReleaseFailed();
     1653    }
     1654
     1655    RTACPIRESDMATRANSFERTYPE enmTransferType = kAcpiResDmaTransferType_Invalid;
     1656    switch (enmDmaTransferSize)
     1657    {
     1658        case RTACPIASLTERMINAL_KEYWORD_TRANSFER_8:    enmTransferType = kAcpiResDmaTransferType_8Bit;       break;
     1659        case RTACPIASLTERMINAL_KEYWORD_TRANSFER_16:   enmTransferType = kAcpiResDmaTransferType_8Bit_16Bit; break;
     1660        case RTACPIASLTERMINAL_KEYWORD_TRANSFER_8_16: enmTransferType = kAcpiResDmaTransferType_16Bit;      break;
     1661        default:
     1662            AssertReleaseFailed();
     1663    }
     1664
     1665    int rc = RTAcpiResourceAddDma(hAcpiRes, enmChanSpeed,
     1666                                  enmBusMaster == RTACPIASLTERMINAL_KEYWORD_BUS_MASTER,
     1667                                  enmTransferType, bmDmaChannels);
    15761668    if (RT_FAILURE(rc))
    15771669        return RTErrInfoSetF(pThis->pErrInfo, rc,
    15781670                             "Failed to add DMA(,,,,, %s)", pszName ? pszName : "<NONE>");
    1579 #endif
     1671
     1672    return VINF_SUCCESS;
     1673}
     1674
     1675
     1676static const RTACPIASLTERMINAL s_aenmResourceUsageKeywords[]      = { RTACPIASLTERMINAL_KEYWORD_RESOURCE_CONSUMER,  RTACPIASLTERMINAL_KEYWORD_RESOURCE_PRODUCER, RTACPIASLTERMINAL_INVALID };
     1677static const RTACPIASLTERMINAL s_aenmIsMinFixedKeywords[]         = { RTACPIASLTERMINAL_KEYWORD_MIN_FIXED,          RTACPIASLTERMINAL_KEYWORD_MIN_NOT_FIXED,     RTACPIASLTERMINAL_INVALID };
     1678static const RTACPIASLTERMINAL s_aenmIsMaxFixedKeywords[]         = { RTACPIASLTERMINAL_KEYWORD_MAX_FIXED,          RTACPIASLTERMINAL_KEYWORD_MAX_NOT_FIXED,     RTACPIASLTERMINAL_INVALID };
     1679static const RTACPIASLTERMINAL s_aenmDecodeKeywords[]             = { RTACPIASLTERMINAL_KEYWORD_POS_DECODE,         RTACPIASLTERMINAL_KEYWORD_SUB_DECODE,        RTACPIASLTERMINAL_INVALID };
     1680static const RTACPIASLTERMINAL s_aenmIsaRangesKeywords[]          = { RTACPIASLTERMINAL_KEYWORD_ISA_ONLY,           RTACPIASLTERMINAL_KEYWORD_NON_ISA_ONLY,
     1681                                                                      RTACPIASLTERMINAL_KEYWORD_ENTIRE_RANGE,       RTACPIASLTERMINAL_INVALID };
     1682static const RTACPIASLTERMINAL s_aenmTranslationTypeKeywords[]    = { RTACPIASLTERMINAL_KEYWORD_TYPE_TRANSLATION,   RTACPIASLTERMINAL_KEYWORD_TYPE_STATIC,       RTACPIASLTERMINAL_INVALID };
     1683static const RTACPIASLTERMINAL s_aenmTranslationDensityKeywords[] = { RTACPIASLTERMINAL_KEYWORD_SPARSE_TRANSLATION, RTACPIASLTERMINAL_KEYWORD_DENSE_TRANSLATION, RTACPIASLTERMINAL_INVALID };
     1684
     1685
     1686static int rtAcpiTblParseResourceWordBusNumber(PRTACPIASLCU pThis, RTACPIRES hAcpiRes, PRTACPIASTNODE pAstNd)
     1687{
     1688    RTACPIASL_PARSE_PUNCTUATOR(RTACPIASLTERMINAL_PUNCTUATOR_OPEN_BRACKET, '(');
     1689    RTACPIASL_PARSE_OPTIONAL_KEYWORD_LIST(enmResourceUsage, s_aenmResourceUsageKeywords, RTACPIASLTERMINAL_KEYWORD_RESOURCE_CONSUMER);
     1690    RTACPIASL_PARSE_PUNCTUATOR(RTACPIASLTERMINAL_PUNCTUATOR_COMMA, ',');
     1691    RTACPIASL_PARSE_OPTIONAL_KEYWORD_LIST(enmIsMinFixed, s_aenmIsMinFixedKeywords, RTACPIASLTERMINAL_KEYWORD_MIN_NOT_FIXED);
     1692    RTACPIASL_PARSE_PUNCTUATOR(RTACPIASLTERMINAL_PUNCTUATOR_COMMA, ',');
     1693    RTACPIASL_PARSE_OPTIONAL_KEYWORD_LIST(enmIsMaxFixed, s_aenmIsMaxFixedKeywords, RTACPIASLTERMINAL_KEYWORD_MAX_NOT_FIXED);
     1694    RTACPIASL_PARSE_PUNCTUATOR(RTACPIASLTERMINAL_PUNCTUATOR_COMMA, ',');
     1695    RTACPIASL_PARSE_OPTIONAL_KEYWORD_LIST(enmDecode, s_aenmDecodeKeywords, RTACPIASLTERMINAL_KEYWORD_POS_DECODE);
     1696    RTACPIASL_PARSE_PUNCTUATOR(RTACPIASLTERMINAL_PUNCTUATOR_COMMA, ',');
     1697    RTACPIASL_PARSE_NATURAL(u64AddrGranularity);
     1698    RTACPIASL_PARSE_PUNCTUATOR(RTACPIASLTERMINAL_PUNCTUATOR_COMMA, ',');
     1699    RTACPIASL_PARSE_NATURAL(u64AddrMin);
     1700    RTACPIASL_PARSE_PUNCTUATOR(RTACPIASLTERMINAL_PUNCTUATOR_COMMA, ',');
     1701    RTACPIASL_PARSE_NATURAL(u64AddrMax);
     1702    RTACPIASL_PARSE_PUNCTUATOR(RTACPIASLTERMINAL_PUNCTUATOR_COMMA, ',');
     1703    RTACPIASL_PARSE_NATURAL(u64AddrTranslation);
     1704    RTACPIASL_PARSE_PUNCTUATOR(RTACPIASLTERMINAL_PUNCTUATOR_COMMA, ',');
     1705    RTACPIASL_PARSE_NATURAL(u64RangeLength);
     1706    RTACPIASL_PARSE_OPTIONAL_PUNCTUATOR(RTACPIASLTERMINAL_PUNCTUATOR_COMMA);
     1707    RTACPIASL_PARSE_OPTIONAL_NATURAL(u64ResSrcIndex, UINT64_MAX);
     1708    RTACPIASL_PARSE_OPTIONAL_PUNCTUATOR(RTACPIASLTERMINAL_PUNCTUATOR_COMMA);
     1709    RTACPIASL_PARSE_OPTIONAL_NAME_STRING(pszResSrc);
     1710    RTACPIASL_PARSE_OPTIONAL_PUNCTUATOR(RTACPIASLTERMINAL_PUNCTUATOR_COMMA);
     1711    RTACPIASL_PARSE_OPTIONAL_NAME_STRING(pszName);
     1712    RTACPIASL_PARSE_PUNCTUATOR(RTACPIASLTERMINAL_PUNCTUATOR_CLOSE_BRACKET, ')');
     1713
     1714    if (pszName)
     1715    {
     1716        static const RTACPIRSRCNSENTRY s_aRsrcNs[] =
     1717        {
     1718            { "_DEC",  4 * 8 + 1,  1 },
     1719            { "_MIF",  4 * 8 + 2,  1 },
     1720            { "_MAF",  4 * 8 + 3,  1 },
     1721            { "_GRA",  6 * 8,     16 },
     1722            { "_MIN",  8 * 8,     16 },
     1723            { "_MAX", 10 * 8,     16 },
     1724            { "_TRA", 12 * 8,     16 },
     1725            { "_LEN", 14 * 8,     16 },
     1726            { NULL,        0,      0 }
     1727        };
     1728        int rc = rtAcpiTblParseResourceNsCreateEntries(pThis, hAcpiRes, pAstNd, "WordBusNumber", pszName, &s_aRsrcNs[0]);
     1729        if (RT_FAILURE(rc))
     1730            return rc;
     1731    }
     1732
     1733    uint32_t fAddrSpace = 0;
     1734    fAddrSpace |= (enmResourceUsage == RTACPIASLTERMINAL_KEYWORD_RESOURCE_CONSUMER) ? RTACPI_RESOURCE_ADDR_RANGE_F_CONSUMER        : RTACPI_RESOURCE_ADDR_RANGE_F_PRODUCER;
     1735    fAddrSpace |= (enmIsMinFixed    == RTACPIASLTERMINAL_KEYWORD_MIN_FIXED)         ? RTACPI_RESOURCE_ADDR_RANGE_F_MIN_ADDR_FIXED  : RTACPI_RESOURCE_ADDR_RANGE_F_MIN_ADDR_CHANGEABLE;
     1736    fAddrSpace |= (enmIsMaxFixed    == RTACPIASLTERMINAL_KEYWORD_MAX_FIXED)         ? RTACPI_RESOURCE_ADDR_RANGE_F_MAX_ADDR_FIXED  : RTACPI_RESOURCE_ADDR_RANGE_F_MAX_ADDR_CHANGEABLE;
     1737    fAddrSpace |= (enmDecode        == RTACPIASLTERMINAL_KEYWORD_POS_DECODE)        ? RTACPI_RESOURCE_ADDR_RANGE_F_DECODE_TYPE_POS : RTACPI_RESOURCE_ADDR_RANGE_F_DECODE_TYPE_SUB;
     1738    int rc = RTAcpiResourceAddWordBusNumberEx(hAcpiRes, fAddrSpace, (uint16_t)u64AddrMin, (uint16_t)u64AddrMax,
     1739                                              (uint16_t)u64AddrTranslation, (uint16_t)u64AddrGranularity, (uint16_t)u64RangeLength,
     1740                                              pszResSrc, (uint8_t)u64ResSrcIndex);
     1741    if (RT_FAILURE(rc))
     1742        return RTErrInfoSetF(pThis->pErrInfo, rc,
     1743                             "Failed to add WordBusNumber(,,,,, %s)", pszName ? pszName : "<NONE>");
     1744
     1745    return VINF_SUCCESS;
     1746}
     1747
     1748
     1749static int rtAcpiTblParseResourceWordIo(PRTACPIASLCU pThis, RTACPIRES hAcpiRes, PRTACPIASTNODE pAstNd)
     1750{
     1751    RTACPIASL_PARSE_PUNCTUATOR(RTACPIASLTERMINAL_PUNCTUATOR_OPEN_BRACKET, '(');
     1752    RTACPIASL_PARSE_OPTIONAL_KEYWORD_LIST(enmResourceUsage, s_aenmResourceUsageKeywords, RTACPIASLTERMINAL_KEYWORD_RESOURCE_CONSUMER);
     1753    RTACPIASL_PARSE_PUNCTUATOR(RTACPIASLTERMINAL_PUNCTUATOR_COMMA, ',');
     1754    RTACPIASL_PARSE_OPTIONAL_KEYWORD_LIST(enmIsMinFixed, s_aenmIsMinFixedKeywords, RTACPIASLTERMINAL_KEYWORD_MIN_NOT_FIXED);
     1755    RTACPIASL_PARSE_PUNCTUATOR(RTACPIASLTERMINAL_PUNCTUATOR_COMMA, ',');
     1756    RTACPIASL_PARSE_OPTIONAL_KEYWORD_LIST(enmIsMaxFixed, s_aenmIsMaxFixedKeywords, RTACPIASLTERMINAL_KEYWORD_MAX_NOT_FIXED);
     1757    RTACPIASL_PARSE_PUNCTUATOR(RTACPIASLTERMINAL_PUNCTUATOR_COMMA, ',');
     1758    RTACPIASL_PARSE_OPTIONAL_KEYWORD_LIST(enmDecode, s_aenmDecodeKeywords, RTACPIASLTERMINAL_KEYWORD_POS_DECODE);
     1759    RTACPIASL_PARSE_PUNCTUATOR(RTACPIASLTERMINAL_PUNCTUATOR_COMMA, ',');
     1760    RTACPIASL_PARSE_KEYWORD_LIST(enmIsaRange, s_aenmIsaRangesKeywords);
     1761    RTACPIASL_PARSE_PUNCTUATOR(RTACPIASLTERMINAL_PUNCTUATOR_COMMA, ',');
     1762    RTACPIASL_PARSE_NATURAL(u64AddrGranularity);
     1763    RTACPIASL_PARSE_PUNCTUATOR(RTACPIASLTERMINAL_PUNCTUATOR_COMMA, ',');
     1764    RTACPIASL_PARSE_NATURAL(u64AddrMin);
     1765    RTACPIASL_PARSE_PUNCTUATOR(RTACPIASLTERMINAL_PUNCTUATOR_COMMA, ',');
     1766    RTACPIASL_PARSE_NATURAL(u64AddrMax);
     1767    RTACPIASL_PARSE_PUNCTUATOR(RTACPIASLTERMINAL_PUNCTUATOR_COMMA, ',');
     1768    RTACPIASL_PARSE_NATURAL(u64AddrTranslation);
     1769    RTACPIASL_PARSE_PUNCTUATOR(RTACPIASLTERMINAL_PUNCTUATOR_COMMA, ',');
     1770    RTACPIASL_PARSE_NATURAL(u64RangeLength);
     1771    RTACPIASL_PARSE_OPTIONAL_PUNCTUATOR(RTACPIASLTERMINAL_PUNCTUATOR_COMMA);
     1772    RTACPIASL_PARSE_OPTIONAL_NATURAL(u64ResSrcIndex, UINT64_MAX);
     1773    RTACPIASL_PARSE_OPTIONAL_PUNCTUATOR(RTACPIASLTERMINAL_PUNCTUATOR_COMMA);
     1774    RTACPIASL_PARSE_OPTIONAL_NAME_STRING(pszResSrc);
     1775    RTACPIASL_PARSE_OPTIONAL_PUNCTUATOR(RTACPIASLTERMINAL_PUNCTUATOR_COMMA);
     1776    RTACPIASL_PARSE_OPTIONAL_NAME_STRING(pszName);
     1777    RTACPIASL_PARSE_OPTIONAL_PUNCTUATOR(RTACPIASLTERMINAL_PUNCTUATOR_COMMA);
     1778    RTACPIASL_PARSE_OPTIONAL_KEYWORD_LIST(enmTranslationType, s_aenmTranslationTypeKeywords, RTACPIASLTERMINAL_KEYWORD_TYPE_STATIC);
     1779    RTACPIASL_PARSE_OPTIONAL_PUNCTUATOR(RTACPIASLTERMINAL_PUNCTUATOR_COMMA);
     1780    RTACPIASL_PARSE_OPTIONAL_KEYWORD_LIST(enmTranslationDensity, s_aenmTranslationDensityKeywords, RTACPIASLTERMINAL_KEYWORD_DENSE_TRANSLATION);
     1781    RTACPIASL_PARSE_PUNCTUATOR(RTACPIASLTERMINAL_PUNCTUATOR_CLOSE_BRACKET, ')');
     1782
     1783    if (pszName)
     1784    {
     1785        static const RTACPIRSRCNSENTRY s_aRsrcNs[] =
     1786        {
     1787            { "_DEC",  4 * 8 + 1,  1 },
     1788            { "_MIF",  4 * 8 + 2,  1 },
     1789            { "_MAF",  4 * 8 + 3,  1 },
     1790            { "_GRA",  6 * 8,     16 },
     1791            { "_MIN",  8 * 8,     16 },
     1792            { "_MAX", 10 * 8,     16 },
     1793            { "_TRA", 12 * 8,     16 },
     1794            { "_LEN", 14 * 8,     16 },
     1795            { NULL,        0,      0 }
     1796        };
     1797        int rc = rtAcpiTblParseResourceNsCreateEntries(pThis, hAcpiRes, pAstNd, "WordIo", pszName, &s_aRsrcNs[0]);
     1798        if (RT_FAILURE(rc))
     1799            return rc;
     1800    }
     1801
     1802    RTACPIRESIORANGE enmIoRange = kAcpiResIoRange_Invalid;
     1803    switch (enmIsaRange)
     1804    {
     1805        case RTACPIASLTERMINAL_KEYWORD_ISA_ONLY:     enmIoRange = kAcpiResIoRange_IsaOnly;    break;
     1806        case RTACPIASLTERMINAL_KEYWORD_NON_ISA_ONLY: enmIoRange = kAcpiResIoRange_NonIsaOnly; break;
     1807        case RTACPIASLTERMINAL_KEYWORD_ENTIRE_RANGE: enmIoRange = kAcpiResIoRange_Whole;      break;
     1808        default:
     1809            AssertReleaseFailed(); /* Impossible */
     1810    }
     1811
     1812    RTACPIRESIORANGETYPE enmIoType = kAcpiResIoRangeType_Static;
     1813    if (enmTranslationType == RTACPIASLTERMINAL_KEYWORD_TYPE_TRANSLATION)
     1814    {
     1815        if (enmTranslationDensity == RTACPIASLTERMINAL_KEYWORD_SPARSE_TRANSLATION)
     1816            enmIoType = kAcpiResIoRangeType_Translation_Sparse;
     1817        else
     1818            enmIoType = kAcpiResIoRangeType_Translation_Dense;
     1819    }
     1820
     1821    uint32_t fAddrSpace = 0;
     1822    fAddrSpace |= (enmResourceUsage == RTACPIASLTERMINAL_KEYWORD_RESOURCE_CONSUMER) ? RTACPI_RESOURCE_ADDR_RANGE_F_CONSUMER        : RTACPI_RESOURCE_ADDR_RANGE_F_PRODUCER;
     1823    fAddrSpace |= (enmIsMinFixed    == RTACPIASLTERMINAL_KEYWORD_MIN_FIXED)         ? RTACPI_RESOURCE_ADDR_RANGE_F_MIN_ADDR_FIXED  : RTACPI_RESOURCE_ADDR_RANGE_F_MIN_ADDR_CHANGEABLE;
     1824    fAddrSpace |= (enmIsMaxFixed    == RTACPIASLTERMINAL_KEYWORD_MAX_FIXED)         ? RTACPI_RESOURCE_ADDR_RANGE_F_MAX_ADDR_FIXED  : RTACPI_RESOURCE_ADDR_RANGE_F_MAX_ADDR_CHANGEABLE;
     1825    fAddrSpace |= (enmDecode        == RTACPIASLTERMINAL_KEYWORD_POS_DECODE)        ? RTACPI_RESOURCE_ADDR_RANGE_F_DECODE_TYPE_POS : RTACPI_RESOURCE_ADDR_RANGE_F_DECODE_TYPE_SUB;
     1826    int rc = RTAcpiResourceAddWordIoRangeEx(hAcpiRes, enmIoType, enmIoRange, fAddrSpace,
     1827                                            (uint16_t)u64AddrMin, (uint16_t)u64AddrMax,
     1828                                            (uint16_t)u64AddrTranslation, (uint16_t)u64AddrGranularity, (uint16_t)u64RangeLength,
     1829                                            pszResSrc, (uint8_t)u64ResSrcIndex);
     1830    if (RT_FAILURE(rc))
     1831        return RTErrInfoSetF(pThis->pErrInfo, rc,
     1832                             "Failed to add WordIo(,,,,, %s)", pszName ? pszName : "<NONE>");
     1833
     1834    return VINF_SUCCESS;
     1835}
     1836
     1837
     1838static const RTACPIASLTERMINAL s_aenmCacheableKeywords[]    = { RTACPIASLTERMINAL_KEYWORD_CACHEABLE,  RTACPIASLTERMINAL_KEYWORD_WRITE_COMBINING,
     1839                                                                RTACPIASLTERMINAL_KEYWORD_PREFETCHABLE, RTACPIASLTERMINAL_KEYWORD_NON_CACHEABLE,
     1840                                                                RTACPIASLTERMINAL_INVALID };
     1841static const RTACPIASLTERMINAL s_aenmMemRangeTypeKeywords[] = { RTACPIASLTERMINAL_KEYWORD_ADDRESS_RANGE_MEMORY, RTACPIASLTERMINAL_KEYWORD_ADDRESS_RANGE_NVS,
     1842                                                                RTACPIASLTERMINAL_KEYWORD_ADDRESS_RANGE_ACPI,   RTACPIASLTERMINAL_KEYWORD_ADDRESS_RANGE_RESERVED,
     1843                                                                RTACPIASLTERMINAL_INVALID };
     1844
     1845static int rtAcpiTblParseResourceDWordMemory(PRTACPIASLCU pThis, RTACPIRES hAcpiRes, PRTACPIASTNODE pAstNd)
     1846{
     1847    RTACPIASL_PARSE_PUNCTUATOR(RTACPIASLTERMINAL_PUNCTUATOR_OPEN_BRACKET, '(');
     1848    RTACPIASL_PARSE_OPTIONAL_KEYWORD_LIST(enmResourceUsage, s_aenmResourceUsageKeywords, RTACPIASLTERMINAL_KEYWORD_RESOURCE_CONSUMER);
     1849    RTACPIASL_PARSE_PUNCTUATOR(RTACPIASLTERMINAL_PUNCTUATOR_COMMA, ',');
     1850    RTACPIASL_PARSE_OPTIONAL_KEYWORD_LIST(enmDecode, s_aenmDecodeKeywords, RTACPIASLTERMINAL_KEYWORD_POS_DECODE);
     1851    RTACPIASL_PARSE_PUNCTUATOR(RTACPIASLTERMINAL_PUNCTUATOR_COMMA, ',');
     1852    RTACPIASL_PARSE_OPTIONAL_KEYWORD_LIST(enmIsMinFixed, s_aenmIsMinFixedKeywords, RTACPIASLTERMINAL_KEYWORD_MIN_NOT_FIXED);
     1853    RTACPIASL_PARSE_PUNCTUATOR(RTACPIASLTERMINAL_PUNCTUATOR_COMMA, ',');
     1854    RTACPIASL_PARSE_OPTIONAL_KEYWORD_LIST(enmIsMaxFixed, s_aenmIsMaxFixedKeywords, RTACPIASLTERMINAL_KEYWORD_MAX_NOT_FIXED);
     1855    RTACPIASL_PARSE_PUNCTUATOR(RTACPIASLTERMINAL_PUNCTUATOR_COMMA, ',');
     1856    RTACPIASL_PARSE_OPTIONAL_KEYWORD_LIST(enmCacheable, s_aenmCacheableKeywords, RTACPIASLTERMINAL_KEYWORD_NON_CACHEABLE);
     1857    RTACPIASL_PARSE_PUNCTUATOR(RTACPIASLTERMINAL_PUNCTUATOR_COMMA, ',');
     1858    RTACPIASL_PARSE_OPTIONAL_KEYWORD_LIST(enmRw, g_aenmRwRoKeywords, RTACPIASLTERMINAL_KEYWORD_READWRITE);
     1859    RTACPIASL_PARSE_PUNCTUATOR(RTACPIASLTERMINAL_PUNCTUATOR_COMMA, ',');
     1860    RTACPIASL_PARSE_NATURAL(u64AddrGranularity);
     1861    RTACPIASL_PARSE_PUNCTUATOR(RTACPIASLTERMINAL_PUNCTUATOR_COMMA, ',');
     1862    RTACPIASL_PARSE_NATURAL(u64AddrMin);
     1863    RTACPIASL_PARSE_PUNCTUATOR(RTACPIASLTERMINAL_PUNCTUATOR_COMMA, ',');
     1864    RTACPIASL_PARSE_NATURAL(u64AddrMax);
     1865    RTACPIASL_PARSE_PUNCTUATOR(RTACPIASLTERMINAL_PUNCTUATOR_COMMA, ',');
     1866    RTACPIASL_PARSE_NATURAL(u64AddrTranslation);
     1867    RTACPIASL_PARSE_PUNCTUATOR(RTACPIASLTERMINAL_PUNCTUATOR_COMMA, ',');
     1868    RTACPIASL_PARSE_NATURAL(u64RangeLength);
     1869    RTACPIASL_PARSE_OPTIONAL_PUNCTUATOR(RTACPIASLTERMINAL_PUNCTUATOR_COMMA);
     1870    RTACPIASL_PARSE_OPTIONAL_NATURAL(u64ResSrcIndex, UINT64_MAX);
     1871    RTACPIASL_PARSE_OPTIONAL_PUNCTUATOR(RTACPIASLTERMINAL_PUNCTUATOR_COMMA);
     1872    RTACPIASL_PARSE_OPTIONAL_NAME_STRING(pszResSrc);
     1873    RTACPIASL_PARSE_OPTIONAL_PUNCTUATOR(RTACPIASLTERMINAL_PUNCTUATOR_COMMA);
     1874    RTACPIASL_PARSE_OPTIONAL_NAME_STRING(pszName);
     1875    RTACPIASL_PARSE_OPTIONAL_PUNCTUATOR(RTACPIASLTERMINAL_PUNCTUATOR_COMMA);
     1876    RTACPIASL_PARSE_OPTIONAL_KEYWORD_LIST(enmMemRangeType, s_aenmMemRangeTypeKeywords, RTACPIASLTERMINAL_KEYWORD_ADDRESS_RANGE_MEMORY);
     1877    RTACPIASL_PARSE_OPTIONAL_PUNCTUATOR(RTACPIASLTERMINAL_PUNCTUATOR_COMMA);
     1878    RTACPIASL_PARSE_OPTIONAL_KEYWORD_LIST(enmTranslationType, s_aenmTranslationTypeKeywords, RTACPIASLTERMINAL_KEYWORD_TYPE_STATIC);
     1879    RTACPIASL_PARSE_PUNCTUATOR(RTACPIASLTERMINAL_PUNCTUATOR_CLOSE_BRACKET, ')');
     1880
     1881    if (pszName)
     1882    {
     1883        static const RTACPIRSRCNSENTRY s_aRsrcNs[] =
     1884        {
     1885            { "_DEC",  4 * 8 + 1,  1 },
     1886            { "_MIF",  4 * 8 + 2,  1 },
     1887            { "_MAF",  4 * 8 + 3,  1 },
     1888            { "_RW_",  5 * 8,      1 },
     1889            { "_MEM",  5 * 8 + 1,  2 },
     1890            { "_MTP",  5 * 8 + 3,  2 },
     1891            { "_TTP",  5 * 8 + 5,  1 },
     1892            { "_GRA",  6 * 8,     32 },
     1893            { "_MIN", 12 * 8,     32 },
     1894            { "_MAX", 16 * 8,     32 },
     1895            { "_TRA", 24 * 8,     32 },
     1896            { "_LEN", 32 * 8,     32 },
     1897            { NULL,        0,      0 }
     1898        };
     1899        int rc = rtAcpiTblParseResourceNsCreateEntries(pThis, hAcpiRes, pAstNd, "DWordMemory", pszName, &s_aRsrcNs[0]);
     1900        if (RT_FAILURE(rc))
     1901            return rc;
     1902    }
     1903
     1904    RTACPIRESMEMRANGECACHEABILITY enmCacheability = kAcpiResMemRangeCacheability_Invalid;
     1905    switch (enmCacheable)
     1906    {
     1907        case RTACPIASLTERMINAL_KEYWORD_CACHEABLE:       enmCacheability = kAcpiResMemRangeCacheability_Cacheable;               break;
     1908        case RTACPIASLTERMINAL_KEYWORD_WRITE_COMBINING: enmCacheability = kAcpiResMemRangeCacheability_CacheableWriteCombining; break;
     1909        case RTACPIASLTERMINAL_KEYWORD_PREFETCHABLE:    enmCacheability = kAcpiResMemRangeCacheability_CacheablePrefetchable;   break;
     1910        case RTACPIASLTERMINAL_KEYWORD_NON_CACHEABLE:   enmCacheability = kAcpiResMemRangeCacheability_NonCacheable;            break;
     1911        default:
     1912            AssertReleaseFailed(); /* Impossible */
     1913    }
     1914
     1915    RTACPIRESMEMRANGETYPE enmRangeType = kAcpiResMemType_Invalid;
     1916    switch (enmMemRangeType)
     1917    {
     1918        case RTACPIASLTERMINAL_KEYWORD_ADDRESS_RANGE_MEMORY:   enmRangeType = kAcpiResMemType_Memory;   break;
     1919        case RTACPIASLTERMINAL_KEYWORD_ADDRESS_RANGE_NVS:      enmRangeType = kAcpiResMemType_Nvs;      break;
     1920        case RTACPIASLTERMINAL_KEYWORD_ADDRESS_RANGE_ACPI:     enmRangeType = kAcpiResMemType_Acpi;     break;
     1921        case RTACPIASLTERMINAL_KEYWORD_ADDRESS_RANGE_RESERVED: enmRangeType = kAcpiResMemType_Reserved; break;
     1922        default:
     1923            AssertReleaseFailed(); /* Impossible */
     1924    }
     1925
     1926    uint32_t fAddrSpace = 0;
     1927    fAddrSpace |= (enmResourceUsage == RTACPIASLTERMINAL_KEYWORD_RESOURCE_CONSUMER) ? RTACPI_RESOURCE_ADDR_RANGE_F_CONSUMER        : RTACPI_RESOURCE_ADDR_RANGE_F_PRODUCER;
     1928    fAddrSpace |= (enmIsMinFixed    == RTACPIASLTERMINAL_KEYWORD_MIN_FIXED)         ? RTACPI_RESOURCE_ADDR_RANGE_F_MIN_ADDR_FIXED  : RTACPI_RESOURCE_ADDR_RANGE_F_MIN_ADDR_CHANGEABLE;
     1929    fAddrSpace |= (enmIsMaxFixed    == RTACPIASLTERMINAL_KEYWORD_MAX_FIXED)         ? RTACPI_RESOURCE_ADDR_RANGE_F_MAX_ADDR_FIXED  : RTACPI_RESOURCE_ADDR_RANGE_F_MAX_ADDR_CHANGEABLE;
     1930    fAddrSpace |= (enmDecode        == RTACPIASLTERMINAL_KEYWORD_POS_DECODE)        ? RTACPI_RESOURCE_ADDR_RANGE_F_DECODE_TYPE_POS : RTACPI_RESOURCE_ADDR_RANGE_F_DECODE_TYPE_SUB;
     1931    int rc = RTAcpiResourceAddDWordMemoryRangeEx(hAcpiRes, enmCacheability, enmRangeType,
     1932                                                 enmRw == RTACPIASLTERMINAL_KEYWORD_READWRITE,
     1933                                                 enmTranslationType == RTACPIASLTERMINAL_KEYWORD_TYPE_STATIC,
     1934                                                 fAddrSpace, (uint32_t)u64AddrMin, (uint32_t)u64AddrMax,
     1935                                                 (uint32_t)u64AddrTranslation, (uint32_t)u64AddrGranularity, (uint32_t)u64RangeLength,
     1936                                                 pszResSrc, (uint8_t)u64ResSrcIndex);
     1937    if (RT_FAILURE(rc))
     1938        return RTErrInfoSetF(pThis->pErrInfo, rc,
     1939                             "Failed to add DWordMemory(,,,,, %s)", pszName ? pszName : "<NONE>");
     1940
     1941    return VINF_SUCCESS;
     1942}
     1943
     1944
     1945static int rtAcpiTblParseResourceQWordMemory(PRTACPIASLCU pThis, RTACPIRES hAcpiRes, PRTACPIASTNODE pAstNd)
     1946{
     1947    RTACPIASL_PARSE_PUNCTUATOR(RTACPIASLTERMINAL_PUNCTUATOR_OPEN_BRACKET, '(');
     1948    RTACPIASL_PARSE_OPTIONAL_KEYWORD_LIST(enmResourceUsage, s_aenmResourceUsageKeywords, RTACPIASLTERMINAL_KEYWORD_RESOURCE_CONSUMER);
     1949    RTACPIASL_PARSE_PUNCTUATOR(RTACPIASLTERMINAL_PUNCTUATOR_COMMA, ',');
     1950    RTACPIASL_PARSE_OPTIONAL_KEYWORD_LIST(enmDecode, s_aenmDecodeKeywords, RTACPIASLTERMINAL_KEYWORD_POS_DECODE);
     1951    RTACPIASL_PARSE_PUNCTUATOR(RTACPIASLTERMINAL_PUNCTUATOR_COMMA, ',');
     1952    RTACPIASL_PARSE_OPTIONAL_KEYWORD_LIST(enmIsMinFixed, s_aenmIsMinFixedKeywords, RTACPIASLTERMINAL_KEYWORD_MIN_NOT_FIXED);
     1953    RTACPIASL_PARSE_PUNCTUATOR(RTACPIASLTERMINAL_PUNCTUATOR_COMMA, ',');
     1954    RTACPIASL_PARSE_OPTIONAL_KEYWORD_LIST(enmIsMaxFixed, s_aenmIsMaxFixedKeywords, RTACPIASLTERMINAL_KEYWORD_MAX_NOT_FIXED);
     1955    RTACPIASL_PARSE_PUNCTUATOR(RTACPIASLTERMINAL_PUNCTUATOR_COMMA, ',');
     1956    RTACPIASL_PARSE_OPTIONAL_KEYWORD_LIST(enmCacheable, s_aenmCacheableKeywords, RTACPIASLTERMINAL_KEYWORD_NON_CACHEABLE);
     1957    RTACPIASL_PARSE_PUNCTUATOR(RTACPIASLTERMINAL_PUNCTUATOR_COMMA, ',');
     1958    RTACPIASL_PARSE_OPTIONAL_KEYWORD_LIST(enmRw, g_aenmRwRoKeywords, RTACPIASLTERMINAL_KEYWORD_READWRITE);
     1959    RTACPIASL_PARSE_PUNCTUATOR(RTACPIASLTERMINAL_PUNCTUATOR_COMMA, ',');
     1960    RTACPIASL_PARSE_NATURAL(u64AddrGranularity);
     1961    RTACPIASL_PARSE_PUNCTUATOR(RTACPIASLTERMINAL_PUNCTUATOR_COMMA, ',');
     1962    RTACPIASL_PARSE_NATURAL(u64AddrMin);
     1963    RTACPIASL_PARSE_PUNCTUATOR(RTACPIASLTERMINAL_PUNCTUATOR_COMMA, ',');
     1964    RTACPIASL_PARSE_NATURAL(u64AddrMax);
     1965    RTACPIASL_PARSE_PUNCTUATOR(RTACPIASLTERMINAL_PUNCTUATOR_COMMA, ',');
     1966    RTACPIASL_PARSE_NATURAL(u64AddrTranslation);
     1967    RTACPIASL_PARSE_PUNCTUATOR(RTACPIASLTERMINAL_PUNCTUATOR_COMMA, ',');
     1968    RTACPIASL_PARSE_NATURAL(u64RangeLength);
     1969    RTACPIASL_PARSE_OPTIONAL_PUNCTUATOR(RTACPIASLTERMINAL_PUNCTUATOR_COMMA);
     1970    RTACPIASL_PARSE_OPTIONAL_NATURAL(u64ResSrcIndex, UINT64_MAX);
     1971    RTACPIASL_PARSE_OPTIONAL_PUNCTUATOR(RTACPIASLTERMINAL_PUNCTUATOR_COMMA);
     1972    RTACPIASL_PARSE_OPTIONAL_NAME_STRING(pszResSrc);
     1973    RTACPIASL_PARSE_OPTIONAL_PUNCTUATOR(RTACPIASLTERMINAL_PUNCTUATOR_COMMA);
     1974    RTACPIASL_PARSE_OPTIONAL_NAME_STRING(pszName);
     1975    RTACPIASL_PARSE_OPTIONAL_PUNCTUATOR(RTACPIASLTERMINAL_PUNCTUATOR_COMMA);
     1976    RTACPIASL_PARSE_OPTIONAL_KEYWORD_LIST(enmMemRangeType, s_aenmMemRangeTypeKeywords, RTACPIASLTERMINAL_KEYWORD_ADDRESS_RANGE_MEMORY);
     1977    RTACPIASL_PARSE_OPTIONAL_PUNCTUATOR(RTACPIASLTERMINAL_PUNCTUATOR_COMMA);
     1978    RTACPIASL_PARSE_OPTIONAL_KEYWORD_LIST(enmTranslationType, s_aenmTranslationTypeKeywords, RTACPIASLTERMINAL_KEYWORD_TYPE_STATIC);
     1979    RTACPIASL_PARSE_PUNCTUATOR(RTACPIASLTERMINAL_PUNCTUATOR_CLOSE_BRACKET, ')');
     1980
     1981    if (pszName)
     1982    {
     1983        static const RTACPIRSRCNSENTRY s_aRsrcNs[] =
     1984        {
     1985            { "_DEC",  4 * 8 + 1,  1 },
     1986            { "_MIF",  4 * 8 + 2,  1 },
     1987            { "_MAF",  4 * 8 + 3,  1 },
     1988            { "_RW_",  5 * 8,      1 },
     1989            { "_MEM",  5 * 8 + 1,  2 },
     1990            { "_MTP",  5 * 8 + 3,  2 },
     1991            { "_TTP",  5 * 8 + 5,  1 },
     1992            { "_GRA",  6 * 8,     64 },
     1993            { "_MIN", 14 * 8,     64 },
     1994            { "_MAX", 22 * 8,     64 },
     1995            { "_TRA", 30 * 8,     64 },
     1996            { "_LEN", 38 * 8,     64 },
     1997            { NULL,        0,      0 }
     1998        };
     1999        int rc = rtAcpiTblParseResourceNsCreateEntries(pThis, hAcpiRes, pAstNd, "QWordMemory", pszName, &s_aRsrcNs[0]);
     2000        if (RT_FAILURE(rc))
     2001            return rc;
     2002    }
     2003
     2004    RTACPIRESMEMRANGECACHEABILITY enmCacheability = kAcpiResMemRangeCacheability_Invalid;
     2005    switch (enmCacheable)
     2006    {
     2007        case RTACPIASLTERMINAL_KEYWORD_CACHEABLE:       enmCacheability = kAcpiResMemRangeCacheability_Cacheable;               break;
     2008        case RTACPIASLTERMINAL_KEYWORD_WRITE_COMBINING: enmCacheability = kAcpiResMemRangeCacheability_CacheableWriteCombining; break;
     2009        case RTACPIASLTERMINAL_KEYWORD_PREFETCHABLE:    enmCacheability = kAcpiResMemRangeCacheability_CacheablePrefetchable;   break;
     2010        case RTACPIASLTERMINAL_KEYWORD_NON_CACHEABLE:   enmCacheability = kAcpiResMemRangeCacheability_NonCacheable;            break;
     2011        default:
     2012            AssertReleaseFailed(); /* Impossible */
     2013    }
     2014
     2015    RTACPIRESMEMRANGETYPE enmRangeType = kAcpiResMemType_Invalid;
     2016    switch (enmMemRangeType)
     2017    {
     2018        case RTACPIASLTERMINAL_KEYWORD_ADDRESS_RANGE_MEMORY:   enmRangeType = kAcpiResMemType_Memory;   break;
     2019        case RTACPIASLTERMINAL_KEYWORD_ADDRESS_RANGE_NVS:      enmRangeType = kAcpiResMemType_Nvs;      break;
     2020        case RTACPIASLTERMINAL_KEYWORD_ADDRESS_RANGE_ACPI:     enmRangeType = kAcpiResMemType_Acpi;     break;
     2021        case RTACPIASLTERMINAL_KEYWORD_ADDRESS_RANGE_RESERVED: enmRangeType = kAcpiResMemType_Reserved; break;
     2022        default:
     2023            AssertReleaseFailed(); /* Impossible */
     2024    }
     2025
     2026    uint32_t fAddrSpace = 0;
     2027    fAddrSpace |= (enmResourceUsage == RTACPIASLTERMINAL_KEYWORD_RESOURCE_CONSUMER) ? RTACPI_RESOURCE_ADDR_RANGE_F_CONSUMER        : RTACPI_RESOURCE_ADDR_RANGE_F_PRODUCER;
     2028    fAddrSpace |= (enmIsMinFixed    == RTACPIASLTERMINAL_KEYWORD_MIN_FIXED)         ? RTACPI_RESOURCE_ADDR_RANGE_F_MIN_ADDR_FIXED  : RTACPI_RESOURCE_ADDR_RANGE_F_MIN_ADDR_CHANGEABLE;
     2029    fAddrSpace |= (enmIsMaxFixed    == RTACPIASLTERMINAL_KEYWORD_MAX_FIXED)         ? RTACPI_RESOURCE_ADDR_RANGE_F_MAX_ADDR_FIXED  : RTACPI_RESOURCE_ADDR_RANGE_F_MAX_ADDR_CHANGEABLE;
     2030    fAddrSpace |= (enmDecode        == RTACPIASLTERMINAL_KEYWORD_POS_DECODE)        ? RTACPI_RESOURCE_ADDR_RANGE_F_DECODE_TYPE_POS : RTACPI_RESOURCE_ADDR_RANGE_F_DECODE_TYPE_SUB;
     2031    int rc = RTAcpiResourceAddQWordMemoryRangeEx(hAcpiRes, enmCacheability, enmRangeType,
     2032                                                 enmRw == RTACPIASLTERMINAL_KEYWORD_READWRITE,
     2033                                                 enmTranslationType == RTACPIASLTERMINAL_KEYWORD_TYPE_STATIC,
     2034                                                 fAddrSpace, u64AddrMin, u64AddrMax, u64AddrTranslation, u64AddrGranularity, u64RangeLength,
     2035                                                 pszResSrc, (uint8_t)u64ResSrcIndex);
     2036    if (RT_FAILURE(rc))
     2037        return RTErrInfoSetF(pThis->pErrInfo, rc,
     2038                             "Failed to add QWordMemory(,,,,, %s)", pszName ? pszName : "<NONE>");
    15802039
    15812040    return VINF_SUCCESS;
    … …  
    15932052        RTACPIASLTERMINAL_KEYWORD_IO,
    15942053        RTACPIASLTERMINAL_KEYWORD_DMA,
     2054        RTACPIASLTERMINAL_KEYWORD_WORD_BUS_NUMBER,
     2055        RTACPIASLTERMINAL_KEYWORD_WORD_IO,
     2056        RTACPIASLTERMINAL_KEYWORD_DWORD_MEMORY,
     2057        RTACPIASLTERMINAL_KEYWORD_QWORD_MEMORY,
    15952058        RTACPIASLTERMINAL_INVALID
    15962059    };
    … …  
    16402103                break;
    16412104            }
     2105            case RTACPIASLTERMINAL_KEYWORD_WORD_BUS_NUMBER:
     2106            {
     2107                rc = rtAcpiTblParseResourceWordBusNumber(pThis, hAcpiRes, pAstNd);
     2108                break;
     2109            }
     2110            case RTACPIASLTERMINAL_KEYWORD_WORD_IO:
     2111            {
     2112                rc = rtAcpiTblParseResourceWordIo(pThis, hAcpiRes, pAstNd);
     2113                break;
     2114            }
     2115            case RTACPIASLTERMINAL_KEYWORD_DWORD_MEMORY:
     2116            {
     2117                rc = rtAcpiTblParseResourceDWordMemory(pThis, hAcpiRes, pAstNd);
     2118                break;
     2119            }
     2120            case RTACPIASLTERMINAL_KEYWORD_QWORD_MEMORY:
     2121            {
     2122                rc = rtAcpiTblParseResourceQWordMemory(pThis, hAcpiRes, pAstNd);
     2123                break;
     2124            }
    16422125            default: /* This should never occur. */
    16432126                AssertReleaseFailed();
    … …  
    18962379static const RTACPIASLKEYWORD g_aAslOps[] =
    18972380{
    1898     /* kAcpiAstNodeOp_Invalid           */  RTACPI_ASL_KEYWORD_DEFINE_INVALID,
    1899     /* kAcpiAstNodeOp_Identifier        */  RTACPI_ASL_KEYWORD_DEFINE_INVALID,
    1900     /* kAcpiAstNodeOp_StringLiteral     */  RTACPI_ASL_KEYWORD_DEFINE_INVALID,
    1901     /* kAcpiAstNodeOp_Number            */  RTACPI_ASL_KEYWORD_DEFINE_INVALID,
    1902     /* kAcpiAstNodeOp_Scope             */  RTACPI_ASL_KEYWORD_DEFINE_1REQ_0OPT("Scope",            RTACPI_AST_NODE_F_NEW_SCOPE | RTACPI_AST_NODE_F_NS_ENTRY,   kAcpiAstArgType_NameString),
    1903     /* kAcpiAstNodeOp_Processor         */  {
    1904                                                 "Processor", NULL, 2, 2, RTACPI_AST_NODE_F_NEW_SCOPE | RTACPI_AST_NODE_F_NS_ENTRY,
    1905                                                 {
    1906                                                     kAcpiAstArgType_NameString,
    1907                                                     kAcpiAstArgType_U8,
    1908                                                     kAcpiAstArgType_Invalid,
    1909                                                     kAcpiAstArgType_Invalid,
    1910                                                     kAcpiAstArgType_Invalid
    1911                                                 },
    1912                                                 {
    1913                                                     { kAcpiAstArgType_U32,     { 0 } },
    1914                                                     { kAcpiAstArgType_U8,      { 0 } },
    1915                                                     { kAcpiAstArgType_Invalid, { 0 } }
    1916                                                 }
    1917                                             },
    1918     /* kAcpiAstNodeOp_External          */  RTACPI_ASL_KEYWORD_DEFINE_HANDLER(  "External",         rtAcpiTblAslParseExternal, 1, 2, RTACPI_AST_NODE_F_DEFAULT),
    1919     /* kAcpiAstNodeOp_Method            */  RTACPI_ASL_KEYWORD_DEFINE_HANDLER(  "Method",           rtAcpiTblAslParseMethod,   1, 3, RTACPI_AST_NODE_F_NEW_SCOPE),
    1920     /* kAcpiAstNodeOp_Device            */  RTACPI_ASL_KEYWORD_DEFINE_1REQ_0OPT("Device",           RTACPI_AST_NODE_F_NEW_SCOPE | RTACPI_AST_NODE_F_NS_ENTRY,   kAcpiAstArgType_NameString),
    1921     /* kAcpiAstNodeOp_If                */  RTACPI_ASL_KEYWORD_DEFINE_1REQ_0OPT("If",               RTACPI_AST_NODE_F_NEW_SCOPE,                                kAcpiAstArgType_AstNode),
    1922     /* kAcpiAstNodeOp_Else              */  RTACPI_ASL_KEYWORD_DEFINE_0REQ_0OPT("Else",             RTACPI_AST_NODE_F_NEW_SCOPE),
    1923     /* kAcpiAstNodeOp_LAnd              */  RTACPI_ASL_KEYWORD_DEFINE_2REQ_0OPT("LAnd",             RTACPI_AST_NODE_F_DEFAULT,                                  kAcpiAstArgType_AstNode, kAcpiAstArgType_AstNode),
    1924     /* kAcpiAstNodeOp_LEqual            */  RTACPI_ASL_KEYWORD_DEFINE_2REQ_0OPT("LEqual",           RTACPI_AST_NODE_F_DEFAULT,                                  kAcpiAstArgType_AstNode, kAcpiAstArgType_AstNode),
    1925     /* kAcpiAstNodeOp_LGreater          */  RTACPI_ASL_KEYWORD_DEFINE_2REQ_0OPT("LGreater",         RTACPI_AST_NODE_F_DEFAULT,                                  kAcpiAstArgType_AstNode, kAcpiAstArgType_AstNode),
    1926     /* kAcpiAstNodeOp_LGreaterEqual     */  RTACPI_ASL_KEYWORD_DEFINE_2REQ_0OPT("LGreaterEqual",    RTACPI_AST_NODE_F_DEFAULT,                                  kAcpiAstArgType_AstNode, kAcpiAstArgType_AstNode),
    1927     /* kAcpiAstNodeOp_LLess             */  RTACPI_ASL_KEYWORD_DEFINE_2REQ_0OPT("LLess",            RTACPI_AST_NODE_F_DEFAULT,                                  kAcpiAstArgType_AstNode, kAcpiAstArgType_AstNode),
    1928     /* kAcpiAstNodeOp_LLessEqual        */  RTACPI_ASL_KEYWORD_DEFINE_2REQ_0OPT("LLessEqual",       RTACPI_AST_NODE_F_DEFAULT,                                  kAcpiAstArgType_AstNode, kAcpiAstArgType_AstNode),
    1929     /* kAcpiAstNodeOp_LNot              */  RTACPI_ASL_KEYWORD_DEFINE_1REQ_0OPT("LNot",             RTACPI_AST_NODE_F_DEFAULT,                                  kAcpiAstArgType_AstNode),
    1930     /* kAcpiAstNodeOp_LNotEqual         */  RTACPI_ASL_KEYWORD_DEFINE_2REQ_0OPT("LNotEqual",        RTACPI_AST_NODE_F_DEFAULT,                                  kAcpiAstArgType_AstNode, kAcpiAstArgType_AstNode),
    1931     /* kAcpiAstNodeOp_Zero              */  RTACPI_ASL_KEYWORD_DEFINE_0REQ_0OPT("Zero",             RTACPI_AST_NODE_F_DEFAULT),
    1932     /* kAcpiAstNodeOp_One               */  RTACPI_ASL_KEYWORD_DEFINE_0REQ_0OPT("One",              RTACPI_AST_NODE_F_DEFAULT),
    1933     /* kAcpiAstNodeOp_Ones              */  RTACPI_ASL_KEYWORD_DEFINE_0REQ_0OPT("Ones",             RTACPI_AST_NODE_F_DEFAULT),
    1934     /* kAcpiAstNodeOp_Return            */  RTACPI_ASL_KEYWORD_DEFINE_HANDLER(  "Return",           rtAcpiTblAslParseReturn,  0, 1, RTACPI_AST_NODE_F_DEFAULT),
    1935     /* kAcpiAstNodeOp_Unicode           */  RTACPI_ASL_KEYWORD_DEFINE_1REQ_0OPT("Unicode",          RTACPI_AST_NODE_F_DEFAULT,                                  kAcpiAstArgType_AstNode), /* Actually only String allowed here */
    1936     /* kAcpiAstNodeOp_OperationRegion   */  RTACPI_ASL_KEYWORD_DEFINE_4REQ_0OPT("OperationRegion",  RTACPI_AST_NODE_F_DEFAULT | RTACPI_AST_NODE_F_NS_ENTRY,     kAcpiAstArgType_NameString, kAcpiAstArgType_RegionSpace, kAcpiAstArgType_AstNode, kAcpiAstArgType_AstNode),
    1937     /* kAcpiAstNodeOp_Field             */  RTACPI_ASL_KEYWORD_DEFINE_HANDLER(  "Field",            rtAcpiTblAslParseFieldOrIndexField, 4, 0, RTACPI_AST_NODE_F_DEFAULT),
    1938     /* kAcpiAstNodeOp_Name              */  RTACPI_ASL_KEYWORD_DEFINE_2REQ_0OPT("Name",             RTACPI_AST_NODE_F_NS_ENTRY,                                 kAcpiAstArgType_NameString, kAcpiAstArgType_AstNode),
    1939     /* kAcpiAstNodeOp_ResourceTemplate  */  RTACPI_ASL_KEYWORD_DEFINE_HANDLER(  "ResourceTemplate", rtAcpiTblAslParseResourceTemplate,  0, 0, RTACPI_AST_NODE_F_DEFAULT),
    1940     /* kAcpiAstNodeOp_Arg0              */  RTACPI_ASL_KEYWORD_DEFINE_0REQ_0OPT("Arg0",             RTACPI_AST_NODE_F_DEFAULT),
    1941     /* kAcpiAstNodeOp_Arg1              */  RTACPI_ASL_KEYWORD_DEFINE_0REQ_0OPT("Arg1",             RTACPI_AST_NODE_F_DEFAULT),
    1942     /* kAcpiAstNodeOp_Arg2              */  RTACPI_ASL_KEYWORD_DEFINE_0REQ_0OPT("Arg2",             RTACPI_AST_NODE_F_DEFAULT),
    1943     /* kAcpiAstNodeOp_Arg3              */  RTACPI_ASL_KEYWORD_DEFINE_0REQ_0OPT("Arg3",             RTACPI_AST_NODE_F_DEFAULT),
    1944     /* kAcpiAstNodeOp_Arg4              */  RTACPI_ASL_KEYWORD_DEFINE_0REQ_0OPT("Arg4",             RTACPI_AST_NODE_F_DEFAULT),
    1945     /* kAcpiAstNodeOp_Arg5              */  RTACPI_ASL_KEYWORD_DEFINE_0REQ_0OPT("Arg5",             RTACPI_AST_NODE_F_DEFAULT),
    1946     /* kAcpiAstNodeOp_Arg6              */  RTACPI_ASL_KEYWORD_DEFINE_0REQ_0OPT("Arg6",             RTACPI_AST_NODE_F_DEFAULT),
    1947     /* kAcpiAstNodeOp_Local0            */  RTACPI_ASL_KEYWORD_DEFINE_0REQ_0OPT("Local0",           RTACPI_AST_NODE_F_DEFAULT),
    1948     /* kAcpiAstNodeOp_Local1            */  RTACPI_ASL_KEYWORD_DEFINE_0REQ_0OPT("Local1",           RTACPI_AST_NODE_F_DEFAULT),
    1949     /* kAcpiAstNodeOp_Local2            */  RTACPI_ASL_KEYWORD_DEFINE_0REQ_0OPT("Local2",           RTACPI_AST_NODE_F_DEFAULT),
    1950     /* kAcpiAstNodeOp_Local3            */  RTACPI_ASL_KEYWORD_DEFINE_0REQ_0OPT("Local3",           RTACPI_AST_NODE_F_DEFAULT),
    1951     /* kAcpiAstNodeOp_Local4            */  RTACPI_ASL_KEYWORD_DEFINE_0REQ_0OPT("Local4",           RTACPI_AST_NODE_F_DEFAULT),
    1952     /* kAcpiAstNodeOp_Local5            */  RTACPI_ASL_KEYWORD_DEFINE_0REQ_0OPT("Local5",           RTACPI_AST_NODE_F_DEFAULT),
    1953     /* kAcpiAstNodeOp_Local6            */  RTACPI_ASL_KEYWORD_DEFINE_0REQ_0OPT("Local6",           RTACPI_AST_NODE_F_DEFAULT),
    1954     /* kAcpiAstNodeOp_Local7            */  RTACPI_ASL_KEYWORD_DEFINE_0REQ_0OPT("Local7",           RTACPI_AST_NODE_F_DEFAULT),
    1955     /* kAcpiAstNodeOp_Package           */  RTACPI_ASL_KEYWORD_DEFINE_HANDLER(  "Package",          rtAcpiTblAslParsePackageOrBuffer, 0, 1, RTACPI_AST_NODE_F_DEFAULT),
    1956     /* kAcpiAstNodeOp_Buffer            */  RTACPI_ASL_KEYWORD_DEFINE_HANDLER(  "Buffer",           rtAcpiTblAslParsePackageOrBuffer, 0, 1, RTACPI_AST_NODE_F_DEFAULT),
    1957     /* kAcpiAstNodeOp_ToUUid            */  RTACPI_ASL_KEYWORD_DEFINE_1REQ_0OPT("ToUUID",           RTACPI_AST_NODE_F_DEFAULT,    kAcpiAstArgType_AstNode),
    1958     /* kAcpiAstNodeOp_DerefOf           */  RTACPI_ASL_KEYWORD_DEFINE_1REQ_0OPT("DerefOf",          RTACPI_AST_NODE_F_DEFAULT,    kAcpiAstArgType_AstNode),
    1959     /* kAcpiAstNodeOp_Index             */  RTACPI_ASL_KEYWORD_DEFINE_2REQ_1OPT("Index",            RTACPI_AST_NODE_F_DEFAULT,    kAcpiAstArgType_AstNode, kAcpiAstArgType_AstNode, kAcpiAstArgType_AstNode),
    1960     /* kAcpiAstNodeOp_Store             */  RTACPI_ASL_KEYWORD_DEFINE_2REQ_0OPT("Store",            RTACPI_AST_NODE_F_DEFAULT,    kAcpiAstArgType_AstNode, kAcpiAstArgType_AstNode),
    1961 
    1962     /* kAcpiAstNodeOp_Break             */  RTACPI_ASL_KEYWORD_DEFINE_0REQ_0OPT("Break",            RTACPI_AST_NODE_F_DEFAULT),
    1963     /* kAcpiAstNodeOp_Continue          */  RTACPI_ASL_KEYWORD_DEFINE_0REQ_0OPT("Continue",         RTACPI_AST_NODE_F_DEFAULT),
    1964     /* kAcpiAstNodeOp_Add               */  RTACPI_ASL_KEYWORD_DEFINE_2REQ_1OPT("Add",              RTACPI_AST_NODE_F_DEFAULT,    kAcpiAstArgType_AstNode, kAcpiAstArgType_AstNode, kAcpiAstArgType_AstNode),
    1965     /* kAcpiAstNodeOp_Subtract          */  RTACPI_ASL_KEYWORD_DEFINE_2REQ_1OPT("Subtract",         RTACPI_AST_NODE_F_DEFAULT,    kAcpiAstArgType_AstNode, kAcpiAstArgType_AstNode, kAcpiAstArgType_AstNode),
    1966     /* kAcpiAstNodeOp_And               */  RTACPI_ASL_KEYWORD_DEFINE_2REQ_1OPT("And",              RTACPI_AST_NODE_F_DEFAULT,    kAcpiAstArgType_AstNode, kAcpiAstArgType_AstNode, kAcpiAstArgType_AstNode),
    1967     /* kAcpiAstNodeOp_Nand              */  RTACPI_ASL_KEYWORD_DEFINE_2REQ_1OPT("Nand",             RTACPI_AST_NODE_F_DEFAULT,    kAcpiAstArgType_AstNode, kAcpiAstArgType_AstNode, kAcpiAstArgType_AstNode),
    1968     /* kAcpiAstNodeOp_Or                */  RTACPI_ASL_KEYWORD_DEFINE_2REQ_1OPT("Or",               RTACPI_AST_NODE_F_DEFAULT,    kAcpiAstArgType_AstNode, kAcpiAstArgType_AstNode, kAcpiAstArgType_AstNode),
    1969     /* kAcpiAstNodeOp_Xor               */  RTACPI_ASL_KEYWORD_DEFINE_2REQ_1OPT("Xor",              RTACPI_AST_NODE_F_DEFAULT,    kAcpiAstArgType_AstNode, kAcpiAstArgType_AstNode, kAcpiAstArgType_AstNode),
    1970     /* kAcpiAstNodeOp_Not               */  RTACPI_ASL_KEYWORD_DEFINE_1REQ_1OPT("Not",              RTACPI_AST_NODE_F_DEFAULT,    kAcpiAstArgType_AstNode, kAcpiAstArgType_AstNode),
    1971     /* kAcpiAstNodeOp_Notify            */  RTACPI_ASL_KEYWORD_DEFINE_2REQ_0OPT("Notify",           RTACPI_AST_NODE_F_DEFAULT,    kAcpiAstArgType_AstNode, kAcpiAstArgType_AstNode),
    1972     /* kAcpiAstNodeOp_SizeOf            */  RTACPI_ASL_KEYWORD_DEFINE_1REQ_0OPT("SizeOf",           RTACPI_AST_NODE_F_DEFAULT,    kAcpiAstArgType_AstNode),
    1973     /* kAcpiAstNodeOp_While             */  RTACPI_ASL_KEYWORD_DEFINE_1REQ_0OPT("While",            RTACPI_AST_NODE_F_NEW_SCOPE,  kAcpiAstArgType_AstNode),
    1974     /* kAcpiAstNodeOp_Increment         */  RTACPI_ASL_KEYWORD_DEFINE_1REQ_0OPT("Increment",        RTACPI_AST_NODE_F_DEFAULT,    kAcpiAstArgType_AstNode),
    1975     /* kAcpiAstNodeOp_Decrement         */  RTACPI_ASL_KEYWORD_DEFINE_1REQ_0OPT("Decrement",        RTACPI_AST_NODE_F_DEFAULT,    kAcpiAstArgType_AstNode),
    1976     /* kAcpiAstNodeOp_CondRefOf         */  RTACPI_ASL_KEYWORD_DEFINE_1REQ_1OPT("CondRefOf",        RTACPI_AST_NODE_F_DEFAULT,    kAcpiAstArgType_AstNode, kAcpiAstArgType_AstNode),
    1977     /* kAcpiAstNodeOp_IndexField        */  RTACPI_ASL_KEYWORD_DEFINE_HANDLER(  "IndexField",       rtAcpiTblAslParseFieldOrIndexField, 5, 0, RTACPI_AST_NODE_F_DEFAULT),
    1978     /* kAcpiAstNodeOp_EisaId            */  RTACPI_ASL_KEYWORD_DEFINE_1REQ_0OPT("EisaId",           RTACPI_AST_NODE_F_DEFAULT,    kAcpiAstArgType_StringLiteral),
    1979     /* kAcpiAstNodeOp_CreateField       */  RTACPI_ASL_KEYWORD_DEFINE_4REQ_0OPT("CreateField",      RTACPI_AST_NODE_F_DEFAULT,    kAcpiAstArgType_AstNode, kAcpiAstArgType_AstNode, kAcpiAstArgType_AstNode, kAcpiAstArgType_NameString),
    1980     /* kAcpiAstNodeOp_CreateBitField    */  RTACPI_ASL_KEYWORD_DEFINE_3REQ_0OPT("CreateBitField",   RTACPI_AST_NODE_F_DEFAULT,    kAcpiAstArgType_AstNode, kAcpiAstArgType_AstNode, kAcpiAstArgType_NameString),
    1981     /* kAcpiAstNodeOp_CreateByteField   */  RTACPI_ASL_KEYWORD_DEFINE_3REQ_0OPT("CreateByteField",  RTACPI_AST_NODE_F_DEFAULT,    kAcpiAstArgType_AstNode, kAcpiAstArgType_AstNode, kAcpiAstArgType_NameString),
    1982     /* kAcpiAstNodeOp_CreateWordField   */  RTACPI_ASL_KEYWORD_DEFINE_3REQ_0OPT("CreateWordField",  RTACPI_AST_NODE_F_DEFAULT,    kAcpiAstArgType_AstNode, kAcpiAstArgType_AstNode, kAcpiAstArgType_NameString),
    1983     /* kAcpiAstNodeOp_CreateDWordField  */  RTACPI_ASL_KEYWORD_DEFINE_3REQ_0OPT("CreateDWordField", RTACPI_AST_NODE_F_DEFAULT,    kAcpiAstArgType_AstNode, kAcpiAstArgType_AstNode, kAcpiAstArgType_NameString),
    1984     /* kAcpiAstNodeOp_CreateQWordField  */  RTACPI_ASL_KEYWORD_DEFINE_3REQ_0OPT("CreateQWordField", RTACPI_AST_NODE_F_DEFAULT,    kAcpiAstArgType_AstNode, kAcpiAstArgType_AstNode, kAcpiAstArgType_NameString),
     2381    /* kAcpiAstNodeOp_Invalid                 */  RTACPI_ASL_KEYWORD_DEFINE_INVALID,
     2382    /* kAcpiAstNodeOp_Identifier              */  RTACPI_ASL_KEYWORD_DEFINE_INVALID,
     2383    /* kAcpiAstNodeOp_StringLiteral           */  RTACPI_ASL_KEYWORD_DEFINE_INVALID,
     2384    /* kAcpiAstNodeOp_Number                  */  RTACPI_ASL_KEYWORD_DEFINE_INVALID,
     2385    /* kAcpiAstNodeOp_Scope                   */  RTACPI_ASL_KEYWORD_DEFINE_1REQ_0OPT("Scope",                  RTACPI_AST_NODE_F_NEW_SCOPE | RTACPI_AST_NODE_F_NS_ENTRY,   kAcpiAstArgType_NameString),
     2386    /* kAcpiAstNodeOp_Processor               */  {
     2387                                                      "Processor", NULL, 2, 2, RTACPI_AST_NODE_F_NEW_SCOPE | RTACPI_AST_NODE_F_NS_ENTRY,
     2388                                                      {
     2389                                                          kAcpiAstArgType_NameString,
     2390                                                          kAcpiAstArgType_U8,
     2391                                                          kAcpiAstArgType_Invalid,
     2392                                                          kAcpiAstArgType_Invalid,
     2393                                                          kAcpiAstArgType_Invalid
     2394                                                      },
     2395                                                      {
     2396                                                          { kAcpiAstArgType_U32,     { 0 } },
     2397                                                          { kAcpiAstArgType_U8,      { 0 } },
     2398                                                          { kAcpiAstArgType_Invalid, { 0 } }
     2399                                                      }
     2400                                                  },
     2401    /* kAcpiAstNodeOp_External                */  RTACPI_ASL_KEYWORD_DEFINE_HANDLER(  "External",               rtAcpiTblAslParseExternal, 1, 2, RTACPI_AST_NODE_F_DEFAULT),
     2402    /* kAcpiAstNodeOp_Method                  */  RTACPI_ASL_KEYWORD_DEFINE_HANDLER(  "Method",                 rtAcpiTblAslParseMethod,   1, 3, RTACPI_AST_NODE_F_NEW_SCOPE),
     2403    /* kAcpiAstNodeOp_Device                  */  RTACPI_ASL_KEYWORD_DEFINE_1REQ_0OPT("Device",                 RTACPI_AST_NODE_F_NEW_SCOPE | RTACPI_AST_NODE_F_NS_ENTRY,   kAcpiAstArgType_NameString),
     2404    /* kAcpiAstNodeOp_If                      */  RTACPI_ASL_KEYWORD_DEFINE_1REQ_0OPT("If",                     RTACPI_AST_NODE_F_NEW_SCOPE,                                kAcpiAstArgType_AstNode),
     2405    /* kAcpiAstNodeOp_Else                    */  RTACPI_ASL_KEYWORD_DEFINE_0REQ_0OPT("Else",                   RTACPI_AST_NODE_F_NEW_SCOPE),
     2406    /* kAcpiAstNodeOp_LAnd                    */  RTACPI_ASL_KEYWORD_DEFINE_2REQ_0OPT("LAnd",                   RTACPI_AST_NODE_F_DEFAULT,                                  kAcpiAstArgType_AstNode, kAcpiAstArgType_AstNode),
     2407    /* kAcpiAstNodeOp_LEqual                  */  RTACPI_ASL_KEYWORD_DEFINE_2REQ_0OPT("LEqual",                 RTACPI_AST_NODE_F_DEFAULT,                                  kAcpiAstArgType_AstNode, kAcpiAstArgType_AstNode),
     2408    /* kAcpiAstNodeOp_LGreater                */  RTACPI_ASL_KEYWORD_DEFINE_2REQ_0OPT("LGreater",               RTACPI_AST_NODE_F_DEFAULT,                                  kAcpiAstArgType_AstNode, kAcpiAstArgType_AstNode),
     2409    /* kAcpiAstNodeOp_LGreaterEqual           */  RTACPI_ASL_KEYWORD_DEFINE_2REQ_0OPT("LGreaterEqual",          RTACPI_AST_NODE_F_DEFAULT,                                  kAcpiAstArgType_AstNode, kAcpiAstArgType_AstNode),
     2410    /* kAcpiAstNodeOp_LLess                   */  RTACPI_ASL_KEYWORD_DEFINE_2REQ_0OPT("LLess",                  RTACPI_AST_NODE_F_DEFAULT,                                  kAcpiAstArgType_AstNode, kAcpiAstArgType_AstNode),
     2411    /* kAcpiAstNodeOp_LLessEqual              */  RTACPI_ASL_KEYWORD_DEFINE_2REQ_0OPT("LLessEqual",             RTACPI_AST_NODE_F_DEFAULT,                                  kAcpiAstArgType_AstNode, kAcpiAstArgType_AstNode),
     2412    /* kAcpiAstNodeOp_LNot                    */  RTACPI_ASL_KEYWORD_DEFINE_1REQ_0OPT("LNot",                   RTACPI_AST_NODE_F_DEFAULT,                                  kAcpiAstArgType_AstNode),
     2413    /* kAcpiAstNodeOp_LNotEqual               */  RTACPI_ASL_KEYWORD_DEFINE_2REQ_0OPT("LNotEqual",              RTACPI_AST_NODE_F_DEFAULT,                                  kAcpiAstArgType_AstNode, kAcpiAstArgType_AstNode),
     2414    /* kAcpiAstNodeOp_Zero                    */  RTACPI_ASL_KEYWORD_DEFINE_0REQ_0OPT("Zero",                   RTACPI_AST_NODE_F_DEFAULT),
     2415    /* kAcpiAstNodeOp_One                     */  RTACPI_ASL_KEYWORD_DEFINE_0REQ_0OPT("One",                    RTACPI_AST_NODE_F_DEFAULT),
     2416    /* kAcpiAstNodeOp_Ones                    */  RTACPI_ASL_KEYWORD_DEFINE_0REQ_0OPT("Ones",                   RTACPI_AST_NODE_F_DEFAULT),
     2417    /* kAcpiAstNodeOp_Return                  */  RTACPI_ASL_KEYWORD_DEFINE_HANDLER(  "Return",                 rtAcpiTblAslParseReturn,  0, 1, RTACPI_AST_NODE_F_DEFAULT),
     2418    /* kAcpiAstNodeOp_Unicode                 */  RTACPI_ASL_KEYWORD_DEFINE_1REQ_0OPT("Unicode",                RTACPI_AST_NODE_F_DEFAULT,                                  kAcpiAstArgType_AstNode), /* Actually only String allowed here */
     2419    /* kAcpiAstNodeOp_OperationRegion         */  RTACPI_ASL_KEYWORD_DEFINE_4REQ_0OPT("OperationRegion",        RTACPI_AST_NODE_F_DEFAULT | RTACPI_AST_NODE_F_NS_ENTRY,     kAcpiAstArgType_NameString, kAcpiAstArgType_RegionSpace, kAcpiAstArgType_AstNode, kAcpiAstArgType_AstNode),
     2420    /* kAcpiAstNodeOp_Field                   */  RTACPI_ASL_KEYWORD_DEFINE_HANDLER(  "Field",                  rtAcpiTblAslParseFieldOrIndexField, 4, 0, RTACPI_AST_NODE_F_DEFAULT),
     2421    /* kAcpiAstNodeOp_Name                    */  RTACPI_ASL_KEYWORD_DEFINE_2REQ_0OPT("Name",                   RTACPI_AST_NODE_F_NS_ENTRY,                                 kAcpiAstArgType_NameString, kAcpiAstArgType_AstNode),
     2422    /* kAcpiAstNodeOp_ResourceTemplate        */  RTACPI_ASL_KEYWORD_DEFINE_HANDLER(  "ResourceTemplate",       rtAcpiTblAslParseResourceTemplate,  0, 0, RTACPI_AST_NODE_F_DEFAULT),
     2423    /* kAcpiAstNodeOp_Arg0                    */  RTACPI_ASL_KEYWORD_DEFINE_0REQ_0OPT("Arg0",                   RTACPI_AST_NODE_F_DEFAULT),
     2424    /* kAcpiAstNodeOp_Arg1                    */  RTACPI_ASL_KEYWORD_DEFINE_0REQ_0OPT("Arg1",                   RTACPI_AST_NODE_F_DEFAULT),
     2425    /* kAcpiAstNodeOp_Arg2                    */  RTACPI_ASL_KEYWORD_DEFINE_0REQ_0OPT("Arg2",                   RTACPI_AST_NODE_F_DEFAULT),
     2426    /* kAcpiAstNodeOp_Arg3                    */  RTACPI_ASL_KEYWORD_DEFINE_0REQ_0OPT("Arg3",                   RTACPI_AST_NODE_F_DEFAULT),
     2427    /* kAcpiAstNodeOp_Arg4                    */  RTACPI_ASL_KEYWORD_DEFINE_0REQ_0OPT("Arg4",                   RTACPI_AST_NODE_F_DEFAULT),
     2428    /* kAcpiAstNodeOp_Arg5                    */  RTACPI_ASL_KEYWORD_DEFINE_0REQ_0OPT("Arg5",                   RTACPI_AST_NODE_F_DEFAULT),
     2429    /* kAcpiAstNodeOp_Arg6                    */  RTACPI_ASL_KEYWORD_DEFINE_0REQ_0OPT("Arg6",                   RTACPI_AST_NODE_F_DEFAULT),
     2430    /* kAcpiAstNodeOp_Local0                  */  RTACPI_ASL_KEYWORD_DEFINE_0REQ_0OPT("Local0",                 RTACPI_AST_NODE_F_DEFAULT),
     2431    /* kAcpiAstNodeOp_Local1                  */  RTACPI_ASL_KEYWORD_DEFINE_0REQ_0OPT("Local1",                 RTACPI_AST_NODE_F_DEFAULT),
     2432    /* kAcpiAstNodeOp_Local2                  */  RTACPI_ASL_KEYWORD_DEFINE_0REQ_0OPT("Local2",                 RTACPI_AST_NODE_F_DEFAULT),
     2433    /* kAcpiAstNodeOp_Local3                  */  RTACPI_ASL_KEYWORD_DEFINE_0REQ_0OPT("Local3",                 RTACPI_AST_NODE_F_DEFAULT),
     2434    /* kAcpiAstNodeOp_Local4                  */  RTACPI_ASL_KEYWORD_DEFINE_0REQ_0OPT("Local4",                 RTACPI_AST_NODE_F_DEFAULT),
     2435    /* kAcpiAstNodeOp_Local5                  */  RTACPI_ASL_KEYWORD_DEFINE_0REQ_0OPT("Local5",                 RTACPI_AST_NODE_F_DEFAULT),
     2436    /* kAcpiAstNodeOp_Local6                  */  RTACPI_ASL_KEYWORD_DEFINE_0REQ_0OPT("Local6",                 RTACPI_AST_NODE_F_DEFAULT),
     2437    /* kAcpiAstNodeOp_Local7                  */  RTACPI_ASL_KEYWORD_DEFINE_0REQ_0OPT("Local7",                 RTACPI_AST_NODE_F_DEFAULT),
     2438    /* kAcpiAstNodeOp_Package                 */  RTACPI_ASL_KEYWORD_DEFINE_HANDLER(  "Package",                rtAcpiTblAslParsePackageOrBuffer, 0, 1, RTACPI_AST_NODE_F_DEFAULT),
     2439    /* kAcpiAstNodeOp_Buffer                  */  RTACPI_ASL_KEYWORD_DEFINE_HANDLER(  "Buffer",                 rtAcpiTblAslParsePackageOrBuffer, 0, 1, RTACPI_AST_NODE_F_DEFAULT),
     2440    /* kAcpiAstNodeOp_ToUUid                  */  RTACPI_ASL_KEYWORD_DEFINE_1REQ_0OPT("ToUUID",                 RTACPI_AST_NODE_F_DEFAULT,    kAcpiAstArgType_AstNode),
     2441    /* kAcpiAstNodeOp_DerefOf                 */  RTACPI_ASL_KEYWORD_DEFINE_1REQ_0OPT("DerefOf",                RTACPI_AST_NODE_F_DEFAULT,    kAcpiAstArgType_AstNode),
     2442    /* kAcpiAstNodeOp_Index                   */  RTACPI_ASL_KEYWORD_DEFINE_2REQ_1OPT("Index",                  RTACPI_AST_NODE_F_DEFAULT,    kAcpiAstArgType_AstNode, kAcpiAstArgType_AstNode, kAcpiAstArgType_AstNode),
     2443    /* kAcpiAstNodeOp_Store                   */  RTACPI_ASL_KEYWORD_DEFINE_2REQ_0OPT("Store",                  RTACPI_AST_NODE_F_DEFAULT,    kAcpiAstArgType_AstNode, kAcpiAstArgType_AstNode),
     2444    /* kAcpiAstNodeOp_Break                   */  RTACPI_ASL_KEYWORD_DEFINE_0REQ_0OPT("Break",                  RTACPI_AST_NODE_F_DEFAULT),
     2445    /* kAcpiAstNodeOp_Continue                */  RTACPI_ASL_KEYWORD_DEFINE_0REQ_0OPT("Continue",               RTACPI_AST_NODE_F_DEFAULT),
     2446    /* kAcpiAstNodeOp_Add                     */  RTACPI_ASL_KEYWORD_DEFINE_2REQ_1OPT("Add",                    RTACPI_AST_NODE_F_DEFAULT,    kAcpiAstArgType_AstNode, kAcpiAstArgType_AstNode, kAcpiAstArgType_AstNode),
     2447    /* kAcpiAstNodeOp_Subtract                */  RTACPI_ASL_KEYWORD_DEFINE_2REQ_1OPT("Subtract",               RTACPI_AST_NODE_F_DEFAULT,    kAcpiAstArgType_AstNode, kAcpiAstArgType_AstNode, kAcpiAstArgType_AstNode),
     2448    /* kAcpiAstNodeOp_Multiply                */  RTACPI_ASL_KEYWORD_DEFINE_2REQ_1OPT("Multiply",               RTACPI_AST_NODE_F_DEFAULT,    kAcpiAstArgType_AstNode, kAcpiAstArgType_AstNode, kAcpiAstArgType_AstNode),
     2449    /* kAcpiAstNodeOp_And                     */  RTACPI_ASL_KEYWORD_DEFINE_2REQ_1OPT("And",                    RTACPI_AST_NODE_F_DEFAULT,    kAcpiAstArgType_AstNode, kAcpiAstArgType_AstNode, kAcpiAstArgType_AstNode),
     2450    /* kAcpiAstNodeOp_Nand                    */  RTACPI_ASL_KEYWORD_DEFINE_2REQ_1OPT("Nand",                   RTACPI_AST_NODE_F_DEFAULT,    kAcpiAstArgType_AstNode, kAcpiAstArgType_AstNode, kAcpiAstArgType_AstNode),
     2451    /* kAcpiAstNodeOp_Or                      */  RTACPI_ASL_KEYWORD_DEFINE_2REQ_1OPT("Or",                     RTACPI_AST_NODE_F_DEFAULT,    kAcpiAstArgType_AstNode, kAcpiAstArgType_AstNode, kAcpiAstArgType_AstNode),
     2452    /* kAcpiAstNodeOp_Xor                     */  RTACPI_ASL_KEYWORD_DEFINE_2REQ_1OPT("Xor",                    RTACPI_AST_NODE_F_DEFAULT,    kAcpiAstArgType_AstNode, kAcpiAstArgType_AstNode, kAcpiAstArgType_AstNode),
     2453    /* kAcpiAstNodeOp_ShiftLeft               */  RTACPI_ASL_KEYWORD_DEFINE_2REQ_1OPT("ShiftLeft",              RTACPI_AST_NODE_F_DEFAULT,    kAcpiAstArgType_AstNode, kAcpiAstArgType_AstNode, kAcpiAstArgType_AstNode),
     2454    /* kAcpiAstNodeOp_ShiftRight              */  RTACPI_ASL_KEYWORD_DEFINE_2REQ_1OPT("ShiftRight",             RTACPI_AST_NODE_F_DEFAULT,    kAcpiAstArgType_AstNode, kAcpiAstArgType_AstNode, kAcpiAstArgType_AstNode),
     2455    /* kAcpiAstNodeOp_Not                     */  RTACPI_ASL_KEYWORD_DEFINE_1REQ_1OPT("Not",                    RTACPI_AST_NODE_F_DEFAULT,    kAcpiAstArgType_AstNode, kAcpiAstArgType_AstNode),
     2456    /* kAcpiAstNodeOp_Notify                  */  RTACPI_ASL_KEYWORD_DEFINE_2REQ_0OPT("Notify",                 RTACPI_AST_NODE_F_DEFAULT,    kAcpiAstArgType_AstNode, kAcpiAstArgType_AstNode),
     2457    /* kAcpiAstNodeOp_SizeOf                  */  RTACPI_ASL_KEYWORD_DEFINE_1REQ_0OPT("SizeOf",                 RTACPI_AST_NODE_F_DEFAULT,    kAcpiAstArgType_AstNode),
     2458    /* kAcpiAstNodeOp_While                   */  RTACPI_ASL_KEYWORD_DEFINE_1REQ_0OPT("While",                  RTACPI_AST_NODE_F_NEW_SCOPE,  kAcpiAstArgType_AstNode),
     2459    /* kAcpiAstNodeOp_Increment               */  RTACPI_ASL_KEYWORD_DEFINE_1REQ_0OPT("Increment",              RTACPI_AST_NODE_F_DEFAULT,    kAcpiAstArgType_AstNode),
     2460    /* kAcpiAstNodeOp_Decrement               */  RTACPI_ASL_KEYWORD_DEFINE_1REQ_0OPT("Decrement",              RTACPI_AST_NODE_F_DEFAULT,    kAcpiAstArgType_AstNode),
     2461    /* kAcpiAstNodeOp_CondRefOf               */  RTACPI_ASL_KEYWORD_DEFINE_1REQ_1OPT("CondRefOf",              RTACPI_AST_NODE_F_DEFAULT,    kAcpiAstArgType_AstNode, kAcpiAstArgType_AstNode),
     2462    /* kAcpiAstNodeOp_IndexField              */  RTACPI_ASL_KEYWORD_DEFINE_HANDLER(  "IndexField",             rtAcpiTblAslParseFieldOrIndexField, 5, 0, RTACPI_AST_NODE_F_DEFAULT),
     2463    /* kAcpiAstNodeOp_EisaId                  */  RTACPI_ASL_KEYWORD_DEFINE_1REQ_0OPT("EisaId",                 RTACPI_AST_NODE_F_DEFAULT,    kAcpiAstArgType_StringLiteral),
     2464    /* kAcpiAstNodeOp_CreateField             */  RTACPI_ASL_KEYWORD_DEFINE_4REQ_0OPT("CreateField",            RTACPI_AST_NODE_F_DEFAULT,    kAcpiAstArgType_AstNode, kAcpiAstArgType_AstNode, kAcpiAstArgType_AstNode, kAcpiAstArgType_NameString),
     2465    /* kAcpiAstNodeOp_CreateBitField          */  RTACPI_ASL_KEYWORD_DEFINE_3REQ_0OPT("CreateBitField",         RTACPI_AST_NODE_F_DEFAULT,    kAcpiAstArgType_AstNode, kAcpiAstArgType_AstNode, kAcpiAstArgType_NameString),
     2466    /* kAcpiAstNodeOp_CreateByteField         */  RTACPI_ASL_KEYWORD_DEFINE_3REQ_0OPT("CreateByteField",        RTACPI_AST_NODE_F_DEFAULT,    kAcpiAstArgType_AstNode, kAcpiAstArgType_AstNode, kAcpiAstArgType_NameString),
     2467    /* kAcpiAstNodeOp_CreateWordField         */  RTACPI_ASL_KEYWORD_DEFINE_3REQ_0OPT("CreateWordField",        RTACPI_AST_NODE_F_DEFAULT,    kAcpiAstArgType_AstNode, kAcpiAstArgType_AstNode, kAcpiAstArgType_NameString),
     2468    /* kAcpiAstNodeOp_CreateDWordField        */  RTACPI_ASL_KEYWORD_DEFINE_3REQ_0OPT("CreateDWordField",       RTACPI_AST_NODE_F_DEFAULT,    kAcpiAstArgType_AstNode, kAcpiAstArgType_AstNode, kAcpiAstArgType_NameString),
     2469    /* kAcpiAstNodeOp_CreateQWordField        */  RTACPI_ASL_KEYWORD_DEFINE_3REQ_0OPT("CreateQWordField",       RTACPI_AST_NODE_F_DEFAULT,    kAcpiAstArgType_AstNode, kAcpiAstArgType_AstNode, kAcpiAstArgType_NameString),
     2470    /* kAcpiAstNodeOp_ConcatenateResTemplate  */  RTACPI_ASL_KEYWORD_DEFINE_3REQ_0OPT("ConcatenateResTemplate", RTACPI_AST_NODE_F_DEFAULT,    kAcpiAstArgType_AstNode, kAcpiAstArgType_AstNode, kAcpiAstArgType_AstNode),
    19852471};
    19862472

  • trunk/src/VBox/Runtime/common/acpi/acpi-ns.cpp

    r108167 r108184  
    231231    int rc = rtAcpiNsAddEntryWorker(pNsRoot, pszNameString, fSwitchTo, &pNsEntry);
    232232    if (RT_SUCCESS(rc))
    233     {
    234         pNsEntry->fAstNode = true;
    235         pNsEntry->u.pAstNd = pAstNd;
    236     }
     233        pNsEntry->pAstNd = pAstNd;
    237234
    238235    return rc;
    … …  
    240237
    241238
    242 DECLHIDDEN(int) rtAcpiNsAddEntryU64(PRTACPINSROOT pNsRoot, const char *pszNameString, uint64_t u64Val, bool fSwitchTo)
     239DECLHIDDEN(int) rtAcpiNsAddEntryRsrcField(PRTACPINSROOT pNsRoot, const char *pszNameString, uint32_t offBits, uint32_t cBits)
    243240{
    244241    PRTACPINSENTRY pNsEntry = NULL;
    245     int rc = rtAcpiNsAddEntryWorker(pNsRoot, pszNameString, fSwitchTo, &pNsEntry);
     242    int rc = rtAcpiNsAddEntryWorker(pNsRoot, pszNameString, false /*fSwitchTo*/, &pNsEntry);
    246243    if (RT_SUCCESS(rc))
    247244    {
    248         pNsEntry->fAstNode = false;
    249         pNsEntry->u.u64Val = u64Val;
     245        pNsEntry->pAstNd  = NULL;
     246        pNsEntry->offBits = offBits;
     247        pNsEntry->cBits   = cBits;
    250248    }
    251249
    252250    return rc;
    253 }
    254 
    255 
    256 DECLHIDDEN(int) rtAcpiNsAddEntryU64F(PRTACPINSROOT pNsRoot, uint64_t u64Val, bool fSwitchTo, const char *pszNameStringFmt, ...)
    257 {
    258     va_list va;
    259     va_start(va, pszNameStringFmt);
    260     int rc = rtAcpiNsAddEntryU64V(pNsRoot, u64Val, fSwitchTo, pszNameStringFmt, va);
    261     va_end(va);
    262     return rc;
    263 }
    264 
    265 
    266 DECLHIDDEN(int) rtAcpiNsAddEntryU64V(PRTACPINSROOT pNsRoot, uint64_t u64Val, bool fSwitchTo, const char *pszNameStringFmt, va_list va)
    267 {
    268     char szName[256];
    269     ssize_t cch = RTStrPrintf2V(&szName[0], sizeof(szName), pszNameStringFmt, va);
    270     if (cch <= 0)
    271         return VERR_BUFFER_OVERFLOW;
    272 
    273     return rtAcpiNsAddEntryU64(pNsRoot, &szName[0], u64Val, fSwitchTo);
    274251}
    275252

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

    r108167 r108184  
    11451145        case kAcpiStmt_Add:        bOp = ACPI_AML_BYTE_CODE_OP_ADD;         break;
    11461146        case kAcpiStmt_Subtract:   bOp = ACPI_AML_BYTE_CODE_OP_SUBTRACT;    break;
     1147        case kAcpiStmt_Multiply:   bOp = ACPI_AML_BYTE_CODE_OP_MULTIPLY;    break;
    11471148        case kAcpiStmt_And:        bOp = ACPI_AML_BYTE_CODE_OP_AND;         break;
    11481149        case kAcpiStmt_Nand:       bOp = ACPI_AML_BYTE_CODE_OP_NAND;        break;
    11491150        case kAcpiStmt_Or:         bOp = ACPI_AML_BYTE_CODE_OP_OR;          break;
    11501151        case kAcpiStmt_Xor:        bOp = ACPI_AML_BYTE_CODE_OP_XOR;         break;
     1152        case kAcpiStmt_ShiftLeft:  bOp = ACPI_AML_BYTE_CODE_OP_SHIFT_LEFT;  break;
     1153        case kAcpiStmt_ShiftRight: bOp = ACPI_AML_BYTE_CODE_OP_SHIFT_RIGHT; break;
    11511154        case kAcpiStmt_Not:        bOp = ACPI_AML_BYTE_CODE_OP_NOT;         break;
    11521155        case kAcpiStmt_Store:      bOp = ACPI_AML_BYTE_CODE_OP_STORE;       break;
    … …  
    17291732 * @param   u64Granularity      The access granularity of the range in bytes.
    17301733 * @param   u64Length           Length of the memory range in bytes.
     1734 * @param   pszRsrcSrc          Name of the device object that produces the the descriptor consumed by the device, optional.
     1735 *                              NULL means the device consumes the resource out of a global pool.
     1736 * @param   bRsrcIndex          Index into the resource descriptor this device consumes from. Ignored if pszRsrcSrc is NULL.
    17311737 */
    17321738static int rtAcpiResourceAddQWordAddressRange(PRTACPIRESINT pThis, uint8_t bType, uint32_t fAddrSpace, uint8_t fType,
    17331739                                              uint64_t u64AddrMin, uint64_t u64AddrMax, uint64_t u64OffTrans,
    1734                                               uint64_t u64Granularity, uint64_t u64Length)
    1735 {
    1736     uint8_t *pb = rtAcpiResBufEnsureSpace(pThis, 3 + 43);
     1740                                              uint64_t u64Granularity, uint64_t u64Length,
     1741                                              const char *pszRsrcSrc, uint8_t bRsrcIndex)
     1742{
     1743    size_t cchRsrcSrc = pszRsrcSrc ? strlen(pszRsrcSrc) + 2 : 0;
     1744    uint8_t *pb = rtAcpiResBufEnsureSpace(pThis, 3 + 43 + cchRsrcSrc);
    17371745    if (!pb)
    17381746        return VERR_NO_MEMORY;
    … …  
    17441752    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)
    17451753            | (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)
    1746             | (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);
     1754            | (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)
     1755            | (fAddrSpace & RTACPI_RESOURCE_ADDR_RANGE_F_PRODUCER        ? ACPI_RSRCS_ADDR_SPACE_F_PRODUCER        : ACPI_RSRCS_ADDR_SPACE_F_CONSUMER);
    17471756    pb[5] = fType;
    17481757
    … …  
    17511760    pb = rtAcpiResEncode64BitInteger(pb,     u64AddrMax);
    17521761    pb = rtAcpiResEncode64BitInteger(pb,     u64OffTrans);
    1753          rtAcpiResEncode64BitInteger(pb,     u64Length);
     1762    pb = rtAcpiResEncode64BitInteger(pb,     u64Length);
     1763    if (pszRsrcSrc)
     1764    {
     1765        *pb++ = bRsrcIndex;
     1766        memcpy(pb, pszRsrcSrc, cchRsrcSrc + 1);
     1767    }
    17541768    return VINF_SUCCESS;
    17551769}
    … …  
    17701784 * @param   u32Granularity      The access granularity of the range in bytes.
    17711785 * @param   u32Length           Length of the memory range in bytes.
     1786 * @param   pszRsrcSrc          Name of the device object that produces the the descriptor consumed by the device, optional.
     1787 *                              NULL means the device consumes the resource out of a global pool.
     1788 * @param   bRsrcIndex          Index into the resource descriptor this device consumes from. Ignored if pszRsrcSrc is NULL.
    17721789 */
    17731790static int rtAcpiResourceAddDWordAddressRange(PRTACPIRESINT pThis, uint8_t bType, uint32_t fAddrSpace, uint8_t fType,
    17741791                                              uint32_t u32AddrMin, uint32_t u32AddrMax, uint32_t u32OffTrans,
    1775                                               uint32_t u32Granularity, uint32_t u32Length)
    1776 {
     1792                                              uint32_t u32Granularity, uint32_t u32Length,
     1793                                              const char *pszRsrcSrc, uint8_t bRsrcIndex)
     1794{
     1795    size_t cchRsrcSrc = pszRsrcSrc ? strlen(pszRsrcSrc) + 2 : 0;
    17771796    uint8_t *pb = rtAcpiResBufEnsureSpace(pThis, 3 + 23);
    17781797    if (!pb)
    … …  
    17851804    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)
    17861805            | (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)
    1787             | (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);
     1806            | (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)
     1807            | (fAddrSpace & RTACPI_RESOURCE_ADDR_RANGE_F_PRODUCER        ? ACPI_RSRCS_ADDR_SPACE_F_PRODUCER        : ACPI_RSRCS_ADDR_SPACE_F_CONSUMER);
    17881808    pb[5] = fType;
    17891809
    … …  
    17921812    pb = rtAcpiResEncode32BitInteger(pb,     u32AddrMax);
    17931813    pb = rtAcpiResEncode32BitInteger(pb,     u32OffTrans);
    1794          rtAcpiResEncode32BitInteger(pb,     u32Length);
     1814    pb = rtAcpiResEncode32BitInteger(pb,     u32Length);
     1815    if (pszRsrcSrc)
     1816    {
     1817        *pb++ = bRsrcIndex;
     1818        memcpy(pb, pszRsrcSrc, cchRsrcSrc + 1);
     1819    }
     1820    return VINF_SUCCESS;
     1821}
     1822
     1823
     1824/**
     1825 * Common worker for encoding a new word (16-bit) address range.
     1826 *
     1827 * @returns IPRT status code
     1828 * @retval  VERR_NO_MEMORY if not enough memory could be reserved in the ACPI resource descriptor.
     1829 * @param   pThis               The ACPI resource instance.
     1830 * @param   bType               The ACPI address range type.
     1831 * @param   fAddrSpace          Combination of RTACPI_RESOURCE_ADDR_RANGE_F_XXX.
     1832 * @param   fType               The range flags returned from rtAcpiResourceMemoryRangeToTypeFlags().
     1833 * @param   u16AddrMin          The start address of the memory range.
     1834 * @param   u16AddrMax          Last valid address of the range.
     1835 * @param   u16OffTrans         Translation offset being applied to the address (for a PCIe bridge or IOMMU for example).
     1836 * @param   u16Granularity      The access granularity of the range in bytes.
     1837 * @param   u16Length           Length of the memory range in bytes.
     1838 * @param   pszRsrcSrc          Name of the device object that produces the the descriptor consumed by the device, optional.
     1839 *                              NULL means the device consumes the resource out of a global pool.
     1840 * @param   bRsrcIndex          Index into the resource descriptor this device consumes from. Ignored if pszRsrcSrc is NULL.
     1841 */
     1842static int rtAcpiResourceAddWordAddressRange(PRTACPIRESINT pThis, uint8_t bType, uint32_t fAddrSpace, uint8_t fType,
     1843                                              uint16_t u16AddrMin, uint16_t u16AddrMax, uint16_t u16OffTrans,
     1844                                              uint16_t u16Granularity, uint16_t u16Length,
     1845                                              const char *pszRsrcSrc, uint8_t bRsrcIndex)
     1846{
     1847    size_t cchRsrcSrc = pszRsrcSrc ? strlen(pszRsrcSrc) + 2 : 0;
     1848    uint8_t *pb = rtAcpiResBufEnsureSpace(pThis, 3 + 13 + cchRsrcSrc);
     1849    if (!pb)
     1850        return VERR_NO_MEMORY;
     1851
     1852    pb[0] = ACPI_RSRCS_LARGE_TYPE | ACPI_RSRCS_ITEM_WORD_ADDR_SPACE;          /* Tag          */
     1853    pb[1] = 13;                                                               /* Length[7:0]  */
     1854    pb[2] = 0;                                                                /* Length[15:8] */
     1855    pb[3] = bType;
     1856    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)
     1857            | (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)
     1858            | (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)
     1859            | (fAddrSpace & RTACPI_RESOURCE_ADDR_RANGE_F_PRODUCER        ? ACPI_RSRCS_ADDR_SPACE_F_PRODUCER        : ACPI_RSRCS_ADDR_SPACE_F_CONSUMER);
     1860    pb[5] = fType;
     1861
     1862    pb = rtAcpiResEncode16BitInteger(&pb[6], u16Granularity);
     1863    pb = rtAcpiResEncode16BitInteger(pb,     u16AddrMin);
     1864    pb = rtAcpiResEncode16BitInteger(pb,     u16AddrMax);
     1865    pb = rtAcpiResEncode16BitInteger(pb,     u16OffTrans);
     1866    pb = rtAcpiResEncode16BitInteger(pb,     u16Length);
     1867    if (pszRsrcSrc)
     1868    {
     1869        *pb++ = bRsrcIndex;
     1870        memcpy(pb, pszRsrcSrc, cchRsrcSrc + 1);
     1871    }
     1872
    17951873    return VINF_SUCCESS;
    17961874}
    … …  
    18041882 * @param   enmType             THe memory range type enum to convert.
    18051883 * @param   fRw                 The read/write flag.
     1884 * @param   fStatic             Static/Translation type flag.
    18061885 */
    18071886DECLINLINE(uint8_t) rtAcpiResourceMemoryRangeToTypeFlags(RTACPIRESMEMRANGECACHEABILITY enmCacheability, RTACPIRESMEMRANGETYPE enmType,
    1808                                                          bool fRw)
    1809 {
    1810     uint8_t fType = fRw ? ACPI_RSRCS_ADDR_SPACE_MEM_F_RW : ACPI_RSRCS_ADDR_SPACE_MEM_F_RO;
     1887                                                         bool fRw, bool fStatic)
     1888{
     1889    uint8_t fType =   (fRw ? ACPI_RSRCS_ADDR_SPACE_MEM_F_RW : ACPI_RSRCS_ADDR_SPACE_MEM_F_RO)
     1890                    | (fStatic ? ACPI_RSRCS_ADDR_SPACE_MEM_F_TYPE_STATIC : ACPI_RSRCS_ADDR_SPACE_MEM_F_TYPE_TRANSLATION);
    18111891
    18121892    switch (enmCacheability)
    … …  
    18571937                                              uint64_t u64Granularity, uint64_t u64Length)
    18581938{
     1939    return RTAcpiResourceAddQWordMemoryRangeEx(hAcpiRes,  enmCacheability, enmType,  fRw, true /*fStatic*/, fAddrSpace,
     1940                                               u64AddrMin, u64AddrMax, u64OffTrans, u64Granularity, u64Length,
     1941                                               NULL /*pszRsrcSrc*/, 0 /*bRsrcIndex*/);
     1942}
     1943
     1944
     1945RTDECL(int) RTAcpiResourceAddQWordMemoryRangeEx(RTACPIRES hAcpiRes, RTACPIRESMEMRANGECACHEABILITY enmCacheability,
     1946                                                RTACPIRESMEMRANGETYPE enmType, bool fRw, bool fStatic, uint32_t fAddrSpace,
     1947                                                uint64_t u64AddrMin, uint64_t u64AddrMax, uint64_t u64OffTrans,
     1948                                                uint64_t u64Granularity, uint64_t u64Length,
     1949                                                const char *pszRsrcSrc, uint8_t bRsrcIndex)
     1950{
    18591951    PRTACPIRESINT pThis = hAcpiRes;
    18601952    AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
    … …  
    18651957    AssertRCReturn(pThis->rcErr, pThis->rcErr);
    18661958
    1867     uint8_t fType = rtAcpiResourceMemoryRangeToTypeFlags(enmCacheability, enmType, fRw);
     1959    uint8_t fType = rtAcpiResourceMemoryRangeToTypeFlags(enmCacheability, enmType, fRw, fStatic);
    18681960    return rtAcpiResourceAddQWordAddressRange(pThis, ACPI_RSRCS_ADDR_SPACE_TYPE_MEMORY, fAddrSpace, fType,
    1869                                               u64AddrMin, u64AddrMax, u64OffTrans, u64Granularity, u64Length);
     1961                                              u64AddrMin, u64AddrMax, u64OffTrans, u64Granularity, u64Length,
     1962                                              pszRsrcSrc, bRsrcIndex);
    18701963}
    18711964
    … …  
    18751968                                              uint32_t u32AddrMin, uint32_t u32AddrMax, uint32_t u32OffTrans,
    18761969                                              uint32_t u32Granularity, uint32_t u32Length)
     1970{
     1971    return RTAcpiResourceAddDWordMemoryRangeEx(hAcpiRes, enmCacheability, enmType, fRw, true /*fStatic*/, fAddrSpace,
     1972                                               u32AddrMin, u32AddrMax, u32OffTrans, u32Granularity, u32Length,
     1973                                               NULL /*pszRsrcSrc*/, 0 /*bRsrcIndex*/);
     1974}
     1975
     1976
     1977RTDECL(int) RTAcpiResourceAddDWordMemoryRangeEx(RTACPIRES hAcpiRes, RTACPIRESMEMRANGECACHEABILITY enmCacheability,
     1978                                                RTACPIRESMEMRANGETYPE enmType, bool fRw, bool fStatic, uint32_t fAddrSpace,
     1979                                                uint32_t u32AddrMin, uint32_t u32AddrMax, uint32_t u32OffTrans,
     1980                                                uint32_t u32Granularity, uint32_t u32Length,
     1981                                                const char *pszRsrcSrc, uint8_t bRsrcIndex)
    18771982{
    18781983    PRTACPIRESINT pThis = hAcpiRes;
    … …  
    18841989    AssertRCReturn(pThis->rcErr, pThis->rcErr);
    18851990
    1886     uint8_t fType = rtAcpiResourceMemoryRangeToTypeFlags(enmCacheability, enmType, fRw);
     1991    uint8_t fType = rtAcpiResourceMemoryRangeToTypeFlags(enmCacheability, enmType, fRw, fStatic);
    18871992    return rtAcpiResourceAddDWordAddressRange(pThis, ACPI_RSRCS_ADDR_SPACE_TYPE_MEMORY, fAddrSpace, fType,
    1888                                               u32AddrMin, u32AddrMax, u32OffTrans, u32Granularity, u32Length);
    1889 }
    1890 
    1891 
    1892 RTDECL(int) RTAcpiResourceAddQWordIoRange(RTACPIRES hAcpiRes, RTACPIRESIORANGETYPE enmIoType, RTACPIRESIORANGE enmIoRange,
    1893                                           uint32_t fAddrSpace, uint64_t u64AddrMin, uint64_t u64AddrMax, uint64_t u64OffTrans,
    1894                                           uint64_t u64Granularity, uint64_t u64Length)
    1895 {
    1896     PRTACPIRESINT pThis = hAcpiRes;
    1897     AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
    1898     AssertReturn(enmIoType != kAcpiResIoRangeType_Invalid, VERR_INVALID_PARAMETER);
    1899     AssertReturn(enmIoRange != kAcpiResIoRange_Invalid, VERR_INVALID_PARAMETER);
    1900     AssertReturn(!(fAddrSpace & ~RTACPI_RESOURCE_ADDR_RANGE_F_VALID_MASK), VERR_INVALID_PARAMETER);
    1901     AssertReturn(!pThis->fSealed, VERR_INVALID_STATE);
    1902     AssertRCReturn(pThis->rcErr, pThis->rcErr);
    1903 
     1993                                              u32AddrMin, u32AddrMax, u32OffTrans, u32Granularity, u32Length,
     1994                                              pszRsrcSrc, bRsrcIndex);
     1995}
     1996
     1997
     1998/**
     1999 * Converts the given I/O type and range flag to the ACPI resource flags.
     2000 *
     2001 * @returns Converted ACPI resource flags.
     2002 * @param   enmIoType           The I/O type enum to convert.
     2003 * @param   enmIoRange          The I/O range enum to convert.
     2004 */
     2005DECLINLINE(uint8_t) rtAcpiResourceIoRangeToTypeFlags(RTACPIRESIORANGETYPE enmIoType, RTACPIRESIORANGE enmIoRange)
     2006{
    19042007    uint8_t fType = 0;
    19052008    switch (enmIoType)
    … …  
    19352038    }
    19362039
    1937     return rtAcpiResourceAddQWordAddressRange(pThis, ACPI_RSRCS_ADDR_SPACE_TYPE_IO, fAddrSpace, fType,
    1938                                               u64AddrMin, u64AddrMax, u64OffTrans, u64Granularity, u64Length);
    1939 }
    1940 
    1941 
    1942 RTDECL(int) RTAcpiResourceAddWordBusNumber(RTACPIRES hAcpiRes, uint32_t fAddrSpace, uint16_t u16BusMin, uint16_t u16BusMax,
    1943                                            uint16_t u16OffTrans, uint16_t u16Granularity, uint16_t u16Length)
     2040    return fType;
     2041}
     2042
     2043
     2044RTDECL(int) RTAcpiResourceAddQWordIoRange(RTACPIRES hAcpiRes, RTACPIRESIORANGETYPE enmIoType, RTACPIRESIORANGE enmIoRange,
     2045                                          uint32_t fAddrSpace, uint64_t u64AddrMin, uint64_t u64AddrMax, uint64_t u64OffTrans,
     2046                                          uint64_t u64Granularity, uint64_t u64Length)
    19442047{
    19452048    PRTACPIRESINT pThis = hAcpiRes;
    19462049    AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
     2050    AssertReturn(enmIoType != kAcpiResIoRangeType_Invalid, VERR_INVALID_PARAMETER);
     2051    AssertReturn(enmIoRange != kAcpiResIoRange_Invalid, VERR_INVALID_PARAMETER);
    19472052    AssertReturn(!(fAddrSpace & ~RTACPI_RESOURCE_ADDR_RANGE_F_VALID_MASK), VERR_INVALID_PARAMETER);
    19482053    AssertReturn(!pThis->fSealed, VERR_INVALID_STATE);
    19492054    AssertRCReturn(pThis->rcErr, pThis->rcErr);
    19502055
    1951     uint8_t *pb = rtAcpiResBufEnsureSpace(pThis, 3 + 13);
    1952     if (!pb)
    1953         return VERR_NO_MEMORY;
    1954 
    1955     pb[0] = ACPI_RSRCS_LARGE_TYPE | ACPI_RSRCS_ITEM_WORD_ADDR_SPACE;          /* Tag          */
    1956     pb[1] = 13;                                                               /* Length[7:0]  */
    1957     pb[2] = 0;                                                                /* Length[15:8] */
    1958     pb[3] = ACPI_RSRCS_ADDR_SPACE_TYPE_BUS_NUM_RANGE;
    1959     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)
    1960             | (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)
    1961             | (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);
    1962     pb[5] = 0;
    1963 
    1964     pb = rtAcpiResEncode16BitInteger(&pb[6], u16Granularity);
    1965     pb = rtAcpiResEncode16BitInteger(pb,     u16BusMin);
    1966     pb = rtAcpiResEncode16BitInteger(pb,     u16BusMax);
    1967     pb = rtAcpiResEncode16BitInteger(pb,     u16OffTrans);
    1968          rtAcpiResEncode16BitInteger(pb,     u16Length);
    1969     return VINF_SUCCESS;
     2056    uint8_t fType = rtAcpiResourceIoRangeToTypeFlags(enmIoType, enmIoRange);
     2057    return rtAcpiResourceAddQWordAddressRange(pThis, ACPI_RSRCS_ADDR_SPACE_TYPE_IO, fAddrSpace, fType,
     2058                                              u64AddrMin, u64AddrMax, u64OffTrans, u64Granularity, u64Length,
     2059                                              NULL /*pszRsrcSrc*/, 0 /*bRsrcIndex*/);
     2060}
     2061
     2062
     2063RTDECL(int) RTAcpiResourceAddWordIoRangeEx(RTACPIRES hAcpiRes, RTACPIRESIORANGETYPE enmIoType, RTACPIRESIORANGE enmIoRange,
     2064                                           uint32_t fAddrSpace, uint16_t u16AddrMin, uint16_t u16AddrMax, uint64_t u16OffTrans,
     2065                                           uint16_t u16Granularity, uint16_t u16Length, const char *pszRsrcSrc, uint8_t bRsrcIndex)
     2066{
     2067    PRTACPIRESINT pThis = hAcpiRes;
     2068    AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
     2069    AssertReturn(enmIoType != kAcpiResIoRangeType_Invalid, VERR_INVALID_PARAMETER);
     2070    AssertReturn(enmIoRange != kAcpiResIoRange_Invalid, VERR_INVALID_PARAMETER);
     2071    AssertReturn(!(fAddrSpace & ~RTACPI_RESOURCE_ADDR_RANGE_F_VALID_MASK), VERR_INVALID_PARAMETER);
     2072    AssertReturn(!pThis->fSealed, VERR_INVALID_STATE);
     2073    AssertRCReturn(pThis->rcErr, pThis->rcErr);
     2074
     2075    uint8_t fType = rtAcpiResourceIoRangeToTypeFlags(enmIoType, enmIoRange);
     2076    return rtAcpiResourceAddWordAddressRange(pThis, ACPI_RSRCS_ADDR_SPACE_TYPE_IO, fAddrSpace, fType,
     2077                                             u16AddrMin, u16AddrMax, u16OffTrans, u16Granularity, u16Length,
     2078                                             pszRsrcSrc, bRsrcIndex);
     2079}
     2080
     2081
     2082RTDECL(int) RTAcpiResourceAddWordBusNumber(RTACPIRES hAcpiRes, uint32_t fAddrSpace, uint16_t u16BusMin, uint16_t u16BusMax,
     2083                                           uint16_t u16OffTrans, uint16_t u16Granularity, uint16_t u16Length)
     2084{
     2085    return RTAcpiResourceAddWordBusNumberEx(hAcpiRes, fAddrSpace, u16BusMin, u16BusMax, u16OffTrans, u16Granularity, u16Length,
     2086                                            NULL /*pszRsrcSrc*/, 0 /*bRsrcIndex*/);
     2087}
     2088
     2089
     2090RTDECL(int) RTAcpiResourceAddWordBusNumberEx(RTACPIRES hAcpiRes, uint32_t fAddrSpace, uint16_t u16BusMin, uint16_t u16BusMax,
     2091                                             uint16_t u16OffTrans, uint16_t u16Granularity, uint16_t u16Length,
     2092                                             const char *pszRsrcSrc, uint8_t bRsrcIndex)
     2093{
     2094    PRTACPIRESINT pThis = hAcpiRes;
     2095    AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
     2096    AssertReturn(!(fAddrSpace & ~RTACPI_RESOURCE_ADDR_RANGE_F_VALID_MASK), VERR_INVALID_PARAMETER);
     2097    AssertReturn(!pThis->fSealed, VERR_INVALID_STATE);
     2098    AssertRCReturn(pThis->rcErr, pThis->rcErr);
     2099
     2100    return rtAcpiResourceAddWordAddressRange(pThis, ACPI_RSRCS_ADDR_SPACE_TYPE_BUS_NUM_RANGE, fAddrSpace, 0 /*fType*/,
     2101                                             u16BusMin, u16BusMax, u16OffTrans, u16Granularity, u16Length,
     2102                                             pszRsrcSrc, bRsrcIndex);
    19702103}
    19712104
    … …  
    20172150    return VINF_SUCCESS;
    20182151}
     2152
     2153
     2154RTDECL(int) RTAcpiResourceAddDma(RTACPIRES hAcpiRes, RTACPIRESDMACHANSPEED enmChanSpeed, bool fBusMaster,
     2155                                 RTACPIRESDMATRANSFERTYPE enmTransferType, uint8_t bmChannels)
     2156{
     2157    PRTACPIRESINT pThis = hAcpiRes;
     2158    AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
     2159    AssertReturn(enmChanSpeed != kAcpiResDmaChanSpeed_Invalid, VERR_INVALID_PARAMETER);
     2160    AssertReturn(enmTransferType != kAcpiResDmaTransferType_Invalid, VERR_INVALID_PARAMETER);
     2161    AssertReturn(!pThis->fSealed, VERR_INVALID_STATE);
     2162    AssertRCReturn(pThis->rcErr, pThis->rcErr);
     2163
     2164    uint8_t *pb = rtAcpiResBufEnsureSpace(pThis, 3);
     2165    if (!pb)
     2166        return VERR_NO_MEMORY;
     2167
     2168    uint8_t fSpeed = 0;
     2169    switch (enmChanSpeed)
     2170    {
     2171        case kAcpiResDmaChanSpeed_Compatibility: fSpeed = 0; break;
     2172        case kAcpiResDmaChanSpeed_TypeA:         fSpeed = 1; break;
     2173        case kAcpiResDmaChanSpeed_TypeB:         fSpeed = 2; break;
     2174        case kAcpiResDmaChanSpeed_TypeF:         fSpeed = 3; break;
     2175        default:
     2176            AssertFailedReturn(VERR_INVALID_PARAMETER);
     2177    }
     2178
     2179    uint8_t fTransferType = 0;
     2180    switch (enmTransferType)
     2181    {
     2182        case kAcpiResDmaTransferType_8Bit:       fTransferType = 0; break;
     2183        case kAcpiResDmaTransferType_8Bit_16Bit: fTransferType = 1; break;
     2184        case kAcpiResDmaTransferType_16Bit:      fTransferType = 2; break;
     2185        default:
     2186            AssertFailedReturn(VERR_INVALID_PARAMETER);
     2187    }
     2188
     2189    pb[0] = ACPI_RSRCS_SMALL_TYPE | (ACPI_RSRCS_ITEM_DMA << 3) | 2; /* Tag */
     2190    pb[1] = bmChannels;
     2191    pb[2] =   fSpeed << 5
     2192            | (fBusMaster ? RT_BIT(2) : 0)
     2193            | fTransferType;
     2194
     2195    return VINF_SUCCESS;
     2196}

  • trunk/src/VBox/Runtime/include/internal/acpi.h

    r108168 r108184  
    162162    kAcpiAstNodeOp_Add,
    163163    kAcpiAstNodeOp_Subtract,
     164    kAcpiAstNodeOp_Multiply,
    164165    kAcpiAstNodeOp_And,
    165166    kAcpiAstNodeOp_Nand,
    166167    kAcpiAstNodeOp_Or,
    167168    kAcpiAstNodeOp_Xor,
     169    kAcpiAstNodeOp_ShiftLeft,
     170    kAcpiAstNodeOp_ShiftRight,
    168171    kAcpiAstNodeOp_Not,
    169172    kAcpiAstNodeOp_Notify,
    … …  
    181184    kAcpiAstNodeOp_CreateDWordField,
    182185    kAcpiAstNodeOp_CreateQWordField,
     186    kAcpiAstNodeOp_ConcatenateResTemplate,
    183187    kAcpiAstNodeOp_32Bit_Hack = 0x7fffffff
    184188} RTACPIASTNODEOP;
    … …  
    248252    /** The name segment identifying the entry. */
    249253    char                    achNameSeg[4];
    250     /** Flag whether the name space entry points to a node or just has some
    251      * integer data attached. */
    252     bool                    fAstNode;
    253     /** Type dependent data. */
    254     union
    255     {
    256         PCRTACPIASTNODE     pAstNd;
    257         uint64_t            u64Val;
    258     } u;
     254    /** The AST node associated with this namespace entry. */
     255    PCRTACPIASTNODE         pAstNd;
     256    /** Bit offset for resource fields. */
     257    uint32_t                offBits;
     258    /** Bit count for resource fields. */
     259    uint32_t                cBits;
    259260    /** List of namespace entries below this entry. */
    260261    RTLISTANCHOR            LstNsEntries;
    … …  
    345346
    346347/**
    347  * Adds a new namespace entry to the given name space - 64-bit value variant.
     348 * Adds a new namespace entry to the given name space - resource field.
    348349 *
    349350 * @returns IPRT status code.
    350351 * @param   pNsRoot             The namespace root to add the entry to.
    351352 * @param   pszNameString       An ACPI NameString (either segment or path).
    352  * @param   u64Val              The 64-bit value to associate with the entry.
    353  * @param   fSwitchTo           Flag whether to switch the current point for the namespace to this entry.
    354  */
    355 DECLHIDDEN(int) rtAcpiNsAddEntryU64(PRTACPINSROOT pNsRoot, const char *pszNameString, uint64_t u64Val, bool fSwitchTo);
    356 
    357 
    358 /**
    359  * Adds a new namespace entry to the given name space - 64-bit value variant with format name string.
    360  *
    361  * @returns IPRT status code.
    362  * @param   pNsRoot             The namespace root to add the entry to.
    363  * @param   u64Val              The 64-bit value to associate with the entry.
    364  * @param   fSwitchTo           Flag whether to switch the current point for the namespace to this entry.
    365  * @param   pszNameStringFmt    An ACPI NameString (either segment or path) as a format string.
    366  * @param   ...                 The arguments for the format string.
    367  */
    368 DECLHIDDEN(int) rtAcpiNsAddEntryU64F(PRTACPINSROOT pNsRoot, uint64_t u64Val, bool fSwitchTo, const char *pszNameStringFmt, ...) RT_IPRT_FORMAT_ATTR(4, 5);
    369 
    370 
    371 /**
    372  * Adds a new namespace entry to the given name space - 64-bit value variant with format name string.
    373  *
    374  * @returns IPRT status code.
    375  * @param   pNsRoot             The namespace root to add the entry to.
    376  * @param   u64Val              The 64-bit value to associate with the entry.
    377  * @param   fSwitchTo           Flag whether to switch the current point for the namespace to this entry.
    378  * @param   pszNameStringFmt    An ACPI NameString (either segment or path) as a format string.
    379  * @param   va                  The format arguments.
    380  */
    381 DECLHIDDEN(int) rtAcpiNsAddEntryU64V(PRTACPINSROOT pNsRoot, uint64_t u64Val, bool fSwitchTo, const char *pszNameStringFmt, va_list va) RT_IPRT_FORMAT_ATTR(4, 0);
     353 * @param   offBits             Bit offset from the beginning of the resource.
     354 * @param   cBits               NUmber of bits this resource field has.
     355 */
     356DECLHIDDEN(int) rtAcpiNsAddEntryRsrcField(PRTACPINSROOT pNsRoot, const char *pszNameString, uint32_t offBits, uint32_t cBits);
    382357
    383358
Note: See TracChangeset for help on using the changeset viewer.

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