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

ACPI_STATUSAcpiRemoveGpeBlock (    ACPI_HANDLE             GpeDevice){    ACPI_OPERAND_OBJECT     *ObjDesc;    ACPI_STATUS             Status;    ACPI_NAMESPACE_NODE     *Node;    ACPI_FUNCTION_TRACE (AcpiRemoveGpeBlock);    if (!GpeDevice)    {        return_ACPI_STATUS (AE_BAD_PARAMETER);    }    Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE);    if (ACPI_FAILURE (Status))    {        return_ACPI_STATUS (Status);    }    Node = AcpiNsValidateHandle (GpeDevice);    if (!Node)    {        Status = AE_BAD_PARAMETER;        goto UnlockAndExit;    }    /* Validate the parent device */    if (Node->Type != ACPI_TYPE_DEVICE)    {        Status = AE_TYPE;        goto UnlockAndExit;    }    /* Get the DeviceObject attached to the node */    ObjDesc = AcpiNsGetAttachedObject (Node);    if (!ObjDesc ||        !ObjDesc->Device.GpeBlock)    {        return_ACPI_STATUS (AE_NULL_OBJECT);    }    /* Delete the GPE block (but not the DeviceObject) */    Status = AcpiEvDeleteGpeBlock (ObjDesc->Device.GpeBlock);    if (ACPI_SUCCESS (Status))    {        ObjDesc->Device.GpeBlock = NULL;    }UnlockAndExit:    (void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);    return_ACPI_STATUS (Status);}

static ACPI_STATUSAcpiEvRegRun (    ACPI_HANDLE             ObjHandle,    UINT32                  Level,    void                    *Context,    void                    **ReturnValue){    ACPI_OPERAND_OBJECT     *ObjDesc;    ACPI_NAMESPACE_NODE     *Node;    ACPI_STATUS             Status;    ACPI_REG_WALK_INFO      *Info;    Info = ACPI_CAST_PTR (ACPI_REG_WALK_INFO, Context);    /* Convert and validate the device handle */    Node = AcpiNsValidateHandle (ObjHandle);    if (!Node)    {        return (AE_BAD_PARAMETER);    }    /*     * We only care about regions.and objects that are allowed to have address     * space handlers     */    if ((Node->Type != ACPI_TYPE_REGION) &&        (Node != AcpiGbl_RootNode))    {        return (AE_OK);    }    /* Check for an existing internal object */    ObjDesc = AcpiNsGetAttachedObject (Node);    if (!ObjDesc)    {        /* No object, just exit */        return (AE_OK);    }    /* Object is a Region */    if (ObjDesc->Region.SpaceId != Info->SpaceId)    {        /* This region is for a different address space, just ignore it */        return (AE_OK);    }    Info->RegRunCount++;    Status = AcpiEvExecuteRegMethod (ObjDesc, ACPI_REG_CONNECT);    return (Status);}

ACPI_STATUSAcpiGetParent (    ACPI_HANDLE             Handle,    ACPI_HANDLE             *RetHandle){    ACPI_NAMESPACE_NODE     *Node;    ACPI_NAMESPACE_NODE     *ParentNode;    ACPI_STATUS             Status;    if (!RetHandle)    {        return (AE_BAD_PARAMETER);    }    /* Special case for the predefined Root Node (no parent) */    if (Handle == ACPI_ROOT_OBJECT)    {        return (AE_NULL_ENTRY);    }    Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE);    if (ACPI_FAILURE (Status))    {        return (Status);    }    /* Convert and validate the handle */    Node = AcpiNsValidateHandle (Handle);    if (!Node)    {        Status = AE_BAD_PARAMETER;        goto UnlockAndExit;    }    /* Get the parent entry */    ParentNode = Node->Parent;    *RetHandle = ACPI_CAST_PTR (ACPI_HANDLE, ParentNode);    /* Return exception if parent is null */    if (!ParentNode)    {        Status = AE_NULL_ENTRY;    }UnlockAndExit:    (void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);    return (Status);}

ACPI_STATUSAcpiInstallAddressSpaceHandler (    ACPI_HANDLE             Device,    ACPI_ADR_SPACE_TYPE     SpaceId,    ACPI_ADR_SPACE_HANDLER  Handler,    ACPI_ADR_SPACE_SETUP    Setup,    void                    *Context){    ACPI_NAMESPACE_NODE     *Node;    ACPI_STATUS             Status;    ACPI_FUNCTION_TRACE (AcpiInstallAddressSpaceHandler);    /* Parameter validation */    if (!Device)    {        return_ACPI_STATUS (AE_BAD_PARAMETER);    }    Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE);    if (ACPI_FAILURE (Status))    {        return_ACPI_STATUS (Status);    }    /* Convert and validate the device handle */    Node = AcpiNsValidateHandle (Device);    if (!Node)    {        Status = AE_BAD_PARAMETER;        goto UnlockAndExit;    }    /* Install the handler for all Regions for this Space ID */    Status = AcpiEvInstallSpaceHandler (                 Node, SpaceId, Handler, Setup, Context);    if (ACPI_FAILURE (Status))    {        goto UnlockAndExit;    }    /* Run all _REG methods for this address space */    AcpiEvExecuteRegMethods (Node, SpaceId, ACPI_REG_CONNECT);UnlockAndExit:    (void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);    return_ACPI_STATUS (Status);}

