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

char *MpGetDdnValue (    char                    *DeviceName){    ACPI_NAMESPACE_NODE     *DeviceNode;    ACPI_NAMESPACE_NODE     *DdnNode;    ACPI_STATUS             Status;    Status = AcpiNsGetNode (NULL, DeviceName, ACPI_NS_NO_UPSEARCH,        &DeviceNode);    if (ACPI_FAILURE (Status))    {        goto ErrorExit;    }    Status = AcpiNsGetNode (DeviceNode, METHOD_NAME__DDN, ACPI_NS_NO_UPSEARCH,        &DdnNode);    if (ACPI_FAILURE (Status))    {        goto ErrorExit;    }    if ((DdnNode->Type != ACPI_TYPE_STRING) ||        !DdnNode->Object)    {        goto ErrorExit;    }    return (DdnNode->Object->String.Pointer);ErrorExit:    return (NULL);}

voidAcpiDbSetScope (    char                    *Name){    ACPI_STATUS             Status;    ACPI_NAMESPACE_NODE     *Node;    if (!Name || Name[0] == 0)    {        AcpiOsPrintf ("Current scope: %s/n", AcpiGbl_DbScopeBuf);        return;    }    AcpiDbPrepNamestring (Name);    if (Name[0] == '//')    {        /* Validate new scope from the root */        Status = AcpiNsGetNode (AcpiGbl_RootNode, Name, ACPI_NS_NO_UPSEARCH,                    &Node);        if (ACPI_FAILURE (Status))        {            goto ErrorExit;        }        ACPI_STRCPY (AcpiGbl_DbScopeBuf, Name);        ACPI_STRCAT (AcpiGbl_DbScopeBuf, "//");    }    else    {        /* Validate new scope relative to old scope */        Status = AcpiNsGetNode (AcpiGbl_DbScopeNode, Name, ACPI_NS_NO_UPSEARCH,                    &Node);        if (ACPI_FAILURE (Status))        {            goto ErrorExit;        }        ACPI_STRCAT (AcpiGbl_DbScopeBuf, Name);        ACPI_STRCAT (AcpiGbl_DbScopeBuf, "//");    }    AcpiGbl_DbScopeNode = Node;    AcpiOsPrintf ("New scope: %s/n", AcpiGbl_DbScopeBuf);    return;ErrorExit:    AcpiOsPrintf ("Could not attach scope: %s, %s/n",        Name, AcpiFormatException (Status));}

voidAcpiNsReportMethodError (    const char              *ModuleName,    UINT32                  LineNumber,    const char              *Message,    ACPI_NAMESPACE_NODE     *PrefixNode,    const char              *Path,    ACPI_STATUS             MethodStatus){    ACPI_STATUS             Status;    ACPI_NAMESPACE_NODE     *Node = PrefixNode;    AcpiOsPrintf ("ACPI Error (%s-%04d): ", ModuleName, LineNumber);    if (Path)    {        Status = AcpiNsGetNode (PrefixNode, Path, ACPI_NS_NO_UPSEARCH,                    &Node);        if (ACPI_FAILURE (Status))        {            AcpiOsPrintf ("[Could not get node by pathname]");        }    }    AcpiNsPrintNodePathname (Node, Message);    AcpiOsPrintf (", %s/n", AcpiFormatException (MethodStatus));}

voidAcpiUtMethodError (    const char              *ModuleName,    UINT32                  LineNumber,    const char              *Message,    ACPI_NAMESPACE_NODE     *PrefixNode,    const char              *Path,    ACPI_STATUS             MethodStatus){    ACPI_STATUS             Status;    ACPI_NAMESPACE_NODE     *Node = PrefixNode;    ACPI_MSG_REDIRECT_BEGIN;    AcpiOsPrintf (ACPI_MSG_ERROR);    if (Path)    {        Status = AcpiNsGetNode (PrefixNode, Path,            ACPI_NS_NO_UPSEARCH, &Node);        if (ACPI_FAILURE (Status))        {            AcpiOsPrintf ("[Could not get node by pathname]");        }    }    AcpiNsPrintNodePathname (Node, Message);    AcpiOsPrintf (", %s", AcpiFormatException (MethodStatus));    ACPI_MSG_SUFFIX;    ACPI_MSG_REDIRECT_END;}

