xref: /netbsd-src/sys/external/bsd/acpica/dist/namespace/nsaccess.c (revision 2c7d7e3ca2e4f0b675c6c58e614f6aede66c678e)
128c506b8Sjruoho /*******************************************************************************
228c506b8Sjruoho  *
328c506b8Sjruoho  * Module Name: nsaccess - Top-level functions for accessing ACPI namespace
428c506b8Sjruoho  *
528c506b8Sjruoho  ******************************************************************************/
628c506b8Sjruoho 
7159c4e26Sjruoho /*
8*2c7d7e3cSchristos  * Copyright (C) 2000 - 2023, Intel Corp.
928c506b8Sjruoho  * All rights reserved.
1028c506b8Sjruoho  *
11159c4e26Sjruoho  * Redistribution and use in source and binary forms, with or without
12159c4e26Sjruoho  * modification, are permitted provided that the following conditions
13159c4e26Sjruoho  * are met:
14159c4e26Sjruoho  * 1. Redistributions of source code must retain the above copyright
15159c4e26Sjruoho  *    notice, this list of conditions, and the following disclaimer,
16159c4e26Sjruoho  *    without modification.
17159c4e26Sjruoho  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
18159c4e26Sjruoho  *    substantially similar to the "NO WARRANTY" disclaimer below
19159c4e26Sjruoho  *    ("Disclaimer") and any redistribution must be conditioned upon
20159c4e26Sjruoho  *    including a substantially similar Disclaimer requirement for further
21159c4e26Sjruoho  *    binary redistribution.
22159c4e26Sjruoho  * 3. Neither the names of the above-listed copyright holders nor the names
23159c4e26Sjruoho  *    of any contributors may be used to endorse or promote products derived
24159c4e26Sjruoho  *    from this software without specific prior written permission.
2528c506b8Sjruoho  *
26159c4e26Sjruoho  * Alternatively, this software may be distributed under the terms of the
27159c4e26Sjruoho  * GNU General Public License ("GPL") version 2 as published by the Free
28159c4e26Sjruoho  * Software Foundation.
2928c506b8Sjruoho  *
30159c4e26Sjruoho  * NO WARRANTY
31159c4e26Sjruoho  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
32159c4e26Sjruoho  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
3398244dcfSchristos  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
34159c4e26Sjruoho  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
35159c4e26Sjruoho  * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
36159c4e26Sjruoho  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
37159c4e26Sjruoho  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
38159c4e26Sjruoho  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
39159c4e26Sjruoho  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
40159c4e26Sjruoho  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
41159c4e26Sjruoho  * POSSIBILITY OF SUCH DAMAGES.
42159c4e26Sjruoho  */
4328c506b8Sjruoho 
4428c506b8Sjruoho #include "acpi.h"
4528c506b8Sjruoho #include "accommon.h"
4628c506b8Sjruoho #include "amlcode.h"
4728c506b8Sjruoho #include "acnamesp.h"
4828c506b8Sjruoho #include "acdispat.h"
4928c506b8Sjruoho 
50ae01dbf5Schristos #ifdef ACPI_ASL_COMPILER
51ae01dbf5Schristos     #include "acdisasm.h"
52ae01dbf5Schristos #endif
5328c506b8Sjruoho 
5428c506b8Sjruoho #define _COMPONENT          ACPI_NAMESPACE
5528c506b8Sjruoho         ACPI_MODULE_NAME    ("nsaccess")
5628c506b8Sjruoho 
5728c506b8Sjruoho 
5828c506b8Sjruoho /*******************************************************************************
5928c506b8Sjruoho  *
6028c506b8Sjruoho  * FUNCTION:    AcpiNsRootInitialize
6128c506b8Sjruoho  *
6228c506b8Sjruoho  * PARAMETERS:  None
6328c506b8Sjruoho  *
6428c506b8Sjruoho  * RETURN:      Status
6528c506b8Sjruoho  *
6628c506b8Sjruoho  * DESCRIPTION: Allocate and initialize the default root named objects
6728c506b8Sjruoho  *
6828c506b8Sjruoho  * MUTEX:       Locks namespace for entire execution
6928c506b8Sjruoho  *
7028c506b8Sjruoho  ******************************************************************************/
7128c506b8Sjruoho 
7228c506b8Sjruoho ACPI_STATUS
AcpiNsRootInitialize(void)7328c506b8Sjruoho AcpiNsRootInitialize (
7428c506b8Sjruoho     void)
7528c506b8Sjruoho {
7628c506b8Sjruoho     ACPI_STATUS                 Status;
7728c506b8Sjruoho     const ACPI_PREDEFINED_NAMES *InitVal = NULL;
7828c506b8Sjruoho     ACPI_NAMESPACE_NODE         *NewNode;
797ab6b89bSchristos     ACPI_NAMESPACE_NODE         *PrevNode = NULL;
8028c506b8Sjruoho     ACPI_OPERAND_OBJECT         *ObjDesc;
8128c506b8Sjruoho     ACPI_STRING                 Val = NULL;
82d5b984e0Schs     UINT32                      Name;
8328c506b8Sjruoho 
8428c506b8Sjruoho 
8528c506b8Sjruoho     ACPI_FUNCTION_TRACE (NsRootInitialize);
8628c506b8Sjruoho 
8728c506b8Sjruoho 
8828c506b8Sjruoho     Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE);
8928c506b8Sjruoho     if (ACPI_FAILURE (Status))
9028c506b8Sjruoho     {
9128c506b8Sjruoho         return_ACPI_STATUS (Status);
9228c506b8Sjruoho     }
9328c506b8Sjruoho 
9428c506b8Sjruoho     /*
9528c506b8Sjruoho      * The global root ptr is initially NULL, so a non-NULL value indicates
9628c506b8Sjruoho      * that AcpiNsRootInitialize() has already been called; just return.
9728c506b8Sjruoho      */
9828c506b8Sjruoho     if (AcpiGbl_RootNode)
9928c506b8Sjruoho     {
10028c506b8Sjruoho         Status = AE_OK;
10128c506b8Sjruoho         goto UnlockAndExit;
10228c506b8Sjruoho     }
10328c506b8Sjruoho 
10428c506b8Sjruoho     /*
10528c506b8Sjruoho      * Tell the rest of the subsystem that the root is initialized
10628c506b8Sjruoho      * (This is OK because the namespace is locked)
10728c506b8Sjruoho      */
10828c506b8Sjruoho     AcpiGbl_RootNode = &AcpiGbl_RootNodeStruct;
10928c506b8Sjruoho 
1107ab6b89bSchristos     /* Enter the predefined names in the name table */
11128c506b8Sjruoho 
11228c506b8Sjruoho     ACPI_DEBUG_PRINT ((ACPI_DB_INFO,
11328c506b8Sjruoho         "Entering predefined entries into namespace\n"));
11428c506b8Sjruoho 
1157ab6b89bSchristos     /*
1167ab6b89bSchristos      * Create the initial (default) namespace.
1177ab6b89bSchristos      * This namespace looks like something similar to this:
1187ab6b89bSchristos      *
1197ab6b89bSchristos      *   ACPI Namespace (from Namespace Root):
1207ab6b89bSchristos      *    0  _GPE Scope        00203160 00
1217ab6b89bSchristos      *    0  _PR_ Scope        002031D0 00
1227ab6b89bSchristos      *    0  _SB_ Device       00203240 00 Notify Object: 0020ADD8
1237ab6b89bSchristos      *    0  _SI_ Scope        002032B0 00
1247ab6b89bSchristos      *    0  _TZ_ Device       00203320 00
1257ab6b89bSchristos      *    0  _REV Integer      00203390 00 = 0000000000000002
1267ab6b89bSchristos      *    0  _OS_ String       00203488 00 Len 14 "Microsoft Windows NT"
1277ab6b89bSchristos      *    0  _GL_ Mutex        00203580 00 Object 002035F0
1287ab6b89bSchristos      *    0  _OSI Method       00203678 00 Args 1 Len 0000 Aml 00000000
1297ab6b89bSchristos      */
13028c506b8Sjruoho     for (InitVal = AcpiGbl_PreDefinedNames; InitVal->Name; InitVal++)
13128c506b8Sjruoho     {
1327ab6b89bSchristos         Status = AE_OK;
1337ab6b89bSchristos 
13428c506b8Sjruoho         /* _OSI is optional for now, will be permanent later */
13528c506b8Sjruoho 
1369b9ee194Schristos         if (!strcmp (InitVal->Name, "_OSI") && !AcpiGbl_CreateOsiMethod)
13728c506b8Sjruoho         {
13828c506b8Sjruoho             continue;
13928c506b8Sjruoho         }
14028c506b8Sjruoho 
1417ab6b89bSchristos         /*
1427ab6b89bSchristos          * Create, init, and link the new predefined name
1437ab6b89bSchristos          * Note: No need to use AcpiNsLookup here because all the
1447ab6b89bSchristos          * predefined names are at the root level. It is much easier to
1457ab6b89bSchristos          * just create and link the new node(s) here.
1467ab6b89bSchristos          */
147d5b984e0Schs         memcpy(&Name, InitVal->Name, sizeof(Name));
148d5b984e0Schs         NewNode = AcpiNsCreateNode (Name);
1497ab6b89bSchristos         if (!NewNode)
15028c506b8Sjruoho         {
1517ab6b89bSchristos             Status = AE_NO_MEMORY;
1527ab6b89bSchristos             goto UnlockAndExit;
15328c506b8Sjruoho         }
15428c506b8Sjruoho 
1557ab6b89bSchristos         NewNode->DescriptorType = ACPI_DESC_TYPE_NAMED;
1567ab6b89bSchristos         NewNode->Type = InitVal->Type;
1577ab6b89bSchristos 
1587ab6b89bSchristos         if (!PrevNode)
1597ab6b89bSchristos         {
1607ab6b89bSchristos             AcpiGbl_RootNodeStruct.Child = NewNode;
1617ab6b89bSchristos         }
1627ab6b89bSchristos         else
1637ab6b89bSchristos         {
1647ab6b89bSchristos             PrevNode->Peer = NewNode;
1657ab6b89bSchristos         }
1667ab6b89bSchristos 
1677ab6b89bSchristos         NewNode->Parent = &AcpiGbl_RootNodeStruct;
1687ab6b89bSchristos         PrevNode = NewNode;
1697ab6b89bSchristos 
17028c506b8Sjruoho         /*
17128c506b8Sjruoho          * Name entered successfully. If entry in PreDefinedNames[] specifies
17228c506b8Sjruoho          * an initial value, create the initial value.
17328c506b8Sjruoho          */
17428c506b8Sjruoho         if (InitVal->Val)
17528c506b8Sjruoho         {
17628c506b8Sjruoho             Status = AcpiOsPredefinedOverride (InitVal, &Val);
17728c506b8Sjruoho             if (ACPI_FAILURE (Status))
17828c506b8Sjruoho             {
17928c506b8Sjruoho                 ACPI_ERROR ((AE_INFO,
18028c506b8Sjruoho                     "Could not override predefined %s",
18128c506b8Sjruoho                     InitVal->Name));
18228c506b8Sjruoho             }
18328c506b8Sjruoho 
18428c506b8Sjruoho             if (!Val)
18528c506b8Sjruoho             {
186716c1ee0Sjruoho                 Val = __UNCONST(InitVal->Val);
18728c506b8Sjruoho             }
18828c506b8Sjruoho 
18928c506b8Sjruoho             /*
19028c506b8Sjruoho              * Entry requests an initial value, allocate a
19128c506b8Sjruoho              * descriptor for it.
19228c506b8Sjruoho              */
19328c506b8Sjruoho             ObjDesc = AcpiUtCreateInternalObject (InitVal->Type);
19428c506b8Sjruoho             if (!ObjDesc)
19528c506b8Sjruoho             {
19628c506b8Sjruoho                 Status = AE_NO_MEMORY;
19728c506b8Sjruoho                 goto UnlockAndExit;
19828c506b8Sjruoho             }
19928c506b8Sjruoho 
20028c506b8Sjruoho             /*
20128c506b8Sjruoho              * Convert value string from table entry to
20228c506b8Sjruoho              * internal representation. Only types actually
20328c506b8Sjruoho              * used for initial values are implemented here.
20428c506b8Sjruoho              */
20528c506b8Sjruoho             switch (InitVal->Type)
20628c506b8Sjruoho             {
20728c506b8Sjruoho             case ACPI_TYPE_METHOD:
208a2c051a9Schristos 
20928c506b8Sjruoho                 ObjDesc->Method.ParamCount = (UINT8) ACPI_TO_INTEGER (Val);
21028c506b8Sjruoho                 ObjDesc->Common.Flags |= AOPOBJ_DATA_VALID;
21128c506b8Sjruoho 
21228c506b8Sjruoho #if defined (ACPI_ASL_COMPILER)
21328c506b8Sjruoho 
21428c506b8Sjruoho                 /* Save the parameter count for the iASL compiler */
21528c506b8Sjruoho 
21628c506b8Sjruoho                 NewNode->Value = ObjDesc->Method.ParamCount;
21728c506b8Sjruoho #else
2187ab6b89bSchristos                 /* Mark this as a very SPECIAL method (_OSI) */
21928c506b8Sjruoho 
220159c4e26Sjruoho                 ObjDesc->Method.InfoFlags = ACPI_METHOD_INTERNAL_ONLY;
221159c4e26Sjruoho                 ObjDesc->Method.Dispatch.Implementation = AcpiUtOsiImplementation;
22228c506b8Sjruoho #endif
22328c506b8Sjruoho                 break;
22428c506b8Sjruoho 
22528c506b8Sjruoho             case ACPI_TYPE_INTEGER:
22628c506b8Sjruoho 
22728c506b8Sjruoho                 ObjDesc->Integer.Value = ACPI_TO_INTEGER (Val);
22828c506b8Sjruoho                 break;
22928c506b8Sjruoho 
23028c506b8Sjruoho             case ACPI_TYPE_STRING:
23128c506b8Sjruoho 
23228c506b8Sjruoho                 /* Build an object around the static string */
23328c506b8Sjruoho 
2349b9ee194Schristos                 ObjDesc->String.Length = (UINT32) strlen (Val);
23528c506b8Sjruoho                 ObjDesc->String.Pointer = Val;
23628c506b8Sjruoho                 ObjDesc->Common.Flags |= AOPOBJ_STATIC_POINTER;
23728c506b8Sjruoho                 break;
23828c506b8Sjruoho 
23928c506b8Sjruoho             case ACPI_TYPE_MUTEX:
24028c506b8Sjruoho 
24128c506b8Sjruoho                 ObjDesc->Mutex.Node = NewNode;
24228c506b8Sjruoho                 ObjDesc->Mutex.SyncLevel = (UINT8) (ACPI_TO_INTEGER (Val) - 1);
24328c506b8Sjruoho 
24428c506b8Sjruoho                 /* Create a mutex */
24528c506b8Sjruoho 
24628c506b8Sjruoho                 Status = AcpiOsCreateMutex (&ObjDesc->Mutex.OsMutex);
24728c506b8Sjruoho                 if (ACPI_FAILURE (Status))
24828c506b8Sjruoho                 {
24928c506b8Sjruoho                     AcpiUtRemoveReference (ObjDesc);
25028c506b8Sjruoho                     goto UnlockAndExit;
25128c506b8Sjruoho                 }
25228c506b8Sjruoho 
25328c506b8Sjruoho                 /* Special case for ACPI Global Lock */
25428c506b8Sjruoho 
2559b9ee194Schristos                 if (strcmp (InitVal->Name, "_GL_") == 0)
25628c506b8Sjruoho                 {
25728c506b8Sjruoho                     AcpiGbl_GlobalLockMutex = ObjDesc;
25828c506b8Sjruoho 
25928c506b8Sjruoho                     /* Create additional counting semaphore for global lock */
26028c506b8Sjruoho 
26128c506b8Sjruoho                     Status = AcpiOsCreateSemaphore (
26228c506b8Sjruoho                         1, 0, &AcpiGbl_GlobalLockSemaphore);
26328c506b8Sjruoho                     if (ACPI_FAILURE (Status))
26428c506b8Sjruoho                     {
26528c506b8Sjruoho                         AcpiUtRemoveReference (ObjDesc);
26628c506b8Sjruoho                         goto UnlockAndExit;
26728c506b8Sjruoho                     }
26828c506b8Sjruoho                 }
26928c506b8Sjruoho                 break;
27028c506b8Sjruoho 
27128c506b8Sjruoho             default:
27228c506b8Sjruoho 
27328c506b8Sjruoho                 ACPI_ERROR ((AE_INFO, "Unsupported initial type value 0x%X",
27428c506b8Sjruoho                     InitVal->Type));
27528c506b8Sjruoho                 AcpiUtRemoveReference (ObjDesc);
27628c506b8Sjruoho                 ObjDesc = NULL;
27728c506b8Sjruoho                 continue;
27828c506b8Sjruoho             }
27928c506b8Sjruoho 
28028c506b8Sjruoho             /* Store pointer to value descriptor in the Node */
28128c506b8Sjruoho 
28228c506b8Sjruoho             Status = AcpiNsAttachObject (NewNode, ObjDesc,
28328c506b8Sjruoho                 ObjDesc->Common.Type);
28428c506b8Sjruoho 
28528c506b8Sjruoho             /* Remove local reference to the object */
28628c506b8Sjruoho 
28728c506b8Sjruoho             AcpiUtRemoveReference (ObjDesc);
28828c506b8Sjruoho         }
28928c506b8Sjruoho     }
29028c506b8Sjruoho 
29128c506b8Sjruoho UnlockAndExit:
29228c506b8Sjruoho     (void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);
29328c506b8Sjruoho 
29428c506b8Sjruoho     /* Save a handle to "_GPE", it is always present */
29528c506b8Sjruoho 
29628c506b8Sjruoho     if (ACPI_SUCCESS (Status))
29728c506b8Sjruoho     {
29828c506b8Sjruoho         Status = AcpiNsGetNode (NULL, "\\_GPE", ACPI_NS_NO_UPSEARCH,
29928c506b8Sjruoho             &AcpiGbl_FadtGpeDevice);
30028c506b8Sjruoho     }
30128c506b8Sjruoho 
30228c506b8Sjruoho     return_ACPI_STATUS (Status);
30328c506b8Sjruoho }
30428c506b8Sjruoho 
30528c506b8Sjruoho 
30628c506b8Sjruoho /*******************************************************************************
30728c506b8Sjruoho  *
30828c506b8Sjruoho  * FUNCTION:    AcpiNsLookup
30928c506b8Sjruoho  *
31028c506b8Sjruoho  * PARAMETERS:  ScopeInfo       - Current scope info block
31128c506b8Sjruoho  *              Pathname        - Search pathname, in internal format
31228c506b8Sjruoho  *                                (as represented in the AML stream)
31328c506b8Sjruoho  *              Type            - Type associated with name
31428c506b8Sjruoho  *              InterpreterMode - IMODE_LOAD_PASS2 => add name if not found
31528c506b8Sjruoho  *              Flags           - Flags describing the search restrictions
31628c506b8Sjruoho  *              WalkState       - Current state of the walk
31728c506b8Sjruoho  *              ReturnNode      - Where the Node is placed (if found
31828c506b8Sjruoho  *                                or created successfully)
31928c506b8Sjruoho  *
32028c506b8Sjruoho  * RETURN:      Status
32128c506b8Sjruoho  *
32228c506b8Sjruoho  * DESCRIPTION: Find or enter the passed name in the name space.
32328c506b8Sjruoho  *              Log an error if name not found in Exec mode.
32428c506b8Sjruoho  *
32528c506b8Sjruoho  * MUTEX:       Assumes namespace is locked.
32628c506b8Sjruoho  *
32728c506b8Sjruoho  ******************************************************************************/
32828c506b8Sjruoho 
32928c506b8Sjruoho ACPI_STATUS
AcpiNsLookup(ACPI_GENERIC_STATE * ScopeInfo,char * Pathname,ACPI_OBJECT_TYPE Type,ACPI_INTERPRETER_MODE InterpreterMode,UINT32 Flags,ACPI_WALK_STATE * WalkState,ACPI_NAMESPACE_NODE ** ReturnNode)33028c506b8Sjruoho AcpiNsLookup (
33128c506b8Sjruoho     ACPI_GENERIC_STATE      *ScopeInfo,
33228c506b8Sjruoho     char                    *Pathname,
33328c506b8Sjruoho     ACPI_OBJECT_TYPE        Type,
33428c506b8Sjruoho     ACPI_INTERPRETER_MODE   InterpreterMode,
33528c506b8Sjruoho     UINT32                  Flags,
33628c506b8Sjruoho     ACPI_WALK_STATE         *WalkState,
33728c506b8Sjruoho     ACPI_NAMESPACE_NODE     **ReturnNode)
33828c506b8Sjruoho {
33928c506b8Sjruoho     ACPI_STATUS             Status;
34028c506b8Sjruoho     char                    *Path = Pathname;
341ae01dbf5Schristos     char                    *ExternalPath;
34228c506b8Sjruoho     ACPI_NAMESPACE_NODE     *PrefixNode;
34328c506b8Sjruoho     ACPI_NAMESPACE_NODE     *CurrentNode = NULL;
34428c506b8Sjruoho     ACPI_NAMESPACE_NODE     *ThisNode = NULL;
34528c506b8Sjruoho     UINT32                  NumSegments;
34628c506b8Sjruoho     UINT32                  NumCarats;
34728c506b8Sjruoho     ACPI_NAME               SimpleName;
34828c506b8Sjruoho     ACPI_OBJECT_TYPE        TypeToCheckFor;
34928c506b8Sjruoho     ACPI_OBJECT_TYPE        ThisSearchType;
35028c506b8Sjruoho     UINT32                  SearchParentFlag = ACPI_NS_SEARCH_PARENT;
35128c506b8Sjruoho     UINT32                  LocalFlags;
3527efa3256Schristos     ACPI_INTERPRETER_MODE   LocalInterpreterMode;
35328c506b8Sjruoho 
35428c506b8Sjruoho 
35528c506b8Sjruoho     ACPI_FUNCTION_TRACE (NsLookup);
35628c506b8Sjruoho 
35728c506b8Sjruoho 
35828c506b8Sjruoho     if (!ReturnNode)
35928c506b8Sjruoho     {
36028c506b8Sjruoho         return_ACPI_STATUS (AE_BAD_PARAMETER);
36128c506b8Sjruoho     }
36228c506b8Sjruoho 
3639b9ee194Schristos     LocalFlags = Flags &
3649b9ee194Schristos         ~(ACPI_NS_ERROR_IF_FOUND | ACPI_NS_OVERRIDE_IF_FOUND |
3659b9ee194Schristos           ACPI_NS_SEARCH_PARENT);
36628c506b8Sjruoho     *ReturnNode = ACPI_ENTRY_NOT_FOUND;
36728c506b8Sjruoho     AcpiGbl_NsLookupCount++;
36828c506b8Sjruoho 
36928c506b8Sjruoho     if (!AcpiGbl_RootNode)
37028c506b8Sjruoho     {
37128c506b8Sjruoho         return_ACPI_STATUS (AE_NO_NAMESPACE);
37228c506b8Sjruoho     }
37328c506b8Sjruoho 
37428c506b8Sjruoho     /* Get the prefix scope. A null scope means use the root scope */
37528c506b8Sjruoho 
37628c506b8Sjruoho     if ((!ScopeInfo) ||
37728c506b8Sjruoho         (!ScopeInfo->Scope.Node))
37828c506b8Sjruoho     {
37928c506b8Sjruoho         ACPI_DEBUG_PRINT ((ACPI_DB_NAMES,
38028c506b8Sjruoho             "Null scope prefix, using root node (%p)\n",
38128c506b8Sjruoho             AcpiGbl_RootNode));
38228c506b8Sjruoho 
38328c506b8Sjruoho         PrefixNode = AcpiGbl_RootNode;
38428c506b8Sjruoho     }
38528c506b8Sjruoho     else
38628c506b8Sjruoho     {
38728c506b8Sjruoho         PrefixNode = ScopeInfo->Scope.Node;
38828c506b8Sjruoho         if (ACPI_GET_DESCRIPTOR_TYPE (PrefixNode) != ACPI_DESC_TYPE_NAMED)
38928c506b8Sjruoho         {
39028c506b8Sjruoho             ACPI_ERROR ((AE_INFO, "%p is not a namespace node [%s]",
39128c506b8Sjruoho                 PrefixNode, AcpiUtGetDescriptorName (PrefixNode)));
39228c506b8Sjruoho             return_ACPI_STATUS (AE_AML_INTERNAL);
39328c506b8Sjruoho         }
39428c506b8Sjruoho 
39528c506b8Sjruoho         if (!(Flags & ACPI_NS_PREFIX_IS_SCOPE))
39628c506b8Sjruoho         {
39728c506b8Sjruoho             /*
39828c506b8Sjruoho              * This node might not be a actual "scope" node (such as a
39928c506b8Sjruoho              * Device/Method, etc.)  It could be a Package or other object
40028c506b8Sjruoho              * node. Backup up the tree to find the containing scope node.
40128c506b8Sjruoho              */
40228c506b8Sjruoho             while (!AcpiNsOpensScope (PrefixNode->Type) &&
40328c506b8Sjruoho                     PrefixNode->Type != ACPI_TYPE_ANY)
40428c506b8Sjruoho             {
40528c506b8Sjruoho                 PrefixNode = PrefixNode->Parent;
40628c506b8Sjruoho             }
40728c506b8Sjruoho         }
40828c506b8Sjruoho     }
40928c506b8Sjruoho 
41028c506b8Sjruoho     /* Save type. TBD: may be no longer necessary */
41128c506b8Sjruoho 
41228c506b8Sjruoho     TypeToCheckFor = Type;
41328c506b8Sjruoho 
41428c506b8Sjruoho     /*
41528c506b8Sjruoho      * Begin examination of the actual pathname
41628c506b8Sjruoho      */
41728c506b8Sjruoho     if (!Pathname)
41828c506b8Sjruoho     {
41928c506b8Sjruoho         /* A Null NamePath is allowed and refers to the root */
42028c506b8Sjruoho 
42128c506b8Sjruoho         NumSegments = 0;
42228c506b8Sjruoho         ThisNode = AcpiGbl_RootNode;
423716c1ee0Sjruoho         Path = __UNCONST("");
42428c506b8Sjruoho 
42528c506b8Sjruoho         ACPI_DEBUG_PRINT ((ACPI_DB_NAMES,
42628c506b8Sjruoho             "Null Pathname (Zero segments), Flags=%X\n", Flags));
42728c506b8Sjruoho     }
42828c506b8Sjruoho     else
42928c506b8Sjruoho     {
43028c506b8Sjruoho         /*
43128c506b8Sjruoho          * Name pointer is valid (and must be in internal name format)
43228c506b8Sjruoho          *
43328c506b8Sjruoho          * Check for scope prefixes:
43428c506b8Sjruoho          *
43528c506b8Sjruoho          * As represented in the AML stream, a namepath consists of an
43628c506b8Sjruoho          * optional scope prefix followed by a name segment part.
43728c506b8Sjruoho          *
43828c506b8Sjruoho          * If present, the scope prefix is either a Root Prefix (in
43928c506b8Sjruoho          * which case the name is fully qualified), or one or more
44028c506b8Sjruoho          * Parent Prefixes (in which case the name's scope is relative
44128c506b8Sjruoho          * to the current scope).
44228c506b8Sjruoho          */
44328c506b8Sjruoho         if (*Path == (UINT8) AML_ROOT_PREFIX)
44428c506b8Sjruoho         {
44528c506b8Sjruoho             /* Pathname is fully qualified, start from the root */
44628c506b8Sjruoho 
44728c506b8Sjruoho             ThisNode = AcpiGbl_RootNode;
44828c506b8Sjruoho             SearchParentFlag = ACPI_NS_NO_UPSEARCH;
44928c506b8Sjruoho 
45028c506b8Sjruoho             /* Point to name segment part */
45128c506b8Sjruoho 
45228c506b8Sjruoho             Path++;
45328c506b8Sjruoho 
45428c506b8Sjruoho             ACPI_DEBUG_PRINT ((ACPI_DB_NAMES,
45528c506b8Sjruoho                 "Path is absolute from root [%p]\n", ThisNode));
45628c506b8Sjruoho         }
45728c506b8Sjruoho         else
45828c506b8Sjruoho         {
45928c506b8Sjruoho             /* Pathname is relative to current scope, start there */
46028c506b8Sjruoho 
46128c506b8Sjruoho             ACPI_DEBUG_PRINT ((ACPI_DB_NAMES,
46228c506b8Sjruoho                 "Searching relative to prefix scope [%4.4s] (%p)\n",
46328c506b8Sjruoho                 AcpiUtGetNodeName (PrefixNode), PrefixNode));
46428c506b8Sjruoho 
46528c506b8Sjruoho             /*
46628c506b8Sjruoho              * Handle multiple Parent Prefixes (carat) by just getting
46728c506b8Sjruoho              * the parent node for each prefix instance.
46828c506b8Sjruoho              */
46928c506b8Sjruoho             ThisNode = PrefixNode;
47028c506b8Sjruoho             NumCarats = 0;
47128c506b8Sjruoho             while (*Path == (UINT8) AML_PARENT_PREFIX)
47228c506b8Sjruoho             {
47328c506b8Sjruoho                 /* Name is fully qualified, no search rules apply */
47428c506b8Sjruoho 
47528c506b8Sjruoho                 SearchParentFlag = ACPI_NS_NO_UPSEARCH;
47628c506b8Sjruoho 
47728c506b8Sjruoho                 /*
47828c506b8Sjruoho                  * Point past this prefix to the name segment
47928c506b8Sjruoho                  * part or the next Parent Prefix
48028c506b8Sjruoho                  */
48128c506b8Sjruoho                 Path++;
48228c506b8Sjruoho 
48328c506b8Sjruoho                 /* Backup to the parent node */
48428c506b8Sjruoho 
48528c506b8Sjruoho                 NumCarats++;
48628c506b8Sjruoho                 ThisNode = ThisNode->Parent;
48728c506b8Sjruoho                 if (!ThisNode)
48828c506b8Sjruoho                 {
489ae01dbf5Schristos                     /*
490ae01dbf5Schristos                      * Current scope has no parent scope. Externalize
491ae01dbf5Schristos                      * the internal path for error message.
492ae01dbf5Schristos                      */
493ae01dbf5Schristos                     Status = AcpiNsExternalizeName (ACPI_UINT32_MAX, Pathname,
494ae01dbf5Schristos                         NULL, &ExternalPath);
495ae01dbf5Schristos                     if (ACPI_SUCCESS (Status))
496ae01dbf5Schristos                     {
49728c506b8Sjruoho                         ACPI_ERROR ((AE_INFO,
498ae01dbf5Schristos                             "%s: Path has too many parent prefixes (^)",
499ae01dbf5Schristos                             ExternalPath));
500ae01dbf5Schristos 
501ae01dbf5Schristos                         ACPI_FREE (ExternalPath);
502ae01dbf5Schristos                     }
503ae01dbf5Schristos 
50428c506b8Sjruoho                     return_ACPI_STATUS (AE_NOT_FOUND);
50528c506b8Sjruoho                 }
50628c506b8Sjruoho             }
50728c506b8Sjruoho 
50828c506b8Sjruoho             if (SearchParentFlag == ACPI_NS_NO_UPSEARCH)
50928c506b8Sjruoho             {
51028c506b8Sjruoho                 ACPI_DEBUG_PRINT ((ACPI_DB_NAMES,
51128c506b8Sjruoho                     "Search scope is [%4.4s], path has %u carat(s)\n",
51228c506b8Sjruoho                     AcpiUtGetNodeName (ThisNode), NumCarats));
51328c506b8Sjruoho             }
51428c506b8Sjruoho         }
51528c506b8Sjruoho 
51628c506b8Sjruoho         /*
51728c506b8Sjruoho          * Determine the number of ACPI name segments in this pathname.
51828c506b8Sjruoho          *
51928c506b8Sjruoho          * The segment part consists of either:
52028c506b8Sjruoho          *  - A Null name segment (0)
52128c506b8Sjruoho          *  - A DualNamePrefix followed by two 4-byte name segments
52228c506b8Sjruoho          *  - A MultiNamePrefix followed by a byte indicating the
52328c506b8Sjruoho          *      number of segments and the segments themselves.
52428c506b8Sjruoho          *  - A single 4-byte name segment
52528c506b8Sjruoho          *
52628c506b8Sjruoho          * Examine the name prefix opcode, if any, to determine the number of
52728c506b8Sjruoho          * segments.
52828c506b8Sjruoho          */
52928c506b8Sjruoho         switch (*Path)
53028c506b8Sjruoho         {
53128c506b8Sjruoho         case 0:
53228c506b8Sjruoho             /*
53328c506b8Sjruoho              * Null name after a root or parent prefixes. We already
53428c506b8Sjruoho              * have the correct target node and there are no name segments.
53528c506b8Sjruoho              */
53628c506b8Sjruoho             NumSegments  = 0;
53728c506b8Sjruoho             Type = ThisNode->Type;
53828c506b8Sjruoho 
53928c506b8Sjruoho             ACPI_DEBUG_PRINT ((ACPI_DB_NAMES,
54028c506b8Sjruoho                 "Prefix-only Pathname (Zero name segments), Flags=%X\n",
54128c506b8Sjruoho                 Flags));
54228c506b8Sjruoho             break;
54328c506b8Sjruoho 
54428c506b8Sjruoho         case AML_DUAL_NAME_PREFIX:
54528c506b8Sjruoho 
54628c506b8Sjruoho             /* More than one NameSeg, search rules do not apply */
54728c506b8Sjruoho 
54828c506b8Sjruoho             SearchParentFlag = ACPI_NS_NO_UPSEARCH;
54928c506b8Sjruoho 
55028c506b8Sjruoho             /* Two segments, point to first name segment */
55128c506b8Sjruoho 
55228c506b8Sjruoho             NumSegments = 2;
55328c506b8Sjruoho             Path++;
55428c506b8Sjruoho 
55528c506b8Sjruoho             ACPI_DEBUG_PRINT ((ACPI_DB_NAMES,
55628c506b8Sjruoho                 "Dual Pathname (2 segments, Flags=%X)\n", Flags));
55728c506b8Sjruoho             break;
55828c506b8Sjruoho 
5598f1e17bdSchristos         case AML_MULTI_NAME_PREFIX:
56028c506b8Sjruoho 
56128c506b8Sjruoho             /* More than one NameSeg, search rules do not apply */
56228c506b8Sjruoho 
56328c506b8Sjruoho             SearchParentFlag = ACPI_NS_NO_UPSEARCH;
56428c506b8Sjruoho 
56528c506b8Sjruoho             /* Extract segment count, point to first name segment */
56628c506b8Sjruoho 
56728c506b8Sjruoho             Path++;
56828c506b8Sjruoho             NumSegments = (UINT32) (UINT8) *Path;
56928c506b8Sjruoho             Path++;
57028c506b8Sjruoho 
57128c506b8Sjruoho             ACPI_DEBUG_PRINT ((ACPI_DB_NAMES,
57228c506b8Sjruoho                 "Multi Pathname (%u Segments, Flags=%X)\n",
57328c506b8Sjruoho                 NumSegments, Flags));
57428c506b8Sjruoho             break;
57528c506b8Sjruoho 
57628c506b8Sjruoho         default:
57728c506b8Sjruoho             /*
57828c506b8Sjruoho              * Not a Null name, no Dual or Multi prefix, hence there is
57928c506b8Sjruoho              * only one name segment and Pathname is already pointing to it.
58028c506b8Sjruoho              */
58128c506b8Sjruoho             NumSegments = 1;
58228c506b8Sjruoho 
58328c506b8Sjruoho             ACPI_DEBUG_PRINT ((ACPI_DB_NAMES,
58428c506b8Sjruoho                 "Simple Pathname (1 segment, Flags=%X)\n", Flags));
58528c506b8Sjruoho             break;
58628c506b8Sjruoho         }
58728c506b8Sjruoho 
58828c506b8Sjruoho         ACPI_DEBUG_EXEC (AcpiNsPrintPathname (NumSegments, Path));
58928c506b8Sjruoho     }
59028c506b8Sjruoho 
59128c506b8Sjruoho 
59228c506b8Sjruoho     /*
59328c506b8Sjruoho      * Search namespace for each segment of the name. Loop through and
59428c506b8Sjruoho      * verify (or add to the namespace) each name segment.
59528c506b8Sjruoho      *
59628c506b8Sjruoho      * The object type is significant only at the last name
59728c506b8Sjruoho      * segment. (We don't care about the types along the path, only
59828c506b8Sjruoho      * the type of the final target object.)
59928c506b8Sjruoho      */
60028c506b8Sjruoho     ThisSearchType = ACPI_TYPE_ANY;
60128c506b8Sjruoho     CurrentNode = ThisNode;
6027efa3256Schristos 
60328c506b8Sjruoho     while (NumSegments && CurrentNode)
60428c506b8Sjruoho     {
60528c506b8Sjruoho         NumSegments--;
60628c506b8Sjruoho         if (!NumSegments)
60728c506b8Sjruoho         {
60828c506b8Sjruoho             /* This is the last segment, enable typechecking */
60928c506b8Sjruoho 
61028c506b8Sjruoho             ThisSearchType = Type;
61128c506b8Sjruoho 
61228c506b8Sjruoho             /*
61328c506b8Sjruoho              * Only allow automatic parent search (search rules) if the caller
61428c506b8Sjruoho              * requested it AND we have a single, non-fully-qualified NameSeg
61528c506b8Sjruoho              */
61628c506b8Sjruoho             if ((SearchParentFlag != ACPI_NS_NO_UPSEARCH) &&
61728c506b8Sjruoho                 (Flags & ACPI_NS_SEARCH_PARENT))
61828c506b8Sjruoho             {
61928c506b8Sjruoho                 LocalFlags |= ACPI_NS_SEARCH_PARENT;
62028c506b8Sjruoho             }
62128c506b8Sjruoho 
62228c506b8Sjruoho             /* Set error flag according to caller */
62328c506b8Sjruoho 
62428c506b8Sjruoho             if (Flags & ACPI_NS_ERROR_IF_FOUND)
62528c506b8Sjruoho             {
62628c506b8Sjruoho                 LocalFlags |= ACPI_NS_ERROR_IF_FOUND;
62728c506b8Sjruoho             }
6289b9ee194Schristos 
6299b9ee194Schristos             /* Set override flag according to caller */
6309b9ee194Schristos 
6319b9ee194Schristos             if (Flags & ACPI_NS_OVERRIDE_IF_FOUND)
6329b9ee194Schristos             {
6339b9ee194Schristos                 LocalFlags |= ACPI_NS_OVERRIDE_IF_FOUND;
6349b9ee194Schristos             }
63528c506b8Sjruoho         }
63628c506b8Sjruoho 
6377efa3256Schristos         /* Handle opcodes that create a new NameSeg via a full NamePath */
6387efa3256Schristos 
6397efa3256Schristos         LocalInterpreterMode = InterpreterMode;
6407efa3256Schristos         if ((Flags & ACPI_NS_PREFIX_MUST_EXIST) && (NumSegments > 0))
6417efa3256Schristos         {
6427efa3256Schristos             /* Every element of the path must exist (except for the final NameSeg) */
6437efa3256Schristos 
6447efa3256Schristos             LocalInterpreterMode = ACPI_IMODE_EXECUTE;
6457efa3256Schristos         }
6467efa3256Schristos 
64728c506b8Sjruoho         /* Extract one ACPI name from the front of the pathname */
64828c506b8Sjruoho 
64928c506b8Sjruoho         ACPI_MOVE_32_TO_32 (&SimpleName, Path);
65028c506b8Sjruoho 
65128c506b8Sjruoho         /* Try to find the single (4 character) ACPI name */
65228c506b8Sjruoho 
65328c506b8Sjruoho         Status = AcpiNsSearchAndEnter (SimpleName, WalkState, CurrentNode,
6547efa3256Schristos             LocalInterpreterMode, ThisSearchType, LocalFlags, &ThisNode);
65528c506b8Sjruoho         if (ACPI_FAILURE (Status))
65628c506b8Sjruoho         {
65728c506b8Sjruoho             if (Status == AE_NOT_FOUND)
65828c506b8Sjruoho             {
6597efa3256Schristos #if !defined ACPI_ASL_COMPILER /* Note: iASL reports this error by itself, not needed here */
6607efa3256Schristos                 if (Flags & ACPI_NS_PREFIX_MUST_EXIST)
6617efa3256Schristos                 {
6627efa3256Schristos                     AcpiOsPrintf (ACPI_MSG_BIOS_ERROR
6637ab6b89bSchristos                         "Object does not exist: %4.4s\n", (char *) &SimpleName);
6647efa3256Schristos                 }
6657efa3256Schristos #endif
66628c506b8Sjruoho                 /* Name not found in ACPI namespace */
66728c506b8Sjruoho 
66828c506b8Sjruoho                 ACPI_DEBUG_PRINT ((ACPI_DB_NAMES,
66928c506b8Sjruoho                     "Name [%4.4s] not found in scope [%4.4s] %p\n",
67028c506b8Sjruoho                     (char *) &SimpleName, (char *) &CurrentNode->Name,
67128c506b8Sjruoho                     CurrentNode));
67228c506b8Sjruoho             }
67328c506b8Sjruoho 
674a147b75fSchristos #ifdef ACPI_EXEC_APP
675a147b75fSchristos             if ((Status == AE_ALREADY_EXISTS) &&
676a147b75fSchristos                 (ThisNode->Flags & ANOBJ_NODE_EARLY_INIT))
677a147b75fSchristos             {
678a147b75fSchristos                 ThisNode->Flags &= ~ANOBJ_NODE_EARLY_INIT;
679a147b75fSchristos                 Status = AE_OK;
680a147b75fSchristos             }
681a147b75fSchristos #endif
682a147b75fSchristos 
683ae01dbf5Schristos #ifdef ACPI_ASL_COMPILER
684ae01dbf5Schristos             /*
685ae01dbf5Schristos              * If this ACPI name already exists within the namespace as an
686ae01dbf5Schristos              * external declaration, then mark the external as a conflicting
687ae01dbf5Schristos              * declaration and proceed to process the current node as if it did
688ae01dbf5Schristos              * not exist in the namespace. If this node is not processed as
689ae01dbf5Schristos              * normal, then it could cause improper namespace resolution
690ae01dbf5Schristos              * by failing to open a new scope.
691ae01dbf5Schristos              */
692ae01dbf5Schristos             if (AcpiGbl_DisasmFlag &&
693ae01dbf5Schristos                 (Status == AE_ALREADY_EXISTS) &&
694ae01dbf5Schristos                 ((ThisNode->Flags & ANOBJ_IS_EXTERNAL) ||
695ae01dbf5Schristos                     (WalkState && WalkState->Opcode == AML_EXTERNAL_OP)))
696ae01dbf5Schristos             {
697ae01dbf5Schristos                 ThisNode->Flags &= ~ANOBJ_IS_EXTERNAL;
698ae01dbf5Schristos                 ThisNode->Type = (UINT8)ThisSearchType;
699ae01dbf5Schristos                 if (WalkState->Opcode != AML_EXTERNAL_OP)
700ae01dbf5Schristos                 {
701ae01dbf5Schristos                     AcpiDmMarkExternalConflict (ThisNode);
702ae01dbf5Schristos                 }
703ae01dbf5Schristos                 break;
704ae01dbf5Schristos             }
705ae01dbf5Schristos #endif
706ae01dbf5Schristos 
70728c506b8Sjruoho             *ReturnNode = ThisNode;
70828c506b8Sjruoho             return_ACPI_STATUS (Status);
70928c506b8Sjruoho         }
71028c506b8Sjruoho 
71128c506b8Sjruoho         /* More segments to follow? */
71228c506b8Sjruoho 
71328c506b8Sjruoho         if (NumSegments > 0)
71428c506b8Sjruoho         {
71528c506b8Sjruoho             /*
71628c506b8Sjruoho              * If we have an alias to an object that opens a scope (such as a
71728c506b8Sjruoho              * device or processor), we need to dereference the alias here so
71828c506b8Sjruoho              * that we can access any children of the original node (via the
71928c506b8Sjruoho              * remaining segments).
72028c506b8Sjruoho              */
72128c506b8Sjruoho             if (ThisNode->Type == ACPI_TYPE_LOCAL_ALIAS)
72228c506b8Sjruoho             {
72328c506b8Sjruoho                 if (!ThisNode->Object)
72428c506b8Sjruoho                 {
72528c506b8Sjruoho                     return_ACPI_STATUS (AE_NOT_EXIST);
72628c506b8Sjruoho                 }
72728c506b8Sjruoho 
72828c506b8Sjruoho                 if (AcpiNsOpensScope (((ACPI_NAMESPACE_NODE *)
72928c506b8Sjruoho                         ThisNode->Object)->Type))
73028c506b8Sjruoho                 {
73128c506b8Sjruoho                     ThisNode = (ACPI_NAMESPACE_NODE *) ThisNode->Object;
73228c506b8Sjruoho                 }
73328c506b8Sjruoho             }
73428c506b8Sjruoho         }
73528c506b8Sjruoho 
73628c506b8Sjruoho         /* Special handling for the last segment (NumSegments == 0) */
73728c506b8Sjruoho 
73828c506b8Sjruoho         else
73928c506b8Sjruoho         {
74028c506b8Sjruoho             /*
74128c506b8Sjruoho              * Sanity typecheck of the target object:
74228c506b8Sjruoho              *
74328c506b8Sjruoho              * If 1) This is the last segment (NumSegments == 0)
74428c506b8Sjruoho              *    2) And we are looking for a specific type
74528c506b8Sjruoho              *       (Not checking for TYPE_ANY)
74628c506b8Sjruoho              *    3) Which is not an alias
74728c506b8Sjruoho              *    4) Which is not a local type (TYPE_SCOPE)
74828c506b8Sjruoho              *    5) And the type of target object is known (not TYPE_ANY)
74928c506b8Sjruoho              *    6) And target object does not match what we are looking for
75028c506b8Sjruoho              *
75128c506b8Sjruoho              * Then we have a type mismatch. Just warn and ignore it.
75228c506b8Sjruoho              */
75328c506b8Sjruoho             if ((TypeToCheckFor != ACPI_TYPE_ANY)                   &&
75428c506b8Sjruoho                 (TypeToCheckFor != ACPI_TYPE_LOCAL_ALIAS)           &&
75528c506b8Sjruoho                 (TypeToCheckFor != ACPI_TYPE_LOCAL_METHOD_ALIAS)    &&
75628c506b8Sjruoho                 (TypeToCheckFor != ACPI_TYPE_LOCAL_SCOPE)           &&
75728c506b8Sjruoho                 (ThisNode->Type != ACPI_TYPE_ANY)                   &&
75828c506b8Sjruoho                 (ThisNode->Type != TypeToCheckFor))
75928c506b8Sjruoho             {
76028c506b8Sjruoho                 /* Complain about a type mismatch */
76128c506b8Sjruoho 
76228c506b8Sjruoho                 ACPI_WARNING ((AE_INFO,
76328c506b8Sjruoho                     "NsLookup: Type mismatch on %4.4s (%s), searching for (%s)",
76428c506b8Sjruoho                     ACPI_CAST_PTR (char, &SimpleName),
76528c506b8Sjruoho                     AcpiUtGetTypeName (ThisNode->Type),
76628c506b8Sjruoho                     AcpiUtGetTypeName (TypeToCheckFor)));
76728c506b8Sjruoho             }
76828c506b8Sjruoho 
76928c506b8Sjruoho             /*
77028c506b8Sjruoho              * If this is the last name segment and we are not looking for a
77128c506b8Sjruoho              * specific type, but the type of found object is known, use that
77228c506b8Sjruoho              * type to (later) see if it opens a scope.
77328c506b8Sjruoho              */
77428c506b8Sjruoho             if (Type == ACPI_TYPE_ANY)
77528c506b8Sjruoho             {
77628c506b8Sjruoho                 Type = ThisNode->Type;
77728c506b8Sjruoho             }
77828c506b8Sjruoho         }
77928c506b8Sjruoho 
78028c506b8Sjruoho         /* Point to next name segment and make this node current */
78128c506b8Sjruoho 
7825b948c02Schristos         Path += ACPI_NAMESEG_SIZE;
78328c506b8Sjruoho         CurrentNode = ThisNode;
78428c506b8Sjruoho     }
78528c506b8Sjruoho 
78628c506b8Sjruoho     /* Always check if we need to open a new scope */
78728c506b8Sjruoho 
78828c506b8Sjruoho     if (!(Flags & ACPI_NS_DONT_OPEN_SCOPE) && (WalkState))
78928c506b8Sjruoho     {
79028c506b8Sjruoho         /*
79128c506b8Sjruoho          * If entry is a type which opens a scope, push the new scope on the
79228c506b8Sjruoho          * scope stack.
79328c506b8Sjruoho          */
79428c506b8Sjruoho         if (AcpiNsOpensScope (Type))
79528c506b8Sjruoho         {
79628c506b8Sjruoho             Status = AcpiDsScopeStackPush (ThisNode, Type, WalkState);
79728c506b8Sjruoho             if (ACPI_FAILURE (Status))
79828c506b8Sjruoho             {
79928c506b8Sjruoho                 return_ACPI_STATUS (Status);
80028c506b8Sjruoho             }
80128c506b8Sjruoho         }
80228c506b8Sjruoho     }
80328c506b8Sjruoho 
804a147b75fSchristos #ifdef ACPI_EXEC_APP
805a147b75fSchristos     if (Flags & ACPI_NS_EARLY_INIT)
806a147b75fSchristos     {
807a147b75fSchristos         ThisNode->Flags |= ANOBJ_NODE_EARLY_INIT;
808a147b75fSchristos     }
809a147b75fSchristos #endif
810a147b75fSchristos 
81128c506b8Sjruoho     *ReturnNode = ThisNode;
81228c506b8Sjruoho     return_ACPI_STATUS (AE_OK);
81328c506b8Sjruoho }
814