自学教程：C++ AcpiGetTableByIndex函数代码示例

ACPI_STATUSAcpiTbInitializeFacs (    void){    /* If Hardware Reduced flag is set, there is no FACS */    if (AcpiGbl_ReducedHardware)    {        AcpiGbl_FACS = NULL;        return (AE_OK);    }    (void) AcpiGetTableByIndex (ACPI_TABLE_INDEX_FACS,                ACPI_CAST_INDIRECT_PTR (ACPI_TABLE_HEADER, &AcpiGbl_Facs32));    (void) AcpiGetTableByIndex (ACPI_TABLE_INDEX_X_FACS,                ACPI_CAST_INDIRECT_PTR (ACPI_TABLE_HEADER, &AcpiGbl_Facs64));    if (AcpiGbl_Facs64 && (!AcpiGbl_Facs32 || !AcpiGbl_Use32BitFacsAddresses))    {        AcpiGbl_FACS = AcpiGbl_Facs64;    }    else if (AcpiGbl_Facs32)    {        AcpiGbl_FACS = AcpiGbl_Facs32;    }    /* If there is no FACS, just continue. There was already an error msg */    return (AE_OK);}

ACPI_STATUSAcpiTbInitializeFacs (    void){    ACPI_TABLE_FACS         *Facs;    /* If Hardware Reduced flag is set, there is no FACS */    if (AcpiGbl_ReducedHardware)    {        AcpiGbl_FACS = NULL;        return (AE_OK);    }    else if (AcpiGbl_FADT.XFacs &&         (!AcpiGbl_FADT.Facs || !AcpiGbl_Use32BitFacsAddresses))    {        (void) AcpiGetTableByIndex (AcpiGbl_XFacsIndex,            ACPI_CAST_INDIRECT_PTR (ACPI_TABLE_HEADER, &Facs));        AcpiGbl_FACS = Facs;    }    else if (AcpiGbl_FADT.Facs)    {        (void) AcpiGetTableByIndex (AcpiGbl_FacsIndex,            ACPI_CAST_INDIRECT_PTR (ACPI_TABLE_HEADER, &Facs));        AcpiGbl_FACS = Facs;    }    /* If there is no FACS, just continue. There was already an error msg */    return (AE_OK);}

ACPI_STATUSAcpiTbInitializeFacs (    void){    ACPI_STATUS             Status;    Status = AcpiGetTableByIndex (ACPI_TABLE_INDEX_FACS,                ACPI_CAST_INDIRECT_PTR (ACPI_TABLE_HEADER, &AcpiGbl_FACS));    return (Status);}

ACPI_STATUSAcpiTbLoadTable (    UINT32                  TableIndex,    ACPI_NAMESPACE_NODE     *ParentNode){    ACPI_TABLE_HEADER       *Table;    ACPI_STATUS             Status;    ACPI_OWNER_ID           OwnerId;    ACPI_FUNCTION_TRACE (TbLoadTable);    /*     * Note: Now table is "INSTALLED", it must be validated before     * using.     */    Status = AcpiGetTableByIndex (TableIndex, &Table);    if (ACPI_FAILURE (Status))    {        return_ACPI_STATUS (Status);    }    Status = AcpiNsLoadTable (TableIndex, ParentNode);    /*     * This case handles the legacy option that groups all module-level     * code blocks together and defers execution until all of the tables     * are loaded. Execute all of these blocks at this time.     * Execute any module-level code that was detected during the table     * load phase.     *     * Note: this option is deprecated and will be eliminated in the     * future. Use of this option can cause problems with AML code that     * depends upon in-order immediate execution of module-level code.     */    AcpiNsExecModuleCodeList ();    /*     * Update GPEs for any new _Lxx/_Exx methods. Ignore errors. The host is     * responsible for discovering any new wake GPEs by running _PRW methods     * that may have been loaded by this table.     */    Status = AcpiTbGetOwnerId (TableIndex, &OwnerId);    if (ACPI_SUCCESS (Status))    {        AcpiEvUpdateGpes (OwnerId);    }    /* Invoke table handler */    AcpiTbNotifyTable (ACPI_TABLE_EVENT_LOAD, Table);    return_ACPI_STATUS (Status);}