static ACPI_STATUSAcpiNsRepair_TSS (    ACPI_EVALUATE_INFO      *Info,    ACPI_OPERAND_OBJECT     **ReturnObjectPtr){    ACPI_OPERAND_OBJECT     *ReturnObject = *ReturnObjectPtr;    ACPI_STATUS             Status;    ACPI_NAMESPACE_NODE     *Node;    /*     * We can only sort the _TSS return package if there is no _PSS in the     * same scope. This is because if _PSS is present, the ACPI specification     * dictates that the _TSS Power Dissipation field is to be ignored, and     * therefore some BIOSs leave garbage values in the _TSS Power field(s).     * In this case, it is best to just return the _TSS package as-is.     * (May, 2011)     */    Status = AcpiNsGetNode (Info->Node, "^_PSS",        ACPI_NS_NO_UPSEARCH, &Node);    if (ACPI_SUCCESS (Status))    {        return (AE_OK);    }    Status = AcpiNsCheckSortedList (Info, ReturnObject, 0, 5, 1,                ACPI_SORT_DESCENDING, "PowerDissipation");    return (Status);}

char *MpGetHidValue (    ACPI_NAMESPACE_NODE     *DeviceNode){    ACPI_NAMESPACE_NODE     *HidNode;    char                    *HidString;    ACPI_STATUS             Status;    Status = AcpiNsGetNode (DeviceNode, METHOD_NAME__HID,        ACPI_NS_NO_UPSEARCH, &HidNode);    if (ACPI_FAILURE (Status))    {        goto ErrorExit;    }    /* If only partial namespace, get the _HID from the parse tree */    if (!HidNode->Object)    {        return (MpGetHidFromParseTree (HidNode));    }    /* Handle the different _HID flavors */    switch (HidNode->Type)    {    case ACPI_TYPE_STRING:        return (HidNode->Object->String.Pointer);    case ACPI_TYPE_INTEGER:        /* Convert EISAID to a string */        HidString = UtLocalCacheCalloc (ACPI_EISAID_STRING_SIZE);        AcpiExEisaIdToString (HidString, HidNode->Object->Integer.Value);        return (HidString);    case ACPI_TYPE_METHOD:        return ("-Method-");    default:        FlPrintFile (ASL_FILE_MAP_OUTPUT, "BAD HID TYPE: %u", HidNode->Type);        break;    }ErrorExit:    return ("-No HID-");}

char *MpGetHidViaNamestring (    char                    *DeviceName){    ACPI_NAMESPACE_NODE     *DeviceNode;    ACPI_STATUS             Status;    Status = AcpiNsGetNode (NULL, DeviceName, ACPI_NS_NO_UPSEARCH,        &DeviceNode);    if (ACPI_FAILURE (Status))    {        goto ErrorExit;    }    return (MpGetHidValue (DeviceNode));ErrorExit:    return ("-No HID-");}

