acnamesp.h File Reference

Go to the source code of this file.

Macros
#define	ACPI_NS_ALL   ((ACPI_HANDLE)0)
#define	ACPI_NS_NORMAL   0
#define	ACPI_NS_NEWSCOPE   1 /* a definition of this type opens a name scope */
#define	ACPI_NS_LOCAL   2 /* suppress search of enclosing scopes */
#define	ACPI_NS_NO_UPSEARCH   0
#define	ACPI_NS_SEARCH_PARENT   0x0001
#define	ACPI_NS_DONT_OPEN_SCOPE   0x0002
#define	ACPI_NS_NO_PEER_SEARCH   0x0004
#define	ACPI_NS_ERROR_IF_FOUND   0x0008
#define	ACPI_NS_PREFIX_IS_SCOPE   0x0010
#define	ACPI_NS_EXTERNAL   0x0020
#define	ACPI_NS_TEMPORARY   0x0040
#define	ACPI_NS_OVERRIDE_IF_FOUND   0x0080
#define	ACPI_NS_EARLY_INIT   0x0100
#define	ACPI_NS_PREFIX_MUST_EXIST   0x0200
#define	ACPI_NS_WALK_NO_UNLOCK   0
#define	ACPI_NS_WALK_UNLOCK   0x01
#define	ACPI_NS_WALK_TEMP_NODES   0x02
#define	ACPI_NOT_PACKAGE_ELEMENT   ACPI_UINT32_MAX
#define	ACPI_ALL_PACKAGE_ELEMENTS   (ACPI_UINT32_MAX-1)
#define	ACPI_WARN_ALWAYS   0

Functions
ACPI_STATUS	AcpiNsInitializeObjects (void)
ACPI_STATUS	AcpiNsInitializeDevices (UINT32 Flags)
ACPI_STATUS	AcpiNsInitOnePackage (ACPI_HANDLE ObjHandle, UINT32 Level, void *Context, void **ReturnValue)
ACPI_STATUS	AcpiNsLoadNamespace (void)
ACPI_STATUS	AcpiNsLoadTable (UINT32 TableIndex, ACPI_NAMESPACE_NODE *Node)
ACPI_STATUS	AcpiNsWalkNamespace (ACPI_OBJECT_TYPE Type, ACPI_HANDLE StartObject, UINT32 MaxDepth, UINT32 Flags, ACPI_WALK_CALLBACK DescendingCallback, ACPI_WALK_CALLBACK AscendingCallback, void *Context, void **ReturnValue)
ACPI_NAMESPACE_NODE *	AcpiNsGetNextNode (ACPI_NAMESPACE_NODE *Parent, ACPI_NAMESPACE_NODE *Child)
ACPI_NAMESPACE_NODE *	AcpiNsGetNextNodeTyped (ACPI_OBJECT_TYPE Type, ACPI_NAMESPACE_NODE *Parent, ACPI_NAMESPACE_NODE *Child)
ACPI_STATUS	AcpiNsParseTable (UINT32 TableIndex, ACPI_NAMESPACE_NODE *StartNode)
ACPI_STATUS	AcpiNsExecuteTable (UINT32 TableIndex, ACPI_NAMESPACE_NODE *StartNode)
ACPI_STATUS	AcpiNsOneCompleteParse (UINT32 PassNumber, UINT32 TableIndex, ACPI_NAMESPACE_NODE *StartNode)
ACPI_STATUS	AcpiNsRootInitialize (void)
ACPI_STATUS	AcpiNsLookup (ACPI_GENERIC_STATE *ScopeInfo, char *Name, ACPI_OBJECT_TYPE Type, ACPI_INTERPRETER_MODE InterpreterMode, UINT32 Flags, ACPI_WALK_STATE *WalkState, ACPI_NAMESPACE_NODE **RetNode)
ACPI_NAMESPACE_NODE *	AcpiNsCreateNode (UINT32 Name)
void	AcpiNsDeleteNode (ACPI_NAMESPACE_NODE *Node)
void	AcpiNsRemoveNode (ACPI_NAMESPACE_NODE *Node)
void	AcpiNsDeleteNamespaceSubtree (ACPI_NAMESPACE_NODE *ParentHandle)
void	AcpiNsDeleteNamespaceByOwner (ACPI_OWNER_ID OwnerId)
void	AcpiNsDetachObject (ACPI_NAMESPACE_NODE *Node)
void	AcpiNsDeleteChildren (ACPI_NAMESPACE_NODE *Parent)
int	AcpiNsCompareNames (char *Name1, char *Name2)
ACPI_STATUS	AcpiNsConvertToInteger (ACPI_OPERAND_OBJECT *OriginalObject, ACPI_OPERAND_OBJECT **ReturnObject)
ACPI_STATUS	AcpiNsConvertToString (ACPI_OPERAND_OBJECT *OriginalObject, ACPI_OPERAND_OBJECT **ReturnObject)
ACPI_STATUS	AcpiNsConvertToBuffer (ACPI_OPERAND_OBJECT *OriginalObject, ACPI_OPERAND_OBJECT **ReturnObject)
ACPI_STATUS	AcpiNsConvertToUnicode (ACPI_NAMESPACE_NODE *Scope, ACPI_OPERAND_OBJECT *OriginalObject, ACPI_OPERAND_OBJECT **ReturnObject)
ACPI_STATUS	AcpiNsConvertToResource (ACPI_NAMESPACE_NODE *Scope, ACPI_OPERAND_OBJECT *OriginalObject, ACPI_OPERAND_OBJECT **ReturnObject)
ACPI_STATUS	AcpiNsConvertToReference (ACPI_NAMESPACE_NODE *Scope, ACPI_OPERAND_OBJECT *OriginalObject, ACPI_OPERAND_OBJECT **ReturnObject)
void	AcpiNsDumpTables (ACPI_HANDLE SearchBase, UINT32 MaxDepth)
void	AcpiNsDumpEntry (ACPI_HANDLE Handle, UINT32 DebugLevel)
void	AcpiNsDumpPathname (ACPI_HANDLE Handle, const char *Msg, UINT32 Level, UINT32 Component)
void	AcpiNsPrintPathname (UINT32 NumSegments, const char *Pathname)
ACPI_STATUS	AcpiNsDumpOneObject (ACPI_HANDLE ObjHandle, UINT32 Level, void *Context, void **ReturnValue)
void	AcpiNsDumpObjects (ACPI_OBJECT_TYPE Type, UINT8 DisplayType, UINT32 MaxDepth, ACPI_OWNER_ID OwnerId, ACPI_HANDLE StartHandle)
void	AcpiNsDumpObjectPaths (ACPI_OBJECT_TYPE Type, UINT8 DisplayType, UINT32 MaxDepth, ACPI_OWNER_ID OwnerId, ACPI_HANDLE StartHandle)
ACPI_STATUS	AcpiNsEvaluate (ACPI_EVALUATE_INFO *Info)
void	AcpiNsCheckArgumentCount (char *Pathname, ACPI_NAMESPACE_NODE *Node, UINT32 UserParamCount, const ACPI_PREDEFINED_INFO *Info)
void	AcpiNsCheckAcpiCompliance (char *Pathname, ACPI_NAMESPACE_NODE *Node, const ACPI_PREDEFINED_INFO *Predefined)
void	AcpiNsCheckArgumentTypes (ACPI_EVALUATE_INFO *Info)
ACPI_STATUS	AcpiNsCheckReturnValue (ACPI_NAMESPACE_NODE *Node, ACPI_EVALUATE_INFO *Info, UINT32 UserParamCount, ACPI_STATUS ReturnStatus, ACPI_OPERAND_OBJECT **ReturnObject)
ACPI_STATUS	AcpiNsCheckObjectType (ACPI_EVALUATE_INFO *Info, ACPI_OPERAND_OBJECT **ReturnObjectPtr, UINT32 ExpectedBtypes, UINT32 PackageIndex)
ACPI_STATUS	AcpiNsCheckPackage (ACPI_EVALUATE_INFO *Info, ACPI_OPERAND_OBJECT **ReturnObjectPtr)
UINT32	AcpiNsOpensScope (ACPI_OBJECT_TYPE Type)
char *	AcpiNsGetExternalPathname (ACPI_NAMESPACE_NODE *Node)
UINT32	AcpiNsBuildNormalizedPath (ACPI_NAMESPACE_NODE *Node, char *FullPath, UINT32 PathSize, BOOLEAN NoTrailing)
void	AcpiNsNormalizePathname (char *OriginalPath)
char *	AcpiNsGetNormalizedPathname (ACPI_NAMESPACE_NODE *Node, BOOLEAN NoTrailing)
char *	AcpiNsBuildPrefixedPathname (ACPI_GENERIC_STATE *PrefixScope, const char *InternalPath)
char *	AcpiNsNameOfCurrentScope (ACPI_WALK_STATE *WalkState)
ACPI_STATUS	AcpiNsHandleToName (ACPI_HANDLE TargetHandle, ACPI_BUFFER *Buffer)
ACPI_STATUS	AcpiNsHandleToPathname (ACPI_HANDLE TargetHandle, ACPI_BUFFER *Buffer, BOOLEAN NoTrailing)
BOOLEAN	AcpiNsPatternMatch (ACPI_NAMESPACE_NODE *ObjNode, char *SearchFor)
ACPI_STATUS	AcpiNsGetNodeUnlocked (ACPI_NAMESPACE_NODE *PrefixNode, const char *ExternalPathname, UINT32 Flags, ACPI_NAMESPACE_NODE **OutNode)
ACPI_STATUS	AcpiNsGetNode (ACPI_NAMESPACE_NODE *PrefixNode, const char *ExternalPathname, UINT32 Flags, ACPI_NAMESPACE_NODE **OutNode)
ACPI_SIZE	AcpiNsGetPathnameLength (ACPI_NAMESPACE_NODE *Node)
ACPI_STATUS	AcpiNsAttachObject (ACPI_NAMESPACE_NODE *Node, ACPI_OPERAND_OBJECT *Object, ACPI_OBJECT_TYPE Type)
ACPI_OPERAND_OBJECT *	AcpiNsGetAttachedObject (ACPI_NAMESPACE_NODE *Node)
ACPI_OPERAND_OBJECT *	AcpiNsGetSecondaryObject (ACPI_OPERAND_OBJECT *ObjDesc)
ACPI_STATUS	AcpiNsAttachData (ACPI_NAMESPACE_NODE *Node, ACPI_OBJECT_HANDLER Handler, void *Data)
ACPI_STATUS	AcpiNsDetachData (ACPI_NAMESPACE_NODE *Node, ACPI_OBJECT_HANDLER Handler)
ACPI_STATUS	AcpiNsGetAttachedData (ACPI_NAMESPACE_NODE *Node, ACPI_OBJECT_HANDLER Handler, void **Data)
ACPI_STATUS	AcpiNsSimpleRepair (ACPI_EVALUATE_INFO *Info, UINT32 ExpectedBtypes, UINT32 PackageIndex, ACPI_OPERAND_OBJECT **ReturnObjectPtr)
ACPI_STATUS	AcpiNsWrapWithPackage (ACPI_EVALUATE_INFO *Info, ACPI_OPERAND_OBJECT *OriginalObject, ACPI_OPERAND_OBJECT **ObjDescPtr)
ACPI_STATUS	AcpiNsRepairNullElement (ACPI_EVALUATE_INFO *Info, UINT32 ExpectedBtypes, UINT32 PackageIndex, ACPI_OPERAND_OBJECT **ReturnObjectPtr)
void	AcpiNsRemoveNullElements (ACPI_EVALUATE_INFO *Info, UINT8 PackageType, ACPI_OPERAND_OBJECT *ObjDesc)
ACPI_STATUS	AcpiNsComplexRepairs (ACPI_EVALUATE_INFO *Info, ACPI_NAMESPACE_NODE *Node, ACPI_STATUS ValidateStatus, ACPI_OPERAND_OBJECT **ReturnObjectPtr)
ACPI_STATUS	AcpiNsSearchAndEnter (UINT32 EntryName, ACPI_WALK_STATE *WalkState, ACPI_NAMESPACE_NODE *Node, ACPI_INTERPRETER_MODE InterpreterMode, ACPI_OBJECT_TYPE Type, UINT32 Flags, ACPI_NAMESPACE_NODE **RetNode)
ACPI_STATUS	AcpiNsSearchOneScope (UINT32 EntryName, ACPI_NAMESPACE_NODE *Node, ACPI_OBJECT_TYPE Type, ACPI_NAMESPACE_NODE **RetNode)
void	AcpiNsInstallNode (ACPI_WALK_STATE *WalkState, ACPI_NAMESPACE_NODE *ParentNode, ACPI_NAMESPACE_NODE *Node, ACPI_OBJECT_TYPE Type)
ACPI_OBJECT_TYPE	AcpiNsGetType (ACPI_NAMESPACE_NODE *Node)
UINT32	AcpiNsLocal (ACPI_OBJECT_TYPE Type)
void	AcpiNsPrintNodePathname (ACPI_NAMESPACE_NODE *Node, const char *Msg)
ACPI_STATUS	AcpiNsBuildInternalName (ACPI_NAMESTRING_INFO *Info)
void	AcpiNsGetInternalNameLength (ACPI_NAMESTRING_INFO *Info)
ACPI_STATUS	AcpiNsInternalizeName (const char *DottedName, char **ConvertedName)
ACPI_STATUS	AcpiNsExternalizeName (UINT32 InternalNameLength, const char *InternalName, UINT32 *ConvertedNameLength, char **ConvertedName)
ACPI_NAMESPACE_NODE *	AcpiNsValidateHandle (ACPI_HANDLE Handle)
void	AcpiNsTerminate (void)

Macro Definition Documentation

ACPI_ALL_PACKAGE_ELEMENTS

#define ACPI_ALL_PACKAGE_ELEMENTS   (ACPI_UINT32_MAX-1)

Definition at line 83 of file acnamesp.h.

ACPI_NOT_PACKAGE_ELEMENT

#define ACPI_NOT_PACKAGE_ELEMENT   ACPI_UINT32_MAX

Definition at line 82 of file acnamesp.h.

ACPI_NS_ALL

#define ACPI_NS_ALL   ((ACPI_HANDLE)0)

Definition at line 50 of file acnamesp.h.

ACPI_NS_DONT_OPEN_SCOPE

#define ACPI_NS_DONT_OPEN_SCOPE   0x0002

Definition at line 64 of file acnamesp.h.

ACPI_NS_EARLY_INIT

#define ACPI_NS_EARLY_INIT   0x0100

Definition at line 71 of file acnamesp.h.

ACPI_NS_ERROR_IF_FOUND

#define ACPI_NS_ERROR_IF_FOUND   0x0008

Definition at line 66 of file acnamesp.h.

ACPI_NS_EXTERNAL

#define ACPI_NS_EXTERNAL   0x0020

Definition at line 68 of file acnamesp.h.

ACPI_NS_LOCAL

#define ACPI_NS_LOCAL   2 /* suppress search of enclosing scopes */

Definition at line 58 of file acnamesp.h.

ACPI_NS_NEWSCOPE

#define ACPI_NS_NEWSCOPE   1 /* a definition of this type opens a name scope */

Definition at line 57 of file acnamesp.h.

ACPI_NS_NO_PEER_SEARCH

#define ACPI_NS_NO_PEER_SEARCH   0x0004

Definition at line 65 of file acnamesp.h.

ACPI_NS_NO_UPSEARCH

#define ACPI_NS_NO_UPSEARCH   0

Definition at line 62 of file acnamesp.h.

ACPI_NS_NORMAL

#define ACPI_NS_NORMAL   0

Definition at line 56 of file acnamesp.h.

ACPI_NS_OVERRIDE_IF_FOUND

#define ACPI_NS_OVERRIDE_IF_FOUND   0x0080

Definition at line 70 of file acnamesp.h.

ACPI_NS_PREFIX_IS_SCOPE

#define ACPI_NS_PREFIX_IS_SCOPE   0x0010

Definition at line 67 of file acnamesp.h.

ACPI_NS_PREFIX_MUST_EXIST

#define ACPI_NS_PREFIX_MUST_EXIST   0x0200

Definition at line 72 of file acnamesp.h.

ACPI_NS_SEARCH_PARENT

#define ACPI_NS_SEARCH_PARENT   0x0001

Definition at line 63 of file acnamesp.h.

ACPI_NS_TEMPORARY

#define ACPI_NS_TEMPORARY   0x0040

Definition at line 69 of file acnamesp.h.

ACPI_NS_WALK_NO_UNLOCK

#define ACPI_NS_WALK_NO_UNLOCK   0

Definition at line 76 of file acnamesp.h.

ACPI_NS_WALK_TEMP_NODES

#define ACPI_NS_WALK_TEMP_NODES   0x02

Definition at line 78 of file acnamesp.h.

ACPI_NS_WALK_UNLOCK

#define ACPI_NS_WALK_UNLOCK   0x01

Definition at line 77 of file acnamesp.h.

ACPI_WARN_ALWAYS

#define ACPI_WARN_ALWAYS   0

Definition at line 87 of file acnamesp.h.

Function Documentation

AcpiNsAttachData()

ACPI_STATUS AcpiNsAttachData	(	ACPI_NAMESPACE_NODE *	Node,
		ACPI_OBJECT_HANDLER	Handler,
		void *	Data
	)

Definition at line 379 of file nsobject.c.

{
    ACPI_OPERAND_OBJECT     *PrevObjDesc;
    ACPI_OPERAND_OBJECT     *ObjDesc;
    ACPI_OPERAND_OBJECT     *DataDesc;
 
 
    /* We only allow one attachment per handler */
 
    PrevObjDesc = NULL;
    ObjDesc = Node->Object;
    while (ObjDesc)
    {
        if ((ObjDesc->Common.Type == ACPI_TYPE_LOCAL_DATA) &&
            (ObjDesc->Data.Handler == Handler))
        {
            return (AE_ALREADY_EXISTS);
        }
 
        PrevObjDesc = ObjDesc;
        ObjDesc = ObjDesc->Common.NextObject;
    }
 
    /* Create an internal object for the data */
 
    DataDesc = AcpiUtCreateInternalObject (ACPI_TYPE_LOCAL_DATA);
    if (!DataDesc)
    {
        return (AE_NO_MEMORY);
    }
 
    DataDesc->Data.Handler = Handler;
    DataDesc->Data.Pointer = Data;
 
    /* Install the data object */
 
    if (PrevObjDesc)
    {
        PrevObjDesc->Common.NextObject = DataDesc;
    }
    else
    {
        Node->Object = DataDesc;
    }
 
    return (AE_OK);
}

Referenced by AcpiAttachData().

AcpiNsAttachObject()

ACPI_STATUS AcpiNsAttachObject	(	ACPI_NAMESPACE_NODE *	Node,
		ACPI_OPERAND_OBJECT *	Object,
		ACPI_OBJECT_TYPE	Type
	)

Definition at line 76 of file nsobject.c.

{
    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);
    }
 
    if (ObjDesc)
    {
        /*
         * Must increment the new value's reference count
         * (if it is an internal object)
         */
        AcpiUtAddReference (ObjDesc);
 
        /*
         * Handle objects with multiple descriptors - walk
         * to the end of the descriptor list
         */
        LastObjDesc = ObjDesc;
        while (LastObjDesc->Common.NextObject)
        {
            LastObjDesc = LastObjDesc->Common.NextObject;
        }
 
        /* Install the object at the front of the object list */
 
        LastObjDesc->Common.NextObject = Node->Object;
    }
 
    Node->Type = (UINT8) ObjectType;
    Node->Object = ObjDesc;
 
    return_ACPI_STATUS (AE_OK);
}

Referenced by AcpiDsCreateBufferField(), AcpiDsCreateNode(), AcpiDsLoad2EndOp(), AcpiEvInstallSpaceHandler(), AcpiExCreateEvent(), AcpiExCreateMethod(), AcpiExCreateMutex(), AcpiExCreatePowerResource(), AcpiExCreateProcessor(), AcpiExCreateRegion(), AcpiExPrepFieldValue(), AcpiExStoreDirectToNode(), AcpiExStoreObjectToNode(), AcpiInstallGpeBlock(), AcpiInstallMethod(), AcpiInstallNotifyHandler(), and AcpiNsRootInitialize().

AcpiNsBuildInternalName()

ACPI_STATUS AcpiNsBuildInternalName

(

ACPI_NAMESTRING_INFO *

Info

)

Definition at line 267 of file nsutils.c.

{
    UINT32                  NumSegments = Info->NumSegments;
    char                    *InternalName = Info->InternalName;
    const char              *ExternalName = Info->NextExternalChar;
    char                    *Result = NULL;
    UINT32                  i;
 
 
    ACPI_FUNCTION_TRACE (NsBuildInternalName);
 
 
    /* Setup the correct prefixes, counts, and pointers */
 
    if (Info->FullyQualified)
    {
        InternalName[0] = AML_ROOT_PREFIX;
 
        if (NumSegments <= 1)
        {
            Result = &InternalName[1];
        }
        else if (NumSegments == 2)
        {
            InternalName[1] = AML_DUAL_NAME_PREFIX;
            Result = &InternalName[2];
        }
        else
        {
            InternalName[1] = AML_MULTI_NAME_PREFIX;
            InternalName[2] = (char) NumSegments;
            Result = &InternalName[3];
        }
    }
    else
    {
        /*
         * Not fully qualified.
         * Handle Carats first, then append the name segments
         */
        i = 0;
        if (Info->NumCarats)
        {
            for (i = 0; i < Info->NumCarats; i++)
            {
                InternalName[i] = AML_PARENT_PREFIX;
            }
        }
 
        if (NumSegments <= 1)
        {
            Result = &InternalName[i];
        }
        else if (NumSegments == 2)
        {
            InternalName[i] = AML_DUAL_NAME_PREFIX;
            Result = &InternalName[(ACPI_SIZE) i+1];
        }
        else
        {
            InternalName[i] = AML_MULTI_NAME_PREFIX;
            InternalName[(ACPI_SIZE) i+1] = (char) NumSegments;
            Result = &InternalName[(ACPI_SIZE) i+2];
        }
    }
 
    /* Build the name (minus path separators) */
 
    for (; NumSegments; NumSegments--)
    {
        for (i = 0; i < ACPI_NAMESEG_SIZE; i++)
        {
            if (ACPI_IS_PATH_SEPARATOR (*ExternalName) ||
               (*ExternalName == 0))
            {
                /* Pad the segment with underscore(s) if segment is short */
 
                Result[i] = '_';
            }
            else
            {
                /* Convert the character to uppercase and save it */
 
                Result[i] = (char) toupper ((int) *ExternalName);
                ExternalName++;
            }
        }
 
        /* Now we must have a path separator, or the pathname is bad */
 
        if (!ACPI_IS_PATH_SEPARATOR (*ExternalName) &&
            (*ExternalName != 0))
        {
            return_ACPI_STATUS (AE_BAD_PATHNAME);
        }
 
        /* Move on the next segment */
 
        ExternalName++;
        Result += ACPI_NAMESEG_SIZE;
    }
 
    /* Terminate the string */
 
    *Result = 0;
 
    if (Info->FullyQualified)
    {
        ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Returning [%p] (abs) \"\\%s\"\n",
            InternalName, InternalName));
    }
    else
    {
        ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Returning [%p] (rel) \"%s\"\n",
            InternalName, InternalName));
    }
 
    return_ACPI_STATUS (AE_OK);
}