ACPI_STATUSAeInstallTables (    void){    ACPI_STATUS             Status;    ACPI_TABLE_HEADER       Header;    ACPI_TABLE_HEADER       *Table;    UINT32                  i;    Status = AcpiInitializeTables (NULL, ACPI_MAX_INIT_TABLES, TRUE);    ACPI_CHECK_OK (AcpiInitializeTables, Status);    if (AcpiGbl_LoadTestTables)    {        /* Test multiple table/UEFI support. First, get the headers */        Status = AcpiGetTableHeader (ACPI_SIG_UEFI, 1, &Header);        ACPI_CHECK_OK (AcpiGetTableHeader, Status);        Status = AcpiGetTableHeader (ACPI_SIG_UEFI, 2, &Header);        ACPI_CHECK_OK (AcpiGetTableHeader, Status);        Status = AcpiGetTableHeader (ACPI_SIG_UEFI, 3, &Header);        ACPI_CHECK_STATUS (AcpiGetTableHeader, Status, AE_NOT_FOUND);        /* Now get the actual tables */        Status = AcpiGetTable (ACPI_SIG_UEFI, 1, &Table);        ACPI_CHECK_OK (AcpiGetTable, Status);        Status = AcpiGetTable (ACPI_SIG_UEFI, 2, &Table);        ACPI_CHECK_OK (AcpiGetTable, Status);        Status = AcpiGetTable (ACPI_SIG_UEFI, 3, &Table);        ACPI_CHECK_STATUS (AcpiGetTable, Status, AE_NOT_FOUND);    }    /* Check that we can get all of the ACPI tables */    for (i = 0; ; i++)    {        Status = AcpiGetTableByIndex (i, &Table);        if ((Status == AE_BAD_PARAMETER) || !Table)        {            break;        }        ACPI_CHECK_OK (AcpiGetTableByIndex, Status);    }    return (AE_OK);}

ACPI_STATUSAcpiTbLoadTable (    UINT32                  TableIndex,    ACPI_NAMESPACE_NODE     *ParentNode){    ACPI_TABLE_HEADER       *Table;    ACPI_STATUS             Status;    ACPI_OWNER_ID           OwnerId;    ACPI_FUNCTION_TRACE (TbLoadTable);    /*     * Note: Now table is "INSTALLED", it must be validated before     * using.     */    Status = AcpiGetTableByIndex (TableIndex, &Table);    if (ACPI_FAILURE (Status))    {        return_ACPI_STATUS (Status);    }    Status = AcpiNsLoadTable (TableIndex, ParentNode);    /* Execute any module-level code that was found in the table */    if (!AcpiGbl_ParseTableAsTermList && AcpiGbl_GroupModuleLevelCode)    {        AcpiNsExecModuleCodeList ();    }    /*     * Update GPEs for any new _Lxx/_Exx methods. Ignore errors. The host is     * responsible for discovering any new wake GPEs by running _PRW methods     * that may have been loaded by this table.     */    Status = AcpiTbGetOwnerId (TableIndex, &OwnerId);    if (ACPI_SUCCESS (Status))    {        AcpiEvUpdateGpes (OwnerId);    }    /* Invoke table handler if present */    if (AcpiGbl_TableHandler)    {        (void) AcpiGbl_TableHandler (ACPI_TABLE_EVENT_LOAD, Table,            AcpiGbl_TableHandlerContext);    }    return_ACPI_STATUS (Status);}

static PyObject *bits_acpi_get_table_by_index(PyObject *self, PyObject *args){    U32 index;    ACPI_TABLE_HEADER *table_header;    if (!PyArg_ParseTuple(args, "I", &index))        return NULL;    if (acpica_init() != GRUB_ERR_NONE)        return PyErr_Format(PyExc_RuntimeError, "ACPICA module failed to initialize.");    if (ACPI_FAILURE(AcpiGetTableByIndex(index, &table_header)))        return Py_BuildValue("");    return Py_BuildValue("s#", table_header, table_header->Length);}