//.........这里部分代码省略.........            switch (InitVal->Type)            {            case ACPI_TYPE_METHOD:                ObjDesc->Method.ParamCount = (UINT8) ACPI_TO_INTEGER (Val);                ObjDesc->Common.Flags |= AOPOBJ_DATA_VALID;#if defined (ACPI_ASL_COMPILER)                /* Save the parameter count for the iASL compiler */                NewNode->Value = ObjDesc->Method.ParamCount;#else                /* Mark this as a very SPECIAL method */                ObjDesc->Method.InfoFlags = ACPI_METHOD_INTERNAL_ONLY;                ObjDesc->Method.Dispatch.Implementation = AcpiUtOsiImplementation;#endif                break;            case ACPI_TYPE_INTEGER:                ObjDesc->Integer.Value = ACPI_TO_INTEGER (Val);                break;            case ACPI_TYPE_STRING:                /* Build an object around the static string */                ObjDesc->String.Length = (UINT32) strlen (Val);                ObjDesc->String.Pointer = Val;                ObjDesc->Common.Flags |= AOPOBJ_STATIC_POINTER;                break;            case ACPI_TYPE_MUTEX:                ObjDesc->Mutex.Node = NewNode;                ObjDesc->Mutex.SyncLevel = (UINT8) (ACPI_TO_INTEGER (Val) - 1);                /* Create a mutex */                Status = AcpiOsCreateMutex (&ObjDesc->Mutex.OsMutex);                if (ACPI_FAILURE (Status))                {                    AcpiUtRemoveReference (ObjDesc);                    goto UnlockAndExit;                }                /* Special case for ACPI Global Lock */                if (strcmp (InitVal->Name, "_GL_") == 0)                {                    AcpiGbl_GlobalLockMutex = ObjDesc;                    /* Create additional counting semaphore for global lock */                    Status = AcpiOsCreateSemaphore (                        1, 0, &AcpiGbl_GlobalLockSemaphore);                    if (ACPI_FAILURE (Status))                    {                        AcpiUtRemoveReference (ObjDesc);                        goto UnlockAndExit;                    }                }                break;            default:                ACPI_ERROR ((AE_INFO, "Unsupported initial type value 0x%X",                    InitVal->Type));                AcpiUtRemoveReference (ObjDesc);                ObjDesc = NULL;                continue;            }            /* Store pointer to value descriptor in the Node */            Status = AcpiNsAttachObject (NewNode, ObjDesc,                ObjDesc->Common.Type);            /* Remove local reference to the object */            AcpiUtRemoveReference (ObjDesc);        }    }UnlockAndExit:    (void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);    /* Save a handle to "_GPE", it is always present */    if (ACPI_SUCCESS (Status))    {        Status = AcpiNsGetNode (NULL, "//_GPE", ACPI_NS_NO_UPSEARCH,            &AcpiGbl_FadtGpeDevice);    }    return_ACPI_STATUS (Status);}