Referenced by AcpiNsInternalizeName().

AcpiNsBuildNormalizedPath()

UINT32 AcpiNsBuildNormalizedPath	(	ACPI_NAMESPACE_NODE *	Node,
		char *	FullPath,
		UINT32	PathSize,
		BOOLEAN	NoTrailing
	)

Definition at line 256 of file nsnames.c.

{
    UINT32                  Length = 0, i;
    char                    Name[ACPI_NAMESEG_SIZE];
    BOOLEAN                 DoNoTrailing;
    char                    c, *Left, *Right;
    ACPI_NAMESPACE_NODE     *NextNode;
 
 
    ACPI_FUNCTION_TRACE_PTR (NsBuildNormalizedPath, Node);
 
 
#define ACPI_PATH_PUT8(Path, Size, Byte, Length)    \
    do {                                            \
        if ((Length) < (Size))                      \
        {                                           \
            (Path)[(Length)] = (Byte);              \
        }                                           \
        (Length)++;                                 \
    } while (0)
 
    /*
     * Make sure the PathSize is correct, so that we don't need to
     * validate both FullPath and PathSize.
     */
    if (!FullPath)
    {
        PathSize = 0;
    }
 
    if (!Node)
    {
        goto BuildTrailingNull;
    }
 
    NextNode = Node;
    while (NextNode && NextNode != AcpiGbl_RootNode)
    {
        if (NextNode != Node)
        {
            ACPI_PATH_PUT8(FullPath, PathSize, AML_DUAL_NAME_PREFIX, Length);
        }
 
        ACPI_MOVE_32_TO_32 (Name, &NextNode->Name);
        DoNoTrailing = NoTrailing;
        for (i = 0; i < 4; i++)
        {
            c = Name[4-i-1];
            if (DoNoTrailing && c != '_')
            {
                DoNoTrailing = FALSE;
            }
            if (!DoNoTrailing)
            {
                ACPI_PATH_PUT8(FullPath, PathSize, c, Length);
            }
        }
 
        NextNode = NextNode->Parent;
    }
 
    ACPI_PATH_PUT8(FullPath, PathSize, AML_ROOT_PREFIX, Length);
 
    /* Reverse the path string */
 
    if (Length <= PathSize)
    {
        Left = FullPath;
        Right = FullPath+Length - 1;
 
        while (Left < Right)
        {
            c = *Left;
            *Left++ = *Right;
            *Right-- = c;
        }
    }
 
    /* Append the trailing null */
 
BuildTrailingNull:
    ACPI_PATH_PUT8 (FullPath, PathSize, '\0', Length);
 
#undef ACPI_PATH_PUT8
 
    return_UINT32 (Length);
}

Referenced by AcpiNsGetNormalizedPathname(), AcpiNsGetPathnameLength(), and AcpiNsHandleToPathname().

AcpiNsBuildPrefixedPathname()

char * AcpiNsBuildPrefixedPathname	(	ACPI_GENERIC_STATE *	PrefixScope,
		const char *	InternalPath
	)

Definition at line 423 of file nsnames.c.

{
    ACPI_STATUS             Status;
    char                    *FullPath = NULL;
    char                    *ExternalPath = NULL;
    char                    *PrefixPath = NULL;
    ACPI_SIZE               PrefixPathLength = 0;
 
 
    /* If there is a prefix, get the pathname to it */
 
    if (PrefixScope && PrefixScope->Scope.Node)
    {
        PrefixPath = AcpiNsGetNormalizedPathname (PrefixScope->Scope.Node, TRUE);
        if (PrefixPath)
        {
            PrefixPathLength = strlen (PrefixPath);
        }
    }
 
    Status = AcpiNsExternalizeName (ACPI_UINT32_MAX, InternalPath,
        NULL, &ExternalPath);
    if (ACPI_FAILURE (Status))
    {
        goto Cleanup;
    }
 
    /* Merge the prefix path and the path. 2 is for one dot and trailing null */
 
    FullPath = ACPI_ALLOCATE_ZEROED (
        PrefixPathLength + strlen (ExternalPath) + 2);
    if (!FullPath)
    {
        goto Cleanup;
    }
 
    /* Don't merge if the External path is already fully qualified */
 
    if (PrefixPath &&
        (*ExternalPath != '\\') &&
        (*ExternalPath != '^'))
    {
        strcat (FullPath, PrefixPath);
        if (PrefixPath[1])
        {
            strcat (FullPath, ".");
        }
    }
 
    AcpiNsNormalizePathname (ExternalPath);
    strcat (FullPath, ExternalPath);
 
Cleanup:
    if (PrefixPath)
    {
        ACPI_FREE (PrefixPath);
    }
    if (ExternalPath)
    {
        ACPI_FREE (ExternalPath);
    }
 
    return (FullPath);
}

Referenced by AcpiUtPrefixedNamespaceError().

AcpiNsCheckAcpiCompliance()

void AcpiNsCheckAcpiCompliance	(	char *	Pathname,
		ACPI_NAMESPACE_NODE *	Node,
		const ACPI_PREDEFINED_INFO *	Predefined
	)

Definition at line 135 of file nsarguments.c.

{
    UINT32                      AmlParamCount;
    UINT32                      RequiredParamCount;
 
 
    if (!Predefined || (Node->Flags & ANOBJ_EVALUATED))
    {
        return;
    }
 
    /* Get the ACPI-required arg count from the predefined info table */
 
    RequiredParamCount =
        METHOD_GET_ARG_COUNT (Predefined->Info.ArgumentList);
 
    /*
     * If this object is not a control method, we can check if the ACPI
     * spec requires that it be a method.
     */
    if (Node->Type != ACPI_TYPE_METHOD)
    {
        if (RequiredParamCount > 0)
        {
            /* Object requires args, must be implemented as a method */
 
            ACPI_BIOS_ERROR_PREDEFINED ((AE_INFO, Pathname, ACPI_WARN_ALWAYS,
                "Object (%s) must be a control method with %u arguments",
                AcpiUtGetTypeName (Node->Type), RequiredParamCount));
        }
        else if (!RequiredParamCount && !Predefined->Info.ExpectedBtypes)
        {
            /* Object requires no args and no return value, must be a method */
 
            ACPI_BIOS_ERROR_PREDEFINED ((AE_INFO, Pathname, ACPI_WARN_ALWAYS,
                "Object (%s) must be a control method "
                "with no arguments and no return value",
                AcpiUtGetTypeName (Node->Type)));
        }
 
        return;
    }
 
    /*
     * This is a control method.
     * Check that the ASL/AML-defined parameter count for this method
     * matches the ACPI-required parameter count
     *
     * Some methods are allowed to have a "minimum" number of args (_SCP)
     * because their definition in ACPI has changed over time.
     *
     * Note: These are BIOS errors in the declaration of the object
     */
    AmlParamCount = Node->Object->Method.ParamCount;
 
    if (AmlParamCount < RequiredParamCount)
    {
        ACPI_BIOS_ERROR_PREDEFINED ((AE_INFO, Pathname, ACPI_WARN_ALWAYS,
            "Insufficient arguments - "
            "ASL declared %u, ACPI requires %u",
            AmlParamCount, RequiredParamCount));
    }
    else if ((AmlParamCount > RequiredParamCount) &&
        !(Predefined->Info.ArgumentList & ARG_COUNT_IS_MINIMUM))
    {
        ACPI_BIOS_ERROR_PREDEFINED ((AE_INFO, Pathname, ACPI_WARN_ALWAYS,
            "Excess arguments - "
            "ASL declared %u, ACPI requires %u",
            AmlParamCount, RequiredParamCount));
    }
}

Referenced by AcpiNsEvaluate().

AcpiNsCheckArgumentCount()

void AcpiNsCheckArgumentCount	(	char *	Pathname,
		ACPI_NAMESPACE_NODE *	Node,
		UINT32	UserParamCount,
		const ACPI_PREDEFINED_INFO *	Info
	)

Definition at line 228 of file nsarguments.c.

{
    UINT32                      AmlParamCount;
    UINT32                      RequiredParamCount;
 
 
    if (Node->Flags & ANOBJ_EVALUATED)
    {
        return;
    }
 
    if (!Predefined)
    {
        /*
         * Not a predefined name. Check the incoming user argument count
         * against the count that is specified in the method/object.
         */
        if (Node->Type != ACPI_TYPE_METHOD)
        {
            if (UserParamCount)
            {
                ACPI_INFO_PREDEFINED ((AE_INFO, Pathname, ACPI_WARN_ALWAYS,
                    "%u arguments were passed to a non-method ACPI object (%s)",
                    UserParamCount, AcpiUtGetTypeName (Node->Type)));
            }
 
            return;
        }
 
        /*
         * This is a control method. Check the parameter count.
         * We can only check the incoming argument count against the
         * argument count declared for the method in the ASL/AML.
         *
         * Emit a message if too few or too many arguments have been passed
         * by the caller.
         *
         * Note: Too many arguments will not cause the method to
         * fail. However, the method will fail if there are too few
         * arguments and the method attempts to use one of the missing ones.
         */
        AmlParamCount = Node->Object->Method.ParamCount;
 
        if (UserParamCount < AmlParamCount)
        {
            ACPI_WARN_PREDEFINED ((AE_INFO, Pathname, ACPI_WARN_ALWAYS,
                "Insufficient arguments - "
                "Caller passed %u, method requires %u",
                UserParamCount, AmlParamCount));
        }
        else if (UserParamCount > AmlParamCount)
        {
            ACPI_INFO_PREDEFINED ((AE_INFO, Pathname, ACPI_WARN_ALWAYS,
                "Excess arguments - "
                "Caller passed %u, method requires %u",
                UserParamCount, AmlParamCount));
        }
 
        return;
    }
 
    /*
     * This is a predefined name. Validate the user-supplied parameter
     * count against the ACPI specification. We don't validate against
     * the method itself because what is important here is that the
     * caller is in conformance with the spec. (The arg count for the
     * method was checked against the ACPI spec earlier.)
     *
     * Some methods are allowed to have a "minimum" number of args (_SCP)
     * because their definition in ACPI has changed over time.
     */
    RequiredParamCount =
        METHOD_GET_ARG_COUNT (Predefined->Info.ArgumentList);
 
    if (UserParamCount < RequiredParamCount)
    {
        ACPI_WARN_PREDEFINED ((AE_INFO, Pathname, ACPI_WARN_ALWAYS,
            "Insufficient arguments - "
            "Caller passed %u, ACPI requires %u",
            UserParamCount, RequiredParamCount));
    }
    else if ((UserParamCount > RequiredParamCount) &&
        !(Predefined->Info.ArgumentList & ARG_COUNT_IS_MINIMUM))
    {
        ACPI_INFO_PREDEFINED ((AE_INFO, Pathname, ACPI_WARN_ALWAYS,
            "Excess arguments - "
            "Caller passed %u, ACPI requires %u",
            UserParamCount, RequiredParamCount));
    }
}

Referenced by AcpiNsEvaluate().

AcpiNsCheckArgumentTypes()

void AcpiNsCheckArgumentTypes

(

ACPI_EVALUATE_INFO *

Info

)

Definition at line 68 of file nsarguments.c.

{
    UINT16                      ArgTypeList;
    UINT8                       ArgCount;
    UINT8                       ArgType;
    UINT8                       UserArgType;
    UINT32                      i;
 
 
    /*
     * If not a predefined name, cannot typecheck args, because
     * we have no idea what argument types are expected.
     * Also, ignore typecheck if warnings/errors if this method
     * has already been evaluated at least once -- in order
     * to suppress repetitive messages.
     */
    if (!Info->Predefined || (Info->Node->Flags & ANOBJ_EVALUATED))
    {
        return;
    }
 
    ArgTypeList = Info->Predefined->Info.ArgumentList;
    ArgCount = METHOD_GET_ARG_COUNT (ArgTypeList);
 
    /* Typecheck all arguments */
 
    for (i = 0; ((i < ArgCount) && (i < Info->ParamCount)); i++)
    {
        ArgType = METHOD_GET_NEXT_TYPE (ArgTypeList);
        UserArgType = Info->Parameters[i]->Common.Type;
 
        /* No typechecking for ACPI_TYPE_ANY */
 
        if ((UserArgType != ArgType) && (ArgType != ACPI_TYPE_ANY))
        {
            ACPI_WARN_PREDEFINED ((AE_INFO, Info->FullPathname, ACPI_WARN_ALWAYS,
                "Argument #%u type mismatch - "
                "Found [%s], ACPI requires [%s]", (i + 1),
                AcpiUtGetTypeName (UserArgType),
                AcpiUtGetTypeName (ArgType)));
 
            /* Prevent any additional typechecking for this method */
 
            Info->Node->Flags |= ANOBJ_EVALUATED;
        }
    }
}

Referenced by AcpiNsEvaluate().

AcpiNsCheckObjectType()

ACPI_STATUS AcpiNsCheckObjectType	(	ACPI_EVALUATE_INFO *	Info,
		ACPI_OPERAND_OBJECT **	ReturnObjectPtr,
		UINT32	ExpectedBtypes,
		UINT32	PackageIndex
	)

Definition at line 245 of file nspredef.c.

{
    ACPI_OPERAND_OBJECT         *ReturnObject = *ReturnObjectPtr;
    ACPI_STATUS                 Status = AE_OK;
    char                        TypeBuffer[96]; /* Room for 10 types */
 
 
    /* A Namespace node should not get here, but make sure */
 
    if (ReturnObject &&
        ACPI_GET_DESCRIPTOR_TYPE (ReturnObject) == ACPI_DESC_TYPE_NAMED)
    {
        ACPI_WARN_PREDEFINED ((AE_INFO, Info->FullPathname, Info->NodeFlags,
            "Invalid return type - Found a Namespace node [%4.4s] type %s",
            ReturnObject->Node.Name.Ascii,
            AcpiUtGetTypeName (ReturnObject->Node.Type)));
        return (AE_AML_OPERAND_TYPE);
    }
 
    /*
     * Convert the object type (ACPI_TYPE_xxx) to a bitmapped object type.
     * The bitmapped type allows multiple possible return types.
     *
     * Note, the cases below must handle all of the possible types returned
     * from all of the predefined names (including elements of returned
     * packages)
     */
    Info->ReturnBtype = AcpiNsGetBitmappedType (ReturnObject);
    if (Info->ReturnBtype == ACPI_RTYPE_ANY)
    {
        /* Not one of the supported objects, must be incorrect */
        goto TypeErrorExit;
    }
 
    /* For reference objects, check that the reference type is correct */
 
    if ((Info->ReturnBtype & ExpectedBtypes) == ACPI_RTYPE_REFERENCE)
    {
        Status = AcpiNsCheckReference (Info, ReturnObject);
        return (Status);
    }
 
    /* Attempt simple repair of the returned object if necessary */
 
    Status = AcpiNsSimpleRepair (Info, ExpectedBtypes,
        PackageIndex, ReturnObjectPtr);
    if (ACPI_SUCCESS (Status))
    {
        return (AE_OK); /* Successful repair */
    }
 
 
TypeErrorExit:
 
    /* Create a string with all expected types for this predefined object */
 
    AcpiUtGetExpectedReturnTypes (TypeBuffer, ExpectedBtypes);
 
    if (!ReturnObject)
    {
        ACPI_WARN_PREDEFINED ((AE_INFO, Info->FullPathname, Info->NodeFlags,
            "Expected return object of type %s",
            TypeBuffer));
    }
    else if (PackageIndex == ACPI_NOT_PACKAGE_ELEMENT)
    {
        ACPI_WARN_PREDEFINED ((AE_INFO, Info->FullPathname, Info->NodeFlags,
            "Return type mismatch - found %s, expected %s",
            AcpiUtGetObjectTypeName (ReturnObject), TypeBuffer));
    }
    else
    {
        ACPI_WARN_PREDEFINED ((AE_INFO, Info->FullPathname, Info->NodeFlags,
            "Return Package type mismatch at index %u - "
            "found %s, expected %s", PackageIndex,
            AcpiUtGetObjectTypeName (ReturnObject), TypeBuffer));
    }
 
    return (AE_AML_OPERAND_TYPE);
}

Referenced by AcpiNsCheckPackage(), AcpiNsCheckPackageElements(), AcpiNsCheckPackageList(), and AcpiNsCheckReturnValue().

AcpiNsCheckPackage()

ACPI_STATUS AcpiNsCheckPackage	(	ACPI_EVALUATE_INFO *	Info,
		ACPI_OPERAND_OBJECT **	ReturnObjectPtr
	)

Definition at line 96 of file nsprepkg.c.

{
    ACPI_OPERAND_OBJECT         *ReturnObject = *ReturnObjectPtr;
    const ACPI_PREDEFINED_INFO  *Package;
    ACPI_OPERAND_OBJECT         **Elements;
    ACPI_STATUS                 Status = AE_OK;
    UINT32                      ExpectedCount;
    UINT32                      Count;
    UINT32                      i;
 
 
    ACPI_FUNCTION_TRACE (NsCheckPackage);
 
 
    /* The package info for this name is in the next table entry */
 
    Package = Info->Predefined + 1;
 
    ACPI_DEBUG_PRINT ((ACPI_DB_NAMES,
        "%s Validating return Package of Type %X, Count %X\n",
        Info->FullPathname, Package->RetInfo.Type,
        ReturnObject->Package.Count));
 
    /*
     * For variable-length Packages, we can safely remove all embedded
     * and trailing NULL package elements
     */
    AcpiNsRemoveNullElements (Info, Package->RetInfo.Type, ReturnObject);
 
    /* Extract package count and elements array */
 
    Elements = ReturnObject->Package.Elements;
    Count = ReturnObject->Package.Count;
 
    /*
     * Most packages must have at least one element. The only exception
     * is the variable-length package (ACPI_PTYPE1_VAR).
     */
    if (!Count)
    {
        if (Package->RetInfo.Type == ACPI_PTYPE1_VAR)
        {
            return_ACPI_STATUS (AE_OK);
        }
 
        ACPI_WARN_PREDEFINED ((AE_INFO, Info->FullPathname, Info->NodeFlags,
            "Return Package has no elements (empty)"));
 
        return_ACPI_STATUS (AE_AML_OPERAND_VALUE);
    }
 
    /*
     * Decode the type of the expected package contents
     *
     * PTYPE1 packages contain no subpackages
     * PTYPE2 packages contain subpackages
     */
    switch (Package->RetInfo.Type)
    {
    case ACPI_PTYPE_CUSTOM:
 
        Status = AcpiNsCustomPackage (Info, Elements, Count);
        break;
 
    case ACPI_PTYPE1_FIXED:
        /*
         * The package count is fixed and there are no subpackages
         *
         * If package is too small, exit.
         * If package is larger than expected, issue warning but continue
         */
        ExpectedCount = Package->RetInfo.Count1 + Package->RetInfo.Count2;
        if (Count < ExpectedCount)
        {
            goto PackageTooSmall;
        }
        else if (Count > ExpectedCount)
        {
            ACPI_DEBUG_PRINT ((ACPI_DB_REPAIR,
                "%s: Return Package is larger than needed - "
                "found %u, expected %u\n",
                Info->FullPathname, Count, ExpectedCount));
        }
 
        /* Validate all elements of the returned package */
 
        Status = AcpiNsCheckPackageElements (Info, Elements,
            Package->RetInfo.ObjectType1, Package->RetInfo.Count1,
            Package->RetInfo.ObjectType2, Package->RetInfo.Count2, 0);
        break;
 
    case ACPI_PTYPE1_VAR:
        /*
         * The package count is variable, there are no subpackages, and all
         * elements must be of the same type
         */
        for (i = 0; i < Count; i++)
        {
            Status = AcpiNsCheckObjectType (Info, Elements,
                Package->RetInfo.ObjectType1, i);
            if (ACPI_FAILURE (Status))
            {
                return_ACPI_STATUS (Status);
            }
 
            Elements++;
        }
        break;
 
    case ACPI_PTYPE1_OPTION:
        /*
         * The package count is variable, there are no subpackages. There are
         * a fixed number of required elements, and a variable number of
         * optional elements.
         *
         * Check if package is at least as large as the minimum required
         */
        ExpectedCount = Package->RetInfo3.Count;
        if (Count < ExpectedCount)
        {
            goto PackageTooSmall;
        }
 
        /* Variable number of sub-objects */
 
        for (i = 0; i < Count; i++)
        {
            if (i < Package->RetInfo3.Count)
            {
                /* These are the required package elements (0, 1, or 2) */
 
                Status = AcpiNsCheckObjectType (Info, Elements,
                    Package->RetInfo3.ObjectType[i], i);
                if (ACPI_FAILURE (Status))
                {
                    return_ACPI_STATUS (Status);
                }
            }
            else
            {
                /* These are the optional package elements */
 
                Status = AcpiNsCheckObjectType (Info, Elements,
                    Package->RetInfo3.TailObjectType, i);
                if (ACPI_FAILURE (Status))
                {
                    return_ACPI_STATUS (Status);
                }
            }
 
            Elements++;
        }
        break;
 
    case ACPI_PTYPE2_REV_FIXED:
 
        /* First element is the (Integer) revision */
 
        Status = AcpiNsCheckObjectType (
            Info, Elements, ACPI_RTYPE_INTEGER, 0);
        if (ACPI_FAILURE (Status))
        {
            return_ACPI_STATUS (Status);
        }
 
        Elements++;
        Count--;
 
        /* Examine the subpackages */
 
        Status = AcpiNsCheckPackageList (Info, Package, Elements, Count);
        break;
 
    case ACPI_PTYPE2_PKG_COUNT:
 
        /* First element is the (Integer) count of subpackages to follow */
 
        Status = AcpiNsCheckObjectType (
            Info, Elements, ACPI_RTYPE_INTEGER, 0);
        if (ACPI_FAILURE (Status))
        {
            return_ACPI_STATUS (Status);
        }
 
        /*
         * Count cannot be larger than the parent package length, but allow it
         * to be smaller. The >= accounts for the Integer above.
         */
        ExpectedCount = (UINT32) (*Elements)->Integer.Value;
        if (ExpectedCount >= Count)
        {
            goto PackageTooSmall;
        }
 
        Count = ExpectedCount;
        Elements++;
 
        /* Examine the subpackages */
 
        Status = AcpiNsCheckPackageList (Info, Package, Elements, Count);
        break;
 
    case ACPI_PTYPE2:
    case ACPI_PTYPE2_FIXED:
    case ACPI_PTYPE2_MIN:
    case ACPI_PTYPE2_COUNT:
    case ACPI_PTYPE2_FIX_VAR:
        /*
         * These types all return a single Package that consists of a
         * variable number of subpackages.
         *
         * First, ensure that the first element is a subpackage. If not,
         * the BIOS may have incorrectly returned the object as a single
         * package instead of a Package of Packages (a common error if
         * there is only one entry). We may be able to repair this by
         * wrapping the returned Package with a new outer Package.
         */
        if (*Elements && ((*Elements)->Common.Type != ACPI_TYPE_PACKAGE))
        {
            /* Create the new outer package and populate it */
 
            Status = AcpiNsWrapWithPackage (
                Info, ReturnObject, ReturnObjectPtr);
            if (ACPI_FAILURE (Status))
            {
                return_ACPI_STATUS (Status);
            }
 
            /* Update locals to point to the new package (of 1 element) */
 
            ReturnObject = *ReturnObjectPtr;
            Elements = ReturnObject->Package.Elements;
            Count = 1;
        }
 
        /* Examine the subpackages */
 
        Status = AcpiNsCheckPackageList (Info, Package, Elements, Count);
        break;
 
    case ACPI_PTYPE2_VAR_VAR:
        /*
         * Returns a variable list of packages, each with a variable list
         * of objects.
         */
        break;
 
    case ACPI_PTYPE2_UUID_PAIR:
 
        /* The package must contain pairs of (UUID + type) */
 
        if (Count & 1)
        {
            ExpectedCount = Count + 1;
            goto PackageTooSmall;
        }
 
        while (Count > 0)
        {
            Status = AcpiNsCheckObjectType(Info, Elements,
                Package->RetInfo.ObjectType1, 0);
            if (ACPI_FAILURE(Status))
            {
                return_ACPI_STATUS (Status);
            }
 
            /* Validate length of the UUID buffer */
 
            if ((*Elements)->Buffer.Length != 16)
            {
                ACPI_WARN_PREDEFINED ((AE_INFO, Info->FullPathname,
                    Info->NodeFlags, "Invalid length for UUID Buffer"));
                return_ACPI_STATUS (AE_AML_OPERAND_VALUE);
            }
 
            Status = AcpiNsCheckObjectType(Info, Elements + 1,
                Package->RetInfo.ObjectType2, 0);
            if (ACPI_FAILURE(Status))
            {
                return_ACPI_STATUS (Status);
            }
 
            Elements += 2;
            Count -= 2;
        }
        break;
 
    default:
 
        /* Should not get here if predefined info table is correct */
 
        ACPI_WARN_PREDEFINED ((AE_INFO, Info->FullPathname, Info->NodeFlags,
            "Invalid internal return type in table entry: %X",
            Package->RetInfo.Type));
 
        return_ACPI_STATUS (AE_AML_INTERNAL);
    }
 
    return_ACPI_STATUS (Status);
 
 
PackageTooSmall:
 
    /* Error exit for the case with an incorrect package count */
 
    ACPI_WARN_PREDEFINED ((AE_INFO, Info->FullPathname, Info->NodeFlags,
        "Return Package is too small - found %u elements, expected %u",
        Count, ExpectedCount));
 
    return_ACPI_STATUS (AE_AML_OPERAND_VALUE);
}

