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

static ACPI_STATUSAcpiDsInitOneObject (    ACPI_HANDLE             ObjHandle,    UINT32                  Level,    void                    *Context,    void                    **ReturnValue){    ACPI_INIT_WALK_INFO     *Info = (ACPI_INIT_WALK_INFO *) Context;    ACPI_NAMESPACE_NODE     *Node = (ACPI_NAMESPACE_NODE *) ObjHandle;    ACPI_STATUS             Status;    ACPI_OPERAND_OBJECT     *ObjDesc;    ACPI_FUNCTION_ENTRY ();    /*     * We are only interested in NS nodes owned by the table that     * was just loaded     */    if (Node->OwnerId != Info->OwnerId)    {        return (AE_OK);    }    Info->ObjectCount++;    /* And even then, we are only interested in a few object types */    switch (AcpiNsGetType (ObjHandle))    {    case ACPI_TYPE_REGION:        Status = AcpiDsInitializeRegion (ObjHandle);        if (ACPI_FAILURE (Status))        {            ACPI_EXCEPTION ((AE_INFO, Status,                "During Region initialization %p [%4.4s]",                ObjHandle, AcpiUtGetNodeName (ObjHandle)));        }        Info->OpRegionCount++;        break;    case ACPI_TYPE_METHOD:        /*         * Auto-serialization support. We will examine each method that is         * NotSerialized to determine if it creates any Named objects. If         * it does, it will be marked serialized to prevent problems if         * the method is entered by two or more threads and an attempt is         * made to create the same named object twice -- which results in         * an AE_ALREADY_EXISTS exception and method abort.         */        Info->MethodCount++;        ObjDesc = AcpiNsGetAttachedObject (Node);        if (!ObjDesc)        {            break;        }        /* Ignore if already serialized */        if (ObjDesc->Method.InfoFlags & ACPI_METHOD_SERIALIZED)        {            Info->SerialMethodCount++;            break;        }        if (AcpiGbl_AutoSerializeMethods)        {            /* Parse/scan method and serialize it if necessary */            AcpiDsAutoSerializeMethod (Node, ObjDesc);            if (ObjDesc->Method.InfoFlags & ACPI_METHOD_SERIALIZED)            {                /* Method was just converted to Serialized */                Info->SerialMethodCount++;                Info->SerializedMethodCount++;                break;            }        }        Info->NonSerialMethodCount++;        break;    case ACPI_TYPE_DEVICE:        Info->DeviceCount++;        break;    default:        break;    }    /*     * We ignore errors from above, and always return OK, since     * we don't want to abort the walk on a single error.     *///.........这里部分代码省略.........

//.........这里部分代码省略.........        /*         * Check to make sure that the target is         * one of the opcodes that actually opens a scope         */        switch (Node->Type)        {        case ACPI_TYPE_ANY:        case ACPI_TYPE_LOCAL_SCOPE:         /* Scope  */        case ACPI_TYPE_DEVICE:        case ACPI_TYPE_POWER:        case ACPI_TYPE_PROCESSOR:        case ACPI_TYPE_THERMAL:            /* These are acceptable types */            break;        case ACPI_TYPE_INTEGER:        case ACPI_TYPE_STRING:        case ACPI_TYPE_BUFFER:            /*             * These types we will allow, but we will change the type.             * This enables some existing code of the form:             *             *  Name (DEB, 0)             *  Scope (DEB) { ... }             *             * Note: silently change the type here. On the second pass,             * we will report a warning             */            ACPI_DEBUG_PRINT ((ACPI_DB_INFO,                "Type override - [%4.4s] had invalid type (%s) "                "for Scope operator, changed to type ANY/n",                AcpiUtGetNodeName (Node), AcpiUtGetTypeName (Node->Type)));            Node->Type = ACPI_TYPE_ANY;            WalkState->ScopeInfo->Common.Value = ACPI_TYPE_ANY;            break;        case ACPI_TYPE_METHOD:            /*             * Allow scope change to root during execution of module-level             * code. Root is typed METHOD during this time.             */            if ((Node == AcpiGbl_RootNode) &&                (WalkState->ParseFlags & ACPI_PARSE_MODULE_LEVEL))            {                break;            }            /*lint -fallthrough */        default:            /* All other types are an error */            ACPI_ERROR ((AE_INFO,                "Invalid type (%s) for target of "                "Scope operator [%4.4s] (Cannot override)",                AcpiUtGetTypeName (Node->Type), AcpiUtGetNodeName (Node)));            return_ACPI_STATUS (AE_AML_OPERAND_TYPE);        }        break;    default:

ACPI_STATUSAcpiNsAttachObject (    ACPI_NAMESPACE_NODE     *Node,    ACPI_OPERAND_OBJECT     *Object,    ACPI_OBJECT_TYPE        Type){    ACPI_OPERAND_OBJECT     *ObjDesc;    ACPI_OPERAND_OBJECT     *LastObjDesc;    ACPI_OBJECT_TYPE        ObjectType = ACPI_TYPE_ANY;    ACPI_FUNCTION_TRACE (NsAttachObject);    /*     * Parameter validation     */    if (!Node)    {        /* Invalid handle */        ACPI_ERROR ((AE_INFO, "Null NamedObj handle"));        return_ACPI_STATUS (AE_BAD_PARAMETER);    }    if (!Object && (ACPI_TYPE_ANY != Type))    {        /* Null object */        ACPI_ERROR ((AE_INFO,            "Null object, but type not ACPI_TYPE_ANY"));        return_ACPI_STATUS (AE_BAD_PARAMETER);    }    if (ACPI_GET_DESCRIPTOR_TYPE (Node) != ACPI_DESC_TYPE_NAMED)    {        /* Not a name handle */        ACPI_ERROR ((AE_INFO, "Invalid handle %p [%s]",            Node, AcpiUtGetDescriptorName (Node)));        return_ACPI_STATUS (AE_BAD_PARAMETER);    }    /* Check if this object is already attached */    if (Node->Object == Object)    {        ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,            "Obj %p already installed in NameObj %p/n",            Object, Node));        return_ACPI_STATUS (AE_OK);    }    /* If null object, we will just install it */    if (!Object)    {        ObjDesc    = NULL;        ObjectType = ACPI_TYPE_ANY;    }    /*     * If the source object is a namespace Node with an attached object,     * we will use that (attached) object     */    else if ((ACPI_GET_DESCRIPTOR_TYPE (Object) == ACPI_DESC_TYPE_NAMED) &&            ((ACPI_NAMESPACE_NODE *) Object)->Object)    {        /*         * Value passed is a name handle and that name has a         * non-null value. Use that name's value and type.         */        ObjDesc = ((ACPI_NAMESPACE_NODE *) Object)->Object;        ObjectType = ((ACPI_NAMESPACE_NODE *) Object)->Type;    }    /*     * Otherwise, we will use the parameter object, but we must type     * it first     */    else    {        ObjDesc = (ACPI_OPERAND_OBJECT  *) Object;        /* Use the given type */        ObjectType = Type;    }    ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Installing %p into Node %p [%4.4s]/n",        ObjDesc, Node, AcpiUtGetNodeName (Node)));    /* Detach an existing attached object if present */    if (Node->Object)    {        AcpiNsDetachObject (Node);    }//.........这里部分代码省略.........

