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