Referenced by AcpiNsCheckReturnValue().

AcpiNsCheckReturnValue()

ACPI_STATUS AcpiNsCheckReturnValue	(	ACPI_NAMESPACE_NODE *	Node,
		ACPI_EVALUATE_INFO *	Info,
		UINT32	UserParamCount,
		ACPI_STATUS	ReturnStatus,
		ACPI_OPERAND_OBJECT **	ReturnObject
	)

Definition at line 108 of file nspredef.c.

{
    ACPI_STATUS                 Status;
    const ACPI_PREDEFINED_INFO  *Predefined;
 
    ACPI_FUNCTION_TRACE (NsCheckReturnValue);
 
    /* If not a predefined name, we cannot validate the return object */
 
    Predefined = Info->Predefined;
    if (!Predefined)
    {
        return_ACPI_STATUS (AE_OK);
    }
 
    /*
     * If the method failed or did not actually return an object, we cannot
     * validate the return object
     */
    if ((ReturnStatus != AE_OK) &&
        (ReturnStatus != AE_CTRL_RETURN_VALUE))
    {
        return_ACPI_STATUS (AE_OK);
    }
 
    /*
     * Return value validation and possible repair.
     *
     * 1) Don't perform return value validation/repair if this feature
     * has been disabled via a global option.
     *
     * 2) We have a return value, but if one wasn't expected, just exit,
     * this is not a problem. For example, if the "Implicit Return"
     * feature is enabled, methods will always return a value.
     *
     * 3) If the return value can be of any type, then we cannot perform
     * any validation, just exit.
     */
    if (AcpiGbl_DisableAutoRepair ||
        (!Predefined->Info.ExpectedBtypes) ||
        (Predefined->Info.ExpectedBtypes == ACPI_RTYPE_ALL))
    {
        return_ACPI_STATUS (AE_OK);
    }
 
    /*
     * Check that the type of the main return object is what is expected
     * for this predefined name
     */
    Status = AcpiNsCheckObjectType (Info, ReturnObjectPtr,
        Predefined->Info.ExpectedBtypes, ACPI_NOT_PACKAGE_ELEMENT);
    if (ACPI_FAILURE (Status))
    {
        goto Exit;
    }
 
    /*
     *
     * 4) If there is no return value and it is optional, just return
     * AE_OK (_WAK).
     */
    if (!(*ReturnObjectPtr))
    {
        goto Exit;
    }
 
    /*
     * For returned Package objects, check the type of all sub-objects.
     * Note: Package may have been newly created by call above.
     */
    if ((*ReturnObjectPtr)->Common.Type == ACPI_TYPE_PACKAGE)
    {
        Info->ParentPackage = *ReturnObjectPtr;
        Status = AcpiNsCheckPackage (Info, ReturnObjectPtr);
        if (ACPI_FAILURE (Status))
        {
            /* We might be able to fix some errors */
 
            if ((Status != AE_AML_OPERAND_TYPE) &&
                (Status != AE_AML_OPERAND_VALUE))
            {
                goto Exit;
            }
        }
    }
 
    /*
     * The return object was OK, or it was successfully repaired above.
     * Now make some additional checks such as verifying that package
     * objects are sorted correctly (if required) or buffer objects have
     * the correct data width (bytes vs. dwords). These repairs are
     * performed on a per-name basis, i.e., the code is specific to
     * particular predefined names.
     */
    Status = AcpiNsComplexRepairs (Info, Node, Status, ReturnObjectPtr);
 
Exit:
    /*
     * If the object validation failed or if we successfully repaired one
     * or more objects, mark the parent node to suppress further warning
     * messages during the next evaluation of the same method/object.
     */
    if (ACPI_FAILURE (Status) ||
       (Info->ReturnFlags & ACPI_OBJECT_REPAIRED))
    {
        Node->Flags |= ANOBJ_EVALUATED;
    }
 
    return_ACPI_STATUS (Status);
}

Referenced by AcpiNsEvaluate().

AcpiNsCompareNames()

int AcpiNsCompareNames	(	char *	Name1,
		char *	Name2
	)

AcpiNsComplexRepairs()

ACPI_STATUS AcpiNsComplexRepairs	(	ACPI_EVALUATE_INFO *	Info,
		ACPI_NAMESPACE_NODE *	Node,
		ACPI_STATUS	ValidateStatus,
		ACPI_OPERAND_OBJECT **	ReturnObjectPtr
	)

Definition at line 206 of file nsrepair2.c.

{
    const ACPI_REPAIR_INFO  *Predefined;
    ACPI_STATUS             Status;
 
 
    ACPI_FUNCTION_TRACE (NsComplexRepairs);
 
    /* Check if this name is in the list of repairable names */
 
    Predefined = AcpiNsMatchComplexRepair (Node);
    if (!Predefined)
    {
        return_ACPI_STATUS (ValidateStatus);
    }
 
    Status = Predefined->RepairFunction (Info, ReturnObjectPtr);
    return_ACPI_STATUS (Status);
}

Referenced by AcpiNsCheckReturnValue().

AcpiNsConvertToBuffer()

ACPI_STATUS AcpiNsConvertToBuffer	(	ACPI_OPERAND_OBJECT *	OriginalObject,
		ACPI_OPERAND_OBJECT **	ReturnObject
	)

Definition at line 233 of file nsconvert.c.

{
    ACPI_OPERAND_OBJECT     *NewObject;
    ACPI_STATUS             Status;
    ACPI_OPERAND_OBJECT     **Elements;
    UINT32                  *DwordBuffer;
    UINT32                  Count;
    UINT32                  i;
 
 
    switch (OriginalObject->Common.Type)
    {
    case ACPI_TYPE_INTEGER:
        /*
         * Integer-to-Buffer conversion.
         * Convert the Integer to a packed-byte buffer. _MAT and other
         * objects need this sometimes, if a read has been performed on a
         * Field object that is less than or equal to the global integer
         * size (32 or 64 bits).
         */
        Status = AcpiExConvertToBuffer (OriginalObject, &NewObject);
        if (ACPI_FAILURE (Status))
        {
            return (Status);
        }
        break;
 
    case ACPI_TYPE_STRING:
 
        /* String-to-Buffer conversion. Simple data copy */
 
        NewObject = AcpiUtCreateBufferObject
            (OriginalObject->String.Length);
        if (!NewObject)
        {
            return (AE_NO_MEMORY);
        }
 
        memcpy (NewObject->Buffer.Pointer,
            OriginalObject->String.Pointer, OriginalObject->String.Length);
        break;
 
    case ACPI_TYPE_PACKAGE:
        /*
         * This case is often seen for predefined names that must return a
         * Buffer object with multiple DWORD integers within. For example,
         * _FDE and _GTM. The Package can be converted to a Buffer.
         */
 
        /* All elements of the Package must be integers */
 
        Elements = OriginalObject->Package.Elements;
        Count = OriginalObject->Package.Count;
 
        for (i = 0; i < Count; i++)
        {
            if ((!*Elements) ||
                ((*Elements)->Common.Type != ACPI_TYPE_INTEGER))
            {
                return (AE_AML_OPERAND_TYPE);
            }
            Elements++;
        }
 
        /* Create the new buffer object to replace the Package */
 
        NewObject = AcpiUtCreateBufferObject (ACPI_MUL_4 (Count));
        if (!NewObject)
        {
            return (AE_NO_MEMORY);
        }
 
        /* Copy the package elements (integers) to the buffer as DWORDs */
 
        Elements = OriginalObject->Package.Elements;
        DwordBuffer = ACPI_CAST_PTR (UINT32, NewObject->Buffer.Pointer);
 
        for (i = 0; i < Count; i++)
        {
            *DwordBuffer = (UINT32) (*Elements)->Integer.Value;
            DwordBuffer++;
            Elements++;
        }
        break;
 
    default:
 
        return (AE_AML_OPERAND_TYPE);
    }
 
    *ReturnObject = NewObject;
    return (AE_OK);
}

Referenced by AcpiNsSimpleRepair().

AcpiNsConvertToInteger()

ACPI_STATUS AcpiNsConvertToInteger	(	ACPI_OPERAND_OBJECT *	OriginalObject,
		ACPI_OPERAND_OBJECT **	ReturnObject
	)

Definition at line 70 of file nsconvert.c.

{
    ACPI_OPERAND_OBJECT     *NewObject;
    ACPI_STATUS             Status;
    UINT64                  Value = 0;
    UINT32                  i;
 
 
    switch (OriginalObject->Common.Type)
    {
    case ACPI_TYPE_STRING:
 
        /* String-to-Integer conversion */
 
        Status = AcpiUtStrtoul64 (OriginalObject->String.Pointer, &Value);
        if (ACPI_FAILURE (Status))
        {
            return (Status);
        }
        break;
 
    case ACPI_TYPE_BUFFER:
 
        /* Buffer-to-Integer conversion. Max buffer size is 64 bits. */
 
        if (OriginalObject->Buffer.Length > 8)
        {
            return (AE_AML_OPERAND_TYPE);
        }
 
        /* Extract each buffer byte to create the integer */
 
        for (i = 0; i < OriginalObject->Buffer.Length; i++)
        {
            Value |= ((UINT64)
                OriginalObject->Buffer.Pointer[i] << (i * 8));
        }
        break;
 
    default:
 
        return (AE_AML_OPERAND_TYPE);
    }
 
    NewObject = AcpiUtCreateIntegerObject (Value);
    if (!NewObject)
    {
        return (AE_NO_MEMORY);
    }
 
    *ReturnObject = NewObject;
    return (AE_OK);
}

Referenced by AcpiNsSimpleRepair().

AcpiNsConvertToReference()

ACPI_STATUS AcpiNsConvertToReference	(	ACPI_NAMESPACE_NODE *	Scope,
		ACPI_OPERAND_OBJECT *	OriginalObject,
		ACPI_OPERAND_OBJECT **	ReturnObject
	)

Definition at line 506 of file nsconvert.c.

{
    ACPI_OPERAND_OBJECT     *NewObject = NULL;
    ACPI_STATUS             Status;
    ACPI_NAMESPACE_NODE     *Node;
    ACPI_GENERIC_STATE      ScopeInfo;
    char                    *Name;
 
 
    ACPI_FUNCTION_NAME (NsConvertToReference);
 
 
    /* Convert path into internal presentation */
 
    Status = AcpiNsInternalizeName (OriginalObject->String.Pointer, &Name);
    if (ACPI_FAILURE (Status))
    {
        return_ACPI_STATUS (Status);
    }
 
    /* Find the namespace node */
 
    ScopeInfo.Scope.Node = ACPI_CAST_PTR (ACPI_NAMESPACE_NODE, Scope);
    Status = AcpiNsLookup (&ScopeInfo, Name,
        ACPI_TYPE_ANY, ACPI_IMODE_EXECUTE,
        ACPI_NS_SEARCH_PARENT | ACPI_NS_DONT_OPEN_SCOPE, NULL, &Node);
    if (ACPI_FAILURE (Status))
    {
        /* Check if we are resolving a named reference within a package */
 
        ACPI_ERROR_NAMESPACE (&ScopeInfo,
            OriginalObject->String.Pointer, Status);
        goto ErrorExit;
    }
 
    /* Create and init a new internal ACPI object */
 
    NewObject = AcpiUtCreateInternalObject (ACPI_TYPE_LOCAL_REFERENCE);
    if (!NewObject)
    {
        Status = AE_NO_MEMORY;
        goto ErrorExit;
    }
    NewObject->Reference.Node = Node;
    NewObject->Reference.Object = Node->Object;
    NewObject->Reference.Class = ACPI_REFCLASS_NAME;
 
    /*
     * Increase reference of the object if needed (the object is likely a
     * null for device nodes).
     */
    AcpiUtAddReference (Node->Object);
 
ErrorExit:
    ACPI_FREE (Name);
    *ReturnObject = NewObject;
    return (Status);
}

AcpiNsConvertToResource()

ACPI_STATUS AcpiNsConvertToResource	(	ACPI_NAMESPACE_NODE *	Scope,
		ACPI_OPERAND_OBJECT *	OriginalObject,
		ACPI_OPERAND_OBJECT **	ReturnObject
	)

Definition at line 420 of file nsconvert.c.

{
    ACPI_OPERAND_OBJECT     *NewObject;
    UINT8                   *Buffer;
 
 
    /*
     * We can fix the following cases for an expected resource template:
     * 1. No return value (interpreter slack mode is disabled)
     * 2. A "Return (Zero)" statement
     * 3. A "Return empty buffer" statement
     *
     * We will return a buffer containing a single EndTag
     * resource descriptor.
     */
    if (OriginalObject)
    {
        switch (OriginalObject->Common.Type)
        {
        case ACPI_TYPE_INTEGER:
 
            /* We can only repair an Integer==0 */
 
            if (OriginalObject->Integer.Value)
            {
                return (AE_AML_OPERAND_TYPE);
            }
            break;
 
        case ACPI_TYPE_BUFFER:
 
            if (OriginalObject->Buffer.Length)
            {
                /* Additional checks can be added in the future */
 
                *ReturnObject = NULL;
                return (AE_OK);
            }
            break;
 
        case ACPI_TYPE_STRING:
        default:
 
            return (AE_AML_OPERAND_TYPE);
        }
    }
 
    /* Create the new buffer object for the resource descriptor */
 
    NewObject = AcpiUtCreateBufferObject (2);
    if (!NewObject)
    {
        return (AE_NO_MEMORY);
    }
 
    Buffer = ACPI_CAST_PTR (UINT8, NewObject->Buffer.Pointer);
 
    /* Initialize the Buffer with a single EndTag descriptor */
 
    Buffer[0] = (ACPI_RESOURCE_NAME_END_TAG | ASL_RDESC_END_TAG_SIZE);
    Buffer[1] = 0x00;
 
    *ReturnObject = NewObject;
    return (AE_OK);
}

AcpiNsConvertToString()

ACPI_STATUS AcpiNsConvertToString	(	ACPI_OPERAND_OBJECT *	OriginalObject,
		ACPI_OPERAND_OBJECT **	ReturnObject
	)

Definition at line 141 of file nsconvert.c.

{
    ACPI_OPERAND_OBJECT     *NewObject;
    ACPI_SIZE               Length;
    ACPI_STATUS             Status;
 
 
    switch (OriginalObject->Common.Type)
    {
    case ACPI_TYPE_INTEGER:
        /*
         * Integer-to-String conversion. Commonly, convert
         * an integer of value 0 to a NULL string. The last element of
         * _BIF and _BIX packages occasionally need this fix.
         */
        if (OriginalObject->Integer.Value == 0)
        {
            /* Allocate a new NULL string object */
 
            NewObject = AcpiUtCreateStringObject (0);
            if (!NewObject)
            {
                return (AE_NO_MEMORY);
            }
        }
        else
        {
            Status = AcpiExConvertToString (OriginalObject,
                &NewObject, ACPI_IMPLICIT_CONVERT_HEX);
            if (ACPI_FAILURE (Status))
            {
                return (Status);
            }
        }
        break;
 
    case ACPI_TYPE_BUFFER:
        /*
         * Buffer-to-String conversion. Use a ToString
         * conversion, no transform performed on the buffer data. The best
         * example of this is the _BIF method, where the string data from
         * the battery is often (incorrectly) returned as buffer object(s).
         */
        Length = 0;
        while ((Length < OriginalObject->Buffer.Length) &&
                (OriginalObject->Buffer.Pointer[Length]))
        {
            Length++;
        }
 
        /* Allocate a new string object */
 
        NewObject = AcpiUtCreateStringObject (Length);
        if (!NewObject)
        {
            return (AE_NO_MEMORY);
        }
 
        /*
         * Copy the raw buffer data with no transform. String is already NULL
         * terminated at Length+1.
         */
        memcpy (NewObject->String.Pointer,
            OriginalObject->Buffer.Pointer, Length);
        break;
 
    default:
 
        return (AE_AML_OPERAND_TYPE);
    }
 
    *ReturnObject = NewObject;
    return (AE_OK);
}

Referenced by AcpiNsSimpleRepair().

AcpiNsConvertToUnicode()

ACPI_STATUS AcpiNsConvertToUnicode	(	ACPI_NAMESPACE_NODE *	Scope,
		ACPI_OPERAND_OBJECT *	OriginalObject,
		ACPI_OPERAND_OBJECT **	ReturnObject
	)

Definition at line 345 of file nsconvert.c.

{
    ACPI_OPERAND_OBJECT     *NewObject;
    char                    *AsciiString;
    UINT16                  *UnicodeBuffer;
    UINT32                  UnicodeLength;
    UINT32                  i;
 
 
    if (!OriginalObject)
    {
        return (AE_OK);
    }
 
    /* If a Buffer was returned, it must be at least two bytes long */
 
    if (OriginalObject->Common.Type == ACPI_TYPE_BUFFER)
    {
        if (OriginalObject->Buffer.Length < 2)
        {
            return (AE_AML_OPERAND_VALUE);
        }
 
        *ReturnObject = NULL;
        return (AE_OK);
    }
 
    /*
     * The original object is an ASCII string. Convert this string to
     * a unicode buffer.
     */
    AsciiString = OriginalObject->String.Pointer;
    UnicodeLength = (OriginalObject->String.Length * 2) + 2;
 
    /* Create a new buffer object for the Unicode data */
 
    NewObject = AcpiUtCreateBufferObject (UnicodeLength);
    if (!NewObject)
    {
        return (AE_NO_MEMORY);
    }
 
    UnicodeBuffer = ACPI_CAST_PTR (UINT16, NewObject->Buffer.Pointer);
 
    /* Convert ASCII to Unicode */
 
    for (i = 0; i < OriginalObject->String.Length; i++)
    {
        UnicodeBuffer[i] = (UINT16) AsciiString[i];
    }
 
    *ReturnObject = NewObject;
    return (AE_OK);
}

AcpiNsCreateNode()

ACPI_NAMESPACE_NODE * AcpiNsCreateNode

(

UINT32

Name

)

Definition at line 66 of file nsalloc.c.

{
    ACPI_NAMESPACE_NODE     *Node;
#ifdef ACPI_DBG_TRACK_ALLOCATIONS
    UINT32                  Temp;
#endif
 
 
    ACPI_FUNCTION_TRACE (NsCreateNode);
 
 
    Node = AcpiOsAcquireObject (AcpiGbl_NamespaceCache);
    if (!Node)
    {
        return_PTR (NULL);
    }
 
    ACPI_MEM_TRACKING (AcpiGbl_NsNodeList->TotalAllocated++);
 
#ifdef ACPI_DBG_TRACK_ALLOCATIONS
        Temp = AcpiGbl_NsNodeList->TotalAllocated -
            AcpiGbl_NsNodeList->TotalFreed;
        if (Temp > AcpiGbl_NsNodeList->MaxOccupied)
        {
            AcpiGbl_NsNodeList->MaxOccupied = Temp;
        }
#endif
 
    Node->Name.Integer = Name;
    ACPI_SET_DESCRIPTOR_TYPE (Node, ACPI_DESC_TYPE_NAMED);
    return_PTR (Node);
}