ACPI_STATUSAcpiNsHandleToPathname (    ACPI_HANDLE             TargetHandle,    ACPI_BUFFER             *Buffer,    BOOLEAN                 NoTrailing){    ACPI_STATUS             Status;    ACPI_NAMESPACE_NODE     *Node;    ACPI_SIZE               RequiredSize;    ACPI_FUNCTION_TRACE_PTR (NsHandleToPathname, TargetHandle);    Node = AcpiNsValidateHandle (TargetHandle);    if (!Node)    {        return_ACPI_STATUS (AE_BAD_PARAMETER);    }    /* Determine size required for the caller buffer */    RequiredSize = AcpiNsBuildNormalizedPath (Node, NULL, 0, NoTrailing);    if (!RequiredSize)    {        return_ACPI_STATUS (AE_BAD_PARAMETER);    }    /* Validate/Allocate/Clear caller buffer */    Status = AcpiUtInitializeBuffer (Buffer, RequiredSize);    if (ACPI_FAILURE (Status))    {        return_ACPI_STATUS (Status);    }    /* Build the path in the caller buffer */    (void) AcpiNsBuildNormalizedPath (Node, Buffer->Pointer,        RequiredSize, NoTrailing);    if (ACPI_FAILURE (Status))    {        return_ACPI_STATUS (Status);    }    ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "%s [%X]/n",        (char *) Buffer->Pointer, (UINT32) RequiredSize));    return_ACPI_STATUS (AE_OK);}

static ACPI_STATUSAcpiRsValidateParameters (    ACPI_HANDLE             DeviceHandle,    ACPI_BUFFER             *Buffer,    ACPI_NAMESPACE_NODE     **ReturnNode){    ACPI_STATUS             Status;    ACPI_NAMESPACE_NODE     *Node;    ACPI_FUNCTION_TRACE (RsValidateParameters);    /*     * Must have a valid handle to an ACPI device     */    if (!DeviceHandle)    {        return_ACPI_STATUS (AE_BAD_PARAMETER);    }    Node = AcpiNsValidateHandle (DeviceHandle);    if (!Node)    {        return_ACPI_STATUS (AE_BAD_PARAMETER);    }    if (Node->Type != ACPI_TYPE_DEVICE)    {        return_ACPI_STATUS (AE_TYPE);    }    /*     * Validate the user buffer object     *     * if there is a non-zero buffer length we also need a valid pointer in     * the buffer. If it's a zero buffer length, we'll be returning the     * needed buffer size (later), so keep going.     */    Status = AcpiUtValidateBuffer (Buffer);    if (ACPI_FAILURE (Status))    {        return_ACPI_STATUS (Status);    }    *ReturnNode = Node;    return_ACPI_STATUS (AE_OK);}

ACPI_STATUSAcpiGetType (    ACPI_HANDLE             Handle,    ACPI_OBJECT_TYPE        *RetType){    ACPI_NAMESPACE_NODE     *Node;    ACPI_STATUS             Status;    /* Parameter Validation */    if (!RetType)    {        return (AE_BAD_PARAMETER);    }    /*     * Special case for the predefined Root Node     * (return type ANY)     */    if (Handle == ACPI_ROOT_OBJECT)    {        *RetType = ACPI_TYPE_ANY;        return (AE_OK);    }    Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE);    if (ACPI_FAILURE (Status))    {        return (Status);    }    /* Convert and validate the handle */    Node = AcpiNsValidateHandle (Handle);    if (!Node)    {        (void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);        return (AE_BAD_PARAMETER);    }    *RetType = Node->Type;    Status = AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);    return (Status);}

static ACPI_STATUSAcpiNsDumpOneObjectPath (    ACPI_HANDLE             ObjHandle,    UINT32                  Level,    void                    *Context,    void                    **ReturnValue){    UINT32                  MaxLevel = *((UINT32 *) Context);    char                    *Pathname;    ACPI_NAMESPACE_NODE     *Node;    int                     PathIndent;    if (!ObjHandle)    {        return (AE_OK);    }    Node = AcpiNsValidateHandle (ObjHandle);    if (!Node)    {        /* Ignore bad node during namespace walk */        return (AE_OK);    }    Pathname = AcpiNsGetNormalizedPathname (Node, TRUE);    PathIndent = 1;    if (Level <= MaxLevel)    {        PathIndent = MaxLevel - Level + 1;    }    AcpiOsPrintf ("%2d%*s%-12s%*s",        Level, Level, " ", AcpiUtGetTypeName (Node->Type),        PathIndent, " ");    AcpiOsPrintf ("%s/n", &Pathname[1]);    ACPI_FREE (Pathname);    return (AE_OK);}