ACPI_STATUSAcpiTbInitializeFacs (    void){    ACPI_STATUS             Status;    /* If Hardware Reduced flag is set, there is no FACS */    if (AcpiGbl_ReducedHardware)    {        AcpiGbl_FACS = NULL;        return (AE_OK);    }    Status = AcpiGetTableByIndex (ACPI_TABLE_INDEX_FACS,                ACPI_CAST_INDIRECT_PTR (ACPI_TABLE_HEADER, &AcpiGbl_FACS));    return (Status);}

ACPI_STATUSAcpiTbUnloadTable (    UINT32                  TableIndex){    ACPI_STATUS             Status = AE_OK;    ACPI_TABLE_HEADER       *Table;    ACPI_FUNCTION_TRACE (TbUnloadTable);    /* Ensure the table is still loaded */    if (!AcpiTbIsTableLoaded (TableIndex))    {        return_ACPI_STATUS (AE_NOT_EXIST);    }    /* Invoke table handler */    Status = AcpiGetTableByIndex (TableIndex, &Table);    if (ACPI_SUCCESS (Status))    {        AcpiTbNotifyTable (ACPI_TABLE_EVENT_UNLOAD, Table);    }    /* Delete the portion of the namespace owned by this table */    Status = AcpiTbDeleteNamespaceByOwner (TableIndex);    if (ACPI_FAILURE (Status))    {        return_ACPI_STATUS (Status);    }    (void) AcpiTbReleaseOwnerId (TableIndex);    AcpiTbSetTableLoadedFlag (TableIndex, FALSE);    return_ACPI_STATUS (Status);}

ACPI_STATUSAcpiDsEvalTableRegionOperands (    ACPI_WALK_STATE         *WalkState,    ACPI_PARSE_OBJECT       *Op){    ACPI_STATUS             Status;    ACPI_OPERAND_OBJECT     *ObjDesc;    ACPI_OPERAND_OBJECT     **Operand;    ACPI_NAMESPACE_NODE     *Node;    ACPI_PARSE_OBJECT       *NextOp;    ACPI_TABLE_HEADER       *Table;    UINT32                  TableIndex;    ACPI_FUNCTION_TRACE_PTR (DsEvalTableRegionOperands, Op);    /*     * This is where we evaluate the Signature string, OemId string,     * and OemTableId string of the Data Table Region declaration     */    Node =  Op->Common.Node;    /* NextOp points to Signature string op */    NextOp = Op->Common.Value.Arg;    /*     * Evaluate/create the Signature string, OemId string,     * and OemTableId string operands     */    Status = AcpiDsCreateOperands (WalkState, NextOp);    if (ACPI_FAILURE (Status))    {        return_ACPI_STATUS (Status);    }    Operand = &WalkState->Operands[0];    /*     * Resolve the Signature string, OemId string,     * and OemTableId string operands     */    Status = AcpiExResolveOperands (Op->Common.AmlOpcode,                ACPI_WALK_OPERANDS, WalkState);    if (ACPI_FAILURE (Status))    {        goto Cleanup;    }    /* Find the ACPI table */    Status = AcpiTbFindTable (                Operand[0]->String.Pointer,                Operand[1]->String.Pointer,                Operand[2]->String.Pointer, &TableIndex);    if (ACPI_FAILURE (Status))    {        if (Status == AE_NOT_FOUND)        {            ACPI_ERROR ((AE_INFO,                "ACPI Table [%4.4s] OEM:(%s, %s) not found in RSDT/XSDT",                Operand[0]->String.Pointer,                Operand[1]->String.Pointer,                Operand[2]->String.Pointer));        }        goto Cleanup;    }    Status = AcpiGetTableByIndex (TableIndex, &Table);    if (ACPI_FAILURE (Status))    {        goto Cleanup;    }    ObjDesc = AcpiNsGetAttachedObject (Node);    if (!ObjDesc)    {        Status = AE_NOT_EXIST;        goto Cleanup;    }    ObjDesc->Region.Address = ACPI_PTR_TO_PHYSADDR (Table);    ObjDesc->Region.Length = Table->Length;    ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "RgnObj %p Addr %8.8X%8.8X Len %X/n",        ObjDesc, ACPI_FORMAT_UINT64 (ObjDesc->Region.Address),        ObjDesc->Region.Length));    /* Now the address and length are valid for this opregion */    ObjDesc->Region.Flags |= AOPOBJ_DATA_VALID;Cleanup:    AcpiUtRemoveReference (Operand[0]);    AcpiUtRemoveReference (Operand[1]);    AcpiUtRemoveReference (Operand[2]);    return_ACPI_STATUS (Status);}