ACPI_STATUSAcpiDsBeginMethodExecution (    ACPI_NAMESPACE_NODE     *MethodNode,    ACPI_OPERAND_OBJECT     *ObjDesc,    ACPI_WALK_STATE         *WalkState){    ACPI_STATUS             Status = AE_OK;    ACPI_FUNCTION_TRACE_PTR (DsBeginMethodExecution, MethodNode);    if (!MethodNode)    {        return_ACPI_STATUS (AE_NULL_ENTRY);    }    AcpiExStartTraceMethod (MethodNode, ObjDesc, WalkState);    /* Prevent wraparound of thread count */    if (ObjDesc->Method.ThreadCount == ACPI_UINT8_MAX)    {        ACPI_ERROR ((AE_INFO,            "Method reached maximum reentrancy limit (255)"));        return_ACPI_STATUS (AE_AML_METHOD_LIMIT);    }    /*     * If this method is serialized, we need to acquire the method mutex.     */    if (ObjDesc->Method.InfoFlags & ACPI_METHOD_SERIALIZED)    {        /*         * Create a mutex for the method if it is defined to be Serialized         * and a mutex has not already been created. We defer the mutex creation         * until a method is actually executed, to minimize the object count         */        if (!ObjDesc->Method.Mutex)        {            Status = AcpiDsCreateMethodMutex (ObjDesc);            if (ACPI_FAILURE (Status))            {                return_ACPI_STATUS (Status);            }        }        /*         * The CurrentSyncLevel (per-thread) must be less than or equal to         * the sync level of the method. This mechanism provides some         * deadlock prevention.         *         * If the method was auto-serialized, we just ignore the sync level         * mechanism, because auto-serialization of methods can interfere         * with ASL code that actually uses sync levels.         *         * Top-level method invocation has no walk state at this point         */        if (WalkState &&            (!(ObjDesc->Method.InfoFlags & ACPI_METHOD_IGNORE_SYNC_LEVEL)) &&            (WalkState->Thread->CurrentSyncLevel >                ObjDesc->Method.Mutex->Mutex.SyncLevel))        {            ACPI_ERROR ((AE_INFO,                "Cannot acquire Mutex for method [%4.4s]"                ", current SyncLevel is too large (%u)",                AcpiUtGetNodeName (MethodNode),                WalkState->Thread->CurrentSyncLevel));            return_ACPI_STATUS (AE_AML_MUTEX_ORDER);        }        /*         * Obtain the method mutex if necessary. Do not acquire mutex for a         * recursive call.         */        if (!WalkState ||            !ObjDesc->Method.Mutex->Mutex.ThreadId ||            (WalkState->Thread->ThreadId !=                ObjDesc->Method.Mutex->Mutex.ThreadId))        {            /*             * Acquire the method mutex. This releases the interpreter if we             * block (and reacquires it before it returns)             */            Status = AcpiExSystemWaitMutex (                ObjDesc->Method.Mutex->Mutex.OsMutex, ACPI_WAIT_FOREVER);            if (ACPI_FAILURE (Status))            {                return_ACPI_STATUS (Status);            }            /* Update the mutex and walk info and save the original SyncLevel */            if (WalkState)            {                ObjDesc->Method.Mutex->Mutex.OriginalSyncLevel =                    WalkState->Thread->CurrentSyncLevel;                ObjDesc->Method.Mutex->Mutex.ThreadId =//.........这里部分代码省略.........

ACPI_STATUSAcpiUtEvaluateObject (    ACPI_NAMESPACE_NODE     *PrefixNode,    char                    *Path,    UINT32                  ExpectedReturnBtypes,    ACPI_OPERAND_OBJECT     **ReturnDesc){    ACPI_EVALUATE_INFO      *Info;    ACPI_STATUS             Status;    UINT32                  ReturnBtype;    ACPI_FUNCTION_TRACE (UtEvaluateObject);    /* Allocate the evaluation information block */    Info = ACPI_ALLOCATE_ZEROED (sizeof (ACPI_EVALUATE_INFO));    if (!Info)    {        return_ACPI_STATUS (AE_NO_MEMORY);    }    Info->PrefixNode = PrefixNode;    Info->Pathname = Path;    /* Evaluate the object/method */    Status = AcpiNsEvaluate (Info);    if (ACPI_FAILURE (Status))    {        if (Status == AE_NOT_FOUND)        {            ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "[%4.4s.%s] was not found/n",                AcpiUtGetNodeName (PrefixNode), Path));        }        else        {            ACPI_ERROR_METHOD ("Method execution failed",                PrefixNode, Path, Status);        }        goto Cleanup;    }    /* Did we get a return object? */    if (!Info->ReturnObject)    {        if (ExpectedReturnBtypes)        {            ACPI_ERROR_METHOD ("No object was returned from",                PrefixNode, Path, AE_NOT_EXIST);            Status = AE_NOT_EXIST;        }        goto Cleanup;    }    /* Map the return object type to the bitmapped type */    switch ((Info->ReturnObject)->Common.Type)    {    case ACPI_TYPE_INTEGER:        ReturnBtype = ACPI_BTYPE_INTEGER;        break;    case ACPI_TYPE_BUFFER:        ReturnBtype = ACPI_BTYPE_BUFFER;        break;    case ACPI_TYPE_STRING:        ReturnBtype = ACPI_BTYPE_STRING;        break;    case ACPI_TYPE_PACKAGE:        ReturnBtype = ACPI_BTYPE_PACKAGE;        break;    default:        ReturnBtype = 0;        break;    }    if ((AcpiGbl_EnableInterpreterSlack) &&        (!ExpectedReturnBtypes))    {        /*         * We received a return object, but one was not expected.  This can         * happen frequently if the "implicit return" feature is enabled.         * Just delete the return object and return AE_OK.         */        AcpiUtRemoveReference (Info->ReturnObject);        goto Cleanup;    }    /* Is the return object one of the expected types? */    if (!(ExpectedReturnBtypes & ReturnBtype))//.........这里部分代码省略.........

//.........这里部分代码省略.........    }    Status = AcpiUtAcquireMutex (ACPI_MTX_EVENTS);    if (ACPI_FAILURE (Status))    {        return_VOID;    }    /* Must revalidate the GpeNumber/GpeBlock */    if (!AcpiEvValidGpeEvent (GpeEventInfo))    {        Status = AcpiUtReleaseMutex (ACPI_MTX_EVENTS);        return_VOID;    }    /*     * Take a snapshot of the GPE info for this level - we copy the info to     * prevent a race condition with RemoveHandler/RemoveBlock.     */    ACPI_MEMCPY (LocalGpeEventInfo, GpeEventInfo,        sizeof (ACPI_GPE_EVENT_INFO));    Status = AcpiUtReleaseMutex (ACPI_MTX_EVENTS);    if (ACPI_FAILURE (Status))    {        return_VOID;    }    /* Do the correct dispatch - normal method or implicit notify */    switch (LocalGpeEventInfo->Flags & ACPI_GPE_DISPATCH_MASK)    {    case ACPI_GPE_DISPATCH_NOTIFY:        /*         * Implicit notify.         * Dispatch a DEVICE_WAKE notify to the appropriate handler.         * NOTE: the request is queued for execution after this method         * completes. The notify handlers are NOT invoked synchronously         * from this thread -- because handlers may in turn run other         * control methods.         *         * June 2012: Expand implicit notify mechanism to support         * notifies on multiple device objects.         */        Notify = LocalGpeEventInfo->Dispatch.NotifyList;        while (ACPI_SUCCESS (Status) && Notify)        {            Status = AcpiEvQueueNotifyRequest (Notify->DeviceNode,                        ACPI_NOTIFY_DEVICE_WAKE);            Notify = Notify->Next;        }        break;    case ACPI_GPE_DISPATCH_METHOD:        /* Allocate the evaluation information block */        Info = ACPI_ALLOCATE_ZEROED (sizeof (ACPI_EVALUATE_INFO));        if (!Info)        {            Status = AE_NO_MEMORY;        }        else        {            /*             * Invoke the GPE Method (_Lxx, _Exx) i.e., evaluate the             * _Lxx/_Exx control method that corresponds to this GPE             */            Info->PrefixNode = LocalGpeEventInfo->Dispatch.MethodNode;            Info->Flags = ACPI_IGNORE_RETURN_VALUE;            Status = AcpiNsEvaluate (Info);            ACPI_FREE (Info);        }        if (ACPI_FAILURE (Status))        {            ACPI_EXCEPTION ((AE_INFO, Status,                "while evaluating GPE method [%4.4s]",                AcpiUtGetNodeName (LocalGpeEventInfo->Dispatch.MethodNode)));        }        break;    default:        return_VOID; /* Should never happen */    }    /* Defer enabling of GPE until all notify handlers are done */    Status = AcpiOsExecute (OSL_NOTIFY_HANDLER,                AcpiEvAsynchEnableGpe, LocalGpeEventInfo);    if (ACPI_FAILURE (Status))    {        ACPI_FREE (LocalGpeEventInfo);    }    return_VOID;}

ACPI_STATUSAcpiExAcquireMutex (    ACPI_OPERAND_OBJECT     *TimeDesc,    ACPI_OPERAND_OBJECT     *ObjDesc,    ACPI_WALK_STATE         *WalkState){    ACPI_STATUS             Status;    ACPI_FUNCTION_TRACE_PTR (ExAcquireMutex, ObjDesc);    if (!ObjDesc)    {        return_ACPI_STATUS (AE_BAD_PARAMETER);    }    /* Sanity check: we must have a valid thread ID */    if (!WalkState->Thread)    {        ACPI_ERROR ((AE_INFO, "Cannot acquire Mutex [%4.4s], null thread info",            AcpiUtGetNodeName (ObjDesc->Mutex.Node)));        return_ACPI_STATUS (AE_AML_INTERNAL);    }    /*     * Current Sync must be less than or equal to the sync level of the     * mutex. This mechanism provides some deadlock prevention     */    if (WalkState->Thread->CurrentSyncLevel > ObjDesc->Mutex.SyncLevel)    {        ACPI_ERROR ((AE_INFO,            "Cannot acquire Mutex [%4.4s], current SyncLevel is too large (%d)",            AcpiUtGetNodeName (ObjDesc->Mutex.Node),            WalkState->Thread->CurrentSyncLevel));        return_ACPI_STATUS (AE_AML_MUTEX_ORDER);    }    /* Support for multiple acquires by the owning thread */    if (ObjDesc->Mutex.OwnerThread)    {        if (ObjDesc->Mutex.OwnerThread->ThreadId ==            WalkState->Thread->ThreadId)        {            /*             * The mutex is already owned by this thread, just increment the             * acquisition depth             */            ObjDesc->Mutex.AcquisitionDepth++;            return_ACPI_STATUS (AE_OK);        }    }    /* Acquire the mutex, wait if necessary. Special case for Global Lock */    if (ObjDesc->Mutex.OsMutex == AcpiGbl_GlobalLockMutex)    {        Status = AcpiEvAcquireGlobalLock ((UINT16) TimeDesc->Integer.Value);    }    else    {        Status = AcpiExSystemWaitMutex (ObjDesc->Mutex.OsMutex,                    (UINT16) TimeDesc->Integer.Value);    }    if (ACPI_FAILURE (Status))    {        /* Includes failure from a timeout on TimeDesc */        return_ACPI_STATUS (Status);    }    /* Have the mutex: update mutex and walk info and save the SyncLevel */    ObjDesc->Mutex.OwnerThread = WalkState->Thread;    ObjDesc->Mutex.AcquisitionDepth = 1;    ObjDesc->Mutex.OriginalSyncLevel = WalkState->Thread->CurrentSyncLevel;    WalkState->Thread->CurrentSyncLevel = ObjDesc->Mutex.SyncLevel;    /* Link the mutex to the current thread for force-unlock at method exit */    AcpiExLinkMutex (ObjDesc, WalkState->Thread);    return_ACPI_STATUS (AE_OK);}

ACPI_STATUSAcpiExReleaseMutex (    ACPI_OPERAND_OBJECT     *ObjDesc,    ACPI_WALK_STATE         *WalkState){    ACPI_STATUS             Status = AE_OK;    ACPI_FUNCTION_TRACE (ExReleaseMutex);    if (!ObjDesc)    {        return_ACPI_STATUS (AE_BAD_PARAMETER);    }    /* The mutex must have been previously acquired in order to release it */    if (!ObjDesc->Mutex.OwnerThread)    {        ACPI_ERROR ((AE_INFO, "Cannot release Mutex [%4.4s], not acquired",            AcpiUtGetNodeName (ObjDesc->Mutex.Node)));        return_ACPI_STATUS (AE_AML_MUTEX_NOT_ACQUIRED);    }    /* Sanity check: we must have a valid thread ID */    if (!WalkState->Thread)    {        ACPI_ERROR ((AE_INFO, "Cannot release Mutex [%4.4s], null thread info",            AcpiUtGetNodeName (ObjDesc->Mutex.Node)));        return_ACPI_STATUS (AE_AML_INTERNAL);    }    /*     * The Mutex is owned, but this thread must be the owner.     * Special case for Global Lock, any thread can release     */    if ((ObjDesc->Mutex.OwnerThread->ThreadId != WalkState->Thread->ThreadId) &&        (ObjDesc->Mutex.OsMutex != AcpiGbl_GlobalLockMutex))    {        ACPI_ERROR ((AE_INFO,            "Thread %X cannot release Mutex [%4.4s] acquired by thread %X",            WalkState->Thread->ThreadId,            AcpiUtGetNodeName (ObjDesc->Mutex.Node),            ObjDesc->Mutex.OwnerThread->ThreadId));        return_ACPI_STATUS (AE_AML_NOT_OWNER);    }    /*     * The sync level of the mutex must be less than or equal to the current     * sync level     */    if (ObjDesc->Mutex.SyncLevel > WalkState->Thread->CurrentSyncLevel)    {        ACPI_ERROR ((AE_INFO,            "Cannot release Mutex [%4.4s], incorrect SyncLevel",            AcpiUtGetNodeName (ObjDesc->Mutex.Node)));        return_ACPI_STATUS (AE_AML_MUTEX_ORDER);    }    /* Match multiple Acquires with multiple Releases */    ObjDesc->Mutex.AcquisitionDepth--;    if (ObjDesc->Mutex.AcquisitionDepth != 0)    {        /* Just decrement the depth and return */        return_ACPI_STATUS (AE_OK);    }    /* Unlink the mutex from the owner's list */    AcpiExUnlinkMutex (ObjDesc);    /* Release the mutex, special case for Global Lock */    if (ObjDesc->Mutex.OsMutex == AcpiGbl_GlobalLockMutex)    {        Status = AcpiEvReleaseGlobalLock ();    }    else    {        AcpiOsReleaseMutex (ObjDesc->Mutex.OsMutex);    }    /* Update the mutex and restore SyncLevel */    ObjDesc->Mutex.OwnerThread = NULL;    WalkState->Thread->CurrentSyncLevel = ObjDesc->Mutex.OriginalSyncLevel;    return_ACPI_STATUS (Status);}

voidAcpiNsInstallNode (    ACPI_WALK_STATE         *WalkState,    ACPI_NAMESPACE_NODE     *ParentNode,    /* Parent */    ACPI_NAMESPACE_NODE     *Node,          /* New Child*/    ACPI_OBJECT_TYPE        Type){    ACPI_OWNER_ID           OwnerId = 0;    ACPI_NAMESPACE_NODE     *ChildNode;    ACPI_FUNCTION_TRACE (NsInstallNode);    if (WalkState)    {        /*         * Get the owner ID from the Walk state. The owner ID is used to         * track table deletion and deletion of objects created by methods.         */        OwnerId = WalkState->OwnerId;        if ((WalkState->MethodDesc) &&            (ParentNode != WalkState->MethodNode))        {            /*             * A method is creating a new node that is not a child of the             * method (it is non-local). Mark the executing method as having             * modified the namespace. This is used for cleanup when the             * method exits.             */            WalkState->MethodDesc->Method.InfoFlags |=                ACPI_METHOD_MODIFIED_NAMESPACE;        }    }    /* Link the new entry into the parent and existing children */    Node->Peer = NULL;    Node->Parent = ParentNode;    ChildNode = ParentNode->Child;    if (!ChildNode)    {        ParentNode->Child = Node;    }    else    {        /* Add node to the end of the peer list */        while (ChildNode->Peer)        {            ChildNode = ChildNode->Peer;        }        ChildNode->Peer = Node;    }    /* Init the new entry */    Node->OwnerId = OwnerId;    Node->Type = (UINT8) Type;    ACPI_DEBUG_PRINT ((ACPI_DB_NAMES,        "%4.4s (%s) [Node %p Owner %X] added to %4.4s (%s) [Node %p]/n",        AcpiUtGetNodeName (Node), AcpiUtGetTypeName (Node->Type), Node, OwnerId,        AcpiUtGetNodeName (ParentNode), AcpiUtGetTypeName (ParentNode->Type),        ParentNode));    return_VOID;}

ACPI_STATUSAcpiEvQueueNotifyRequest (    ACPI_NAMESPACE_NODE     *Node,    UINT32                  NotifyValue){    ACPI_OPERAND_OBJECT     *ObjDesc;    ACPI_OPERAND_OBJECT     *HandlerListHead = NULL;    ACPI_GENERIC_STATE      *Info;    UINT8                   HandlerListId = 0;    ACPI_STATUS             Status = AE_OK;    ACPI_FUNCTION_NAME (EvQueueNotifyRequest);    /* Are Notifies allowed on this object? */    if (!AcpiEvIsNotifyObject (Node))    {        return (AE_TYPE);    }    /* Get the correct notify list type (System or Device) */    if (NotifyValue <= ACPI_MAX_SYS_NOTIFY)    {        HandlerListId = ACPI_SYSTEM_HANDLER_LIST;    }    else    {        HandlerListId = ACPI_DEVICE_HANDLER_LIST;    }    /* Get the notify object attached to the namespace Node */    ObjDesc = AcpiNsGetAttachedObject (Node);    if (ObjDesc)    {        /* We have an attached object, Get the correct handler list */        HandlerListHead = ObjDesc->CommonNotify.NotifyList[HandlerListId];    }    /*     * If there is no notify handler (Global or Local)     * for this object, just ignore the notify     */    if (!AcpiGbl_GlobalNotify[HandlerListId].Handler && !HandlerListHead)    {        ACPI_DEBUG_PRINT ((ACPI_DB_INFO,            "No notify handler for Notify, ignoring (%4.4s, %X) node %p/n",            AcpiUtGetNodeName (Node), NotifyValue, Node));        return (AE_OK);    }    /* Setup notify info and schedule the notify dispatcher */    Info = AcpiUtCreateGenericState ();    if (!Info)    {        return (AE_NO_MEMORY);    }    Info->Common.DescriptorType = ACPI_DESC_TYPE_STATE_NOTIFY;    Info->Notify.Node = Node;    Info->Notify.Value = (UINT16) NotifyValue;    Info->Notify.HandlerListId = HandlerListId;    Info->Notify.HandlerListHead = HandlerListHead;    Info->Notify.Global = &AcpiGbl_GlobalNotify[HandlerListId];    ACPI_DEBUG_PRINT ((ACPI_DB_INFO,        "Dispatching Notify on [%4.4s] (%s) Value 0x%2.2X (%s) Node %p/n",        AcpiUtGetNodeName (Node), AcpiUtGetTypeName (Node->Type),        NotifyValue, AcpiUtGetNotifyName (NotifyValue), Node));    Status = AcpiOsExecute (OSL_NOTIFY_HANDLER, AcpiEvNotifyDispatch,        Info);    if (ACPI_FAILURE (Status))    {        AcpiUtDeleteGenericState (Info);    }    return (Status);}

static voidAeCommonNotifyHandler (    ACPI_HANDLE             Device,    UINT32                  Value,    UINT32                  HandlerId){    char                    *Type;    Type = "Device";    if (Value <= ACPI_MAX_SYS_NOTIFY)    {        Type = "System";    }    switch (Value)    {#if 0    case 0:        printf ("[AcpiExec] Method Error 0x%X: Results not equal/n", Value);        if (AcpiGbl_DebugFile)        {            AcpiOsPrintf ("[AcpiExec] Method Error: Results not equal/n");        }        break;    case 1:        printf ("[AcpiExec] Method Error: Incorrect numeric result/n");        if (AcpiGbl_DebugFile)        {            AcpiOsPrintf ("[AcpiExec] Method Error: Incorrect numeric result/n");        }        break;    case 2:        printf ("[AcpiExec] Method Error: An operand was overwritten/n");        if (AcpiGbl_DebugFile)        {            AcpiOsPrintf ("[AcpiExec] Method Error: An operand was overwritten/n");        }        break;#endif    default:        printf ("[AcpiExec] Handler %u: Received a %s Notify on [%4.4s] %p Value 0x%2.2X (%s)/n",            HandlerId, Type, AcpiUtGetNodeName (Device), Device, Value,            AcpiUtGetNotifyName (Value, ACPI_TYPE_ANY));        if (AcpiGbl_DebugFile)        {            AcpiOsPrintf ("[AcpiExec] Handler %u: Received a %s notify, Value 0x%2.2X/n",                HandlerId, Type, Value);        }        (void) AcpiEvaluateObject (Device, "_NOT", NULL, NULL);        break;    }}

//.........这里部分代码省略.........        AcpiUtAddReference (ObjDesc->BankField.RegionObj);        AcpiUtAddReference (ObjDesc->BankField.BankObj);        ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,            "Bank Field: BitOff %X, Off %X, Gran %X, Region %p, BankReg %p/n",            ObjDesc->BankField.StartFieldBitOffset,            ObjDesc->BankField.BaseByteOffset,            ObjDesc->Field.AccessByteWidth,            ObjDesc->BankField.RegionObj,            ObjDesc->BankField.BankObj));        /*         * Remember location in AML stream of the field unit         * opcode and operands -- since the BankValue         * operands must be evaluated.         */        SecondDesc = ObjDesc->Common.NextObject;        SecondDesc->Extra.AmlStart = ACPI_CAST_PTR (ACPI_PARSE_OBJECT,            Info->DataRegisterNode)->Named.Data;        SecondDesc->Extra.AmlLength = ACPI_CAST_PTR (ACPI_PARSE_OBJECT,            Info->DataRegisterNode)->Named.Length;        break;    case ACPI_TYPE_LOCAL_INDEX_FIELD:        /* Get the Index and Data registers */        ObjDesc->IndexField.IndexObj =            AcpiNsGetAttachedObject (Info->RegisterNode);        ObjDesc->IndexField.DataObj =            AcpiNsGetAttachedObject (Info->DataRegisterNode);        if (!ObjDesc->IndexField.DataObj || !ObjDesc->IndexField.IndexObj)        {            ACPI_ERROR ((AE_INFO, "Null Index Object during field prep"));            AcpiUtDeleteObjectDesc (ObjDesc);            return_ACPI_STATUS (AE_AML_INTERNAL);        }        /* An additional reference for the attached objects */        AcpiUtAddReference (ObjDesc->IndexField.DataObj);        AcpiUtAddReference (ObjDesc->IndexField.IndexObj);        /*         * April 2006: Changed to match MS behavior         *         * The value written to the Index register is the byte offset of the         * target field in units of the granularity of the IndexField         *         * Previously, the value was calculated as an index in terms of the         * width of the Data register, as below:         *         *      ObjDesc->IndexField.Value = (UINT32)         *          (Info->FieldBitPosition / ACPI_MUL_8 (         *              ObjDesc->Field.AccessByteWidth));         *         * February 2006: Tried value as a byte offset:         *      ObjDesc->IndexField.Value = (UINT32)         *          ACPI_DIV_8 (Info->FieldBitPosition);         */        ObjDesc->IndexField.Value = (UINT32) ACPI_ROUND_DOWN (            ACPI_DIV_8 (Info->FieldBitPosition),            ObjDesc->IndexField.AccessByteWidth);        ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,            "IndexField: BitOff %X, Off %X, Value %X, "            "Gran %X, Index %p, Data %p/n",            ObjDesc->IndexField.StartFieldBitOffset,            ObjDesc->IndexField.BaseByteOffset,            ObjDesc->IndexField.Value,            ObjDesc->Field.AccessByteWidth,            ObjDesc->IndexField.IndexObj,            ObjDesc->IndexField.DataObj));        break;    default:        /* No other types should get here */        break;    }    /*     * Store the constructed descriptor (ObjDesc) into the parent Node,     * preserving the current type of that NamedObj.     */    Status = AcpiNsAttachObject (        Info->FieldNode, ObjDesc, AcpiNsGetType (Info->FieldNode));    ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,        "Set NamedObj %p [%4.4s], ObjDesc %p/n",        Info->FieldNode, AcpiUtGetNodeName (Info->FieldNode), ObjDesc));    /* Remove local reference to the object */    AcpiUtRemoveReference (ObjDesc);    return_ACPI_STATUS (Status);}

voidAcpiNsDetachObject (    ACPI_NAMESPACE_NODE     *Node){    ACPI_OPERAND_OBJECT     *ObjDesc;    ACPI_FUNCTION_TRACE (NsDetachObject);    ObjDesc = Node->Object;    if (!ObjDesc ||        (ObjDesc->Common.Type == ACPI_TYPE_LOCAL_DATA))    {        return_VOID;    }    if (Node->Flags & ANOBJ_ALLOCATED_BUFFER)    {        /* Free the dynamic aml buffer */        if (ObjDesc->Common.Type == ACPI_TYPE_METHOD)        {            ACPI_FREE (ObjDesc->Method.AmlStart);        }    }    /* Clear the Node entry in all cases */    Node->Object = NULL;    if (ACPI_GET_DESCRIPTOR_TYPE (ObjDesc) == ACPI_DESC_TYPE_OPERAND)    {        /* Unlink object from front of possible object list */        Node->Object = ObjDesc->Common.NextObject;        /* Handle possible 2-descriptor object */        if (Node->Object &&           (Node->Object->Common.Type != ACPI_TYPE_LOCAL_DATA))        {            Node->Object = Node->Object->Common.NextObject;        }        /*         * Detach the object from any data objects (which are still held by         * the namespace node)         */        if (ObjDesc->Common.NextObject &&           ((ObjDesc->Common.NextObject)->Common.Type == ACPI_TYPE_LOCAL_DATA))        {           ObjDesc->Common.NextObject = NULL;        }    }    /* Reset the node type to untyped */    Node->Type = ACPI_TYPE_ANY;    ACPI_DEBUG_PRINT ((ACPI_DB_NAMES, "Node %p [%4.4s] Object %p/n",        Node, AcpiUtGetNodeName (Node), ObjDesc));    /* Remove one reference on the object (and all subobjects) */    AcpiUtRemoveReference (ObjDesc);    return_VOID;}

ACPI_STATUSAcpiDsScopeStackPush (    ACPI_NAMESPACE_NODE     *Node,    ACPI_OBJECT_TYPE        Type,    ACPI_WALK_STATE         *WalkState){    ACPI_GENERIC_STATE      *ScopeInfo;    ACPI_GENERIC_STATE      *OldScopeInfo;    ACPI_FUNCTION_TRACE (DsScopeStackPush);    if (!Node)    {        /* Invalid scope   */        ACPI_ERROR ((AE_INFO, "Null scope parameter"));        return_ACPI_STATUS (AE_BAD_PARAMETER);    }    /* Make sure object type is valid */    if (!AcpiUtValidObjectType (Type))    {        ACPI_WARNING ((AE_INFO,            "Invalid object type: 0x%X", Type));    }    /* Allocate a new scope object */    ScopeInfo = AcpiUtCreateGenericState ();    if (!ScopeInfo)    {        return_ACPI_STATUS (AE_NO_MEMORY);    }    /* Init new scope object */    ScopeInfo->Common.DescriptorType = ACPI_DESC_TYPE_STATE_WSCOPE;    ScopeInfo->Scope.Node = Node;    ScopeInfo->Common.Value = (UINT16) Type;    WalkState->ScopeDepth++;    ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,        "[%.2d] Pushed scope ", (UINT32) WalkState->ScopeDepth));    OldScopeInfo = WalkState->ScopeInfo;    if (OldScopeInfo)    {        ACPI_DEBUG_PRINT_RAW ((ACPI_DB_EXEC,            "[%4.4s] (%s)",            AcpiUtGetNodeName (OldScopeInfo->Scope.Node),            AcpiUtGetTypeName (OldScopeInfo->Common.Value)));    }    else    {        ACPI_DEBUG_PRINT_RAW ((ACPI_DB_EXEC,            "[//___] (%s)", "ROOT"));    }    ACPI_DEBUG_PRINT_RAW ((ACPI_DB_EXEC,        ", New scope -> [%4.4s] (%s)/n",        AcpiUtGetNodeName (ScopeInfo->Scope.Node),        AcpiUtGetTypeName (ScopeInfo->Common.Value)));    /* Push new scope object onto stack */    AcpiUtPushGenericState (&WalkState->ScopeInfo, ScopeInfo);    return_ACPI_STATUS (AE_OK);}

ACPI_STATUSAcpiEvAddressSpaceDispatch (    ACPI_OPERAND_OBJECT     *RegionObj,    ACPI_OPERAND_OBJECT     *FieldObj,    UINT32                  Function,    UINT32                  RegionOffset,    UINT32                  BitWidth,    UINT64                  *Value){    ACPI_STATUS             Status;    ACPI_ADR_SPACE_HANDLER  Handler;    ACPI_ADR_SPACE_SETUP    RegionSetup;    ACPI_OPERAND_OBJECT     *HandlerDesc;    ACPI_OPERAND_OBJECT     *RegionObj2;    void                    *RegionContext = NULL;    ACPI_CONNECTION_INFO    *Context;    ACPI_FUNCTION_TRACE (EvAddressSpaceDispatch);    RegionObj2 = AcpiNsGetSecondaryObject (RegionObj);    if (!RegionObj2)    {        return_ACPI_STATUS (AE_NOT_EXIST);    }    /* Ensure that there is a handler associated with this region */    HandlerDesc = RegionObj->Region.Handler;    if (!HandlerDesc)    {        ACPI_ERROR ((AE_INFO,            "No handler for Region [%4.4s] (%p) [%s]",            AcpiUtGetNodeName (RegionObj->Region.Node),            RegionObj, AcpiUtGetRegionName (RegionObj->Region.SpaceId)));        return_ACPI_STATUS (AE_NOT_EXIST);    }    Context = HandlerDesc->AddressSpace.Context;    /*     * It may be the case that the region has never been initialized.     * Some types of regions require special init code     */    if (!(RegionObj->Region.Flags & AOPOBJ_SETUP_COMPLETE))    {        /* This region has not been initialized yet, do it */        RegionSetup = HandlerDesc->AddressSpace.Setup;        if (!RegionSetup)        {            /* No initialization routine, exit with error */            ACPI_ERROR ((AE_INFO,                "No init routine for region(%p) [%s]",                RegionObj, AcpiUtGetRegionName (RegionObj->Region.SpaceId)));            return_ACPI_STATUS (AE_NOT_EXIST);        }        /*         * We must exit the interpreter because the region setup will         * potentially execute control methods (for example, the _REG method         * for this region)         */        AcpiExExitInterpreter ();        Status = RegionSetup (RegionObj, ACPI_REGION_ACTIVATE,                    Context, &RegionContext);        /* Re-enter the interpreter */        AcpiExEnterInterpreter ();        /* Check for failure of the Region Setup */        if (ACPI_FAILURE (Status))        {            ACPI_EXCEPTION ((AE_INFO, Status,                "During region initialization: [%s]",                AcpiUtGetRegionName (RegionObj->Region.SpaceId)));            return_ACPI_STATUS (Status);        }        /* Region initialization may have been completed by RegionSetup */        if (!(RegionObj->Region.Flags & AOPOBJ_SETUP_COMPLETE))        {            RegionObj->Region.Flags |= AOPOBJ_SETUP_COMPLETE;            if (RegionObj2->Extra.RegionContext)            {                /* The handler for this region was already installed */                ACPI_FREE (RegionContext);            }            else            {                /*//.........这里部分代码省略.........

//.........这里部分代码省略.........        Info->OpRegionCount++;        break;    case ACPI_TYPE_BUFFER_FIELD:        Info->FieldCount++;        break;    case ACPI_TYPE_LOCAL_BANK_FIELD:        Info->FieldCount++;        break;    case ACPI_TYPE_BUFFER:        Info->BufferCount++;        break;    case ACPI_TYPE_PACKAGE:        Info->PackageCount++;        break;    default:        /* No init required, just exit now */        return (AE_OK);    }    /* If the object is already initialized, nothing else to do */    if (ObjDesc->Common.Flags & AOPOBJ_DATA_VALID)    {        return (AE_OK);    }    /* Must lock the interpreter before executing AML code */    AcpiExEnterInterpreter ();    /*     * Each of these types can contain executable AML code within the     * declaration.     */    switch (Type)    {    case ACPI_TYPE_REGION:        Info->OpRegionInit++;        Status = AcpiDsGetRegionArguments (ObjDesc);        break;    case ACPI_TYPE_BUFFER_FIELD:        Info->FieldInit++;        Status = AcpiDsGetBufferFieldArguments (ObjDesc);        break;    case ACPI_TYPE_LOCAL_BANK_FIELD:        Info->FieldInit++;        Status = AcpiDsGetBankFieldArguments (ObjDesc);        break;    case ACPI_TYPE_BUFFER:        Info->BufferInit++;        Status = AcpiDsGetBufferArguments (ObjDesc);        break;    case ACPI_TYPE_PACKAGE:        Info->PackageInit++;        Status = AcpiDsGetPackageArguments (ObjDesc);        break;    default:        /* No other types can get here */        break;    }    if (ACPI_FAILURE (Status))    {        ACPI_EXCEPTION ((AE_INFO, Status,            "Could not execute arguments for [%4.4s] (%s)",            AcpiUtGetNodeName (Node), AcpiUtGetTypeName (Type)));    }    /*     * Print a dot for each object unless we are going to print the entire     * pathname     */    if (!(AcpiDbgLevel & ACPI_LV_INIT_NAMES))    {        ACPI_DEBUG_PRINT_RAW ((ACPI_DB_INIT, "."));    }    /*     * We ignore errors from above, and always return OK, since we don't want     * to abort the walk on any single error.     */    AcpiExExitInterpreter ();    return (AE_OK);}

ACPI_STATUSAcpiDsRestartControlMethod (    ACPI_WALK_STATE         *WalkState,    ACPI_OPERAND_OBJECT     *ReturnDesc){    ACPI_STATUS             Status;    int                     SameAsImplicitReturn;    ACPI_FUNCTION_TRACE_PTR (DsRestartControlMethod, WalkState);    ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,        "****Restart [%4.4s] Op %p ReturnValueFromCallee %p/n",        AcpiUtGetNodeName (WalkState->MethodNode),        WalkState->MethodCallOp, ReturnDesc));    ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,        "    ReturnFromThisMethodUsed?=%X ResStack %p Walk %p/n",        WalkState->ReturnUsed,        WalkState->Results, WalkState));    /* Did the called method return a value? */    if (ReturnDesc)    {        /* Is the implicit return object the same as the return desc? */        SameAsImplicitReturn = (WalkState->ImplicitReturnObj == ReturnDesc);        /* Are we actually going to use the return value? */        if (WalkState->ReturnUsed)        {            /* Save the return value from the previous method */            Status = AcpiDsResultPush (ReturnDesc, WalkState);            if (ACPI_FAILURE (Status))            {                AcpiUtRemoveReference (ReturnDesc);                return_ACPI_STATUS (Status);            }            /*             * Save as THIS method's return value in case it is returned             * immediately to yet another method             */            WalkState->ReturnDesc = ReturnDesc;        }        /*         * The following code is the optional support for the so-called         * "implicit return". Some AML code assumes that the last value of the         * method is "implicitly" returned to the caller, in the absence of an         * explicit return value.         *         * Just save the last result of the method as the return value.         *         * NOTE: this is optional because the ASL language does not actually         * support this behavior.         */        else if (!AcpiDsDoImplicitReturn (ReturnDesc, WalkState, FALSE) ||                 SameAsImplicitReturn)        {            /*             * Delete the return value if it will not be used by the             * calling method or remove one reference if the explicit return             * is the same as the implicit return value.             */            AcpiUtRemoveReference (ReturnDesc);        }    }    return_ACPI_STATUS (AE_OK);}

voidAcpiDmDumpMethodInfo (    ACPI_STATUS             Status,    ACPI_WALK_STATE         *WalkState,    ACPI_PARSE_OBJECT       *Op){    ACPI_PARSE_OBJECT       *Next;    ACPI_THREAD_STATE       *Thread;    ACPI_WALK_STATE         *NextWalkState;    ACPI_NAMESPACE_NODE     *PreviousMethod = NULL;    /* Ignore control codes, they are not errors */    if ((Status & AE_CODE_MASK) == AE_CODE_CONTROL)    {        return;    }    /* We may be executing a deferred opcode */    if (WalkState->DeferredNode)    {        AcpiOsPrintf ("Executing subtree for Buffer/Package/Region/n");        return;    }    /*     * If there is no Thread, we are not actually executing a method.     * This can happen when the iASL compiler calls the interpreter     * to perform constant folding.     */    Thread = WalkState->Thread;    if (!Thread)    {        return;    }    /* Display exception and method name */    AcpiOsPrintf ("/n**** Exception %s during execution of method ",        AcpiFormatException (Status));    AcpiNsPrintNodePathname (WalkState->MethodNode, NULL);    /* Display stack of executing methods */    AcpiOsPrintf ("/n/nMethod Execution Stack:/n");    NextWalkState = Thread->WalkStateList;    /* Walk list of linked walk states */    while (NextWalkState)    {        AcpiOsPrintf ("    Method [%4.4s] executing: ",                AcpiUtGetNodeName (NextWalkState->MethodNode));        /* First method is the currently executing method */        if (NextWalkState == WalkState)        {            if (Op)            {                /* Display currently executing ASL statement */                Next = Op->Common.Next;                Op->Common.Next = NULL;                AcpiDmDisassemble (NextWalkState, Op, ACPI_UINT32_MAX);                Op->Common.Next = Next;            }        }        else        {            /*             * This method has called another method             * NOTE: the method call parse subtree is already deleted at this             * point, so we cannot disassemble the method invocation.             */            AcpiOsPrintf ("Call to method ");            AcpiNsPrintNodePathname (PreviousMethod, NULL);        }        PreviousMethod = NextWalkState->MethodNode;        NextWalkState = NextWalkState->Next;        AcpiOsPrintf ("/n");    }    /* Display the method locals and arguments */    AcpiOsPrintf ("/n");    AcpiDmDisplayLocals (WalkState);    AcpiOsPrintf ("/n");    AcpiDmDisplayArguments (WalkState);    AcpiOsPrintf ("/n");}

//.........这里部分代码省略.........        /*         * Name pointer is valid (and must be in internal name format)         *         * Check for scope prefixes:         *         * As represented in the AML stream, a namepath consists of an         * optional scope prefix followed by a name segment part.         *         * If present, the scope prefix is either a Root Prefix (in         * which case the name is fully qualified), or one or more         * Parent Prefixes (in which case the name's scope is relative         * to the current scope).         */        if (*Path == (UINT8) AML_ROOT_PREFIX)        {            /* Pathname is fully qualified, start from the root */            ThisNode = AcpiGbl_RootNode;            SearchParentFlag = ACPI_NS_NO_UPSEARCH;            /* Point to name segment part */            Path++;            ACPI_DEBUG_PRINT ((ACPI_DB_NAMES,                               "Path is absolute from root [%p]/n", ThisNode));        }        else        {            /* Pathname is relative to current scope, start there */            ACPI_DEBUG_PRINT ((ACPI_DB_NAMES,                               "Searching relative to prefix scope [%4.4s] (%p)/n",                               AcpiUtGetNodeName (PrefixNode), PrefixNode));            /*             * Handle multiple Parent Prefixes (carat) by just getting             * the parent node for each prefix instance.             */            ThisNode = PrefixNode;            NumCarats = 0;            while (*Path == (UINT8) AML_PARENT_PREFIX)            {                /* Name is fully qualified, no search rules apply */                SearchParentFlag = ACPI_NS_NO_UPSEARCH;                /*                 * Point past this prefix to the name segment                 * part or the next Parent Prefix                 */                Path++;                /* Backup to the parent node */                NumCarats++;                ThisNode = ThisNode->Parent;                if (!ThisNode)                {                    /* Current scope has no parent scope */                    ACPI_ERROR ((AE_INFO,                                 "ACPI path has too many parent prefixes (^) "                                 "- reached beyond root node"));                    return_ACPI_STATUS (AE_NOT_FOUND);                }

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://.........这里部分代码省略.........

//.........这里部分代码省略.........        break;    case AML_CREATE_WORD_FIELD_OP:        /* Offset is in bytes, field is one word */        BitOffset  = 8 * Offset;        BitCount   = 16;        FieldFlags = AML_FIELD_ACCESS_WORD;        break;    case AML_CREATE_DWORD_FIELD_OP:        /* Offset is in bytes, field is one dword */        BitOffset  = 8 * Offset;        BitCount   = 32;        FieldFlags = AML_FIELD_ACCESS_DWORD;        break;    case AML_CREATE_QWORD_FIELD_OP:        /* Offset is in bytes, field is one qword */        BitOffset  = 8 * Offset;        BitCount   = 64;        FieldFlags = AML_FIELD_ACCESS_QWORD;        break;    default:        ACPI_ERROR ((AE_INFO,            "Unknown field creation opcode 0x%02X",            AmlOpcode));        Status = AE_AML_BAD_OPCODE;        goto Cleanup;    }    /* Entire field must fit within the current length of the buffer */    if ((BitOffset + BitCount) >        (8 * (UINT32) BufferDesc->Buffer.Length))    {        ACPI_ERROR ((AE_INFO,            "Field [%4.4s] at %u exceeds Buffer [%4.4s] size %u (bits)",            AcpiUtGetNodeName (ResultDesc),            BitOffset + BitCount,            AcpiUtGetNodeName (BufferDesc->Buffer.Node),            8 * (UINT32) BufferDesc->Buffer.Length));        Status = AE_AML_BUFFER_LIMIT;        goto Cleanup;    }    /*     * Initialize areas of the field object that are common to all fields     * For FieldFlags, use LOCK_RULE = 0 (NO_LOCK),     * UPDATE_RULE = 0 (UPDATE_PRESERVE)     */    Status = AcpiExPrepCommonFieldObject (ObjDesc, FieldFlags, 0,                                            BitOffset, BitCount);    if (ACPI_FAILURE (Status))    {        goto Cleanup;    }    ObjDesc->BufferField.BufferObj = BufferDesc;    /* Reference count for BufferDesc inherits ObjDesc count */    BufferDesc->Common.ReferenceCount = (UINT16)        (BufferDesc->Common.ReferenceCount + ObjDesc->Common.ReferenceCount);Cleanup:    /* Always delete the operands */    AcpiUtRemoveReference (OffsetDesc);    AcpiUtRemoveReference (BufferDesc);    if (AmlOpcode == AML_CREATE_FIELD_OP)    {        AcpiUtRemoveReference (LengthDesc);    }    /* On failure, delete the result descriptor */    if (ACPI_FAILURE (Status))    {        AcpiUtRemoveReference (ResultDesc);     /* Result descriptor */    }    else    {        /* Now the address and length are valid for this BufferField */        ObjDesc->BufferField.Flags |= AOPOBJ_DATA_VALID;    }    return_ACPI_STATUS (Status);}

static ACPI_STATUSAcpiDsInitOneObject (    ACPI_HANDLE             ObjHandle,    UINT32                  Level,    void                    *Context,    void                    **ReturnValue){    ACPI_INIT_WALK_INFO     *Info = (ACPI_INIT_WALK_INFO *) Context;    ACPI_NAMESPACE_NODE     *Node = (ACPI_NAMESPACE_NODE *) ObjHandle;    ACPI_OBJECT_TYPE        Type;    ACPI_STATUS             Status;    ACPI_FUNCTION_ENTRY ();    /*     * We are only interested in NS nodes owned by the table that     * was just loaded     */    if (Node->OwnerId != Info->OwnerId)    {        return (AE_OK);    }    Info->ObjectCount++;    /* And even then, we are only interested in a few object types */    Type = AcpiNsGetType (ObjHandle);    switch (Type)    {    case ACPI_TYPE_REGION:        Status = AcpiDsInitializeRegion (ObjHandle);        if (ACPI_FAILURE (Status))        {            ACPI_EXCEPTION ((AE_INFO, Status,                "During Region initialization %p [%4.4s]",                ObjHandle, AcpiUtGetNodeName (ObjHandle)));        }        Info->OpRegionCount++;        break;    case ACPI_TYPE_METHOD:        Info->MethodCount++;        break;    case ACPI_TYPE_DEVICE:        Info->DeviceCount++;        break;    default:        break;    }    /*     * We ignore errors from above, and always return OK, since     * we don't want to abort the walk on a single error.     */    return (AE_OK);}

//.........这里部分代码省略.........    /*     * If the Region Address and Length have not been previously evaluated,     * evaluate them now and save the results.     */    if (!(RgnDesc->Common.Flags & AOPOBJ_DATA_VALID))    {        Status = AcpiDsGetRegionArguments (RgnDesc);        if (ACPI_FAILURE (Status))        {            return_ACPI_STATUS (Status);        }    }    /*     * Exit now for SMBus, GSBus or IPMI address space, it has a non-linear     * address space and the request cannot be directly validated     */    if (SpaceId == ACPI_ADR_SPACE_SMBUS ||        SpaceId == ACPI_ADR_SPACE_GSBUS ||        SpaceId == ACPI_ADR_SPACE_IPMI)    {        /* SMBus or IPMI has a non-linear address space */        return_ACPI_STATUS (AE_OK);    }#ifdef ACPI_UNDER_DEVELOPMENT    /*     * If the Field access is AnyAcc, we can now compute the optimal     * access (because we know know the length of the parent region)     */    if (!(ObjDesc->Common.Flags & AOPOBJ_DATA_VALID))    {        if (ACPI_FAILURE (Status))        {            return_ACPI_STATUS (Status);        }    }#endif    /*     * Validate the request. The entire request from the byte offset for a     * length of one field datum (access width) must fit within the region.     * (Region length is specified in bytes)     */    if (RgnDesc->Region.Length <        (ObjDesc->CommonField.BaseByteOffset + FieldDatumByteOffset +        ObjDesc->CommonField.AccessByteWidth))    {        if (AcpiGbl_EnableInterpreterSlack)        {            /*             * Slack mode only:  We will go ahead and allow access to this             * field if it is within the region length rounded up to the next             * access width boundary. ACPI_SIZE cast for 64-bit compile.             */            if (ACPI_ROUND_UP (RgnDesc->Region.Length,                    ObjDesc->CommonField.AccessByteWidth) >=                ((ACPI_SIZE) ObjDesc->CommonField.BaseByteOffset +                    ObjDesc->CommonField.AccessByteWidth +                    FieldDatumByteOffset))            {                return_ACPI_STATUS (AE_OK);            }        }        if (RgnDesc->Region.Length < ObjDesc->CommonField.AccessByteWidth)        {            /*             * This is the case where the AccessType (AccWord, etc.) is wider             * than the region itself. For example, a region of length one             * byte, and a field with Dword access specified.             */            ACPI_ERROR ((AE_INFO,                "Field [%4.4s] access width (%u bytes) "                "too large for region [%4.4s] (length %u)",                AcpiUtGetNodeName (ObjDesc->CommonField.Node),                ObjDesc->CommonField.AccessByteWidth,                AcpiUtGetNodeName (RgnDesc->Region.Node),                RgnDesc->Region.Length));        }        /*         * Offset rounded up to next multiple of field width         * exceeds region length, indicate an error         */        ACPI_ERROR ((AE_INFO,            "Field [%4.4s] Base+Offset+Width %u+%u+%u "            "is beyond end of region [%4.4s] (length %u)",            AcpiUtGetNodeName (ObjDesc->CommonField.Node),            ObjDesc->CommonField.BaseByteOffset,            FieldDatumByteOffset, ObjDesc->CommonField.AccessByteWidth,            AcpiUtGetNodeName (RgnDesc->Region.Node),            RgnDesc->Region.Length));        return_ACPI_STATUS (AE_AML_REGION_LIMIT);    }    return_ACPI_STATUS (AE_OK);}

//.........这里部分代码省略.........        }    }    else    {        ACPI_DEBUG_PRINT ((ACPI_DB_OPREGION,            "Creating object on Device %p while installing handler/n", Node));        /* ObjDesc does not exist, create one */        if (Node->Type == ACPI_TYPE_ANY)        {            Type = ACPI_TYPE_DEVICE;        }        else        {            Type = Node->Type;        }        ObjDesc = AcpiUtCreateInternalObject (Type);        if (!ObjDesc)        {            Status = AE_NO_MEMORY;            goto UnlockAndExit;        }        /* Init new descriptor */        ObjDesc->Common.Type = (UINT8) Type;        /* Attach the new object to the Node */        Status = AcpiNsAttachObject (Node, ObjDesc, Type);        /* Remove local reference to the object */        AcpiUtRemoveReference (ObjDesc);        if (ACPI_FAILURE (Status))        {            goto UnlockAndExit;        }    }    ACPI_DEBUG_PRINT ((ACPI_DB_OPREGION,        "Installing address handler for region %s(%X) on Device %4.4s %p(%p)/n",        AcpiUtGetRegionName (SpaceId), SpaceId,        AcpiUtGetNodeName (Node), Node, ObjDesc));    /*     * Install the handler     *     * At this point there is no existing handler. Just allocate the object     * for the handler and link it into the list.     */    HandlerObj = AcpiUtCreateInternalObject (ACPI_TYPE_LOCAL_ADDRESS_HANDLER);    if (!HandlerObj)    {        Status = AE_NO_MEMORY;        goto UnlockAndExit;    }    /* Init handler obj */    HandlerObj->AddressSpace.SpaceId = (UINT8) SpaceId;    HandlerObj->AddressSpace.HandlerFlags = Flags;    HandlerObj->AddressSpace.RegionList = NULL;    HandlerObj->AddressSpace.Node = Node;    HandlerObj->AddressSpace.Handler = Handler;    HandlerObj->AddressSpace.Context = Context;    HandlerObj->AddressSpace.Setup  = Setup;    /* Install at head of Device.AddressSpace list */    HandlerObj->AddressSpace.Next = ObjDesc->Device.Handler;    /*     * The Device object is the first reference on the HandlerObj.     * Each region that uses the handler adds a reference.     */    ObjDesc->Device.Handler = HandlerObj;    /*     * Walk the namespace finding all of the regions this     * handler will manage.     *     * Start at the device and search the branch toward     * the leaf nodes until either the leaf is encountered or     * a device is detected that has an address handler of the     * same type.     *     * In either case, back up and search down the remainder     * of the branch     */    Status = AcpiNsWalkNamespace (ACPI_TYPE_ANY, Node, ACPI_UINT32_MAX,                ACPI_NS_WALK_UNLOCK, AcpiEvInstallHandler, NULL,                HandlerObj, NULL);UnlockAndExit:    return_ACPI_STATUS (Status);}

ACPI_STATUSAcpiEvPciConfigRegionSetup (    ACPI_HANDLE             Handle,    UINT32                  Function,    void                    *HandlerContext,    void                    **RegionContext){    ACPI_STATUS             Status = AE_OK;    UINT64                  PciValue;    ACPI_PCI_ID             *PciId = *RegionContext;    ACPI_OPERAND_OBJECT     *HandlerObj;    ACPI_NAMESPACE_NODE     *ParentNode;    ACPI_NAMESPACE_NODE     *PciRootNode;    ACPI_NAMESPACE_NODE     *PciDeviceNode;    ACPI_OPERAND_OBJECT     *RegionObj = (ACPI_OPERAND_OBJECT  *) Handle;    ACPI_FUNCTION_TRACE (EvPciConfigRegionSetup);    HandlerObj = RegionObj->Region.Handler;    if (!HandlerObj)    {        /*         * No installed handler. This shouldn't happen because the dispatch         * routine checks before we get here, but we check again just in case.         */        ACPI_DEBUG_PRINT ((ACPI_DB_OPREGION,            "Attempting to init a region %p, with no handler/n", RegionObj));        return_ACPI_STATUS (AE_NOT_EXIST);    }    *RegionContext = NULL;    if (Function == ACPI_REGION_DEACTIVATE)    {        if (PciId)        {            ACPI_FREE (PciId);        }        return_ACPI_STATUS (Status);    }    ParentNode = RegionObj->Region.Node->Parent;    /*     * Get the _SEG and _BBN values from the device upon which the handler     * is installed.     *     * We need to get the _SEG and _BBN objects relative to the PCI BUS device.     * This is the device the handler has been registered to handle.     */    /*     * If the AddressSpace.Node is still pointing to the root, we need     * to scan upward for a PCI Root bridge and re-associate the OpRegion     * handlers with that device.     */    if (HandlerObj->AddressSpace.Node == AcpiGbl_RootNode)    {        /* Start search from the parent object */        PciRootNode = ParentNode;        while (PciRootNode != AcpiGbl_RootNode)        {            /* Get the _HID/_CID in order to detect a RootBridge */            if (AcpiEvIsPciRootBridge (PciRootNode))            {                /* Install a handler for this PCI root bridge */                Status = AcpiInstallAddressSpaceHandler (                            (ACPI_HANDLE) PciRootNode,                            ACPI_ADR_SPACE_PCI_CONFIG,                            ACPI_DEFAULT_HANDLER, NULL, NULL);                if (ACPI_FAILURE (Status))                {                    if (Status == AE_SAME_HANDLER)                    {                        /*                         * It is OK if the handler is already installed on the                         * root bridge. Still need to return a context object                         * for the new PCI_Config operation region, however.                         */                        Status = AE_OK;                    }                    else                    {                        ACPI_EXCEPTION ((AE_INFO, Status,                            "Could not install PciConfig handler "                            "for Root Bridge %4.4s",                            AcpiUtGetNodeName (PciRootNode)));                    }                }                break;            }            PciRootNode = PciRootNode->Parent;        }        /* PCI root bridge not found, use namespace root node *///.........这里部分代码省略.........

ACPI_STATUSAcpiExReleaseMutex (    ACPI_OPERAND_OBJECT     *ObjDesc,    ACPI_WALK_STATE         *WalkState){    ACPI_STATUS             Status = AE_OK;    UINT8                   PreviousSyncLevel;    ACPI_THREAD_STATE       *OwnerThread;    ACPI_FUNCTION_TRACE (ExReleaseMutex);    if (!ObjDesc)    {        return_ACPI_STATUS (AE_BAD_PARAMETER);    }    OwnerThread = ObjDesc->Mutex.OwnerThread;    /* The mutex must have been previously acquired in order to release it */    if (!OwnerThread)    {        ACPI_ERROR ((AE_INFO,            "Cannot release Mutex [%4.4s], not acquired",            AcpiUtGetNodeName (ObjDesc->Mutex.Node)));        return_ACPI_STATUS (AE_AML_MUTEX_NOT_ACQUIRED);    }    /* Must have a valid thread ID */    if (!WalkState->Thread)    {        ACPI_ERROR ((AE_INFO,            "Cannot release Mutex [%4.4s], null thread info",            AcpiUtGetNodeName (ObjDesc->Mutex.Node)));        return_ACPI_STATUS (AE_AML_INTERNAL);    }    /*     * The Mutex is owned, but this thread must be the owner.     * Special case for Global Lock, any thread can release     */    if ((OwnerThread->ThreadId != WalkState->Thread->ThreadId) &&        (ObjDesc != AcpiGbl_GlobalLockMutex))    {        ACPI_ERROR ((AE_INFO,            "Thread %u cannot release Mutex [%4.4s] acquired by thread %u",            (UINT32) WalkState->Thread->ThreadId,            AcpiUtGetNodeName (ObjDesc->Mutex.Node),            (UINT32) OwnerThread->ThreadId));        return_ACPI_STATUS (AE_AML_NOT_OWNER);    }    /*     * The sync level of the mutex must be equal to the current sync level. In     * other words, the current level means that at least one mutex at that     * level is currently being held. Attempting to release a mutex of a     * different level can only mean that the mutex ordering rule is being     * violated. This behavior is clarified in ACPI 4.0 specification.     */    if (ObjDesc->Mutex.SyncLevel != OwnerThread->CurrentSyncLevel)    {        ACPI_ERROR ((AE_INFO,            "Cannot release Mutex [%4.4s], SyncLevel mismatch: mutex %u current %u",            AcpiUtGetNodeName (ObjDesc->Mutex.Node),            ObjDesc->Mutex.SyncLevel, WalkState->Thread->CurrentSyncLevel));        return_ACPI_STATUS (AE_AML_MUTEX_ORDER);    }    /*     * Get the previous SyncLevel from the head of the acquired mutex list.     * This handles the case where several mutexes at the same level have been     * acquired, but are not released in reverse order.     */    PreviousSyncLevel =        OwnerThread->AcquiredMutexList->Mutex.OriginalSyncLevel;    Status = AcpiExReleaseMutexObject (ObjDesc);    if (ACPI_FAILURE (Status))    {        return_ACPI_STATUS (Status);    }    if (ObjDesc->Mutex.AcquisitionDepth == 0)    {        /* Restore the previous SyncLevel */        OwnerThread->CurrentSyncLevel = PreviousSyncLevel;    }    return_ACPI_STATUS (Status);}