ACPI_STATUSAcpiAttachData (    ACPI_HANDLE             ObjHandle,    ACPI_OBJECT_HANDLER     Handler,    void                    *Data){    ACPI_NAMESPACE_NODE     *Node;    ACPI_STATUS             Status;    /* Parameter validation */    if (!ObjHandle  ||        !Handler    ||        !Data)    {        return (AE_BAD_PARAMETER);    }    Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE);    if (ACPI_FAILURE (Status))    {        return (Status);    }    /* Convert and validate the handle */    Node = AcpiNsValidateHandle (ObjHandle);    if (!Node)    {        Status = AE_BAD_PARAMETER;        goto UnlockAndExit;    }    Status = AcpiNsAttachData (Node, Handler, Data);UnlockAndExit:    (void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);    return (Status);}

ACPI_STATUSAcpiNsHandleToName (    ACPI_HANDLE             TargetHandle,    ACPI_BUFFER             *Buffer){    ACPI_STATUS             Status;    ACPI_NAMESPACE_NODE     *Node;    const char              *NodeName;    ACPI_FUNCTION_TRACE_PTR (NsHandleToName, TargetHandle);    Node = AcpiNsValidateHandle (TargetHandle);    if (!Node)    {        return_ACPI_STATUS (AE_BAD_PARAMETER);    }    /* Validate/Allocate/Clear caller buffer */    Status = AcpiUtInitializeBuffer (Buffer, ACPI_PATH_SEGMENT_LENGTH);    if (ACPI_FAILURE (Status))    {        return_ACPI_STATUS (Status);    }    /* Just copy the ACPI name from the Node and zero terminate it */    NodeName = AcpiUtGetNodeName (Node);    ACPI_MOVE_NAME (Buffer->Pointer, NodeName);    ((char *) Buffer->Pointer) [ACPI_NAME_SIZE] = 0;    ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "%4.4s/n", (char *) Buffer->Pointer));    return_ACPI_STATUS (AE_OK);}