Referenced by AcpiNsRootInitialize(), and AcpiNsSearchAndEnter().

AcpiNsDeleteChildren()

void AcpiNsDeleteChildren

(

ACPI_NAMESPACE_NODE *

Parent

)

Definition at line 341 of file nsalloc.c.

{
    ACPI_NAMESPACE_NODE     *NextNode;
    ACPI_NAMESPACE_NODE     *NodeToDelete;
 
 
    ACPI_FUNCTION_TRACE_PTR (NsDeleteChildren, ParentNode);
 
 
    if (!ParentNode)
    {
        return_VOID;
    }
 
    /* Deallocate all children at this level */
 
    NextNode = ParentNode->Child;
    while (NextNode)
    {
        /* Grandchildren should have all been deleted already */
 
        if (NextNode->Child)
        {
            ACPI_ERROR ((AE_INFO, "Found a grandchild! P=%p C=%p",
                ParentNode, NextNode));
        }
 
        /*
         * Delete this child node and move on to the next child in the list.
         * No need to unlink the node since we are deleting the entire branch.
         */
        NodeToDelete = NextNode;
        NextNode = NextNode->Peer;
        AcpiNsDeleteNode (NodeToDelete);
    }
 
    /* Clear the parent's child pointer */
 
    ParentNode->Child = NULL;
    return_VOID;
}

Referenced by AcpiNsDeleteNamespaceByOwner(), AcpiNsDeleteNamespaceSubtree(), AcpiNsSearchAndEnter(), and AcpiPsCompleteOp().

AcpiNsDeleteNamespaceByOwner()

void AcpiNsDeleteNamespaceByOwner

(

ACPI_OWNER_ID

OwnerId

)

Definition at line 497 of file nsalloc.c.

{
    ACPI_NAMESPACE_NODE     *ChildNode;
    ACPI_NAMESPACE_NODE     *DeletionNode;
    ACPI_NAMESPACE_NODE     *ParentNode;
    UINT32                  Level;
    ACPI_STATUS             Status;
 
 
    ACPI_FUNCTION_TRACE_U32 (NsDeleteNamespaceByOwner, OwnerId);
 
 
    if (OwnerId == 0)
    {
        return_VOID;
    }
 
    /* Lock namespace for possible update */
 
    Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE);
    if (ACPI_FAILURE (Status))
    {
        return_VOID;
    }
 
    DeletionNode = NULL;
    ParentNode = AcpiGbl_RootNode;
    ChildNode = NULL;
    Level = 1;
 
    /*
     * Traverse the tree of nodes until we bubble back up
     * to where we started.
     */
    while (Level > 0)
    {
        /*
         * Get the next child of this parent node. When ChildNode is NULL,
         * the first child of the parent is returned
         */
        ChildNode = AcpiNsGetNextNode (ParentNode, ChildNode);
 
        if (DeletionNode)
        {
            AcpiNsDeleteChildren (DeletionNode);
            AcpiNsRemoveNode (DeletionNode);
            DeletionNode = NULL;
        }
 
        if (ChildNode)
        {
            if (ChildNode->OwnerId == OwnerId)
            {
                /* Found a matching child node - detach any attached object */
 
                AcpiNsDetachObject (ChildNode);
            }
 
            /* Check if this node has any children */
 
            if (ChildNode->Child)
            {
                /*
                 * There is at least one child of this node,
                 * visit the node
                 */
                Level++;
                ParentNode = ChildNode;
                ChildNode  = NULL;
            }
            else if (ChildNode->OwnerId == OwnerId)
            {
                DeletionNode = ChildNode;
            }
        }
        else
        {
            /*
             * No more children of this parent node.
             * Move up to the grandparent.
             */
            Level--;
            if (Level != 0)
            {
                if (ParentNode->OwnerId == OwnerId)
                {
                    DeletionNode = ParentNode;
                }
            }
 
            /* New "last child" is this parent node */
 
            ChildNode = ParentNode;
 
            /* Move up the tree to the grandparent */
 
            ParentNode = ParentNode->Parent;
        }
    }
 
    (void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);
    return_VOID;
}

Referenced by AcpiDsTerminateControlMethod(), AcpiNsLoadTable(), and AcpiTbDeleteNamespaceByOwner().

AcpiNsDeleteNamespaceSubtree()

void AcpiNsDeleteNamespaceSubtree

(

ACPI_NAMESPACE_NODE *

ParentHandle

)

Definition at line 399 of file nsalloc.c.

{
    ACPI_NAMESPACE_NODE     *ChildNode = NULL;
    UINT32                  Level = 1;
    ACPI_STATUS             Status;
 
 
    ACPI_FUNCTION_TRACE (NsDeleteNamespaceSubtree);
 
 
    if (!ParentNode)
    {
        return_VOID;
    }
 
    /* Lock namespace for possible update */
 
    Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE);
    if (ACPI_FAILURE (Status))
    {
        return_VOID;
    }
 
    /*
     * Traverse the tree of objects until we bubble back up
     * to where we started.
     */
    while (Level > 0)
    {
        /* Get the next node in this scope (NULL if none) */
 
        ChildNode = AcpiNsGetNextNode (ParentNode, ChildNode);
        if (ChildNode)
        {
            /* Found a child node - detach any attached object */
 
            AcpiNsDetachObject (ChildNode);
 
            /* Check if this node has any children */
 
            if (ChildNode->Child)
            {
                /*
                 * There is at least one child of this node,
                 * visit the node
                 */
                Level++;
                ParentNode = ChildNode;
                ChildNode  = NULL;
            }
        }
        else
        {
            /*
             * No more children of this parent node.
             * Move up to the grandparent.
             */
            Level--;
 
            /*
             * Now delete all of the children of this parent
             * all at the same time.
             */
            AcpiNsDeleteChildren (ParentNode);
 
            /* New "last child" is this parent node */
 
            ChildNode = ParentNode;
 
            /* Move up the tree to the grandparent */
 
            ParentNode = ParentNode->Parent;
        }
    }
 
    (void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);
    return_VOID;
}

Referenced by AcpiDsTerminateControlMethod(), and AcpiNsTerminate().

AcpiNsDeleteNode()

void AcpiNsDeleteNode

(

ACPI_NAMESPACE_NODE *

Node

)

Definition at line 117 of file nsalloc.c.

{
    ACPI_OPERAND_OBJECT     *ObjDesc;
    ACPI_OPERAND_OBJECT     *NextDesc;
 
 
    ACPI_FUNCTION_NAME (NsDeleteNode);
 
 
    if (!Node)
    {
        return_VOID;
    }
 
    /* Detach an object if there is one */
 
    AcpiNsDetachObject (Node);
 
    /*
     * Delete an attached data object list if present (objects that were
     * attached via AcpiAttachData). Note: After any normal object is
     * detached above, the only possible remaining object(s) are data
     * objects, in a linked list.
     */
    ObjDesc = Node->Object;
    while (ObjDesc &&
        (ObjDesc->Common.Type == ACPI_TYPE_LOCAL_DATA))
    {
        /* Invoke the attached data deletion handler if present */
 
        if (ObjDesc->Data.Handler)
        {
            ObjDesc->Data.Handler (Node, ObjDesc->Data.Pointer);
        }
 
        NextDesc = ObjDesc->Common.NextObject;
        AcpiUtRemoveReference (ObjDesc);
        ObjDesc = NextDesc;
    }
 
    /* Special case for the statically allocated root node */
 
    if (Node == AcpiGbl_RootNode)
    {
        return;
    }
 
    /* Now we can delete the node */
 
    (void) AcpiOsReleaseObject (AcpiGbl_NamespaceCache, Node);
 
    ACPI_MEM_TRACKING (AcpiGbl_NsNodeList->TotalFreed++);
    ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS, "Node %p, Remaining %X\n",
        Node, AcpiGbl_CurrentNodeCount));
}

Referenced by AcpiNsDeleteChildren(), AcpiNsRemoveNode(), and AcpiNsTerminate().

AcpiNsDetachData()

ACPI_STATUS AcpiNsDetachData	(	ACPI_NAMESPACE_NODE *	Node,
		ACPI_OBJECT_HANDLER	Handler
	)

Definition at line 446 of file nsobject.c.

{
    ACPI_OPERAND_OBJECT     *ObjDesc;
    ACPI_OPERAND_OBJECT     *PrevObjDesc;
 
 
    PrevObjDesc = NULL;
    ObjDesc = Node->Object;
    while (ObjDesc)
    {
        if ((ObjDesc->Common.Type == ACPI_TYPE_LOCAL_DATA) &&
            (ObjDesc->Data.Handler == Handler))
        {
            if (PrevObjDesc)
            {
                PrevObjDesc->Common.NextObject = ObjDesc->Common.NextObject;
            }
            else
            {
                Node->Object = ObjDesc->Common.NextObject;
            }
 
            AcpiUtRemoveReference (ObjDesc);
            return (AE_OK);
        }
 
        PrevObjDesc = ObjDesc;
        ObjDesc = ObjDesc->Common.NextObject;
    }
 
    return (AE_NOT_FOUND);
}

Referenced by AcpiDetachData().

AcpiNsDetachObject()

void AcpiNsDetachObject

(

ACPI_NAMESPACE_NODE *

Node

)

Definition at line 220 of file nsobject.c.

{
    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);
        }
    }
 
    if (ObjDesc->Common.Type == ACPI_TYPE_REGION)
    {
        AcpiUtRemoveAddressRange(ObjDesc->Region.SpaceId, Node);
    }
 
    /* 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;
}

Referenced by AcpiDsLoad2EndOp(), AcpiDsMethodDataDeleteAll(), AcpiNsAttachObject(), AcpiNsDeleteNamespaceByOwner(), AcpiNsDeleteNamespaceSubtree(), and AcpiNsDeleteNode().

AcpiNsDumpEntry()

void AcpiNsDumpEntry	(	ACPI_HANDLE	Handle,
		UINT32	DebugLevel
	)

AcpiNsDumpObjectPaths()

void AcpiNsDumpObjectPaths	(	ACPI_OBJECT_TYPE	Type,
		UINT8	DisplayType,
		UINT32	MaxDepth,
		ACPI_OWNER_ID	OwnerId,
		ACPI_HANDLE	StartHandle
	)

AcpiNsDumpObjects()

void AcpiNsDumpObjects	(	ACPI_OBJECT_TYPE	Type,
		UINT8	DisplayType,
		UINT32	MaxDepth,
		ACPI_OWNER_ID	OwnerId,
		ACPI_HANDLE	StartHandle
	)

AcpiNsDumpOneObject()

ACPI_STATUS AcpiNsDumpOneObject	(	ACPI_HANDLE	ObjHandle,
		UINT32	Level,
		void *	Context,
		void **	ReturnValue
	)

AcpiNsDumpPathname()

void AcpiNsDumpPathname	(	ACPI_HANDLE	Handle,
		const char *	Msg,
		UINT32	Level,
		UINT32	Component
	)

AcpiNsDumpTables()

void AcpiNsDumpTables	(	ACPI_HANDLE	SearchBase,
		UINT32	MaxDepth
	)

AcpiNsEvaluate()

ACPI_STATUS AcpiNsEvaluate

(

ACPI_EVALUATE_INFO *

Info

)

Definition at line 82 of file nseval.c.

{
    ACPI_STATUS             Status;
 
 
    ACPI_FUNCTION_TRACE (NsEvaluate);
 
 
    if (!Info)
    {
        return_ACPI_STATUS (AE_BAD_PARAMETER);
    }
 
    if (!Info->Node)
    {
        /*
         * Get the actual namespace node for the target object if we
         * need to. Handles these cases:
         *
         * 1) Null node, valid pathname from root (absolute path)
         * 2) Node and valid pathname (path relative to Node)
         * 3) Node, Null pathname
         */
        Status = AcpiNsGetNode (Info->PrefixNode, Info->RelativePathname,
            ACPI_NS_NO_UPSEARCH, &Info->Node);
        if (ACPI_FAILURE (Status))
        {
            return_ACPI_STATUS (Status);
        }
    }
 
    /*
     * For a method alias, we must grab the actual method node so that
     * proper scoping context will be established before execution.
     */
    if (AcpiNsGetType (Info->Node) == ACPI_TYPE_LOCAL_METHOD_ALIAS)
    {
        Info->Node = ACPI_CAST_PTR (
            ACPI_NAMESPACE_NODE, Info->Node->Object);
    }
 
    /* Complete the info block initialization */
 
    Info->ReturnObject = NULL;
    Info->NodeFlags = Info->Node->Flags;
    Info->ObjDesc = AcpiNsGetAttachedObject (Info->Node);
 
    ACPI_DEBUG_PRINT ((ACPI_DB_NAMES, "%s [%p] Value %p\n",
        Info->RelativePathname, Info->Node,
        AcpiNsGetAttachedObject (Info->Node)));
 
    /* Get info if we have a predefined name (_HID, etc.) */
 
    Info->Predefined = AcpiUtMatchPredefinedMethod (Info->Node->Name.Ascii);
 
    /* Get the full pathname to the object, for use in warning messages */
 
    Info->FullPathname = AcpiNsGetNormalizedPathname (Info->Node, TRUE);
    if (!Info->FullPathname)
    {
        return_ACPI_STATUS (AE_NO_MEMORY);
    }
 
    /* Optional object evaluation log */
 
    ACPI_DEBUG_PRINT_RAW ((ACPI_DB_EVALUATION,
        "%-26s:  %s (%s)\n", "   Enter evaluation",
        &Info->FullPathname[1], AcpiUtGetTypeName (Info->Node->Type)));
 
    /* Count the number of arguments being passed in */
 
    Info->ParamCount = 0;
    if (Info->Parameters)
    {
        while (Info->Parameters[Info->ParamCount])
        {
            Info->ParamCount++;
        }
 
        /* Warn on impossible argument count */
 
        if (Info->ParamCount > ACPI_METHOD_NUM_ARGS)
        {
            ACPI_WARN_PREDEFINED ((AE_INFO, Info->FullPathname, ACPI_WARN_ALWAYS,
                "Excess arguments (%u) - using only %u",
                Info->ParamCount, ACPI_METHOD_NUM_ARGS));
 
            Info->ParamCount = ACPI_METHOD_NUM_ARGS;
        }
    }
 
    /*
     * For predefined names: Check that the declared argument count
     * matches the ACPI spec -- otherwise this is a BIOS error.
     */
    AcpiNsCheckAcpiCompliance (Info->FullPathname, Info->Node,
        Info->Predefined);
 
    /*
     * For all names: Check that the incoming argument count for
     * this method/object matches the actual ASL/AML definition.
     */
    AcpiNsCheckArgumentCount (Info->FullPathname, Info->Node,
        Info->ParamCount, Info->Predefined);
 
    /* For predefined names: Typecheck all incoming arguments */
 
    AcpiNsCheckArgumentTypes (Info);
 
    /*
     * Three major evaluation cases:
     *
     * 1) Object types that cannot be evaluated by definition
     * 2) The object is a control method -- execute it
     * 3) The object is not a method -- just return it's current value
     */
    switch (AcpiNsGetType (Info->Node))
    {
    case ACPI_TYPE_ANY:
    case ACPI_TYPE_DEVICE:
    case ACPI_TYPE_EVENT:
    case ACPI_TYPE_MUTEX:
    case ACPI_TYPE_REGION:
    case ACPI_TYPE_THERMAL:
    case ACPI_TYPE_LOCAL_SCOPE:
        /*
         * 1) Disallow evaluation of these object types. For these,
         *    object evaluation is undefined.
         */
        ACPI_ERROR ((AE_INFO,
            "%s: This object type [%s] "
            "never contains data and cannot be evaluated",
            Info->FullPathname, AcpiUtGetTypeName (Info->Node->Type)));
 
        Status = AE_TYPE;
        goto Cleanup;
 
    case ACPI_TYPE_METHOD:
        /*
         * 2) Object is a control method - execute it
         */
 
        /* Verify that there is a method object associated with this node */
 
        if (!Info->ObjDesc)
        {
            ACPI_ERROR ((AE_INFO, "%s: Method has no attached sub-object",
                Info->FullPathname));
            Status = AE_NULL_OBJECT;
            goto Cleanup;
        }
 
        ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
            "**** Execute method [%s] at AML address %p length %X\n",
            Info->FullPathname,
            Info->ObjDesc->Method.AmlStart + 1,
            Info->ObjDesc->Method.AmlLength - 1));
 
        /*
         * Any namespace deletion must acquire both the namespace and
         * interpreter locks to ensure that no thread is using the portion of
         * the namespace that is being deleted.
         *
         * Execute the method via the interpreter. The interpreter is locked
         * here before calling into the AML parser
         */
        AcpiExEnterInterpreter ();
        Status = AcpiPsExecuteMethod (Info);
        AcpiExExitInterpreter ();
        break;
 
    default:
        /*
         * 3) All other non-method objects -- get the current object value
         */
 
        /*
         * Some objects require additional resolution steps (e.g., the Node
         * may be a field that must be read, etc.) -- we can't just grab
         * the object out of the node.
         *
         * Use ResolveNodeToValue() to get the associated value.
         *
         * NOTE: we can get away with passing in NULL for a walk state because
         * the Node is guaranteed to not be a reference to either a method
         * local or a method argument (because this interface is never called
         * from a running method.)
         *
         * Even though we do not directly invoke the interpreter for object
         * resolution, we must lock it because we could access an OpRegion.
         * The OpRegion access code assumes that the interpreter is locked.
         */
        AcpiExEnterInterpreter ();
 
        /* TBD: ResolveNodeToValue has a strange interface, fix */
 
        Info->ReturnObject = ACPI_CAST_PTR (ACPI_OPERAND_OBJECT, Info->Node);
 
        Status = AcpiExResolveNodeToValue (ACPI_CAST_INDIRECT_PTR (
            ACPI_NAMESPACE_NODE, &Info->ReturnObject), NULL);
        AcpiExExitInterpreter ();
 
        if (ACPI_FAILURE (Status))
        {
            Info->ReturnObject = NULL;
            goto Cleanup;
        }
 
        ACPI_DEBUG_PRINT ((ACPI_DB_NAMES, "Returned object %p [%s]\n",
            Info->ReturnObject,
            AcpiUtGetObjectTypeName (Info->ReturnObject)));
 
        Status = AE_CTRL_RETURN_VALUE; /* Always has a "return value" */
        break;
    }
 
    /*
     * For predefined names, check the return value against the ACPI
     * specification. Some incorrect return value types are repaired.
     */
    (void) AcpiNsCheckReturnValue (Info->Node, Info, Info->ParamCount,
        Status, &Info->ReturnObject);
 
    /* Check if there is a return value that must be dealt with */
 
    if (Status == AE_CTRL_RETURN_VALUE)
    {
        /* If caller does not want the return value, delete it */
 
        if (Info->Flags & ACPI_IGNORE_RETURN_VALUE)
        {
            AcpiUtRemoveReference (Info->ReturnObject);
            Info->ReturnObject = NULL;
        }
 
        /* Map AE_CTRL_RETURN_VALUE to AE_OK, we are done with it */
 
        Status = AE_OK;
    }
    else if (ACPI_FAILURE(Status))
    {
        /* If ReturnObject exists, delete it */
 
        if (Info->ReturnObject)
        {
            AcpiUtRemoveReference (Info->ReturnObject);
            Info->ReturnObject = NULL;
        }
    }
 
    ACPI_DEBUG_PRINT ((ACPI_DB_NAMES,
        "*** Completed evaluation of object %s ***\n",
        Info->RelativePathname));
 
Cleanup:
    /* Optional object evaluation log */
 
    ACPI_DEBUG_PRINT_RAW ((ACPI_DB_EVALUATION,
        "%-26s:  %s\n", "   Exit evaluation",
        &Info->FullPathname[1]));
 
    /*
     * Namespace was unlocked by the handling AcpiNs* function, so we
     * just free the pathname and return
     */
    ACPI_FREE (Info->FullPathname);
    Info->FullPathname = NULL;
    return_ACPI_STATUS (Status);
}

Referenced by AcpiEvaluateObject(), AcpiEvAsynchExecuteGpeMethod(), AcpiEvExecuteRegMethod(), AcpiGetSleepTypeData(), AcpiNsInitializeDevices(), AcpiNsInitOneDevice(), AcpiRsSetSrsMethodData(), and AcpiUtEvaluateObject().

AcpiNsExecuteTable()

ACPI_STATUS AcpiNsExecuteTable	(	UINT32	TableIndex,
		ACPI_NAMESPACE_NODE *	StartNode
	)

Definition at line 81 of file nsparse.c.

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

Referenced by AcpiNsParseTable().

AcpiNsExternalizeName()

ACPI_STATUS AcpiNsExternalizeName	(	UINT32	InternalNameLength,
		const char *	InternalName,
		UINT32 *	ConvertedNameLength,
		char **	ConvertedName
	)

Definition at line 470 of file nsutils.c.