ACPI_STATUSAcpiExLoadTableOp (    ACPI_WALK_STATE         *WalkState,    ACPI_OPERAND_OBJECT     **ReturnDesc){    ACPI_STATUS             Status;    ACPI_OPERAND_OBJECT     **Operand = &WalkState->Operands[0];    ACPI_NAMESPACE_NODE     *ParentNode;    ACPI_NAMESPACE_NODE     *StartNode;    ACPI_NAMESPACE_NODE     *ParameterNode = NULL;    ACPI_OPERAND_OBJECT     *DdbHandle;    ACPI_TABLE_HEADER       *Table;    UINT32                  TableIndex;    ACPI_FUNCTION_TRACE (ExLoadTableOp);    /* Validate lengths for the SignatureString, OEMIDString, OEMTableID */    if ((Operand[0]->String.Length > ACPI_NAME_SIZE) ||        (Operand[1]->String.Length > ACPI_OEM_ID_SIZE) ||        (Operand[2]->String.Length > ACPI_OEM_TABLE_ID_SIZE))    {        return_ACPI_STATUS (AE_BAD_PARAMETER);    }    /* Find the ACPI table in the RSDT/XSDT */    Status = AcpiTbFindTable (Operand[0]->String.Pointer,                              Operand[1]->String.Pointer,                              Operand[2]->String.Pointer, &TableIndex);    if (ACPI_FAILURE (Status))    {        if (Status != AE_NOT_FOUND)        {            return_ACPI_STATUS (Status);        }        /* Table not found, return an Integer=0 and 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))//.........这里部分代码省略.........

ACPI_STATUSAcpiEvMatchPrwAndGpe (    ACPI_HANDLE             ObjHandle,    UINT32                  Level,    void                    *Context,    void                    **ReturnValue){    ACPI_GPE_WALK_INFO      *WalkInfo = ACPI_CAST_PTR (ACPI_GPE_WALK_INFO, Context);    ACPI_NAMESPACE_NODE     *GpeDevice;    ACPI_GPE_BLOCK_INFO     *GpeBlock;    ACPI_NAMESPACE_NODE     *TargetGpeDevice;    ACPI_NAMESPACE_NODE     *PrwNode;    ACPI_GPE_EVENT_INFO     *GpeEventInfo;    ACPI_OPERAND_OBJECT     *PkgDesc;    ACPI_OPERAND_OBJECT     *ObjDesc;    UINT32                  GpeNumber;    ACPI_STATUS             Status;    ACPI_FUNCTION_TRACE (EvMatchPrwAndGpe);    /* Check for a _PRW method under this device */    Status = AcpiNsGetNode (ObjHandle, METHOD_NAME__PRW,                ACPI_NS_NO_UPSEARCH, &PrwNode);    if (ACPI_FAILURE (Status))    {        return_ACPI_STATUS (AE_OK);    }    /* Check if requested OwnerId matches this OwnerId */    if ((WalkInfo->ExecuteByOwnerId) &&        (PrwNode->OwnerId != WalkInfo->OwnerId))    {        return_ACPI_STATUS (AE_OK);    }    /* Execute the _PRW */    Status = AcpiUtEvaluateObject (PrwNode, NULL,                ACPI_BTYPE_PACKAGE, &PkgDesc);    if (ACPI_FAILURE (Status))    {        return_ACPI_STATUS (AE_OK);    }    /* The returned _PRW package must have at least two elements */    if (PkgDesc->Package.Count < 2)    {        goto Cleanup;    }    /* Extract pointers from the input context */    GpeDevice = WalkInfo->GpeDevice;    GpeBlock = WalkInfo->GpeBlock;    /*     * The _PRW object must return a package, we are only interested     * in the first element     */    ObjDesc = PkgDesc->Package.Elements[0];    if (ObjDesc->Common.Type == ACPI_TYPE_INTEGER)    {        /* Use FADT-defined GPE device (from definition of _PRW) */        TargetGpeDevice = NULL;        if (GpeDevice)        {            TargetGpeDevice = AcpiGbl_FadtGpeDevice;        }        /* Integer is the GPE number in the FADT described GPE blocks */        GpeNumber = (UINT32) ObjDesc->Integer.Value;    }    else if (ObjDesc->Common.Type == ACPI_TYPE_PACKAGE)    {        /* Package contains a GPE reference and GPE number within a GPE block */        if ((ObjDesc->Package.Count < 2) ||            ((ObjDesc->Package.Elements[0])->Common.Type !=                ACPI_TYPE_LOCAL_REFERENCE) ||            ((ObjDesc->Package.Elements[1])->Common.Type !=                ACPI_TYPE_INTEGER))        {            goto Cleanup;        }        /* Get GPE block reference and decode */        TargetGpeDevice = ObjDesc->Package.Elements[0]->Reference.Node;        GpeNumber = (UINT32) ObjDesc->Package.Elements[1]->Integer.Value;    }    else    {//.........这里部分代码省略.........

ACPI_STATUSAcpiGetHandle (    ACPI_HANDLE             Parent,    ACPI_STRING             Pathname,    ACPI_HANDLE             *RetHandle){    ACPI_STATUS             Status;    ACPI_NAMESPACE_NODE     *Node = NULL;    ACPI_NAMESPACE_NODE     *PrefixNode = NULL;    FUNCTION_ENTRY ();    /* Ensure that ACPI has been initialized */    ACPI_IS_INITIALIZATION_COMPLETE (Status);    if (ACPI_FAILURE (Status))    {        return (Status);    }    /* Parameter Validation */    if (!RetHandle || !Pathname)    {        return (AE_BAD_PARAMETER);    }    /* Convert a parent handle to a prefix node */    if (Parent)    {        AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE);        PrefixNode = AcpiNsConvertHandleToEntry (Parent);        if (!PrefixNode)        {            AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);            return (AE_BAD_PARAMETER);        }        AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);    }    /* Special case for root, since we can't search for it */    if (STRCMP (Pathname, NS_ROOT_PATH) == 0)    {        *RetHandle = AcpiNsConvertEntryToHandle (AcpiGbl_RootNode);        return (AE_OK);    }    /*     *  Find the Node and convert to a handle     */    Status = AcpiNsGetNode (Pathname, PrefixNode, &Node);    *RetHandle = NULL;    if (ACPI_SUCCESS (Status))    {        *RetHandle = AcpiNsConvertEntryToHandle (Node);    }    return (Status);}