ACPI_STATUSAcpiExUnloadTable (    ACPI_OPERAND_OBJECT     *DdbHandle){    ACPI_STATUS             Status = AE_OK;    ACPI_OPERAND_OBJECT     *TableDesc = DdbHandle;    UINT32                  TableIndex;    ACPI_TABLE_HEADER       *Table;    ACPI_FUNCTION_TRACE (ExUnloadTable);    /*     * Validate the handle     * Although the handle is partially validated in AcpiExReconfiguration()     * when it calls AcpiExResolveOperands(), the handle is more completely     * validated here.     *     * Handle must be a valid operand object of type reference. Also, the     * DdbHandle must still be marked valid (table has not been previously     * unloaded)     */    if ((!DdbHandle) ||        (ACPI_GET_DESCRIPTOR_TYPE (DdbHandle) != ACPI_DESC_TYPE_OPERAND) ||        (DdbHandle->Common.Type != ACPI_TYPE_LOCAL_REFERENCE) ||        (!(DdbHandle->Common.Flags & AOPOBJ_DATA_VALID)))    {        return_ACPI_STATUS (AE_BAD_PARAMETER);    }    /* Get the table index from the DdbHandle */    TableIndex = TableDesc->Reference.Value;    /* Ensure the table is still loaded */    if (!AcpiTbIsTableLoaded (TableIndex))    {        return_ACPI_STATUS (AE_NOT_EXIST);    }    /* Invoke table handler if present */    if (AcpiGbl_TableHandler)    {        Status = AcpiGetTableByIndex (TableIndex, &Table);        if (ACPI_SUCCESS (Status))        {            (void) AcpiGbl_TableHandler (ACPI_TABLE_EVENT_UNLOAD, Table,                        AcpiGbl_TableHandlerContext);        }    }    /* Delete the portion of the namespace owned by this table */    Status = AcpiTbDeleteNamespaceByOwner (TableIndex);    if (ACPI_FAILURE (Status))    {        return_ACPI_STATUS (Status);    }    (void) AcpiTbReleaseOwnerId (TableIndex);    AcpiTbSetTableLoadedFlag (TableIndex, FALSE);    /*     * Invalidate the handle. We do this because the handle may be stored     * in a named object and may not be actually deleted until much later.     */    DdbHandle->Common.Flags &= ~AOPOBJ_DATA_VALID;    return_ACPI_STATUS (AE_OK);}

//.........这里部分代码省略.........        DdbHandle = AcpiUtCreateIntegerObject ((UINT64) 0);        if (!DdbHandle)        {            return_ACPI_STATUS (AE_NO_MEMORY);        }        *ReturnDesc = DdbHandle;        return_ACPI_STATUS (AE_OK);    }    /* Default nodes */    StartNode = WalkState->ScopeInfo->Scope.Node;    ParentNode = AcpiGbl_RootNode;    /* RootPath (optional parameter) */    if (Operand[3]->String.Length > 0)    {        /*         * Find the node referenced by the RootPathString.  This is the         * location within the namespace where the table will be loaded.         */        Status = AcpiNsGetNode (StartNode, Operand[3]->String.Pointer,                    ACPI_NS_SEARCH_PARENT, &ParentNode);        if (ACPI_FAILURE (Status))        {            return_ACPI_STATUS (Status);        }    }    /* ParameterPath (optional parameter) */    if (Operand[4]->String.Length > 0)    {        if ((Operand[4]->String.Pointer[0] != '//') &&            (Operand[4]->String.Pointer[0] != '^'))        {            /*             * Path is not absolute, so it will be relative to the node             * referenced by the RootPathString (or the NS root if omitted)             */            StartNode = ParentNode;        }        /* Find the node referenced by the ParameterPathString */        Status = AcpiNsGetNode (StartNode, Operand[4]->String.Pointer,                    ACPI_NS_SEARCH_PARENT, &ParameterNode);        if (ACPI_FAILURE (Status))        {            return_ACPI_STATUS (Status);        }    }    /* Load the table into the namespace */    Status = AcpiExAddTable (TableIndex, ParentNode, &DdbHandle);    if (ACPI_FAILURE (Status))    {        return_ACPI_STATUS (Status);    }    /* Parameter Data (optional) */    if (ParameterNode)    {        /* Store the parameter data into the optional parameter object */        Status = AcpiExStore (Operand[5],                    ACPI_CAST_PTR (ACPI_OPERAND_OBJECT, ParameterNode),                    WalkState);        if (ACPI_FAILURE (Status))        {            (void) AcpiExUnloadTable (DdbHandle);            AcpiUtRemoveReference (DdbHandle);            return_ACPI_STATUS (Status);        }    }    Status = AcpiGetTableByIndex (TableIndex, &Table);    if (ACPI_SUCCESS (Status))    {        ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Dynamic OEM Table Load:"));        AcpiTbPrintTableHeader (0, Table);    }    /* Invoke table handler if present */    if (AcpiGbl_TableHandler)    {        (void) AcpiGbl_TableHandler (ACPI_TABLE_EVENT_LOAD, Table,                    AcpiGbl_TableHandlerContext);    }    *ReturnDesc = DdbHandle;    return_ACPI_STATUS  (Status);}