{
    UINT32                  NamesIndex = 0;
    UINT32                  NumSegments = 0;
    UINT32                  RequiredLength;
    UINT32                  PrefixLength = 0;
    UINT32                  i = 0;
    UINT32                  j = 0;
 
 
    ACPI_FUNCTION_TRACE (NsExternalizeName);
 
 
    if (!InternalNameLength     ||
        !InternalName           ||
        !ConvertedName)
    {
        return_ACPI_STATUS (AE_BAD_PARAMETER);
    }
 
    /* Check for a prefix (one '\' | one or more '^') */
 
    switch (InternalName[0])
    {
    case AML_ROOT_PREFIX:
 
        PrefixLength = 1;
        break;
 
    case AML_PARENT_PREFIX:
 
        for (i = 0; i < InternalNameLength; i++)
        {
            if (ACPI_IS_PARENT_PREFIX (InternalName[i]))
            {
                PrefixLength = i + 1;
            }
            else
            {
                break;
            }
        }
 
        if (i == InternalNameLength)
        {
            PrefixLength = i;
        }
 
        break;
 
    default:
 
        break;
    }
 
    /*
     * Check for object names. Note that there could be 0-255 of these
     * 4-byte elements.
     */
    if (PrefixLength < InternalNameLength)
    {
        switch (InternalName[PrefixLength])
        {
        case AML_MULTI_NAME_PREFIX:
 
            /* <count> 4-byte names */
 
            NamesIndex = PrefixLength + 2;
            NumSegments = (UINT8)
                InternalName[(ACPI_SIZE) PrefixLength + 1];
            break;
 
        case AML_DUAL_NAME_PREFIX:
 
            /* Two 4-byte names */
 
            NamesIndex = PrefixLength + 1;
            NumSegments = 2;
            break;
 
        case 0:
 
            /* NullName */
 
            NamesIndex = 0;
            NumSegments = 0;
            break;
 
        default:
 
            /* one 4-byte name */
 
            NamesIndex = PrefixLength;
            NumSegments = 1;
            break;
        }
    }
 
    /*
     * Calculate the length of ConvertedName, which equals the length
     * of the prefix, length of all object names, length of any required
     * punctuation ('.') between object names, plus the NULL terminator.
     */
    RequiredLength = PrefixLength + (4 * NumSegments) +
        ((NumSegments > 0) ? (NumSegments - 1) : 0) + 1;
 
    /*
     * Check to see if we're still in bounds. If not, there's a problem
     * with InternalName (invalid format).
     */
    if (RequiredLength > InternalNameLength)
    {
        ACPI_ERROR ((AE_INFO, "Invalid internal name"));
        return_ACPI_STATUS (AE_BAD_PATHNAME);
    }
 
    /* Build the ConvertedName */
 
    *ConvertedName = ACPI_ALLOCATE_ZEROED (RequiredLength);
    if (!(*ConvertedName))
    {
        return_ACPI_STATUS (AE_NO_MEMORY);
    }
 
    j = 0;
 
    for (i = 0; i < PrefixLength; i++)
    {
        (*ConvertedName)[j++] = InternalName[i];
    }
 
    if (NumSegments > 0)
    {
        for (i = 0; i < NumSegments; i++)
        {
            if (i > 0)
            {
                (*ConvertedName)[j++] = '.';
            }
 
            /* Copy and validate the 4-char name segment */
 
            ACPI_COPY_NAMESEG (&(*ConvertedName)[j],
                &InternalName[NamesIndex]);
            AcpiUtRepairName (&(*ConvertedName)[j]);
 
            j += ACPI_NAMESEG_SIZE;
            NamesIndex += ACPI_NAMESEG_SIZE;
        }
    }
 
    if (ConvertedNameLength)
    {
        *ConvertedNameLength = (UINT32) RequiredLength;
    }
 
    return_ACPI_STATUS (AE_OK);
}

Referenced by AcpiDsResolvePackageElement(), AcpiNsBuildPrefixedPathname(), and AcpiNsLookup().

AcpiNsGetAttachedData()

ACPI_STATUS AcpiNsGetAttachedData	(	ACPI_NAMESPACE_NODE *	Node,
		ACPI_OBJECT_HANDLER	Handler,
		void **	Data
	)

Definition at line 498 of file nsobject.c.

{
    ACPI_OPERAND_OBJECT     *ObjDesc;
 
 
    ObjDesc = Node->Object;
    while (ObjDesc)
    {
        if ((ObjDesc->Common.Type == ACPI_TYPE_LOCAL_DATA) &&
            (ObjDesc->Data.Handler == Handler))
        {
            *Data = ObjDesc->Data.Pointer;
            return (AE_OK);
        }
 
        ObjDesc = ObjDesc->Common.NextObject;
    }
 
    return (AE_NOT_FOUND);
}

Referenced by AcpiGetData().

AcpiNsGetAttachedObject()

ACPI_OPERAND_OBJECT * AcpiNsGetAttachedObject

(

ACPI_NAMESPACE_NODE *

Node

)

Definition at line 308 of file nsobject.c.

{
    ACPI_FUNCTION_TRACE_PTR (NsGetAttachedObject, Node);
 
 
    if (!Node)
    {
        ACPI_WARNING ((AE_INFO, "Null Node ptr"));
        return_PTR (NULL);
    }
 
    if (!Node->Object ||
            ((ACPI_GET_DESCRIPTOR_TYPE (Node->Object) != ACPI_DESC_TYPE_OPERAND) &&
             (ACPI_GET_DESCRIPTOR_TYPE (Node->Object) != ACPI_DESC_TYPE_NAMED))  ||
        ((Node->Object)->Common.Type == ACPI_TYPE_LOCAL_DATA))
    {
        return_PTR (NULL);
    }
 
    return_PTR (Node->Object);
}

Referenced by AcpiDsCallControlMethod(), AcpiDsCreateBufferField(), AcpiDsCreateNode(), AcpiDsEvalBankFieldOperands(), AcpiDsEvalBufferFieldOperands(), AcpiDsEvalRegionOperands(), AcpiDsEvalTableRegionOperands(), AcpiDsExecEndOp(), AcpiDsGetFieldNames(), AcpiDsInitAmlWalk(), AcpiDsInitializeRegion(), AcpiDsInitOneObject(), AcpiDsLoad1EndOp(), AcpiDsLoad2EndOp(), AcpiDsMethodDataDeleteValue(), AcpiDsStoreObjectToLocal(), AcpiEvGetGpeEventInfo(), AcpiEvHasDefaultHandler(), AcpiEvInitializeRegion(), AcpiEvInstallHandler(), AcpiEvInstallSpaceHandler(), AcpiEvQueueNotifyRequest(), AcpiEvRegRun(), AcpiExCreateRegion(), AcpiExLoadOp(), AcpiExOpcode_1A_0T_1R(), AcpiExPrepFieldValue(), AcpiExResolveMultiple(), AcpiExResolveNodeToValue(), AcpiExResolveOperands(), AcpiExStoreObjectToNode(), AcpiInstallGpeBlock(), AcpiInstallNotifyHandler(), AcpiNsEvaluate(), AcpiNsInitOneObject(), AcpiNsInitOnePackage(), AcpiPsGetNextNamepath(), AcpiRemoveAddressSpaceHandler(), AcpiRemoveGpeBlock(), AcpiRemoveNotifyHandler(), and AcpiUtGetMutexObject().

AcpiNsGetExternalPathname()

char * AcpiNsGetExternalPathname

(

ACPI_NAMESPACE_NODE *

Node

)

Definition at line 70 of file nsnames.c.

{
    char                    *NameBuffer;
 
 
    ACPI_FUNCTION_TRACE_PTR (NsGetExternalPathname, Node);
 
 
    NameBuffer = AcpiNsGetNormalizedPathname (Node, FALSE);
    return_PTR (NameBuffer);
}

Referenced by AcpiDsExecEndOp(), AcpiDsGetFieldNames(), AcpiDsLoad2EndOp(), and AcpiEvaluateObjectTyped().

AcpiNsGetInternalNameLength()

void AcpiNsGetInternalNameLength

(

ACPI_NAMESTRING_INFO *

Info

)

Definition at line 183 of file nsutils.c.

{
    const char              *NextExternalChar;
    UINT32                  i;
 
 
    ACPI_FUNCTION_ENTRY ();
 
 
    NextExternalChar = Info->ExternalName;
    Info->NumCarats = 0;
    Info->NumSegments = 0;
    Info->FullyQualified = FALSE;
 
    /*
     * For the internal name, the required length is 4 bytes per segment,
     * plus 1 each for RootPrefix, MultiNamePrefixOp, segment count,
     * trailing null (which is not really needed, but no there's harm in
     * putting it there)
     *
     * strlen() + 1 covers the first NameSeg, which has no path separator
     */
    if (ACPI_IS_ROOT_PREFIX (*NextExternalChar))
    {
        Info->FullyQualified = TRUE;
        NextExternalChar++;
 
        /* Skip redundant RootPrefix, like \\_SB.PCI0.SBRG.EC0 */
 
        while (ACPI_IS_ROOT_PREFIX (*NextExternalChar))
        {
            NextExternalChar++;
        }
    }
    else
    {
        /* Handle Carat prefixes */
 
        while (ACPI_IS_PARENT_PREFIX (*NextExternalChar))
        {
            Info->NumCarats++;
            NextExternalChar++;
        }
    }
 
    /*
     * Determine the number of ACPI name "segments" by counting the number of
     * path separators within the string. Start with one segment since the
     * segment count is [(# separators) + 1], and zero separators is ok.
     */
    if (*NextExternalChar)
    {
        Info->NumSegments = 1;
        for (i = 0; NextExternalChar[i]; i++)
        {
            if (ACPI_IS_PATH_SEPARATOR (NextExternalChar[i]))
            {
                Info->NumSegments++;
            }
        }
    }
 
    Info->Length = (ACPI_NAMESEG_SIZE * Info->NumSegments) +
        4 + Info->NumCarats;
 
    Info->NextExternalChar = NextExternalChar;
}

Referenced by AcpiNsInternalizeName().

AcpiNsGetNextNode()

ACPI_NAMESPACE_NODE * AcpiNsGetNextNode	(	ACPI_NAMESPACE_NODE *	Parent,
		ACPI_NAMESPACE_NODE *	Child
	)

Definition at line 72 of file nswalk.c.

{
    ACPI_FUNCTION_ENTRY ();
 
 
    if (!ChildNode)
    {
        /* It's really the parent's _scope_ that we want */
 
        return (ParentNode->Child);
    }
 
    /* Otherwise just return the next peer */
 
    return (ChildNode->Peer);
}

Referenced by AcpiEvExecuteOrphanRegMethod(), AcpiNsDeleteNamespaceByOwner(), AcpiNsDeleteNamespaceSubtree(), AcpiNsGetNextNodeTyped(), and AcpiNsWalkNamespace().

AcpiNsGetNextNodeTyped()

ACPI_NAMESPACE_NODE * AcpiNsGetNextNodeTyped	(	ACPI_OBJECT_TYPE	Type,
		ACPI_NAMESPACE_NODE *	Parent,
		ACPI_NAMESPACE_NODE *	Child
	)

Definition at line 112 of file nswalk.c.

{
    ACPI_NAMESPACE_NODE     *NextNode = NULL;
 
 
    ACPI_FUNCTION_ENTRY ();
 
 
    NextNode = AcpiNsGetNextNode (ParentNode, ChildNode);
 
    /* If any type is OK, we are done */
 
    if (Type == ACPI_TYPE_ANY)
    {
        /* NextNode is NULL if we are at the end-of-list */
 
        return (NextNode);
    }
 
    /* Must search for the node -- but within this scope only */
 
    while (NextNode)
    {
        /* If type matches, we are done */
 
        if (NextNode->Type == Type)
        {
            return (NextNode);
        }
 
        /* Otherwise, move on to the next peer node */
 
        NextNode = NextNode->Peer;
    }
 
    /* Not found */
 
    return (NULL);
}

Referenced by AcpiGetNextObject().

AcpiNsGetNode()

ACPI_STATUS AcpiNsGetNode	(	ACPI_NAMESPACE_NODE *	PrefixNode,
		const char *	ExternalPathname,
		UINT32	Flags,
		ACPI_NAMESPACE_NODE **	OutNode
	)

Definition at line 863 of file nsutils.c.

{
    ACPI_STATUS             Status;
 
 
    ACPI_FUNCTION_TRACE_PTR (NsGetNode, ACPI_CAST_PTR (char, Pathname));
 
 
    Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE);
    if (ACPI_FAILURE (Status))
    {
        return_ACPI_STATUS (Status);
    }
 
    Status = AcpiNsGetNodeUnlocked (PrefixNode, Pathname,
        Flags, ReturnNode);
 
    (void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);
    return_ACPI_STATUS (Status);
}

Referenced by AcpiGetHandle(), AcpiNsEvaluate(), AcpiNsRepair_TSS(), AcpiNsRootInitialize(), and AcpiUtMethodError().

AcpiNsGetNodeUnlocked()

ACPI_STATUS AcpiNsGetNodeUnlocked	(	ACPI_NAMESPACE_NODE *	PrefixNode,
		const char *	ExternalPathname,
		UINT32	Flags,
		ACPI_NAMESPACE_NODE **	OutNode
	)

Definition at line 777 of file nsutils.c.

{
    ACPI_GENERIC_STATE      ScopeInfo;
    ACPI_STATUS             Status;
    char                    *InternalPath;
 
 
    ACPI_FUNCTION_TRACE_PTR (NsGetNodeUnlocked, ACPI_CAST_PTR (char, Pathname));
 
 
    /* Simplest case is a null pathname */
 
    if (!Pathname)
    {
        *ReturnNode = PrefixNode;
        if (!PrefixNode)
        {
            *ReturnNode = AcpiGbl_RootNode;
        }
 
        return_ACPI_STATUS (AE_OK);
    }
 
    /* Quick check for a reference to the root */
 
    if (ACPI_IS_ROOT_PREFIX (Pathname[0]) && (!Pathname[1]))
    {
        *ReturnNode = AcpiGbl_RootNode;
        return_ACPI_STATUS (AE_OK);
    }
 
    /* Convert path to internal representation */
 
    Status = AcpiNsInternalizeName (Pathname, &InternalPath);
    if (ACPI_FAILURE (Status))
    {
        return_ACPI_STATUS (Status);
    }
 
    /* Setup lookup scope (search starting point) */
 
    ScopeInfo.Scope.Node = PrefixNode;
 
    /* Lookup the name in the namespace */
 
    Status = AcpiNsLookup (&ScopeInfo, InternalPath, ACPI_TYPE_ANY,
        ACPI_IMODE_EXECUTE, (Flags | ACPI_NS_DONT_OPEN_SCOPE),
        NULL, ReturnNode);
    if (ACPI_FAILURE (Status))
    {
        ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "%s, %s\n",
            Pathname, AcpiFormatException (Status)));
    }
 
    ACPI_FREE (InternalPath);
    return_ACPI_STATUS (Status);
}

Referenced by AcpiExLoadTableOp(), AcpiExOpcode_1A_0T_1R(), and AcpiNsGetNode().

AcpiNsGetNormalizedPathname()

char * AcpiNsGetNormalizedPathname	(	ACPI_NAMESPACE_NODE *	Node,
		BOOLEAN	NoTrailing
	)

Definition at line 367 of file nsnames.c.

{
    char                    *NameBuffer;
    ACPI_SIZE               Size;
 
 
    ACPI_FUNCTION_TRACE_PTR (NsGetNormalizedPathname, Node);
 
 
    /* Calculate required buffer size based on depth below root */
 
    Size = AcpiNsBuildNormalizedPath (Node, NULL, 0, NoTrailing);
    if (!Size)
    {
        return_PTR (NULL);
    }
 
    /* Allocate a buffer to be returned to caller */
 
    NameBuffer = ACPI_ALLOCATE_ZEROED (Size);
    if (!NameBuffer)
    {
        ACPI_ERROR ((AE_INFO,
            "Could not allocate %u bytes", (UINT32) Size));
        return_PTR (NULL);
    }
 
    /* Build the path in the allocated buffer */
 
    (void) AcpiNsBuildNormalizedPath (Node, NameBuffer, (UINT32) Size, NoTrailing);
 
    ACPI_DEBUG_PRINT_RAW ((ACPI_DB_NAMES, "%s: Path \"%s\"\n",
        ACPI_GET_FUNCTION_NAME, NameBuffer));
 
    return_PTR (NameBuffer);
}

Referenced by AcpiDsCallControlMethod(), AcpiExStartTraceMethod(), AcpiExStopTraceMethod(), AcpiNsBuildPrefixedPathname(), AcpiNsEvaluate(), AcpiNsExecuteTable(), AcpiNsGetExternalPathname(), AcpiNsInitOneDevice(), AcpiNsSearchOneScope(), and AcpiUtCheckAddressRange().

AcpiNsGetPathnameLength()

ACPI_SIZE AcpiNsGetPathnameLength

(

ACPI_NAMESPACE_NODE *

Node

)

Definition at line 97 of file nsnames.c.

{
    ACPI_SIZE               Size;
 
 
    /* Validate the Node */
 
    if (ACPI_GET_DESCRIPTOR_TYPE (Node) != ACPI_DESC_TYPE_NAMED)
    {
        ACPI_ERROR ((AE_INFO,
            "Invalid/cached reference target node: %p, descriptor type %d",
            Node, ACPI_GET_DESCRIPTOR_TYPE (Node)));
        return (0);
    }
 
    Size = AcpiNsBuildNormalizedPath (Node, NULL, 0, FALSE);
    return (Size);
}

Referenced by AcpiRsGetPciRoutingTableLength(), and AcpiUtGetSimpleObjectSize().

AcpiNsGetSecondaryObject()

ACPI_OPERAND_OBJECT * AcpiNsGetSecondaryObject

(

ACPI_OPERAND_OBJECT *

ObjDesc

)

Definition at line 346 of file nsobject.c.

{
    ACPI_FUNCTION_TRACE_PTR (NsGetSecondaryObject, ObjDesc);
 
 
    if ((!ObjDesc)                                     ||
        (ObjDesc->Common.Type== ACPI_TYPE_LOCAL_DATA)  ||
        (!ObjDesc->Common.NextObject)                  ||
        ((ObjDesc->Common.NextObject)->Common.Type == ACPI_TYPE_LOCAL_DATA))
    {
        return_PTR (NULL);
    }
 
    return_PTR (ObjDesc->Common.NextObject);
}

Referenced by AcpiDsGetBankFieldArguments(), AcpiDsGetBufferFieldArguments(), AcpiDsGetRegionArguments(), AcpiEvAddressSpaceDispatch(), AcpiEvDetachRegion(), AcpiEvExecuteRegMethod(), AcpiExCreateRegion(), and AcpiUtDeleteInternalObj().

AcpiNsGetType()

ACPI_OBJECT_TYPE AcpiNsGetType

(

ACPI_NAMESPACE_NODE *

Node

)

Definition at line 120 of file nsutils.c.

{
    ACPI_FUNCTION_TRACE (NsGetType);
 
 
    if (!Node)
    {
        ACPI_WARNING ((AE_INFO, "Null Node parameter"));
        return_UINT8 (ACPI_TYPE_ANY);
    }
 
    return_UINT8 (Node->Type);
}

Referenced by AcpiDsInitOneObject(), AcpiEvaluateObject(), AcpiExPrepFieldValue(), AcpiExResolveMultiple(), AcpiExResolveNodeToValue(), AcpiExStoreObjectToNode(), AcpiNsEvaluate(), AcpiNsInitOneObject(), AcpiNsSearchOneScope(), and AcpiUtCopyIsimpleToEsimple().

AcpiNsHandleToName()

ACPI_STATUS AcpiNsHandleToName	(	ACPI_HANDLE	TargetHandle,
		ACPI_BUFFER *	Buffer
	)

Definition at line 133 of file nsnames.c.

{
    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_COPY_NAMESEG (Buffer->Pointer, NodeName);
    ((char *) Buffer->Pointer) [ACPI_NAMESEG_SIZE] = 0;
 
    ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "%4.4s\n", (char *) Buffer->Pointer));
    return_ACPI_STATUS (AE_OK);
}

Referenced by AcpiGetName().

AcpiNsHandleToPathname()

ACPI_STATUS AcpiNsHandleToPathname	(	ACPI_HANDLE	TargetHandle,
		ACPI_BUFFER *	Buffer,
		BOOLEAN	NoTrailing
	)

Definition at line 187 of file nsnames.c.

{
    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,
        (UINT32) RequiredSize, NoTrailing);
 
    ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "%s [%X]\n",
        (char *) Buffer->Pointer, (UINT32) RequiredSize));
    return_ACPI_STATUS (AE_OK);
}

Referenced by AcpiGetName(), AcpiNsPrintNodePathname(), and AcpiRsCreatePciRoutingTable().

AcpiNsInitializeDevices()

ACPI_STATUS AcpiNsInitializeDevices

(

UINT32

Flags

)

Definition at line 157 of file nsinit.c.

{
    ACPI_STATUS             Status = AE_OK;
    ACPI_DEVICE_WALK_INFO   Info;
    ACPI_HANDLE             Handle;
 
 
    ACPI_FUNCTION_TRACE (NsInitializeDevices);
 
 
    if (!(Flags & ACPI_NO_DEVICE_INIT))
    {
        ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
            "[Init] Initializing ACPI Devices\n"));
 
        /* Init counters */
 
        Info.DeviceCount = 0;
        Info.Num_STA = 0;
        Info.Num_INI = 0;
 
        ACPI_DEBUG_PRINT_RAW ((ACPI_DB_INIT,
            "Initializing Device/Processor/Thermal objects "
            "and executing _INI/_STA methods:\n"));
 
        /* Tree analysis: find all subtrees that contain _INI methods */
 
        Status = AcpiNsWalkNamespace (ACPI_TYPE_ANY, ACPI_ROOT_OBJECT,
            ACPI_UINT32_MAX, FALSE, AcpiNsFindIniMethods, NULL, &Info, NULL);
        if (ACPI_FAILURE (Status))
        {
            goto ErrorExit;
        }
 
        /* Allocate the evaluation information block */
 
        Info.EvaluateInfo = ACPI_ALLOCATE_ZEROED (sizeof (ACPI_EVALUATE_INFO));
        if (!Info.EvaluateInfo)
        {
            Status = AE_NO_MEMORY;
            goto ErrorExit;
        }
 
        /*
         * Execute the "global" _INI method that may appear at the root.
         * This support is provided for Windows compatibility (Vista+) and
         * is not part of the ACPI specification.
         */
        Info.EvaluateInfo->PrefixNode = AcpiGbl_RootNode;
        Info.EvaluateInfo->RelativePathname = METHOD_NAME__INI;
        Info.EvaluateInfo->Parameters = NULL;
        Info.EvaluateInfo->Flags = ACPI_IGNORE_RETURN_VALUE;
 
        Status = AcpiNsEvaluate (Info.EvaluateInfo);
        if (ACPI_SUCCESS (Status))
        {
            Info.Num_INI++;
        }
 
        /*
         * Execute \_SB._INI.
         * There appears to be a strict order requirement for \_SB._INI,
         * which should be evaluated before any _REG evaluations.
         */
        Status = AcpiGetHandle (NULL, "\\_SB", &Handle);
        if (ACPI_SUCCESS (Status))
        {
            memset (Info.EvaluateInfo, 0, sizeof (ACPI_EVALUATE_INFO));
            Info.EvaluateInfo->PrefixNode = Handle;
            Info.EvaluateInfo->RelativePathname = METHOD_NAME__INI;
            Info.EvaluateInfo->Parameters = NULL;
            Info.EvaluateInfo->Flags = ACPI_IGNORE_RETURN_VALUE;
 
            Status = AcpiNsEvaluate (Info.EvaluateInfo);
            if (ACPI_SUCCESS (Status))
            {
                Info.Num_INI++;
            }
        }
    }
 
    /*
     * Run all _REG methods
     *
     * Note: Any objects accessed by the _REG methods will be automatically
     * initialized, even if they contain executable AML (see the call to
     * AcpiNsInitializeObjects below).
     *
     * Note: According to the ACPI specification, we actually needn't execute
     * _REG for SystemMemory/SystemIo operation regions, but for PCI_Config
     * operation regions, it is required to evaluate _REG for those on a PCI
     * root bus that doesn't contain _BBN object. So this code is kept here
     * in order not to break things.
     */
    if (!(Flags & ACPI_NO_ADDRESS_SPACE_INIT))
    {
        ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
            "[Init] Executing _REG OpRegion methods\n"));
 
        Status = AcpiEvInitializeOpRegions ();
        if (ACPI_FAILURE (Status))
        {
            goto ErrorExit;
        }
    }
 
    if (!(Flags & ACPI_NO_DEVICE_INIT))
    {
        /* Walk namespace to execute all _INIs on present devices */
 
        Status = AcpiNsWalkNamespace (ACPI_TYPE_ANY, ACPI_ROOT_OBJECT,
            ACPI_UINT32_MAX, FALSE, AcpiNsInitOneDevice, NULL, &Info, NULL);
 
        /*
         * Any _OSI requests should be completed by now. If the BIOS has
         * requested any Windows OSI strings, we will always truncate
         * I/O addresses to 16 bits -- for Windows compatibility.
         */
        if (AcpiGbl_OsiData >= ACPI_OSI_WIN_2000)
        {
            AcpiGbl_TruncateIoAddresses = TRUE;
        }
 
        ACPI_FREE (Info.EvaluateInfo);
        if (ACPI_FAILURE (Status))
        {
            goto ErrorExit;
        }
 
        ACPI_DEBUG_PRINT_RAW ((ACPI_DB_INIT,
            "    Executed %u _INI methods requiring %u _STA executions "
            "(examined %u objects)\n",
            Info.Num_INI, Info.Num_STA, Info.DeviceCount));
    }
 
    return_ACPI_STATUS (Status);
 
 