ACPI_STATUSAcpiGetHandle (    ACPI_HANDLE             Parent,    ACPI_STRING             Pathname,    ACPI_HANDLE             *RetHandle){    ACPI_STATUS             Status;    ACPI_NAMESPACE_NODE     *Node = NULL;    ACPI_NAMESPACE_NODE     *PrefixNode = NULL;    ACPI_FUNCTION_ENTRY ();    /* Parameter Validation */    if (!RetHandle || !Pathname)    {        return (AE_BAD_PARAMETER);    }    /* Convert a parent handle to a prefix node */    if (Parent)    {        PrefixNode = AcpiNsMapHandleToNode (Parent);        if (!PrefixNode)        {            return (AE_BAD_PARAMETER);        }    }    /*     * Valid cases are:     * 1) Fully qualified pathname     * 2) Parent + Relative pathname     *     * Error for <null Parent + relative path>     */    if (AcpiNsValidRootPrefix (Pathname[0]))    {        /* Pathname is fully qualified (starts with '/') */        /* Special case for root-only, since we can't search for it */        if (!ACPI_STRCMP (Pathname, ACPI_NS_ROOT_PATH))        {            *RetHandle = AcpiNsConvertEntryToHandle (AcpiGbl_RootNode);            return (AE_OK);        }    }    else if (!PrefixNode)    {        /* Relative path with null prefix is disallowed */        return (AE_BAD_PARAMETER);    }    /* Find the Node and convert to a handle */    Status = AcpiNsGetNode (PrefixNode, Pathname, ACPI_NS_NO_UPSEARCH, &Node);    if (ACPI_SUCCESS (Status))    {        *RetHandle = AcpiNsConvertEntryToHandle (Node);    }    return (Status);}