ACPI_STATUSAcpiDsEvalTableRegionOperands (    ACPI_WALK_STATE         *WalkState,    ACPI_PARSE_OBJECT       *Op){    ACPI_STATUS             Status;    ACPI_OPERAND_OBJECT     *ObjDesc;    ACPI_OPERAND_OBJECT     **Operand;    ACPI_NAMESPACE_NODE     *Node;    ACPI_PARSE_OBJECT       *NextOp;    UINT32                  TableIndex;    ACPI_TABLE_HEADER       *Table;    ACPI_FUNCTION_TRACE_PTR (DsEvalTableRegionOperands, Op);    /*     * This is where we evaluate the SignatureString and OemIDString     * and OemTableIDString of the DataTableRegion declaration     */    Node =  Op->Common.Node;    /* NextOp points to SignatureString op */    NextOp = Op->Common.Value.Arg;    /*     * Evaluate/create the SignatureString and OemIDString     * and OemTableIDString operands     */    Status = AcpiDsCreateOperands (WalkState, NextOp);    if (ACPI_FAILURE (Status))    {        return_ACPI_STATUS (Status);    }    /*     * Resolve the SignatureString and OemIDString     * and OemTableIDString operands     */    Status = AcpiExResolveOperands (Op->Common.AmlOpcode,                ACPI_WALK_OPERANDS, WalkState);    if (ACPI_FAILURE (Status))    {        return_ACPI_STATUS (Status);    }    Operand = &WalkState->Operands[0];    /* Find the ACPI table */    Status = AcpiTbFindTable (Operand[0]->String.Pointer,                Operand[1]->String.Pointer, Operand[2]->String.Pointer,                &TableIndex);    if (ACPI_FAILURE (Status))    {        return_ACPI_STATUS (Status);    }    AcpiUtRemoveReference (Operand[0]);    AcpiUtRemoveReference (Operand[1]);    AcpiUtRemoveReference (Operand[2]);    Status = AcpiGetTableByIndex (TableIndex, &Table);    if (ACPI_FAILURE (Status))    {        return_ACPI_STATUS (Status);    }    ObjDesc = AcpiNsGetAttachedObject (Node);    if (!ObjDesc)    {        return_ACPI_STATUS (AE_NOT_EXIST);    }    ObjDesc->Region.Address = (ACPI_PHYSICAL_ADDRESS) ACPI_TO_INTEGER (Table);    ObjDesc->Region.Length = Table->Length;    ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "RgnObj %p Addr %8.8X%8.8X Len %X/n",        ObjDesc,        ACPI_FORMAT_NATIVE_UINT (ObjDesc->Region.Address),        ObjDesc->Region.Length));    /* Now the address and length are valid for this opregion */    ObjDesc->Region.Flags |= AOPOBJ_DATA_VALID;    return_ACPI_STATUS (Status);}