ErrorExit:
    ACPI_EXCEPTION ((AE_INFO, Status, "During device initialization"));
    return_ACPI_STATUS (Status);
}

Referenced by AcpiInitializeObjects().

AcpiNsInitializeObjects()

ACPI_STATUS AcpiNsInitializeObjects

(

void

)

Definition at line 92 of file nsinit.c.

{
    ACPI_STATUS             Status;
    ACPI_INIT_WALK_INFO     Info;
 
 
    ACPI_FUNCTION_TRACE (NsInitializeObjects);
 
 
    ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
        "[Init] Completing Initialization of ACPI Objects\n"));
    ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
        "**** Starting initialization of namespace objects ****\n"));
    ACPI_DEBUG_PRINT_RAW ((ACPI_DB_INIT,
        "Final data object initialization: "));
 
    /* Clear the info block */
 
    memset (&Info, 0, sizeof (ACPI_INIT_WALK_INFO));
 
    /* Walk entire namespace from the supplied root */
 
    /*
     * TBD: will become ACPI_TYPE_PACKAGE as this type object
     * is now the only one that supports deferred initialization
     * (forward references).
     */
    Status = AcpiWalkNamespace (ACPI_TYPE_ANY, ACPI_ROOT_OBJECT,
        ACPI_UINT32_MAX, AcpiNsInitOneObject, NULL, &Info, NULL);
    if (ACPI_FAILURE (Status))
    {
        ACPI_EXCEPTION ((AE_INFO, Status, "During WalkNamespace"));
    }
 
    ACPI_DEBUG_PRINT_RAW ((ACPI_DB_INIT,
        "Namespace contains %u (0x%X) objects\n",
        Info.ObjectCount,
        Info.ObjectCount));
 
    ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
        "%u Control Methods found\n%u Op Regions found\n",
        Info.MethodCount, Info.OpRegionCount));
 
    return_ACPI_STATUS (AE_OK);
}

Referenced by AcpiExLoadOp(), AcpiExLoadTableOp(), AcpiInitializeObjects(), AcpiLoadTable(), and AcpiLoadTables().

AcpiNsInitOnePackage()

ACPI_STATUS AcpiNsInitOnePackage	(	ACPI_HANDLE	ObjHandle,
		UINT32	Level,
		void *	Context,
		void **	ReturnValue
	)

Definition at line 319 of file nsinit.c.

{
    ACPI_STATUS             Status;
    ACPI_OPERAND_OBJECT     *ObjDesc;
    ACPI_NAMESPACE_NODE     *Node = (ACPI_NAMESPACE_NODE *) ObjHandle;
 
 
    ObjDesc = AcpiNsGetAttachedObject (Node);
    if (!ObjDesc)
    {
        return (AE_OK);
    }
 
    /* Exit if package is already initialized */
 
    if (ObjDesc->Package.Flags & AOPOBJ_DATA_VALID)
    {
        return (AE_OK);
    }
 
    Status = AcpiDsGetPackageArguments (ObjDesc);
    if (ACPI_FAILURE (Status))
    {
        return (AE_OK);
    }
 
    Status = AcpiUtWalkPackageTree (ObjDesc, NULL, AcpiDsInitPackageElement,
        NULL);
    if (ACPI_FAILURE (Status))
    {
        return (AE_OK);
    }
 
    ObjDesc->Package.Flags |= AOPOBJ_DATA_VALID;
    return (AE_OK);
}

Referenced by AcpiNsInitOneObject().

AcpiNsInstallNode()

void AcpiNsInstallNode	(	ACPI_WALK_STATE *	WalkState,
		ACPI_NAMESPACE_NODE *	ParentNode,
		ACPI_NAMESPACE_NODE *	Node,
		ACPI_OBJECT_TYPE	Type
	)

Definition at line 255 of file nsalloc.c.

{
    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 %3.3X] added to %4.4s (%s) [Node %p]\n",
        AcpiUtGetNodeName (Node), AcpiUtGetTypeName (Node->Type), Node, OwnerId,
        AcpiUtGetNodeName (ParentNode), AcpiUtGetTypeName (ParentNode->Type),
        ParentNode));
 
    return_VOID;
}

Referenced by AcpiNsSearchAndEnter().

AcpiNsInternalizeName()

ACPI_STATUS AcpiNsInternalizeName	(	const char *	DottedName,
		char **	ConvertedName
	)

Definition at line 405 of file nsutils.c.

{
    char                    *InternalName;
    ACPI_NAMESTRING_INFO    Info;
    ACPI_STATUS             Status;
 
 
    ACPI_FUNCTION_TRACE (NsInternalizeName);
 
 
    if ((!ExternalName)      ||
        (*ExternalName == 0) ||
        (!ConvertedName))
    {
        return_ACPI_STATUS (AE_BAD_PARAMETER);
    }
 
    /* Get the length of the new internal name */
 
    Info.ExternalName = ExternalName;
    AcpiNsGetInternalNameLength (&Info);
 
    /* We need a segment to store the internal  name */
 
    InternalName = ACPI_ALLOCATE_ZEROED (Info.Length);
    if (!InternalName)
    {
        return_ACPI_STATUS (AE_NO_MEMORY);
    }
 
    /* Build the name */
 
    Info.InternalName = InternalName;
    Status = AcpiNsBuildInternalName (&Info);
    if (ACPI_FAILURE (Status))
    {
        ACPI_FREE (InternalName);
        return_ACPI_STATUS (Status);
    }
 
    *ConvertedName = InternalName;
    return_ACPI_STATUS (AE_OK);
}

Referenced by AcpiNsConvertToReference(), and AcpiNsGetNodeUnlocked().

AcpiNsLoadNamespace()

ACPI_STATUS AcpiNsLoadNamespace

(

void

)

AcpiNsLoadTable()

ACPI_STATUS AcpiNsLoadTable	(	UINT32	TableIndex,
		ACPI_NAMESPACE_NODE *	Node
	)

Definition at line 82 of file nsload.c.

{
    ACPI_STATUS             Status;
 
 
    ACPI_FUNCTION_TRACE (NsLoadTable);
 
 
    /* If table already loaded into namespace, just return */
 
    if (AcpiTbIsTableLoaded (TableIndex))
    {
        Status = AE_ALREADY_EXISTS;
        goto Unlock;
    }
 
    ACPI_DEBUG_PRINT ((ACPI_DB_INFO,
        "**** Loading table into namespace ****\n"));
 
    Status = AcpiTbAllocateOwnerId (TableIndex);
    if (ACPI_FAILURE (Status))
    {
        goto Unlock;
    }
 
    /*
     * Parse the table and load the namespace with all named
     * objects found within. Control methods are NOT parsed
     * at this time. In fact, the control methods cannot be
     * parsed until the entire namespace is loaded, because
     * if a control method makes a forward reference (call)
     * to another control method, we can't continue parsing
     * because we don't know how many arguments to parse next!
     */
    Status = AcpiNsParseTable (TableIndex, Node);
    if (ACPI_SUCCESS (Status))
    {
        AcpiTbSetTableLoadedFlag (TableIndex, TRUE);
    }
    else
    {
        /*
         * On error, delete any namespace objects created by this table.
         * We cannot initialize these objects, so delete them. There are
         * a couple of especially bad cases:
         * AE_ALREADY_EXISTS - namespace collision.
         * AE_NOT_FOUND - the target of a Scope operator does not
         * exist. This target of Scope must already exist in the
         * namespace, as per the ACPI specification.
         */
        AcpiNsDeleteNamespaceByOwner (
            AcpiGbl_RootTableList.Tables[TableIndex].OwnerId);
 
        AcpiTbReleaseOwnerId (TableIndex);
        return_ACPI_STATUS (Status);
    }
 
Unlock:
    if (ACPI_FAILURE (Status))
    {
        return_ACPI_STATUS (Status);
    }
 
    /*
     * Now we can parse the control methods. We always parse
     * them here for a sanity check, and if configured for
     * just-in-time parsing, we delete the control method
     * parse trees.
     */
    ACPI_DEBUG_PRINT ((ACPI_DB_INFO,
        "**** Begin Table Object Initialization\n"));
 
    AcpiExEnterInterpreter ();
    Status = AcpiDsInitializeObjects (TableIndex, Node);
    AcpiExExitInterpreter ();
 
    ACPI_DEBUG_PRINT ((ACPI_DB_INFO,
        "**** Completed Table Object Initialization\n"));
 
    return_ACPI_STATUS (Status);
}

Referenced by AcpiTbLoadNamespace(), and AcpiTbLoadTable().

AcpiNsLocal()

UINT32 AcpiNsLocal

(

ACPI_OBJECT_TYPE

Type

)

Definition at line 150 of file nsutils.c.

{
    ACPI_FUNCTION_TRACE (NsLocal);
 
 
    if (!AcpiUtValidObjectType (Type))
    {
        /* Type code out of range  */
 
        ACPI_WARNING ((AE_INFO, "Invalid Object Type 0x%X", Type));
        return_UINT32 (ACPI_NS_NORMAL);
    }
 
    return_UINT32 (AcpiGbl_NsProperties[Type] & ACPI_NS_LOCAL);
}

Referenced by AcpiNsSearchParentTree().

AcpiNsLookup()

ACPI_STATUS AcpiNsLookup	(	ACPI_GENERIC_STATE *	ScopeInfo,
		char *	Name,
		ACPI_OBJECT_TYPE	Type,
		ACPI_INTERPRETER_MODE	InterpreterMode,
		UINT32	Flags,
		ACPI_WALK_STATE *	WalkState,
		ACPI_NAMESPACE_NODE **	RetNode
	)

Definition at line 328 of file nsaccess.c.

{
    ACPI_STATUS             Status;
    char                    *Path = Pathname;
    char                    *ExternalPath;
    ACPI_NAMESPACE_NODE     *PrefixNode;
    ACPI_NAMESPACE_NODE     *CurrentNode = NULL;
    ACPI_NAMESPACE_NODE     *ThisNode = NULL;
    UINT32                  NumSegments;
    UINT32                  NumCarats;
    ACPI_NAME               SimpleName;
    ACPI_OBJECT_TYPE        TypeToCheckFor;
    ACPI_OBJECT_TYPE        ThisSearchType;
    UINT32                  SearchParentFlag = ACPI_NS_SEARCH_PARENT;
    UINT32                  LocalFlags;
    ACPI_INTERPRETER_MODE   LocalInterpreterMode;
 
 
    ACPI_FUNCTION_TRACE (NsLookup);
 
 
    if (!ReturnNode)
    {
        return_ACPI_STATUS (AE_BAD_PARAMETER);
    }
 
    LocalFlags = Flags &
        ~(ACPI_NS_ERROR_IF_FOUND | ACPI_NS_OVERRIDE_IF_FOUND |
          ACPI_NS_SEARCH_PARENT);
    *ReturnNode = ACPI_ENTRY_NOT_FOUND;
    AcpiGbl_NsLookupCount++;
 
    if (!AcpiGbl_RootNode)
    {
        return_ACPI_STATUS (AE_NO_NAMESPACE);
    }
 
    /* Get the prefix scope. A null scope means use the root scope */
 
    if ((!ScopeInfo) ||
        (!ScopeInfo->Scope.Node))
    {
        ACPI_DEBUG_PRINT ((ACPI_DB_NAMES,
            "Null scope prefix, using root node (%p)\n",
            AcpiGbl_RootNode));
 
        PrefixNode = AcpiGbl_RootNode;
    }
    else
    {
        PrefixNode = ScopeInfo->Scope.Node;
        if (ACPI_GET_DESCRIPTOR_TYPE (PrefixNode) != ACPI_DESC_TYPE_NAMED)
        {
            ACPI_ERROR ((AE_INFO, "%p is not a namespace node [%s]",
                PrefixNode, AcpiUtGetDescriptorName (PrefixNode)));
            return_ACPI_STATUS (AE_AML_INTERNAL);
        }
 
        if (!(Flags & ACPI_NS_PREFIX_IS_SCOPE))
        {
            /*
             * This node might not be a actual "scope" node (such as a
             * Device/Method, etc.)  It could be a Package or other object
             * node. Backup up the tree to find the containing scope node.
             */
            while (!AcpiNsOpensScope (PrefixNode->Type) &&
                    PrefixNode->Type != ACPI_TYPE_ANY)
            {
                PrefixNode = PrefixNode->Parent;
            }
        }
    }
 
    /* Save type. TBD: may be no longer necessary */
 
    TypeToCheckFor = Type;
 
    /*
     * Begin examination of the actual pathname
     */
    if (!Pathname)
    {
        /* A Null NamePath is allowed and refers to the root */
 
        NumSegments = 0;
        ThisNode = AcpiGbl_RootNode;
        Path = "";
 
        ACPI_DEBUG_PRINT ((ACPI_DB_NAMES,
            "Null Pathname (Zero segments), Flags=%X\n", Flags));
    }
    else
    {
        /*
         * 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. Externalize
                     * the internal path for error message.
                     */
                    Status = AcpiNsExternalizeName (ACPI_UINT32_MAX, Pathname,
                        NULL, &ExternalPath);
                    if (ACPI_SUCCESS (Status))
                    {
                        ACPI_ERROR ((AE_INFO,
                            "%s: Path has too many parent prefixes (^)",
                            ExternalPath));
 
                        ACPI_FREE (ExternalPath);
                    }
 
                    return_ACPI_STATUS (AE_NOT_FOUND);
                }
            }
 
            if (SearchParentFlag == ACPI_NS_NO_UPSEARCH)
            {
                ACPI_DEBUG_PRINT ((ACPI_DB_NAMES,
                    "Search scope is [%4.4s], path has %u carat(s)\n",
                    AcpiUtGetNodeName (ThisNode), NumCarats));
            }
        }
 
        /*
         * Determine the number of ACPI name segments in this pathname.
         *
         * The segment part consists of either:
         *  - A Null name segment (0)
         *  - A DualNamePrefix followed by two 4-byte name segments
         *  - A MultiNamePrefix followed by a byte indicating the
         *      number of segments and the segments themselves.
         *  - A single 4-byte name segment
         *
         * Examine the name prefix opcode, if any, to determine the number of
         * segments.
         */
        switch (*Path)
        {
        case 0:
            /*
             * Null name after a root or parent prefixes. We already
             * have the correct target node and there are no name segments.
             */
            NumSegments  = 0;
            Type = ThisNode->Type;
 
            ACPI_DEBUG_PRINT ((ACPI_DB_NAMES,
                "Prefix-only Pathname (Zero name segments), Flags=%X\n",
                Flags));
            break;
 
        case AML_DUAL_NAME_PREFIX:
 
            /* More than one NameSeg, search rules do not apply */
 
            SearchParentFlag = ACPI_NS_NO_UPSEARCH;
 
            /* Two segments, point to first name segment */
 
            NumSegments = 2;
            Path++;
 
            ACPI_DEBUG_PRINT ((ACPI_DB_NAMES,
                "Dual Pathname (2 segments, Flags=%X)\n", Flags));
            break;
 
        case AML_MULTI_NAME_PREFIX:
 
            /* More than one NameSeg, search rules do not apply */
 
            SearchParentFlag = ACPI_NS_NO_UPSEARCH;
 
            /* Extract segment count, point to first name segment */
 
            Path++;
            NumSegments = (UINT32) (UINT8) *Path;
            Path++;
 
            ACPI_DEBUG_PRINT ((ACPI_DB_NAMES,
                "Multi Pathname (%u Segments, Flags=%X)\n",
                NumSegments, Flags));
            break;
 
        default:
            /*
             * Not a Null name, no Dual or Multi prefix, hence there is
             * only one name segment and Pathname is already pointing to it.
             */
            NumSegments = 1;
 
            ACPI_DEBUG_PRINT ((ACPI_DB_NAMES,
                "Simple Pathname (1 segment, Flags=%X)\n", Flags));
            break;
        }
 
        ACPI_DEBUG_EXEC (AcpiNsPrintPathname (NumSegments, Path));
    }
 
 
    /*
     * Search namespace for each segment of the name. Loop through and
     * verify (or add to the namespace) each name segment.
     *
     * The object type is significant only at the last name
     * segment. (We don't care about the types along the path, only
     * the type of the final target object.)
     */
    ThisSearchType = ACPI_TYPE_ANY;
    CurrentNode = ThisNode;
 
    while (NumSegments && CurrentNode)
    {
        NumSegments--;
        if (!NumSegments)
        {
            /* This is the last segment, enable typechecking */
 
            ThisSearchType = Type;
 
            /*
             * Only allow automatic parent search (search rules) if the caller
             * requested it AND we have a single, non-fully-qualified NameSeg
             */
            if ((SearchParentFlag != ACPI_NS_NO_UPSEARCH) &&
                (Flags & ACPI_NS_SEARCH_PARENT))
            {
                LocalFlags |= ACPI_NS_SEARCH_PARENT;
            }
 
            /* Set error flag according to caller */
 
            if (Flags & ACPI_NS_ERROR_IF_FOUND)
            {
                LocalFlags |= ACPI_NS_ERROR_IF_FOUND;
            }
 
            /* Set override flag according to caller */
 
            if (Flags & ACPI_NS_OVERRIDE_IF_FOUND)
            {
                LocalFlags |= ACPI_NS_OVERRIDE_IF_FOUND;
            }
        }
 
        /* Handle opcodes that create a new NameSeg via a full NamePath */
 
        LocalInterpreterMode = InterpreterMode;
        if ((Flags & ACPI_NS_PREFIX_MUST_EXIST) && (NumSegments > 0))
        {
            /* Every element of the path must exist (except for the final NameSeg) */
 
            LocalInterpreterMode = ACPI_IMODE_EXECUTE;
        }
 
        /* Extract one ACPI name from the front of the pathname */
 
        ACPI_MOVE_32_TO_32 (&SimpleName, Path);
 
        /* Try to find the single (4 character) ACPI name */
 
        Status = AcpiNsSearchAndEnter (SimpleName, WalkState, CurrentNode,
            LocalInterpreterMode, ThisSearchType, LocalFlags, &ThisNode);
        if (ACPI_FAILURE (Status))
        {
            if (Status == AE_NOT_FOUND)
            {
#if !defined ACPI_ASL_COMPILER /* Note: iASL reports this error by itself, not needed here */
                if (Flags & ACPI_NS_PREFIX_MUST_EXIST)
                {
                    AcpiOsPrintf (ACPI_MSG_BIOS_ERROR
                        "Object does not exist: %4.4s\n", (char *) &SimpleName);
                }
#endif
                /* Name not found in ACPI namespace */
 
                ACPI_DEBUG_PRINT ((ACPI_DB_NAMES,
                    "Name [%4.4s] not found in scope [%4.4s] %p\n",
                    (char *) &SimpleName, (char *) &CurrentNode->Name,
                    CurrentNode));
            }
 
#ifdef ACPI_EXEC_APP
            if ((Status == AE_ALREADY_EXISTS) &&
                (ThisNode->Flags & ANOBJ_NODE_EARLY_INIT))
            {
                ThisNode->Flags &= ~ANOBJ_NODE_EARLY_INIT;
                Status = AE_OK;
            }
#endif
 
#ifdef ACPI_ASL_COMPILER
            /*
             * If this ACPI name already exists within the namespace as an
             * external declaration, then mark the external as a conflicting
             * declaration and proceed to process the current node as if it did
             * not exist in the namespace. If this node is not processed as
             * normal, then it could cause improper namespace resolution
             * by failing to open a new scope.
             */
            if (AcpiGbl_DisasmFlag &&
                (Status == AE_ALREADY_EXISTS) &&
                ((ThisNode->Flags & ANOBJ_IS_EXTERNAL) ||
                    (WalkState && WalkState->Opcode == AML_EXTERNAL_OP)))
            {
                ThisNode->Flags &= ~ANOBJ_IS_EXTERNAL;
                ThisNode->Type = (UINT8)ThisSearchType;
                if (WalkState->Opcode != AML_EXTERNAL_OP)
                {
                    AcpiDmMarkExternalConflict (ThisNode);
                }
                break;
            }
#endif
 
            *ReturnNode = ThisNode;
            return_ACPI_STATUS (Status);
        }
 
        /* More segments to follow? */
 
        if (NumSegments > 0)
        {
            /*
             * If we have an alias to an object that opens a scope (such as a
             * device or processor), we need to dereference the alias here so
             * that we can access any children of the original node (via the
             * remaining segments).
             */
            if (ThisNode->Type == ACPI_TYPE_LOCAL_ALIAS)
            {
                if (!ThisNode->Object)
                {
                    return_ACPI_STATUS (AE_NOT_EXIST);
                }
 
                if (AcpiNsOpensScope (((ACPI_NAMESPACE_NODE *)
                        ThisNode->Object)->Type))
                {
                    ThisNode = (ACPI_NAMESPACE_NODE *) ThisNode->Object;
                }
            }
        }
 
        /* Special handling for the last segment (NumSegments == 0) */
 
        else
        {
            /*
             * Sanity typecheck of the target object:
             *
             * If 1) This is the last segment (NumSegments == 0)
             *    2) And we are looking for a specific type
             *       (Not checking for TYPE_ANY)
             *    3) Which is not an alias
             *    4) Which is not a local type (TYPE_SCOPE)
             *    5) And the type of target object is known (not TYPE_ANY)
             *    6) And target object does not match what we are looking for
             *
             * Then we have a type mismatch. Just warn and ignore it.
             */
            if ((TypeToCheckFor != ACPI_TYPE_ANY)                   &&
                (TypeToCheckFor != ACPI_TYPE_LOCAL_ALIAS)           &&
                (TypeToCheckFor != ACPI_TYPE_LOCAL_METHOD_ALIAS)    &&
                (TypeToCheckFor != ACPI_TYPE_LOCAL_SCOPE)           &&
                (ThisNode->Type != ACPI_TYPE_ANY)                   &&
                (ThisNode->Type != TypeToCheckFor))
            {
                /* Complain about a type mismatch */
 
                ACPI_WARNING ((AE_INFO,
                    "NsLookup: Type mismatch on %4.4s (%s), searching for (%s)",
                    ACPI_CAST_PTR (char, &SimpleName),
                    AcpiUtGetTypeName (ThisNode->Type),
                    AcpiUtGetTypeName (TypeToCheckFor)));
            }
 
            /*
             * If this is the last name segment and we are not looking for a
             * specific type, but the type of found object is known, use that
             * type to (later) see if it opens a scope.
             */
            if (Type == ACPI_TYPE_ANY)
            {
                Type = ThisNode->Type;
            }
        }
 
        /* Point to next name segment and make this node current */
 
        Path += ACPI_NAMESEG_SIZE;
        CurrentNode = ThisNode;
    }
 
    /* Always check if we need to open a new scope */
 
    if (!(Flags & ACPI_NS_DONT_OPEN_SCOPE) && (WalkState))
    {
        /*
         * If entry is a type which opens a scope, push the new scope on the
         * scope stack.
         */
        if (AcpiNsOpensScope (Type))
        {
            Status = AcpiDsScopeStackPush (ThisNode, Type, WalkState);
            if (ACPI_FAILURE (Status))
            {
                return_ACPI_STATUS (Status);
            }
        }
    }
 