ACPI_STATUSAcpiNsEvaluate (    ACPI_EVALUATE_INFO      *Info){    ACPI_STATUS             Status;    ACPI_NAMESPACE_NODE     *Node;    ACPI_FUNCTION_TRACE (NsEvaluate);    if (!Info)    {        return_ACPI_STATUS (AE_BAD_PARAMETER);    }    /* Initialize the return value to an invalid object */    Info->ReturnObject = NULL;    Info->ParamCount = 0;    /*     * Get the actual namespace node for the target object. Handles these cases:     *     * 1) Null node, Pathname (absolute path)     * 2) Node, Pathname (path relative to Node)     * 3) Node, Null Pathname     */    Status = AcpiNsGetNode (Info->PrefixNode, Info->Pathname,                ACPI_NS_NO_UPSEARCH, &Info->ResolvedNode);    if (ACPI_FAILURE (Status))    {        return_ACPI_STATUS (Status);    }    /*     * For a method alias, we must grab the actual method node so that proper     * scoping context will be established before execution.     */    if (AcpiNsGetType (Info->ResolvedNode) == ACPI_TYPE_LOCAL_METHOD_ALIAS)    {        Info->ResolvedNode =            ACPI_CAST_PTR (ACPI_NAMESPACE_NODE, Info->ResolvedNode->Object);    }    ACPI_DEBUG_PRINT ((ACPI_DB_NAMES, "%s [%p] Value %p/n", Info->Pathname,        Info->ResolvedNode, AcpiNsGetAttachedObject (Info->ResolvedNode)));    Node = Info->ResolvedNode;    /*     * Two major cases here:     *     * 1) The object is a control method -- execute it     * 2) The object is not a method -- just return it's current value     */    if (AcpiNsGetType (Info->ResolvedNode) == ACPI_TYPE_METHOD)    {        /*         * 1) Object is a control method - execute it         */        /* Verify that there is a method object associated with this node */        Info->ObjDesc = AcpiNsGetAttachedObject (Info->ResolvedNode);        if (!Info->ObjDesc)        {            ACPI_ERROR ((AE_INFO, "Control method has no attached sub-object"));            return_ACPI_STATUS (AE_NULL_OBJECT);        }        /* Count the number of arguments being passed to the method */        if (Info->Parameters)        {            while (Info->Parameters[Info->ParamCount])            {                if (Info->ParamCount > ACPI_METHOD_MAX_ARG)                {                    return_ACPI_STATUS (AE_LIMIT);                }                Info->ParamCount++;            }        }        ACPI_DUMP_PATHNAME (Info->ResolvedNode, "ACPI: Execute Method",            ACPI_LV_INFO, _COMPONENT);        ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,            "Method at AML address %p Length %X/n",            Info->ObjDesc->Method.AmlStart + 1,            Info->ObjDesc->Method.AmlLength - 1));        /*         * Any namespace deletion must acquire both the namespace and         * interpreter locks to ensure that no thread is using the portion of         * the namespace that is being deleted.         *         * Execute the method via the interpreter. The interpreter is locked         * here before calling into the AML parser//.........这里部分代码省略.........

ACPI_STATUSAcpiNsEvaluate (    ACPI_EVALUATE_INFO      *Info){    ACPI_STATUS             Status;    ACPI_FUNCTION_TRACE (NsEvaluate);    if (!Info)    {        return_ACPI_STATUS (AE_BAD_PARAMETER);    }    if (!Info->Node)    {        /*         * Get the actual namespace node for the target object if we         * need to. Handles these cases:         *         * 1) Null node, valid pathname from root (absolute path)         * 2) Node and valid pathname (path relative to Node)         * 3) Node, Null pathname         */        Status = AcpiNsGetNode (Info->PrefixNode, Info->RelativePathname,            ACPI_NS_NO_UPSEARCH, &Info->Node);        if (ACPI_FAILURE (Status))        {            return_ACPI_STATUS (Status);        }    }    /*     * For a method alias, we must grab the actual method node so that     * proper scoping context will be established before execution.     */    if (AcpiNsGetType (Info->Node) == ACPI_TYPE_LOCAL_METHOD_ALIAS)    {        Info->Node = ACPI_CAST_PTR (            ACPI_NAMESPACE_NODE, Info->Node->Object);    }    /* Complete the info block initialization */    Info->ReturnObject = NULL;    Info->NodeFlags = Info->Node->Flags;    Info->ObjDesc = AcpiNsGetAttachedObject (Info->Node);    ACPI_DEBUG_PRINT ((ACPI_DB_NAMES, "%s [%p] Value %p/n",        Info->RelativePathname, Info->Node,        AcpiNsGetAttachedObject (Info->Node)));    /* Get info if we have a predefined name (_HID, etc.) */    Info->Predefined = AcpiUtMatchPredefinedMethod (Info->Node->Name.Ascii);    /* Get the full pathname to the object, for use in warning messages */    Info->FullPathname = AcpiNsGetExternalPathname (Info->Node);    if (!Info->FullPathname)    {        return_ACPI_STATUS (AE_NO_MEMORY);    }    /* Count the number of arguments being passed in */    Info->ParamCount = 0;    if (Info->Parameters)    {        while (Info->Parameters[Info->ParamCount])        {            Info->ParamCount++;        }        /* Warn on impossible argument count */        if (Info->ParamCount > ACPI_METHOD_NUM_ARGS)        {            ACPI_WARN_PREDEFINED ((AE_INFO, Info->FullPathname, ACPI_WARN_ALWAYS,                "Excess arguments (%u) - using only %u",                Info->ParamCount, ACPI_METHOD_NUM_ARGS));            Info->ParamCount = ACPI_METHOD_NUM_ARGS;        }    }    /*     * For predefined names: Check that the declared argument count     * matches the ACPI spec -- otherwise this is a BIOS error.     */    AcpiNsCheckAcpiCompliance (Info->FullPathname, Info->Node,        Info->Predefined);    /*     * For all names: Check that the incoming argument count for     * this method/object matches the actual ASL/AML definition.     */    AcpiNsCheckArgumentCount (Info->FullPathname, Info->Node,        Info->ParamCount, Info->Predefined);//.........这里部分代码省略.........