ACPI_STATUSAcpiEvaluateObject (    ACPI_HANDLE             Handle,    ACPI_STRING             Pathname,    ACPI_OBJECT_LIST        *ExternalParams,    ACPI_BUFFER             *ReturnBuffer){    ACPI_STATUS             Status;    ACPI_EVALUATE_INFO      *Info;    ACPI_SIZE               BufferSpaceNeeded;    UINT32                  i;    ACPI_FUNCTION_TRACE (AcpiEvaluateObject);    /* Allocate and initialize the evaluation information block */    Info = ACPI_ALLOCATE_ZEROED (sizeof (ACPI_EVALUATE_INFO));    if (!Info)    {        return_ACPI_STATUS (AE_NO_MEMORY);    }    Info->Pathname = Pathname;    /* Convert and validate the device handle */    Info->PrefixNode = AcpiNsValidateHandle (Handle);    if (!Info->PrefixNode)    {        Status = AE_BAD_PARAMETER;        goto Cleanup;    }    /*     * If there are parameters to be passed to a control method, the external     * objects must all be converted to internal objects     */    if (ExternalParams && ExternalParams->Count)    {        /*         * Allocate a new parameter block for the internal objects         * Add 1 to count to allow for null terminated internal list         */        Info->Parameters = ACPI_ALLOCATE_ZEROED (            ((ACPI_SIZE) ExternalParams->Count + 1) * sizeof (void *));        if (!Info->Parameters)        {            Status = AE_NO_MEMORY;            goto Cleanup;        }        /* Convert each external object in the list to an internal object */        for (i = 0; i < ExternalParams->Count; i++)        {            Status = AcpiUtCopyEobjectToIobject (                        &ExternalParams->Pointer[i], &Info->Parameters[i]);            if (ACPI_FAILURE (Status))            {                goto Cleanup;            }        }        Info->Parameters[ExternalParams->Count] = NULL;    }    /*     * Three major cases:     * 1) Fully qualified pathname     * 2) No handle, not fully qualified pathname (error)     * 3) Valid handle     */    if ((Pathname) &&        (AcpiNsValidRootPrefix (Pathname[0])))    {        /* The path is fully qualified, just evaluate by name */        Info->PrefixNode = NULL;        Status = AcpiNsEvaluate (Info);    }    else if (!Handle)    {        /*         * A handle is optional iff a fully qualified pathname is specified.         * Since we've already handled fully qualified names above, this is         * an error         */        if (!Pathname)        {            ACPI_DEBUG_PRINT ((ACPI_DB_INFO,                "Both Handle and Pathname are NULL"));        }        else        {            ACPI_DEBUG_PRINT ((ACPI_DB_INFO,                "Null Handle with relative pathname [%s]", Pathname));        }        Status = AE_BAD_PARAMETER;//.........这里部分代码省略.........

ACPI_STATUSAcpiInstallGpeBlock (    ACPI_HANDLE             GpeDevice,    ACPI_GENERIC_ADDRESS    *GpeBlockAddress,    UINT32                  RegisterCount,    UINT32                  InterruptNumber){    ACPI_STATUS             Status;    ACPI_OPERAND_OBJECT     *ObjDesc;    ACPI_NAMESPACE_NODE     *Node;    ACPI_GPE_BLOCK_INFO     *GpeBlock;    ACPI_FUNCTION_TRACE (AcpiInstallGpeBlock);    if ((!GpeDevice)       ||        (!GpeBlockAddress) ||        (!RegisterCount))    {        return_ACPI_STATUS (AE_BAD_PARAMETER);    }    Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE);    if (ACPI_FAILURE (Status))    {        return_ACPI_STATUS (Status);    }    Node = AcpiNsValidateHandle (GpeDevice);    if (!Node)    {        Status = AE_BAD_PARAMETER;        goto UnlockAndExit;    }    /* Validate the parent device */    if (Node->Type != ACPI_TYPE_DEVICE)    {        Status = AE_TYPE;        goto UnlockAndExit;    }    if (Node->Object)    {        Status = AE_ALREADY_EXISTS;        goto UnlockAndExit;    }    /*     * For user-installed GPE Block Devices, the GpeBlockBaseNumber     * is always zero     */    Status = AcpiEvCreateGpeBlock (Node, GpeBlockAddress->Address,        GpeBlockAddress->SpaceId, RegisterCount,        0, InterruptNumber, &GpeBlock);    if (ACPI_FAILURE (Status))    {        goto UnlockAndExit;    }    /* Install block in the DeviceObject attached to the node */    ObjDesc = AcpiNsGetAttachedObject (Node);    if (!ObjDesc)    {        /*         * No object, create a new one (Device nodes do not always have         * an attached object)         */        ObjDesc = AcpiUtCreateInternalObject (ACPI_TYPE_DEVICE);        if (!ObjDesc)        {            Status = AE_NO_MEMORY;            goto UnlockAndExit;        }        Status = AcpiNsAttachObject (Node, ObjDesc, ACPI_TYPE_DEVICE);        /* Remove local reference to the object */        AcpiUtRemoveReference (ObjDesc);        if (ACPI_FAILURE (Status))        {            goto UnlockAndExit;        }    }    /* Now install the GPE block in the DeviceObject */    ObjDesc->Device.GpeBlock = GpeBlock;UnlockAndExit:    (void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);    return_ACPI_STATUS (Status);}

static ACPI_STATUSAcpiNsGetDeviceCallback (    ACPI_HANDLE             ObjHandle,    UINT32                  NestingLevel,    void                    *Context,    void                    **ReturnValue){    ACPI_GET_DEVICES_INFO   *Info = Context;    ACPI_STATUS             Status;    ACPI_NAMESPACE_NODE     *Node;    UINT32                  Flags;    ACPI_PNP_DEVICE_ID      *Hid;    ACPI_PNP_DEVICE_ID_LIST *Cid;    UINT32                  i;    BOOLEAN                 Found;    int                     NoMatch;    Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE);    if (ACPI_FAILURE (Status))    {        return (Status);    }    Node = AcpiNsValidateHandle (ObjHandle);    Status = AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);    if (ACPI_FAILURE (Status))    {        return (Status);    }    if (!Node)    {        return (AE_BAD_PARAMETER);    }    /*     * First, filter based on the device HID and CID.     *     * 01/2010: For this case where a specific HID is requested, we don't     * want to run _STA until we have an actual HID match. Thus, we will     * not unnecessarily execute _STA on devices for which the caller     * doesn't care about. Previously, _STA was executed unconditionally     * on all devices found here.     *     * A side-effect of this change is that now we will continue to search     * for a matching HID even under device trees where the parent device     * would have returned a _STA that indicates it is not present or     * not functioning (thus aborting the search on that branch).     */    if (Info->Hid != NULL)    {        Status = AcpiUtExecute_HID (Node, &Hid);        if (Status == AE_NOT_FOUND)        {            return (AE_OK);        }        else if (ACPI_FAILURE (Status))        {            return (AE_CTRL_DEPTH);        }        NoMatch = strcmp (Hid->String, Info->Hid);        ACPI_FREE (Hid);        if (NoMatch)        {            /*             * HID does not match, attempt match within the             * list of Compatible IDs (CIDs)             */            Status = AcpiUtExecute_CID (Node, &Cid);            if (Status == AE_NOT_FOUND)            {                return (AE_OK);            }            else if (ACPI_FAILURE (Status))            {                return (AE_CTRL_DEPTH);            }            /* Walk the CID list */            Found = FALSE;            for (i = 0; i < Cid->Count; i++)            {                if (strcmp (Cid->Ids[i].String, Info->Hid) == 0)                {                    /* Found a matching CID */                    Found = TRUE;                    break;                }            }            ACPI_FREE (Cid);            if (!Found)            {                return (AE_OK);            }//.........这里部分代码省略.........

ACPI_STATUSAcpiWalkNamespace (    ACPI_OBJECT_TYPE        Type,    ACPI_HANDLE             StartObject,    UINT32                  MaxDepth,    ACPI_WALK_CALLBACK      DescendingCallback,    ACPI_WALK_CALLBACK      AscendingCallback,    void                    *Context,    void                    **ReturnValue){    ACPI_STATUS             Status;    ACPI_FUNCTION_TRACE (AcpiWalkNamespace);    /* Parameter validation */    if ((Type > ACPI_TYPE_LOCAL_MAX) ||        (!MaxDepth)                  ||        (!DescendingCallback && !AscendingCallback))    {        return_ACPI_STATUS (AE_BAD_PARAMETER);    }    /*     * Need to acquire the namespace reader lock to prevent interference     * with any concurrent table unloads (which causes the deletion of     * namespace objects). We cannot allow the deletion of a namespace node     * while the user function is using it. The exception to this are the     * nodes created and deleted during control method execution -- these     * nodes are marked as temporary nodes and are ignored by the namespace     * walk. Thus, control methods can be executed while holding the     * namespace deletion lock (and the user function can execute control     * methods.)     */    Status = AcpiUtAcquireReadLock (&AcpiGbl_NamespaceRwLock);    if (ACPI_FAILURE (Status))    {        return_ACPI_STATUS (Status);    }    /*     * Lock the namespace around the walk. The namespace will be     * unlocked/locked around each call to the user function - since the user     * function must be allowed to make ACPICA calls itself (for example, it     * will typically execute control methods during device enumeration.)     */    Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE);    if (ACPI_FAILURE (Status))    {        goto UnlockAndExit;    }    /* Now we can validate the starting node */    if (!AcpiNsValidateHandle (StartObject))    {        Status = AE_BAD_PARAMETER;        goto UnlockAndExit2;    }    Status = AcpiNsWalkNamespace (Type, StartObject, MaxDepth,        ACPI_NS_WALK_UNLOCK, DescendingCallback,        AscendingCallback, Context, ReturnValue);UnlockAndExit2:    (void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);UnlockAndExit:    (void) AcpiUtReleaseReadLock (&AcpiGbl_NamespaceRwLock);    return_ACPI_STATUS (Status);}

ACPI_STATUSAcpiEvaluateObject (    ACPI_HANDLE             Handle,    ACPI_STRING             Pathname,    ACPI_OBJECT_LIST        *ExternalParams,    ACPI_BUFFER             *ReturnBuffer){    ACPI_STATUS             Status;    ACPI_EVALUATE_INFO      *Info;    ACPI_SIZE               BufferSpaceNeeded;    UINT32                  i;    ACPI_FUNCTION_TRACE (AcpiEvaluateObject);    /* Allocate and initialize the evaluation information block */    Info = ACPI_ALLOCATE_ZEROED (sizeof (ACPI_EVALUATE_INFO));    if (!Info)    {        return_ACPI_STATUS (AE_NO_MEMORY);    }    /* Convert and validate the device handle */    Info->PrefixNode = AcpiNsValidateHandle (Handle);    if (!Info->PrefixNode)    {        Status = AE_BAD_PARAMETER;        goto Cleanup;    }    /*     * Get the actual namespace node for the target object.     * 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     */    if ((Pathname) &&        (ACPI_IS_ROOT_PREFIX (Pathname[0])))    {        /* The path is fully qualified, just evaluate by name */        Info->PrefixNode = NULL;    }    else if (!Handle)    {        /*         * A handle is optional iff a fully qualified pathname is specified.         * Since we've already handled fully qualified names above, this is         * an error.         */        if (!Pathname)        {            ACPI_DEBUG_PRINT ((ACPI_DB_INFO,                "Both Handle and Pathname are NULL"));        }        else        {            ACPI_DEBUG_PRINT ((ACPI_DB_INFO,                "Null Handle with relative pathname [%s]", Pathname));        }        Status = AE_BAD_PARAMETER;        goto Cleanup;    }    Info->RelativePathname = Pathname;    /*     * Convert all external objects passed as arguments to the     * internal version(s).     */    if (ExternalParams && ExternalParams->Count)    {        Info->ParamCount = (UINT16) ExternalParams->Count;        /* Warn on impossible argument count */        if (Info->ParamCount > ACPI_METHOD_NUM_ARGS)        {            ACPI_WARN_PREDEFINED ((AE_INFO, Pathname, ACPI_WARN_ALWAYS,                "Excess arguments (%u) - using only %u",                Info->ParamCount, ACPI_METHOD_NUM_ARGS));            Info->ParamCount = ACPI_METHOD_NUM_ARGS;        }        /*         * Allocate a new parameter block for the internal objects         * Add 1 to count to allow for null terminated internal list         */        Info->Parameters = ACPI_ALLOCATE_ZEROED (            ((ACPI_SIZE) Info->ParamCount + 1) * sizeof (void *));        if (!Info->Parameters)        {            Status = AE_NO_MEMORY;//.........这里部分代码省略.........

ACPI_STATUSAcpiInstallNotifyHandler (    ACPI_HANDLE             Device,    UINT32                  HandlerType,    ACPI_NOTIFY_HANDLER     Handler,    void                    *Context){    ACPI_OPERAND_OBJECT     *ObjDesc;    ACPI_OPERAND_OBJECT     *NotifyObj;    ACPI_NAMESPACE_NODE     *Node;    ACPI_STATUS             Status;    ACPI_FUNCTION_TRACE (AcpiInstallNotifyHandler);    /* Parameter validation */    if ((!Device)  ||        (!Handler) ||        (HandlerType > ACPI_MAX_NOTIFY_HANDLER_TYPE))    {        return_ACPI_STATUS (AE_BAD_PARAMETER);    }    Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE);    if (ACPI_FAILURE (Status))    {        return_ACPI_STATUS (Status);    }    /* Convert and validate the device handle */    Node = AcpiNsValidateHandle (Device);    if (!Node)    {        Status = AE_BAD_PARAMETER;        goto UnlockAndExit;    }    /*     * Root Object:     * Registering a notify handler on the root object indicates that the     * caller wishes to receive notifications for all objects. Note that     * only one <external> global handler can be regsitered (per notify type).     */    if (Device == ACPI_ROOT_OBJECT)    {        /* Make sure the handler is not already installed */        if (((HandlerType & ACPI_SYSTEM_NOTIFY) &&                AcpiGbl_SystemNotify.Handler)       ||            ((HandlerType & ACPI_DEVICE_NOTIFY) &&                AcpiGbl_DeviceNotify.Handler))        {            Status = AE_ALREADY_EXISTS;            goto UnlockAndExit;        }        if (HandlerType & ACPI_SYSTEM_NOTIFY)        {            AcpiGbl_SystemNotify.Node    = Node;            AcpiGbl_SystemNotify.Handler = Handler;            AcpiGbl_SystemNotify.Context = Context;        }        if (HandlerType & ACPI_DEVICE_NOTIFY)        {            AcpiGbl_DeviceNotify.Node    = Node;            AcpiGbl_DeviceNotify.Handler = Handler;            AcpiGbl_DeviceNotify.Context = Context;        }        /* Global notify handler installed */    }    /*     * All Other Objects:     * Caller will only receive notifications specific to the target object.     * Note that only certain object types can receive notifications.     */    else    {        /* Notifies allowed on this object? */        if (!AcpiEvIsNotifyObject (Node))        {            Status = AE_TYPE;            goto UnlockAndExit;        }        /* Check for an existing internal object */        ObjDesc = AcpiNsGetAttachedObject (Node);        if (ObjDesc)        {            /* Object exists - make sure there's no handler */            if (((HandlerType & ACPI_SYSTEM_NOTIFY) &&                    ObjDesc->CommonNotify.SystemNotify)   ||//.........这里部分代码省略.........

ACPI_STATUSAcpiRemoveNotifyHandler (    ACPI_HANDLE             Device,    UINT32                  HandlerType,    ACPI_NOTIFY_HANDLER     Handler){    ACPI_OPERAND_OBJECT     *NotifyObj;    ACPI_OPERAND_OBJECT     *ObjDesc;    ACPI_NAMESPACE_NODE     *Node;    ACPI_STATUS             Status;    ACPI_FUNCTION_TRACE (AcpiRemoveNotifyHandler);    /* Parameter validation */    if ((!Device)  ||        (!Handler) ||        (HandlerType > ACPI_MAX_NOTIFY_HANDLER_TYPE))    {        return_ACPI_STATUS (AE_BAD_PARAMETER);    }    Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE);    if (ACPI_FAILURE (Status))    {        return_ACPI_STATUS (Status);    }    /* Convert and validate the device handle */    Node = AcpiNsValidateHandle (Device);    if (!Node)    {        Status = AE_BAD_PARAMETER;        goto UnlockAndExit;    }    /* Root Object */    if (Device == ACPI_ROOT_OBJECT)    {        ACPI_DEBUG_PRINT ((ACPI_DB_INFO,            "Removing notify handler for namespace root object/n"));        if (((HandlerType & ACPI_SYSTEM_NOTIFY) &&              !AcpiGbl_SystemNotify.Handler)        ||            ((HandlerType & ACPI_DEVICE_NOTIFY) &&              !AcpiGbl_DeviceNotify.Handler))        {            Status = AE_NOT_EXIST;            goto UnlockAndExit;        }        if (HandlerType & ACPI_SYSTEM_NOTIFY)        {            AcpiGbl_SystemNotify.Node    = NULL;            AcpiGbl_SystemNotify.Handler = NULL;            AcpiGbl_SystemNotify.Context = NULL;        }        if (HandlerType & ACPI_DEVICE_NOTIFY)        {            AcpiGbl_DeviceNotify.Node    = NULL;            AcpiGbl_DeviceNotify.Handler = NULL;            AcpiGbl_DeviceNotify.Context = NULL;        }    }    /* All Other Objects */    else    {        /* Notifies allowed on this object? */        if (!AcpiEvIsNotifyObject (Node))        {            Status = AE_TYPE;            goto UnlockAndExit;        }        /* Check for an existing internal object */        ObjDesc = AcpiNsGetAttachedObject (Node);        if (!ObjDesc)        {            Status = AE_NOT_EXIST;            goto UnlockAndExit;        }        /* Object exists - make sure there's an existing handler */        if (HandlerType & ACPI_SYSTEM_NOTIFY)        {            NotifyObj = ObjDesc->CommonNotify.SystemNotify;            if (!NotifyObj)            {                Status = AE_NOT_EXIST;                goto UnlockAndExit;//.........这里部分代码省略.........

static ACPI_STATUSAcpiEvInstallHandler (    ACPI_HANDLE             ObjHandle,    UINT32                  Level,    void                    *Context,    void                    **ReturnValue){    ACPI_OPERAND_OBJECT     *HandlerObj;    ACPI_OPERAND_OBJECT     *NextHandlerObj;    ACPI_OPERAND_OBJECT     *ObjDesc;    ACPI_NAMESPACE_NODE     *Node;    ACPI_STATUS             Status;    ACPI_FUNCTION_NAME (EvInstallHandler);    HandlerObj = (ACPI_OPERAND_OBJECT  *) Context;    /* Parameter validation */    if (!HandlerObj)    {        return (AE_OK);    }    /* Convert and validate the device handle */    Node = AcpiNsValidateHandle (ObjHandle);    if (!Node)    {        return (AE_BAD_PARAMETER);    }    /*     * We only care about regions and objects that are allowed to have     * address space handlers     */    if ((Node->Type != ACPI_TYPE_DEVICE) &&            (Node->Type != ACPI_TYPE_REGION) &&            (Node != AcpiGbl_RootNode))    {        return (AE_OK);    }    /* Check for an existing internal object */    ObjDesc = AcpiNsGetAttachedObject (Node);    if (!ObjDesc)    {        /* No object, just exit */        return (AE_OK);    }    /* Devices are handled different than regions */    if (ObjDesc->Common.Type == ACPI_TYPE_DEVICE)    {        /* Check if this Device already has a handler for this address space */        NextHandlerObj = AcpiEvFindRegionHandler (                             HandlerObj->AddressSpace.SpaceId, ObjDesc->CommonNotify.Handler);        if (NextHandlerObj)        {            /* Found a handler, is it for the same address space? */            ACPI_DEBUG_PRINT ((ACPI_DB_OPREGION,                               "Found handler for region [%s] in device %p(%p) handler %p/n",                               AcpiUtGetRegionName (HandlerObj->AddressSpace.SpaceId),                               ObjDesc, NextHandlerObj, HandlerObj));            /*             * Since the object we found it on was a device, then it means             * that someone has already installed a handler for the branch             * of the namespace from this device on. Just bail out telling             * the walk routine to not traverse this branch. This preserves             * the scoping rule for handlers.             */            return (AE_CTRL_DEPTH);        }        /*         * As long as the device didn't have a handler for this space we         * don't care about it. We just ignore it and proceed.         */        return (AE_OK);    }    /* Object is a Region */    if (ObjDesc->Region.SpaceId != HandlerObj->AddressSpace.SpaceId)    {        /* This region is for a different address space, just ignore it */        return (AE_OK);    }    /*     * Now we have a region and it is for the handler's address space type.//.........这里部分代码省略.........

ACPI_STATUSAcpiNsDumpOneObject (    ACPI_HANDLE             ObjHandle,    UINT32                  Level,    void                    *Context,    void                    **ReturnValue){    ACPI_WALK_INFO          *Info = (ACPI_WALK_INFO *) Context;    ACPI_NAMESPACE_NODE     *ThisNode;    ACPI_OPERAND_OBJECT     *ObjDesc = NULL;    ACPI_OBJECT_TYPE        ObjType;    ACPI_OBJECT_TYPE        Type;    UINT32                  BytesToDump;    UINT32                  DbgLevel;    UINT32                  i;    ACPI_FUNCTION_NAME (NsDumpOneObject);    /* Is output enabled? */    if (!(AcpiDbgLevel & Info->DebugLevel))    {        return (AE_OK);    }    if (!ObjHandle)    {        ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Null object handle/n"));        return (AE_OK);    }    ThisNode = AcpiNsValidateHandle (ObjHandle);    if (!ThisNode)    {        ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Invalid object handle %p/n",            ObjHandle));        return (AE_OK);    }    Type = ThisNode->Type;    /* Check if the owner matches */    if ((Info->OwnerId != ACPI_OWNER_ID_MAX) &&        (Info->OwnerId != ThisNode->OwnerId))    {        return (AE_OK);    }    if (!(Info->DisplayType & ACPI_DISPLAY_SHORT))    {        /* Indent the object according to the level */        AcpiOsPrintf ("%2d%*s", (UINT32) Level - 1, (int) Level * 2, " ");        /* Check the node type and name */        if (Type > ACPI_TYPE_LOCAL_MAX)        {            ACPI_WARNING ((AE_INFO,                "Invalid ACPI Object Type 0x%08X", Type));        }        AcpiOsPrintf ("%4.4s", AcpiUtGetNodeName (ThisNode));    }    /* Now we can print out the pertinent information */    AcpiOsPrintf (" %-12s %p %2.2X ",        AcpiUtGetTypeName (Type), ThisNode, ThisNode->OwnerId);    DbgLevel = AcpiDbgLevel;    AcpiDbgLevel = 0;    ObjDesc = AcpiNsGetAttachedObject (ThisNode);    AcpiDbgLevel = DbgLevel;    /* Temp nodes are those nodes created by a control method */    if (ThisNode->Flags & ANOBJ_TEMPORARY)    {        AcpiOsPrintf ("(T) ");    }    switch (Info->DisplayType & ACPI_DISPLAY_MASK)    {    case ACPI_DISPLAY_SUMMARY:        if (!ObjDesc)        {            /* No attached object. Some types should always have an object */            switch (Type)            {            case ACPI_TYPE_INTEGER:            case ACPI_TYPE_PACKAGE:            case ACPI_TYPE_BUFFER:            case ACPI_TYPE_STRING:            case ACPI_TYPE_METHOD://.........这里部分代码省略.........

ACPI_STATUSAcpiGetNextObject (    ACPI_OBJECT_TYPE        Type,    ACPI_HANDLE             Parent,    ACPI_HANDLE             Child,    ACPI_HANDLE             *RetHandle){    ACPI_STATUS             Status;    ACPI_NAMESPACE_NODE     *Node;    ACPI_NAMESPACE_NODE     *ParentNode = NULL;    ACPI_NAMESPACE_NODE     *ChildNode = NULL;    /* Parameter validation */    if (Type > ACPI_TYPE_EXTERNAL_MAX)    {        return (AE_BAD_PARAMETER);    }    Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE);    if (ACPI_FAILURE (Status))    {        return (Status);    }    /* If null handle, use the parent */    if (!Child)    {        /* Start search at the beginning of the specified scope */        ParentNode = AcpiNsValidateHandle (Parent);        if (!ParentNode)        {            Status = AE_BAD_PARAMETER;            goto UnlockAndExit;        }    }    else    {        /* Non-null handle, ignore the parent */        /* Convert and validate the handle */        ChildNode = AcpiNsValidateHandle (Child);        if (!ChildNode)        {            Status = AE_BAD_PARAMETER;            goto UnlockAndExit;        }    }    /* Internal function does the real work */    Node = AcpiNsGetNextNodeTyped (Type, ParentNode, ChildNode);    if (!Node)    {        Status = AE_NOT_FOUND;        goto UnlockAndExit;    }    if (RetHandle)    {        *RetHandle = ACPI_CAST_PTR (ACPI_HANDLE, Node);    }UnlockAndExit:    (void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);    return (Status);}

static ACPI_STATUSAcpiNsGetDeviceCallback (    ACPI_HANDLE             ObjHandle,    UINT32                  NestingLevel,    void                    *Context,    void                    **ReturnValue){    ACPI_GET_DEVICES_INFO   *Info = Context;    ACPI_STATUS             Status;    ACPI_NAMESPACE_NODE     *Node;    UINT32                  Flags;    ACPI_DEVICE_ID          *Hid;    ACPI_DEVICE_ID_LIST     *Cid;    UINT32                  i;    BOOLEAN                 Found;    int                     NoMatch;    Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE);    if (ACPI_FAILURE (Status))    {        return (Status);    }    Node = AcpiNsValidateHandle (ObjHandle);    Status = AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);    if (ACPI_FAILURE (Status))    {        return (Status);    }    if (!Node)    {        return (AE_BAD_PARAMETER);    }    /* Run _STA to determine if device is present */    Status = AcpiUtExecute_STA (Node, &Flags);    if (ACPI_FAILURE (Status))    {        return (AE_CTRL_DEPTH);    }    if (!(Flags & ACPI_STA_DEVICE_PRESENT) &&        !(Flags & ACPI_STA_DEVICE_FUNCTIONING))    {        /*         * Don't examine the children of the device only when the         * device is neither present nor functional. See ACPI spec,         * description of _STA for more information.         */        return (AE_CTRL_DEPTH);    }    /* Filter based on device HID & CID */    if (Info->Hid != NULL)    {        Status = AcpiUtExecute_HID (Node, &Hid);        if (Status == AE_NOT_FOUND)        {            return (AE_OK);        }        else if (ACPI_FAILURE (Status))        {            return (AE_CTRL_DEPTH);        }        NoMatch = ACPI_STRCMP (Hid->String, Info->Hid);        ACPI_FREE (Hid);        if (NoMatch)        {            /*             * HID does not match, attempt match within the             * list of Compatible IDs (CIDs)             */            Status = AcpiUtExecute_CID (Node, &Cid);            if (Status == AE_NOT_FOUND)            {                return (AE_OK);            }            else if (ACPI_FAILURE (Status))            {                return (AE_CTRL_DEPTH);            }            /* Walk the CID list */            Found = FALSE;            for (i = 0; i < Cid->Count; i++)            {                if (ACPI_STRCMP (Cid->Ids[i].String, Info->Hid) == 0)                {                    /* Found a matching CID */                    Found = TRUE;                    break;                }//.........这里部分代码省略.........