#ifdef ACPI_EXEC_APP
    if (Flags & ACPI_NS_EARLY_INIT)
    {
        ThisNode->Flags |= ANOBJ_NODE_EARLY_INIT;
    }
#endif
 
    *ReturnNode = ThisNode;
    return_ACPI_STATUS (AE_OK);
}

Referenced by AcpiDsBuildInternalObject(), AcpiDsCreateBankField(), AcpiDsCreateBufferField(), AcpiDsCreateField(), AcpiDsCreateIndexField(), AcpiDsCreateOperand(), AcpiDsGetFieldNames(), AcpiDsInitFieldObjects(), AcpiDsLoad1BeginOp(), AcpiDsLoad2BeginOp(), AcpiDsLoad2EndOp(), AcpiDsResolvePackageElement(), AcpiInstallMethod(), AcpiNsConvertToReference(), AcpiNsGetNodeUnlocked(), and AcpiPsGetNextNamepath().

AcpiNsNameOfCurrentScope()

char * AcpiNsNameOfCurrentScope

(

ACPI_WALK_STATE *

WalkState

)

AcpiNsNormalizePathname()

void AcpiNsNormalizePathname

(

char *

OriginalPath

)

Definition at line 506 of file nsnames.c.

{
    char                    *InputPath = OriginalPath;
    char                    *NewPathBuffer;
    char                    *NewPath;
    UINT32                  i;
 
 
    /* Allocate a temp buffer in which to construct the new path */
 
    NewPathBuffer = ACPI_ALLOCATE_ZEROED (strlen (InputPath) + 1);
    NewPath = NewPathBuffer;
    if (!NewPathBuffer)
    {
        return;
    }
 
    /* Special characters may appear at the beginning of the path */
 
    if (*InputPath == '\\')
    {
        *NewPath = *InputPath;
        NewPath++;
        InputPath++;
    }
 
    while (*InputPath == '^')
    {
        *NewPath = *InputPath;
        NewPath++;
        InputPath++;
    }
 
    /* Remainder of the path */
 
    while (*InputPath)
    {
        /* Do one nameseg at a time */
 
        for (i = 0; (i < ACPI_NAMESEG_SIZE) && *InputPath; i++)
        {
            if ((i == 0) || (*InputPath != '_')) /* First char is allowed to be underscore */
            {
                *NewPath = *InputPath;
                NewPath++;
            }
 
            InputPath++;
        }
 
        /* Dot means that there are more namesegs to come */
 
        if (*InputPath == '.')
        {
            *NewPath = *InputPath;
            NewPath++;
            InputPath++;
        }
    }
 
    *NewPath = 0;
    strcpy (OriginalPath, NewPathBuffer);
    ACPI_FREE (NewPathBuffer);
}

Referenced by AcpiNsBuildPrefixedPathname().

AcpiNsOneCompleteParse()

ACPI_STATUS AcpiNsOneCompleteParse	(	UINT32	PassNumber,
		UINT32	TableIndex,
		ACPI_NAMESPACE_NODE *	StartNode
	)

Definition at line 194 of file nsparse.c.

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

AcpiNsOpensScope()

UINT32 AcpiNsOpensScope

(

ACPI_OBJECT_TYPE

Type

)

Definition at line 736 of file nsutils.c.

{
    ACPI_FUNCTION_ENTRY ();
 
 
    if (Type > ACPI_TYPE_LOCAL_MAX)
    {
        /* type code out of range  */
 
        ACPI_WARNING ((AE_INFO, "Invalid Object Type 0x%X", Type));
        return (ACPI_NS_NORMAL);
    }
 
    return (((UINT32) AcpiGbl_NsProperties[Type]) & ACPI_NS_NEWSCOPE);
}

Referenced by AcpiDsExecBeginOp(), AcpiDsLoad1BeginOp(), AcpiDsLoad1EndOp(), AcpiDsLoad2BeginOp(), AcpiDsLoad2EndOp(), AcpiNsLookup(), and AcpiPsParseLoop().

AcpiNsParseTable()

ACPI_STATUS AcpiNsParseTable	(	UINT32	TableIndex,
		ACPI_NAMESPACE_NODE *	StartNode
	)

Definition at line 307 of file nsparse.c.

{
    ACPI_STATUS             Status;
 
 
    ACPI_FUNCTION_TRACE (NsParseTable);
 
 
    /*
     * Executes the AML table as one large control method.
     * The point of this is to execute any module-level code in-place
     * as the table is parsed. Some AML code depends on this behavior.
     *
     * Note: This causes the table to only have a single-pass parse.
     * However, this is compatible with other ACPI implementations.
     */
    ACPI_DEBUG_PRINT_RAW ((ACPI_DB_PARSE,
        "%s: **** Start table execution pass\n", ACPI_GET_FUNCTION_NAME));
 
    Status = AcpiNsExecuteTable (TableIndex, StartNode);
 
    return_ACPI_STATUS (Status);
}

Referenced by AcpiNsLoadTable().

AcpiNsPatternMatch()

BOOLEAN AcpiNsPatternMatch	(	ACPI_NAMESPACE_NODE *	ObjNode,
		char *	SearchFor
	)

AcpiNsPrintNodePathname()

void AcpiNsPrintNodePathname	(	ACPI_NAMESPACE_NODE *	Node,
		const char *	Msg
	)

Definition at line 75 of file nsutils.c.

{
    ACPI_BUFFER             Buffer;
    ACPI_STATUS             Status;
 
 
    if (!Node)
    {
        AcpiOsPrintf ("[NULL NAME]");
        return;
    }
 
    /* Convert handle to full pathname and print it (with supplied message) */
 
    Buffer.Length = ACPI_ALLOCATE_LOCAL_BUFFER;
 
    Status = AcpiNsHandleToPathname (Node, &Buffer, TRUE);
    if (ACPI_SUCCESS (Status))
    {
        if (Message)
        {
            AcpiOsPrintf ("%s ", Message);
        }
 
        AcpiOsPrintf ("%s", (char *) Buffer.Pointer);
        ACPI_FREE (Buffer.Pointer);
    }
}

Referenced by AcpiPsParseAml(), and AcpiUtMethodError().

AcpiNsPrintPathname()

void AcpiNsPrintPathname	(	UINT32	NumSegments,
		const char *	Pathname
	)

Referenced by AcpiNsLookup().

AcpiNsRemoveNode()

void AcpiNsRemoveNode

(

ACPI_NAMESPACE_NODE *

Node

)

Definition at line 188 of file nsalloc.c.

{
    ACPI_NAMESPACE_NODE     *ParentNode;
    ACPI_NAMESPACE_NODE     *PrevNode;
    ACPI_NAMESPACE_NODE     *NextNode;
 
 
    ACPI_FUNCTION_TRACE_PTR (NsRemoveNode, Node);
 
 
    ParentNode = Node->Parent;
 
    PrevNode = NULL;
    NextNode = ParentNode->Child;
 
    /* Find the node that is the previous peer in the parent's child list */
 
    while (NextNode != Node)
    {
        PrevNode = NextNode;
        NextNode = NextNode->Peer;
    }
 
    if (PrevNode)
    {
        /* Node is not first child, unlink it */
 
        PrevNode->Peer = Node->Peer;
    }
    else
    {
        /*
         * Node is first child (has no previous peer).
         * Link peer list to parent
         */
        ParentNode->Child = Node->Peer;
    }
 
    /* Delete the node and any attached objects */
 
    AcpiNsDeleteNode (Node);
    return_VOID;
}

Referenced by AcpiNsDeleteNamespaceByOwner(), AcpiNsSearchAndEnter(), and AcpiPsCompleteOp().

AcpiNsRemoveNullElements()

void AcpiNsRemoveNullElements	(	ACPI_EVALUATE_INFO *	Info,
		UINT8	PackageType,
		ACPI_OPERAND_OBJECT *	ObjDesc
	)

Definition at line 494 of file nsrepair.c.

{
    ACPI_OPERAND_OBJECT     **Source;
    ACPI_OPERAND_OBJECT     **Dest;
    UINT32                  Count;
    UINT32                  NewCount;
    UINT32                  i;
 
 
    ACPI_FUNCTION_NAME (NsRemoveNullElements);
 
 
    /*
     * We can safely remove all NULL elements from these package types:
     * PTYPE1_VAR packages contain a variable number of simple data types.
     * PTYPE2 packages contain a variable number of subpackages.
     */
    switch (PackageType)
    {
    case ACPI_PTYPE1_VAR:
    case ACPI_PTYPE2:
    case ACPI_PTYPE2_COUNT:
    case ACPI_PTYPE2_PKG_COUNT:
    case ACPI_PTYPE2_FIXED:
    case ACPI_PTYPE2_MIN:
    case ACPI_PTYPE2_REV_FIXED:
    case ACPI_PTYPE2_FIX_VAR:
        break;
 
    default:
    case ACPI_PTYPE2_VAR_VAR:
    case ACPI_PTYPE1_FIXED:
    case ACPI_PTYPE1_OPTION:
        return;
    }
 
    Count = ObjDesc->Package.Count;
    NewCount = Count;
 
    Source = ObjDesc->Package.Elements;
    Dest = Source;
 
    /* Examine all elements of the package object, remove nulls */
 
    for (i = 0; i < Count; i++)
    {
        if (!*Source)
        {
            NewCount--;
        }
        else
        {
            *Dest = *Source;
            Dest++;
        }
 
        Source++;
    }
 
    /* Update parent package if any null elements were removed */
 
    if (NewCount < Count)
    {
        ACPI_DEBUG_PRINT ((ACPI_DB_REPAIR,
            "%s: Found and removed %u NULL elements\n",
            Info->FullPathname, (Count - NewCount)));
 
        /* NULL terminate list and update the package count */
 
        *Dest = NULL;
        ObjDesc->Package.Count = NewCount;
    }
}

Referenced by AcpiNsCheckPackage().

AcpiNsRepairNullElement()

ACPI_STATUS AcpiNsRepairNullElement	(	ACPI_EVALUATE_INFO *	Info,
		UINT32	ExpectedBtypes,
		UINT32	PackageIndex,
		ACPI_OPERAND_OBJECT **	ReturnObjectPtr
	)

Definition at line 405 of file nsrepair.c.

{
    ACPI_OPERAND_OBJECT     *ReturnObject = *ReturnObjectPtr;
    ACPI_OPERAND_OBJECT     *NewObject;
 
 
    ACPI_FUNCTION_NAME (NsRepairNullElement);
 
 
    /* No repair needed if return object is non-NULL */
 
    if (ReturnObject)
    {
        return (AE_OK);
    }
 
    /*
     * Attempt to repair a NULL element of a Package object. This applies to
     * predefined names that return a fixed-length package and each element
     * is required. It does not apply to variable-length packages where NULL
     * elements are allowed, especially at the end of the package.
     */
    if (ExpectedBtypes & ACPI_RTYPE_INTEGER)
    {
        /* Need an Integer - create a zero-value integer */
 
        NewObject = AcpiUtCreateIntegerObject ((UINT64) 0);
    }
    else if (ExpectedBtypes & ACPI_RTYPE_STRING)
    {
        /* Need a String - create a NULL string */
 
        NewObject = AcpiUtCreateStringObject (0);
    }
    else if (ExpectedBtypes & ACPI_RTYPE_BUFFER)
    {
        /* Need a Buffer - create a zero-length buffer */
 
        NewObject = AcpiUtCreateBufferObject (0);
    }
    else
    {
        /* Error for all other expected types */
 
        return (AE_AML_OPERAND_TYPE);
    }
 
    if (!NewObject)
    {
        return (AE_NO_MEMORY);
    }
 
    /* Set the reference count according to the parent Package object */
 
    NewObject->Common.ReferenceCount =
        Info->ParentPackage->Common.ReferenceCount;
 
    ACPI_DEBUG_PRINT ((ACPI_DB_REPAIR,
        "%s: Converted NULL package element to expected %s at index %u\n",
        Info->FullPathname, AcpiUtGetObjectTypeName (NewObject),
        PackageIndex));
 
    *ReturnObjectPtr = NewObject;
    Info->ReturnFlags |= ACPI_OBJECT_REPAIRED;
    return (AE_OK);
}

Referenced by AcpiNsSimpleRepair().

AcpiNsRootInitialize()

ACPI_STATUS AcpiNsRootInitialize

(

void

)

Definition at line 73 of file nsaccess.c.

{
    ACPI_STATUS                 Status;
    const ACPI_PREDEFINED_NAMES *InitVal = NULL;
    ACPI_NAMESPACE_NODE         *NewNode;
    ACPI_NAMESPACE_NODE         *PrevNode = NULL;
    ACPI_OPERAND_OBJECT         *ObjDesc;
    ACPI_STRING                 Val = NULL;
 
 
    ACPI_FUNCTION_TRACE (NsRootInitialize);
 
 
    Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE);
    if (ACPI_FAILURE (Status))
    {
        return_ACPI_STATUS (Status);
    }
 
    /*
     * The global root ptr is initially NULL, so a non-NULL value indicates
     * that AcpiNsRootInitialize() has already been called; just return.
     */
    if (AcpiGbl_RootNode)
    {
        Status = AE_OK;
        goto UnlockAndExit;
    }
 
    /*
     * Tell the rest of the subsystem that the root is initialized
     * (This is OK because the namespace is locked)
     */
    AcpiGbl_RootNode = &AcpiGbl_RootNodeStruct;
 
    /* Enter the predefined names in the name table */
 
    ACPI_DEBUG_PRINT ((ACPI_DB_INFO,
        "Entering predefined entries into namespace\n"));
 
    /*
     * Create the initial (default) namespace.
     * This namespace looks like something similar to this:
     *
     *   ACPI Namespace (from Namespace Root):
     *    0  _GPE Scope        00203160 00
     *    0  _PR_ Scope        002031D0 00
     *    0  _SB_ Device       00203240 00 Notify Object: 0020ADD8
     *    0  _SI_ Scope        002032B0 00
     *    0  _TZ_ Device       00203320 00
     *    0  _REV Integer      00203390 00 = 0000000000000002
     *    0  _OS_ String       00203488 00 Len 14 "Microsoft Windows NT"
     *    0  _GL_ Mutex        00203580 00 Object 002035F0
     *    0  _OSI Method       00203678 00 Args 1 Len 0000 Aml 00000000
     */
    for (InitVal = AcpiGbl_PreDefinedNames; InitVal->Name; InitVal++)
    {
        Status = AE_OK;
 
        /* _OSI is optional for now, will be permanent later */
 
        if (!strcmp (InitVal->Name, "_OSI") && !AcpiGbl_CreateOsiMethod)
        {
            continue;
        }
 
        /*
         * Create, init, and link the new predefined name
         * Note: No need to use AcpiNsLookup here because all the
         * predefined names are at the root level. It is much easier to
         * just create and link the new node(s) here.
         */
        NewNode = AcpiNsCreateNode (*ACPI_CAST_PTR (UINT32, InitVal->Name));
        if (!NewNode)
        {
            Status = AE_NO_MEMORY;
            goto UnlockAndExit;
        }
 
        NewNode->DescriptorType = ACPI_DESC_TYPE_NAMED;
        NewNode->Type = InitVal->Type;
 
        if (!PrevNode)
        {
            AcpiGbl_RootNodeStruct.Child = NewNode;
        }
        else
        {
            PrevNode->Peer = NewNode;
        }
 
        NewNode->Parent = &AcpiGbl_RootNodeStruct;
        PrevNode = NewNode;
 
        /*
         * Name entered successfully. If entry in PreDefinedNames[] specifies
         * an initial value, create the initial value.
         */
        if (InitVal->Val)
        {
            Status = AcpiOsPredefinedOverride (InitVal, &Val);
            if (ACPI_FAILURE (Status))
            {
                ACPI_ERROR ((AE_INFO,
                    "Could not override predefined %s",
                    InitVal->Name));
            }
 
            if (!Val)
            {
                Val = InitVal->Val;
            }
 
            /*
             * Entry requests an initial value, allocate a
             * descriptor for it.
             */
            ObjDesc = AcpiUtCreateInternalObject (InitVal->Type);
            if (!ObjDesc)
            {
                Status = AE_NO_MEMORY;
                goto UnlockAndExit;
            }
 
            /*
             * Convert value string from table entry to
             * internal representation. Only types actually
             * used for initial values are implemented here.
             */
            switch (InitVal->Type)
            {
            case ACPI_TYPE_METHOD:
 
                ObjDesc->Method.ParamCount = (UINT8) ACPI_TO_INTEGER (Val);
                ObjDesc->Common.Flags |= AOPOBJ_DATA_VALID;
 
#if defined (ACPI_ASL_COMPILER)
 
                /* Save the parameter count for the iASL compiler */
 
                NewNode->Value = ObjDesc->Method.ParamCount;
#else
                /* Mark this as a very SPECIAL method (_OSI) */
 
                ObjDesc->Method.InfoFlags = ACPI_METHOD_INTERNAL_ONLY;
                ObjDesc->Method.Dispatch.Implementation = AcpiUtOsiImplementation;
#endif
                break;
 
            case ACPI_TYPE_INTEGER:
 
                ObjDesc->Integer.Value = ACPI_TO_INTEGER (Val);
                break;
 
            case ACPI_TYPE_STRING:
 
                /* Build an object around the static string */
 
                ObjDesc->String.Length = (UINT32) strlen (Val);
                ObjDesc->String.Pointer = Val;
                ObjDesc->Common.Flags |= AOPOBJ_STATIC_POINTER;
                break;
 
            case ACPI_TYPE_MUTEX:
 
                ObjDesc->Mutex.Node = NewNode;
                ObjDesc->Mutex.SyncLevel = (UINT8) (ACPI_TO_INTEGER (Val) - 1);
 
                /* Create a mutex */
 
                Status = AcpiOsCreateMutex (&ObjDesc->Mutex.OsMutex);
                if (ACPI_FAILURE (Status))
                {
                    AcpiUtRemoveReference (ObjDesc);
                    goto UnlockAndExit;
                }
 
                /* Special case for ACPI Global Lock */
 
                if (strcmp (InitVal->Name, "_GL_") == 0)
                {
                    AcpiGbl_GlobalLockMutex = ObjDesc;
 
                    /* Create additional counting semaphore for global lock */
 
                    Status = AcpiOsCreateSemaphore (
                        1, 0, &AcpiGbl_GlobalLockSemaphore);
                    if (ACPI_FAILURE (Status))
                    {
                        AcpiUtRemoveReference (ObjDesc);
                        goto UnlockAndExit;
                    }
                }
                break;
 
            default:
 
                ACPI_ERROR ((AE_INFO, "Unsupported initial type value 0x%X",
                    InitVal->Type));
                AcpiUtRemoveReference (ObjDesc);
                ObjDesc = NULL;
                continue;
            }
 
            /* Store pointer to value descriptor in the Node */
 
            Status = AcpiNsAttachObject (NewNode, ObjDesc,
                ObjDesc->Common.Type);
 
            /* Remove local reference to the object */
 
            AcpiUtRemoveReference (ObjDesc);
        }
    }
 
UnlockAndExit:
    (void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);
 
    /* Save a handle to "_GPE", it is always present */
 
    if (ACPI_SUCCESS (Status))
    {
        Status = AcpiNsGetNode (NULL, "\\_GPE", ACPI_NS_NO_UPSEARCH,
            &AcpiGbl_FadtGpeDevice);
    }
 
    return_ACPI_STATUS (Status);
}

Referenced by AcpiInitializeSubsystem().

AcpiNsSearchAndEnter()

ACPI_STATUS AcpiNsSearchAndEnter	(	UINT32	EntryName,
		ACPI_WALK_STATE *	WalkState,
		ACPI_NAMESPACE_NODE *	Node,
		ACPI_INTERPRETER_MODE	InterpreterMode,
		ACPI_OBJECT_TYPE	Type,
		UINT32	Flags,
		ACPI_NAMESPACE_NODE **	RetNode
	)

Definition at line 294 of file nssearch.c.