voidAcpiDbSetScope (    char                    *Name){    ACPI_STATUS             Status;    ACPI_NAMESPACE_NODE     *Node;    if (!Name || Name[0] == 0)    {        AcpiOsPrintf ("Current scope: %s/n", AcpiGbl_DbScopeBuf);        return;    }    AcpiDbPrepNamestring (Name);    if (ACPI_IS_ROOT_PREFIX (Name[0]))    {        /* Validate new scope from the root */        Status = AcpiNsGetNode (AcpiGbl_RootNode, Name, ACPI_NS_NO_UPSEARCH,                    &Node);        if (ACPI_FAILURE (Status))        {            goto ErrorExit;        }        AcpiGbl_DbScopeBuf[0] = 0;    }    else    {        /* Validate new scope relative to old scope */        Status = AcpiNsGetNode (AcpiGbl_DbScopeNode, Name, ACPI_NS_NO_UPSEARCH,                    &Node);        if (ACPI_FAILURE (Status))        {            goto ErrorExit;        }    }    /* Build the final pathname */    if (AcpiUtSafeStrcat (AcpiGbl_DbScopeBuf, sizeof (AcpiGbl_DbScopeBuf),        Name))    {        Status = AE_BUFFER_OVERFLOW;        goto ErrorExit;    }    if (AcpiUtSafeStrcat (AcpiGbl_DbScopeBuf, sizeof (AcpiGbl_DbScopeBuf),        "//"))    {        Status = AE_BUFFER_OVERFLOW;        goto ErrorExit;    }    AcpiGbl_DbScopeNode = Node;    AcpiOsPrintf ("New scope: %s/n", AcpiGbl_DbScopeBuf);    return;ErrorExit:    AcpiOsPrintf ("Could not attach scope: %s, %s/n",        Name, AcpiFormatException (Status));}

ACPI_STATUSAcpiGetHandle (    ACPI_HANDLE             Parent,    ACPI_STRING             Pathname,    ACPI_HANDLE             *RetHandle){    ACPI_STATUS             Status;    ACPI_NAMESPACE_NODE     *Node = NULL;    ACPI_NAMESPACE_NODE     *PrefixNode = NULL;    ACPI_FUNCTION_ENTRY ();    /* Parameter Validation */    if (!RetHandle || !Pathname)    {        return (AE_BAD_PARAMETER);    }    /* Convert a parent handle to a prefix node */    if (Parent)    {        Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE);        if (ACPI_FAILURE (Status))        {            return (Status);        }        PrefixNode = AcpiNsMapHandleToNode (Parent);        if (!PrefixNode)        {            (void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);            return (AE_BAD_PARAMETER);        }        Status = AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);        if (ACPI_FAILURE (Status))        {            return (Status);        }    }    /* Special case for root, since we can't search for it */    if (ACPI_STRCMP (Pathname, ACPI_NS_ROOT_PATH) == 0)    {        *RetHandle = AcpiNsConvertEntryToHandle (AcpiGbl_RootNode);        return (AE_OK);    }    /*     *  Find the Node and convert to a handle     */    Status = AcpiNsGetNode (PrefixNode, Pathname, ACPI_NS_NO_UPSEARCH,                &Node);    *RetHandle = NULL;    if (ACPI_SUCCESS (Status))    {        *RetHandle = AcpiNsConvertEntryToHandle (Node);    }    return (Status);}