ACPI_STATUSAcpiDsInitializeObjects (    UINT32                  TableIndex,    ACPI_NAMESPACE_NODE     *StartNode){    ACPI_STATUS             Status;    ACPI_INIT_WALK_INFO     Info;    ACPI_TABLE_HEADER       *Table;    ACPI_OWNER_ID           OwnerId;    ACPI_FUNCTION_TRACE (DsInitializeObjects);    Status = AcpiTbGetOwnerId (TableIndex, &OwnerId);    if (ACPI_FAILURE (Status))    {        return_ACPI_STATUS (Status);    }    ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,        "**** Starting initialization of namespace objects ****/n"));    ACPI_DEBUG_PRINT_RAW ((ACPI_DB_INIT, "Parsing all Control Methods:"));    /* Set all init info to zero */    ACPI_MEMSET (&Info, 0, sizeof (ACPI_INIT_WALK_INFO));    Info.OwnerId = OwnerId;    Info.TableIndex = TableIndex;    /* Walk entire namespace from the supplied root */    Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE);    if (ACPI_FAILURE (Status))    {        return_ACPI_STATUS (Status);    }    /*     * We don't use AcpiWalkNamespace since we do not want to acquire     * the namespace reader lock.     */    Status = AcpiNsWalkNamespace (ACPI_TYPE_ANY, StartNode, ACPI_UINT32_MAX,                ACPI_NS_WALK_UNLOCK, AcpiDsInitOneObject, NULL, &Info, NULL);    if (ACPI_FAILURE (Status))    {        ACPI_EXCEPTION ((AE_INFO, Status, "During WalkNamespace"));    }    (void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);    Status = AcpiGetTableByIndex (TableIndex, &Table);    if (ACPI_FAILURE (Status))    {        return_ACPI_STATUS (Status);    }    ACPI_DEBUG_PRINT_RAW ((ACPI_DB_INIT,        "/nTable [%4.4s](id %4.4X) - %u Objects with %u Devices %u Methods %u Regions/n",        Table->Signature, OwnerId, Info.ObjectCount,        Info.DeviceCount, Info.MethodCount, Info.OpRegionCount));    ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,        "%u Methods, %u Regions/n", Info.MethodCount, Info.OpRegionCount));    return_ACPI_STATUS (AE_OK);}

ACPI_STATUSAcpiNsExecuteTable (    UINT32                  TableIndex,    ACPI_NAMESPACE_NODE     *StartNode){    ACPI_STATUS             Status;    ACPI_TABLE_HEADER       *Table;    ACPI_OWNER_ID           OwnerId;    ACPI_EVALUATE_INFO      *Info = NULL;    UINT32                  AmlLength;    UINT8                   *AmlStart;    ACPI_OPERAND_OBJECT     *MethodObj = NULL;    ACPI_FUNCTION_TRACE (NsExecuteTable);    Status = AcpiGetTableByIndex (TableIndex, &Table);    if (ACPI_FAILURE (Status))    {        return_ACPI_STATUS (Status);    }    /* Table must consist of at least a complete header */    if (Table->Length < sizeof (ACPI_TABLE_HEADER))    {        return_ACPI_STATUS (AE_BAD_HEADER);    }    AmlStart = (UINT8 *) Table + sizeof (ACPI_TABLE_HEADER);    AmlLength = Table->Length - sizeof (ACPI_TABLE_HEADER);    Status = AcpiTbGetOwnerId (TableIndex, &OwnerId);    if (ACPI_FAILURE (Status))    {        return_ACPI_STATUS (Status);    }    /* Create, initialize, and link a new temporary method object */    MethodObj = AcpiUtCreateInternalObject (ACPI_TYPE_METHOD);    if (!MethodObj)    {        return_ACPI_STATUS (AE_NO_MEMORY);    }    /* Allocate the evaluation information block */    Info = ACPI_ALLOCATE_ZEROED (sizeof (ACPI_EVALUATE_INFO));    if (!Info)    {        Status = AE_NO_MEMORY;        goto Cleanup;    }    ACPI_DEBUG_PRINT_RAW ((ACPI_DB_PARSE,        "%s: Create table pseudo-method for [%4.4s] @%p, method %p/n",        ACPI_GET_FUNCTION_NAME, Table->Signature, Table, MethodObj));    MethodObj->Method.AmlStart = AmlStart;    MethodObj->Method.AmlLength = AmlLength;    MethodObj->Method.OwnerId = OwnerId;    MethodObj->Method.InfoFlags |= ACPI_METHOD_MODULE_LEVEL;    Info->PassNumber = ACPI_IMODE_EXECUTE;    Info->Node = StartNode;    Info->ObjDesc = MethodObj;    Info->NodeFlags = Info->Node->Flags;    Info->FullPathname = AcpiNsGetNormalizedPathname (Info->Node, TRUE);    if (!Info->FullPathname)    {        Status = AE_NO_MEMORY;        goto Cleanup;    }    Status = AcpiPsExecuteTable (Info);Cleanup:    if (Info)    {        ACPI_FREE (Info->FullPathname);        Info->FullPathname = NULL;    }    ACPI_FREE (Info);    AcpiUtRemoveReference (MethodObj);    return_ACPI_STATUS (Status);}