{
    ACPI_STATUS             Status;
    ACPI_NAMESPACE_NODE     *NewNode;
 
 
    ACPI_FUNCTION_TRACE (NsSearchAndEnter);
 
 
    /* Parameter validation */
 
    if (!Node || !TargetName || !ReturnNode)
    {
        ACPI_ERROR ((AE_INFO,
            "Null parameter: Node %p Name 0x%X ReturnNode %p",
            Node, TargetName, ReturnNode));
        return_ACPI_STATUS (AE_BAD_PARAMETER);
    }
 
    /*
     * Name must consist of valid ACPI characters. We will repair the name if
     * necessary because we don't want to abort because of this, but we want
     * all namespace names to be printable. A warning message is appropriate.
     *
     * This issue came up because there are in fact machines that exhibit
     * this problem, and we want to be able to enable ACPI support for them,
     * even though there are a few bad names.
     */
    AcpiUtRepairName (ACPI_CAST_PTR (char, &TargetName));
 
    /* Try to find the name in the namespace level specified by the caller */
 
    *ReturnNode = ACPI_ENTRY_NOT_FOUND;
    Status = AcpiNsSearchOneScope (TargetName, Node, Type, ReturnNode);
    if (Status != AE_NOT_FOUND)
    {
        /*
         * If we found it AND the request specifies that a find is an error,
         * return the error
         */
        if (Status == AE_OK)
        {
            /* The node was found in the namespace */
 
            /*
             * If the namespace override feature is enabled for this node,
             * delete any existing attached sub-object and make the node
             * look like a new node that is owned by the override table.
             */
            if (Flags & ACPI_NS_OVERRIDE_IF_FOUND)
            {
                ACPI_DEBUG_PRINT ((ACPI_DB_NAMES,
                    "Namespace override: %4.4s pass %u type %X Owner %X\n",
                    ACPI_CAST_PTR(char, &TargetName), InterpreterMode,
                    (*ReturnNode)->Type, WalkState->OwnerId));
 
                AcpiNsDeleteChildren (*ReturnNode);
                if (AcpiGbl_RuntimeNamespaceOverride)
                {
                    AcpiUtRemoveReference ((*ReturnNode)->Object);
                    (*ReturnNode)->Object = NULL;
                    (*ReturnNode)->OwnerId = WalkState->OwnerId;
                }
                else
                {
                    AcpiNsRemoveNode (*ReturnNode);
                    *ReturnNode = ACPI_ENTRY_NOT_FOUND;
                }
            }
 
            /* Return an error if we don't expect to find the object */
 
            else if (Flags & ACPI_NS_ERROR_IF_FOUND)
            {
                Status = AE_ALREADY_EXISTS;
            }
        }
 
#ifdef ACPI_ASL_COMPILER
        if (*ReturnNode && (*ReturnNode)->Type == ACPI_TYPE_ANY)
        {
            (*ReturnNode)->Flags |= ANOBJ_IS_EXTERNAL;
        }
#endif
 
        /* Either found it or there was an error: finished either way */
 
        return_ACPI_STATUS (Status);
    }
 
    /*
     * The name was not found. If we are NOT performing the first pass
     * (name entry) of loading the namespace, search the parent tree (all the
     * way to the root if necessary.) We don't want to perform the parent
     * search when the namespace is actually being loaded. We want to perform
     * the search when namespace references are being resolved (load pass 2)
     * and during the execution phase.
     */
    if ((InterpreterMode != ACPI_IMODE_LOAD_PASS1) &&
        (Flags & ACPI_NS_SEARCH_PARENT))
    {
        /*
         * Not found at this level - search parent tree according to the
         * ACPI specification
         */
        Status = AcpiNsSearchParentTree (TargetName, Node, Type, ReturnNode);
        if (ACPI_SUCCESS (Status))
        {
            return_ACPI_STATUS (Status);
        }
    }
 
    /* In execute mode, just search, never add names. Exit now */
 
    if (InterpreterMode == ACPI_IMODE_EXECUTE)
    {
        ACPI_DEBUG_PRINT ((ACPI_DB_NAMES,
            "%4.4s Not found in %p [Not adding]\n",
            ACPI_CAST_PTR (char, &TargetName), Node));
 
        return_ACPI_STATUS (AE_NOT_FOUND);
    }
 
    /* Create the new named object */
 
    NewNode = AcpiNsCreateNode (TargetName);
    if (!NewNode)
    {
        return_ACPI_STATUS (AE_NO_MEMORY);
    }
 
#ifdef ACPI_ASL_COMPILER
 
    /* Node is an object defined by an External() statement */
 
    if (Flags & ACPI_NS_EXTERNAL ||
        (WalkState && WalkState->Opcode == AML_SCOPE_OP))
    {
        NewNode->Flags |= ANOBJ_IS_EXTERNAL;
    }
#endif
 
    if (Flags & ACPI_NS_TEMPORARY)
    {
        NewNode->Flags |= ANOBJ_TEMPORARY;
    }
 
    /* Install the new object into the parent's list of children */
 
    AcpiNsInstallNode (WalkState, Node, NewNode, Type);
    *ReturnNode = NewNode;
    return_ACPI_STATUS (AE_OK);
}

Referenced by AcpiNsLookup().

AcpiNsSearchOneScope()

ACPI_STATUS AcpiNsSearchOneScope	(	UINT32	EntryName,
		ACPI_NAMESPACE_NODE *	Node,
		ACPI_OBJECT_TYPE	Type,
		ACPI_NAMESPACE_NODE **	RetNode
	)

Definition at line 98 of file nssearch.c.

{
    ACPI_NAMESPACE_NODE     *Node;
 
 
    ACPI_FUNCTION_TRACE (NsSearchOneScope);
 
 
#ifdef ACPI_DEBUG_OUTPUT
    if (ACPI_LV_NAMES & AcpiDbgLevel)
    {
        char                *ScopeName;
 
        ScopeName = AcpiNsGetNormalizedPathname (ParentNode, TRUE);
        if (ScopeName)
        {
            ACPI_DEBUG_PRINT ((ACPI_DB_NAMES,
                "Searching %s (%p) For [%4.4s] (%s)\n",
                ScopeName, ParentNode, ACPI_CAST_PTR (char, &TargetName),
                AcpiUtGetTypeName (Type)));
 
            ACPI_FREE (ScopeName);
        }
    }
#endif
 
    /*
     * Search for name at this namespace level, which is to say that we
     * must search for the name among the children of this object
     */
    Node = ParentNode->Child;
    while (Node)
    {
        /* Check for match against the name */
 
        if (Node->Name.Integer == TargetName)
        {
            /* Resolve a control method alias if any */
 
            if (AcpiNsGetType (Node) == ACPI_TYPE_LOCAL_METHOD_ALIAS)
            {
                Node = ACPI_CAST_PTR (ACPI_NAMESPACE_NODE, Node->Object);
            }
 
            /* Found matching entry */
 
            ACPI_DEBUG_PRINT ((ACPI_DB_NAMES,
                "Name [%4.4s] (%s) %p found in scope [%4.4s] %p\n",
                ACPI_CAST_PTR (char, &TargetName),
                AcpiUtGetTypeName (Node->Type),
                Node, AcpiUtGetNodeName (ParentNode), ParentNode));
 
            *ReturnNode = Node;
            return_ACPI_STATUS (AE_OK);
        }
 
        /* Didn't match name, move on to the next peer object */
 
        Node = Node->Peer;
    }
 
    /* Searched entire namespace level, not found */
 
    ACPI_DEBUG_PRINT ((ACPI_DB_NAMES,
        "Name [%4.4s] (%s) not found in search in scope [%4.4s] "
        "%p first child %p\n",
        ACPI_CAST_PTR (char, &TargetName), AcpiUtGetTypeName (Type),
        AcpiUtGetNodeName (ParentNode), ParentNode, ParentNode->Child));
 
    return_ACPI_STATUS (AE_NOT_FOUND);
}

Referenced by AcpiEvExecuteRegMethod(), AcpiNsSearchAndEnter(), and AcpiNsSearchParentTree().

AcpiNsSimpleRepair()

ACPI_STATUS AcpiNsSimpleRepair	(	ACPI_EVALUATE_INFO *	Info,
		UINT32	ExpectedBtypes,
		UINT32	PackageIndex,
		ACPI_OPERAND_OBJECT **	ReturnObjectPtr
	)

Definition at line 153 of file nsrepair.c.

{
    ACPI_OPERAND_OBJECT     *ReturnObject = *ReturnObjectPtr;
    ACPI_OPERAND_OBJECT     *NewObject = NULL;
    ACPI_STATUS             Status;
    const ACPI_SIMPLE_REPAIR_INFO   *Predefined;
 
 
    ACPI_FUNCTION_NAME (NsSimpleRepair);
 
 
    /*
     * Special repairs for certain names that are in the repair table.
     * Check if this name is in the list of repairable names.
     */
    Predefined = AcpiNsMatchSimpleRepair (Info->Node,
        Info->ReturnBtype, PackageIndex);
    if (Predefined)
    {
        if (!ReturnObject)
        {
            ACPI_WARN_PREDEFINED ((AE_INFO, Info->FullPathname,
                ACPI_WARN_ALWAYS, "Missing expected return value"));
        }
 
        Status = Predefined->ObjectConverter (Info->Node, ReturnObject,
            &NewObject);
        if (ACPI_FAILURE (Status))
        {
            /* A fatal error occurred during a conversion */
 
            ACPI_EXCEPTION ((AE_INFO, Status,
                "During return object analysis"));
            return (Status);
        }
        if (NewObject)
        {
            goto ObjectRepaired;
        }
    }
 
    /*
     * Do not perform simple object repair unless the return type is not
     * expected.
     */
    if (Info->ReturnBtype & ExpectedBtypes)
    {
        return (AE_OK);
    }
 
    /*
     * At this point, we know that the type of the returned object was not
     * one of the expected types for this predefined name. Attempt to
     * repair the object by converting it to one of the expected object
     * types for this predefined name.
     */
 
    /*
     * If there is no return value, check if we require a return value for
     * this predefined name. Either one return value is expected, or none,
     * for both methods and other objects.
     *
     * Try to fix if there was no return object. Warning if failed to fix.
     */
    if (!ReturnObject)
    {
        if (ExpectedBtypes && (!(ExpectedBtypes & ACPI_RTYPE_NONE)))
        {
            if (PackageIndex != ACPI_NOT_PACKAGE_ELEMENT)
            {
                ACPI_WARN_PREDEFINED ((AE_INFO, Info->FullPathname,
                    ACPI_WARN_ALWAYS, "Found unexpected NULL package element"));
 
                Status = AcpiNsRepairNullElement (Info, ExpectedBtypes,
                    PackageIndex, ReturnObjectPtr);
                if (ACPI_SUCCESS (Status))
                {
                    return (AE_OK); /* Repair was successful */
                }
            }
            else
            {
                ACPI_WARN_PREDEFINED ((AE_INFO, Info->FullPathname,
                    ACPI_WARN_ALWAYS, "Missing expected return value"));
            }
 
            return (AE_AML_NO_RETURN_VALUE);
        }
    }
 
    if (ExpectedBtypes & ACPI_RTYPE_INTEGER)
    {
        Status = AcpiNsConvertToInteger (ReturnObject, &NewObject);
        if (ACPI_SUCCESS (Status))
        {
            goto ObjectRepaired;
        }
    }
    if (ExpectedBtypes & ACPI_RTYPE_STRING)
    {
        Status = AcpiNsConvertToString (ReturnObject, &NewObject);
        if (ACPI_SUCCESS (Status))
        {
            goto ObjectRepaired;
        }
    }
    if (ExpectedBtypes & ACPI_RTYPE_BUFFER)
    {
        Status = AcpiNsConvertToBuffer (ReturnObject, &NewObject);
        if (ACPI_SUCCESS (Status))
        {
            goto ObjectRepaired;
        }
    }
    if (ExpectedBtypes & ACPI_RTYPE_PACKAGE)
    {
        /*
         * A package is expected. We will wrap the existing object with a
         * new package object. It is often the case that if a variable-length
         * package is required, but there is only a single object needed, the
         * BIOS will return that object instead of wrapping it with a Package
         * object. Note: after the wrapping, the package will be validated
         * for correct contents (expected object type or types).
         */
        Status = AcpiNsWrapWithPackage (Info, ReturnObject, &NewObject);
        if (ACPI_SUCCESS (Status))
        {
            /*
             * The original object just had its reference count
             * incremented for being inserted into the new package.
             */
            *ReturnObjectPtr = NewObject;       /* New Package object */
            Info->ReturnFlags |= ACPI_OBJECT_REPAIRED;
            return (AE_OK);
        }
    }
 
    /* We cannot repair this object */
 
    return (AE_AML_OPERAND_TYPE);
 
 
ObjectRepaired:
 
    /* Object was successfully repaired */
 
    if (PackageIndex != ACPI_NOT_PACKAGE_ELEMENT)
    {
        /* Update reference count of new object */
 
        if (!(Info->ReturnFlags & ACPI_OBJECT_WRAPPED))
        {
            NewObject->Common.ReferenceCount =
                ReturnObject->Common.ReferenceCount;
        }
 
        ACPI_DEBUG_PRINT ((ACPI_DB_REPAIR,
            "%s: Converted %s to expected %s at Package index %u\n",
            Info->FullPathname, AcpiUtGetObjectTypeName (ReturnObject),
            AcpiUtGetObjectTypeName (NewObject), PackageIndex));
    }
    else
    {
        ACPI_DEBUG_PRINT ((ACPI_DB_REPAIR,
            "%s: Converted %s to expected %s\n",
            Info->FullPathname, AcpiUtGetObjectTypeName (ReturnObject),
            AcpiUtGetObjectTypeName (NewObject)));
    }
 
    /* Delete old object, install the new return object */
 
    AcpiUtRemoveReference (ReturnObject);
    *ReturnObjectPtr = NewObject;
    Info->ReturnFlags |= ACPI_OBJECT_REPAIRED;
    return (AE_OK);
}

Referenced by AcpiNsCheckObjectType().

AcpiNsTerminate()

void AcpiNsTerminate

(

void

)

Definition at line 693 of file nsutils.c.

{
    ACPI_STATUS             Status;
 
 
    ACPI_FUNCTION_TRACE (NsTerminate);
 
 
    /*
     * Free the entire namespace -- all nodes and all objects
     * attached to the nodes
     */
    AcpiNsDeleteNamespaceSubtree (AcpiGbl_RootNode);
 
    /* Delete any objects attached to the root node */
 
    Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE);
    if (ACPI_FAILURE (Status))
    {
        return_VOID;
    }
 
    AcpiNsDeleteNode (AcpiGbl_RootNode);
    (void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);
 
    ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Namespace freed\n"));
    return_VOID;
}

Referenced by AcpiUtSubsystemShutdown().

AcpiNsValidateHandle()

ACPI_NAMESPACE_NODE * AcpiNsValidateHandle

(

ACPI_HANDLE

Handle

)

Definition at line 655 of file nsutils.c.

{
 
    ACPI_FUNCTION_ENTRY ();
 
 
    /* Parameter validation */
 
    if ((!Handle) || (Handle == ACPI_ROOT_OBJECT))
    {
        return (AcpiGbl_RootNode);
    }
 
    /* We can at least attempt to verify the handle */
 
    if (ACPI_GET_DESCRIPTOR_TYPE (Handle) != ACPI_DESC_TYPE_NAMED)
    {
        return (NULL);
    }
 
    return (ACPI_CAST_PTR (ACPI_NAMESPACE_NODE, Handle));
}

Referenced by AcpiAttachData(), AcpiDetachData(), AcpiEvaluateObject(), AcpiEvInstallHandler(), AcpiEvRegRun(), AcpiGetData(), AcpiGetHandle(), AcpiGetNextObject(), AcpiGetObjectInfo(), AcpiGetParent(), AcpiGetType(), AcpiInstallAddressSpaceHandler(), AcpiInstallGpeBlock(), AcpiNsGetDeviceCallback(), AcpiNsHandleToName(), AcpiNsHandleToPathname(), AcpiRemoveAddressSpaceHandler(), AcpiRemoveGpeBlock(), AcpiRsValidateParameters(), and AcpiWalkNamespace().

AcpiNsWalkNamespace()

ACPI_STATUS AcpiNsWalkNamespace	(	ACPI_OBJECT_TYPE	Type,
		ACPI_HANDLE	StartObject,
		UINT32	MaxDepth,
		UINT32	Flags,
		ACPI_WALK_CALLBACK	DescendingCallback,
		ACPI_WALK_CALLBACK	AscendingCallback,
		void *	Context,
		void **	ReturnValue
	)

Definition at line 190 of file nswalk.c.

{
    ACPI_STATUS             Status;
    ACPI_STATUS             MutexStatus;
    ACPI_NAMESPACE_NODE     *ChildNode;
    ACPI_NAMESPACE_NODE     *ParentNode;
    ACPI_OBJECT_TYPE        ChildType;
    UINT32                  Level;
    BOOLEAN                 NodePreviouslyVisited = FALSE;
 
 
    ACPI_FUNCTION_TRACE (NsWalkNamespace);
 
 
    /* Special case for the namespace Root Node */
 
    if (StartNode == ACPI_ROOT_OBJECT)
    {
        StartNode = AcpiGbl_RootNode;
        if (!StartNode)
        {
            return_ACPI_STATUS (AE_NO_NAMESPACE);
        }
    }
 
    /* Null child means "get first node" */
 
    ParentNode = StartNode;
    ChildNode = AcpiNsGetNextNode (ParentNode, NULL);
    ChildType = ACPI_TYPE_ANY;
    Level = 1;
 
    /*
     * Traverse the tree of nodes until we bubble back up to where we
     * started. When Level is zero, the loop is done because we have
     * bubbled up to (and passed) the original parent handle (StartEntry)
     */
    while (Level > 0 && ChildNode)
    {
        Status = AE_OK;
 
        /* Found next child, get the type if we are not searching for ANY */
 
        if (Type != ACPI_TYPE_ANY)
        {
            ChildType = ChildNode->Type;
        }
 
        /*
         * Ignore all temporary namespace nodes (created during control
         * method execution) unless told otherwise. These temporary nodes
         * can cause a race condition because they can be deleted during
         * the execution of the user function (if the namespace is
         * unlocked before invocation of the user function.) Only the
         * debugger namespace dump will examine the temporary nodes.
         */
        if ((ChildNode->Flags & ANOBJ_TEMPORARY) &&
            !(Flags & ACPI_NS_WALK_TEMP_NODES))
        {
            Status = AE_CTRL_DEPTH;
        }
 
        /* Type must match requested type */
 
        else if (ChildType == Type)
        {
            /*
             * Found a matching node, invoke the user callback function.
             * Unlock the namespace if flag is set.
             */
            if (Flags & ACPI_NS_WALK_UNLOCK)
            {
                MutexStatus = AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);
                if (ACPI_FAILURE (MutexStatus))
                {
                    return_ACPI_STATUS (MutexStatus);
                }
            }
 
            /*
             * Invoke the user function, either descending, ascending,
             * or both.
             */
            if (!NodePreviouslyVisited)
            {
                if (DescendingCallback)
                {
                    Status = DescendingCallback (ChildNode, Level,
                        Context, ReturnValue);
                }
            }
            else
            {
                if (AscendingCallback)
                {
                    Status = AscendingCallback (ChildNode, Level,
                        Context, ReturnValue);
                }
            }
 
            if (Flags & ACPI_NS_WALK_UNLOCK)
            {
                MutexStatus = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE);
                if (ACPI_FAILURE (MutexStatus))
                {
                    return_ACPI_STATUS (MutexStatus);
                }
            }
 
            switch (Status)
            {
            case AE_OK:
            case AE_CTRL_DEPTH:
 
                /* Just keep going */
                break;
 
            case AE_CTRL_TERMINATE:
 
                /* Exit now, with OK status */
 
                return_ACPI_STATUS (AE_OK);
 
            default:
 
                /* All others are valid exceptions */
 
                return_ACPI_STATUS (Status);
            }
        }
 
        /*
         * Depth first search: Attempt to go down another level in the
         * namespace if we are allowed to. Don't go any further if we have
         * reached the caller specified maximum depth or if the user
         * function has specified that the maximum depth has been reached.
         */
        if (!NodePreviouslyVisited &&
            (Level < MaxDepth) &&
            (Status != AE_CTRL_DEPTH))
        {
            if (ChildNode->Child)
            {
                /* There is at least one child of this node, visit it */
 
                Level++;
                ParentNode = ChildNode;
                ChildNode = AcpiNsGetNextNode (ParentNode, NULL);
                continue;
            }
        }
 
        /* No more children, re-visit this node */
 
        if (!NodePreviouslyVisited)
        {
            NodePreviouslyVisited = TRUE;
            continue;
        }
 
        /* No more children, visit peers */
 
        ChildNode = AcpiNsGetNextNode (ParentNode, ChildNode);
        if (ChildNode)
        {
            NodePreviouslyVisited = FALSE;
        }
 
        /* No peers, re-visit parent */
 
        else
        {
            /*
             * No more children of this node (AcpiNsGetNextNode failed), go
             * back upwards in the namespace tree to the node's parent.
             */
            Level--;
            ChildNode = ParentNode;
            ParentNode = ParentNode->Parent;
 
            NodePreviouslyVisited = TRUE;
        }
    }
 
    /* Complete walk, not terminated by user function */
 
    return_ACPI_STATUS (AE_OK);
}

Referenced by AcpiDsInitializeObjects(), AcpiEvCreateGpeBlock(), AcpiEvExecuteRegMethods(), AcpiEvInstallSpaceHandler(), AcpiEvUpdateGpes(), AcpiGetDevices(), AcpiNsInitializeDevices(), and AcpiWalkNamespace().

AcpiNsWrapWithPackage()

ACPI_STATUS AcpiNsWrapWithPackage	(	ACPI_EVALUATE_INFO *	Info,
		ACPI_OPERAND_OBJECT *	OriginalObject,
		ACPI_OPERAND_OBJECT **	ObjDescPtr
	)

Definition at line 597 of file nsrepair.c.

{
    ACPI_OPERAND_OBJECT     *PkgObjDesc;
 
 
    ACPI_FUNCTION_NAME (NsWrapWithPackage);
 
 
    /*
     * Create the new outer package and populate it. The new
     * package will have a single element, the lone sub-object.
     */
    PkgObjDesc = AcpiUtCreatePackageObject (1);
    if (!PkgObjDesc)
    {
        return (AE_NO_MEMORY);
    }
 
    PkgObjDesc->Package.Elements[0] = OriginalObject;
 
    ACPI_DEBUG_PRINT ((ACPI_DB_REPAIR,
        "%s: Wrapped %s with expected Package object\n",
        Info->FullPathname, AcpiUtGetObjectTypeName (OriginalObject)));
 
    /* Return the new object in the object pointer */
 
    *ObjDescPtr = PkgObjDesc;
    Info->ReturnFlags |= ACPI_OBJECT_REPAIRED | ACPI_OBJECT_WRAPPED;
    return (AE_OK);
}

Referenced by AcpiNsCheckPackage(), and AcpiNsSimpleRepair().