ACPI_STATUSAcpiNsOneCompleteParse (    UINT32                  PassNumber,    UINT32                  TableIndex,    ACPI_NAMESPACE_NODE     *StartNode){    ACPI_PARSE_OBJECT       *ParseRoot;    ACPI_STATUS             Status;    UINT32                  AmlLength;    UINT8                   *AmlStart;    ACPI_WALK_STATE         *WalkState;    ACPI_TABLE_HEADER       *Table;    ACPI_OWNER_ID           OwnerId;    ACPI_FUNCTION_TRACE (NsOneCompleteParse);    Status = AcpiGetTableByIndex (TableIndex, &Table);    if (ACPI_FAILURE (Status))    {        return_ACPI_STATUS (Status);    }    /* Table must consist of at least a complete header */    if (Table->Length < sizeof (ACPI_TABLE_HEADER))    {        return_ACPI_STATUS (AE_BAD_HEADER);    }    AmlStart = (UINT8 *) Table + sizeof (ACPI_TABLE_HEADER);    AmlLength = Table->Length - sizeof (ACPI_TABLE_HEADER);    Status = AcpiTbGetOwnerId (TableIndex, &OwnerId);    if (ACPI_FAILURE (Status))    {        return_ACPI_STATUS (Status);    }    /* Create and init a Root Node */    ParseRoot = AcpiPsCreateScopeOp (AmlStart);    if (!ParseRoot)    {        return_ACPI_STATUS (AE_NO_MEMORY);    }    /* Create and initialize a new walk state */    WalkState = AcpiDsCreateWalkState (OwnerId, NULL, NULL, NULL);    if (!WalkState)    {        AcpiPsFreeOp (ParseRoot);        return_ACPI_STATUS (AE_NO_MEMORY);    }    Status = AcpiDsInitAmlWalk (WalkState, ParseRoot, NULL,        AmlStart, AmlLength, NULL, (UINT8) PassNumber);    if (ACPI_FAILURE (Status))    {        AcpiDsDeleteWalkState (WalkState);        goto Cleanup;    }    /* Found OSDT table, enable the namespace override feature */    if (ACPI_COMPARE_NAME(Table->Signature, ACPI_SIG_OSDT) &&        PassNumber == ACPI_IMODE_LOAD_PASS1)    {        WalkState->NamespaceOverride = TRUE;    }    /* StartNode is the default location to load the table  */    if (StartNode && StartNode != AcpiGbl_RootNode)    {        Status = AcpiDsScopeStackPush (            StartNode, ACPI_TYPE_METHOD, WalkState);        if (ACPI_FAILURE (Status))        {            AcpiDsDeleteWalkState (WalkState);            goto Cleanup;        }    }    /* Parse the AML */    ACPI_DEBUG_PRINT ((ACPI_DB_PARSE,        "*PARSE* pass %u parse/n", PassNumber));    AcpiExEnterInterpreter ();    Status = AcpiPsParseAml (WalkState);    AcpiExExitInterpreter ();Cleanup:    AcpiPsDeleteParseTree (ParseRoot);    return_ACPI_STATUS (Status);}