1 /*******************************************************************************
3 * Module Name: nsaccess - Top-level functions for accessing ACPI namespace
6 ******************************************************************************/
8 /******************************************************************************
12 * Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp.
13 * All rights reserved.
17 * 2.1. This is your license from Intel Corp. under its intellectual property
18 * rights. You may have additional license terms from the party that provided
19 * you this software, covering your right to use that party's intellectual
22 * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
23 * copy of the source code appearing in this file ("Covered Code") an
24 * irrevocable, perpetual, worldwide license under Intel's copyrights in the
25 * base code distributed originally by Intel ("Original Intel Code") to copy,
26 * make derivatives, distribute, use and display any portion of the Covered
27 * Code in any form, with the right to sublicense such rights; and
29 * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
30 * license (with the right to sublicense), under only those claims of Intel
31 * patents that are infringed by the Original Intel Code, to make, use, sell,
32 * offer to sell, and import the Covered Code and derivative works thereof
33 * solely to the minimum extent necessary to exercise the above copyright
34 * license, and in no event shall the patent license extend to any additions
35 * to or modifications of the Original Intel Code. No other license or right
36 * is granted directly or by implication, estoppel or otherwise;
38 * The above copyright and patent license is granted only if the following
43 * 3.1. Redistribution of Source with Rights to Further Distribute Source.
44 * Redistribution of source code of any substantial portion of the Covered
45 * Code or modification with rights to further distribute source must include
46 * the above Copyright Notice, the above License, this list of Conditions,
47 * and the following Disclaimer and Export Compliance provision. In addition,
48 * Licensee must cause all Covered Code to which Licensee contributes to
49 * contain a file documenting the changes Licensee made to create that Covered
50 * Code and the date of any change. Licensee must include in that file the
51 * documentation of any changes made by any predecessor Licensee. Licensee
52 * must include a prominent statement that the modification is derived,
53 * directly or indirectly, from Original Intel Code.
55 * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
56 * Redistribution of source code of any substantial portion of the Covered
57 * Code or modification without rights to further distribute source must
58 * include the following Disclaimer and Export Compliance provision in the
59 * documentation and/or other materials provided with distribution. In
60 * addition, Licensee may not authorize further sublicense of source of any
61 * portion of the Covered Code, and must include terms to the effect that the
62 * license from Licensee to its licensee is limited to the intellectual
63 * property embodied in the software Licensee provides to its licensee, and
64 * not to intellectual property embodied in modifications its licensee may
67 * 3.3. Redistribution of Executable. Redistribution in executable form of any
68 * substantial portion of the Covered Code or modification must reproduce the
69 * above Copyright Notice, and the following Disclaimer and Export Compliance
70 * provision in the documentation and/or other materials provided with the
73 * 3.4. Intel retains all right, title, and interest in and to the Original
76 * 3.5. Neither the name Intel nor any other trademark owned or controlled by
77 * Intel shall be used in advertising or otherwise to promote the sale, use or
78 * other dealings in products derived from or relating to the Covered Code
79 * without prior written authorization from Intel.
81 * 4. Disclaimer and Export Compliance
83 * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
84 * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
85 * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE,
86 * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY
87 * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY
88 * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
91 * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
92 * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
93 * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
94 * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
95 * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
96 * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS
97 * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
100 * 4.3. Licensee shall not export, either directly or indirectly, any of this
101 * software or system incorporating such software without first obtaining any
102 * required license or other approval from the U. S. Department of Commerce or
103 * any other agency or department of the United States Government. In the
104 * event Licensee exports any such software from the United States or
105 * re-exports any such software from a foreign destination, Licensee shall
106 * ensure that the distribution and export/re-export of the software is in
107 * compliance with all laws, regulations, orders, or other restrictions of the
108 * U.S. Export Administration Regulations. Licensee agrees that neither it nor
109 * any of its subsidiaries will export/re-export any technical data, process,
110 * software, or service, directly or indirectly, to any country for which the
111 * United States government or any agency thereof requires an export license,
112 * other governmental approval, or letter of assurance, without first obtaining
113 * such license, approval or letter.
115 *****************************************************************************/
117 #define __NSACCESS_C__
121 #include "acinterp.h"
122 #include "acnamesp.h"
123 #include "acdispat.h"
126 #define _COMPONENT ACPI_NAMESPACE
127 MODULE_NAME ("nsaccess")
130 /*******************************************************************************
132 * FUNCTION: AcpiNsRootInitialize
138 * DESCRIPTION: Allocate and initialize the default root named objects
140 * MUTEX: Locks namespace for entire execution
142 ******************************************************************************/
145 AcpiNsRootInitialize (void)
147 ACPI_STATUS Status = AE_OK;
148 const PREDEFINED_NAMES *InitVal = NULL;
149 ACPI_NAMESPACE_NODE *NewNode;
150 ACPI_OPERAND_OBJECT *ObjDesc;
153 FUNCTION_TRACE ("NsRootInitialize");
156 AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE);
159 * The global root ptr is initially NULL, so a non-NULL value indicates
160 * that AcpiNsRootInitialize() has already been called; just return.
162 if (AcpiGbl_RootNode)
169 * Tell the rest of the subsystem that the root is initialized
170 * (This is OK because the namespace is locked)
172 AcpiGbl_RootNode = &AcpiGbl_RootNodeStruct;
174 /* Enter the pre-defined names in the name table */
176 ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Entering predefined entries into namespace\n"));
178 for (InitVal = AcpiGbl_PreDefinedNames; InitVal->Name; InitVal++)
180 Status = AcpiNsLookup (NULL, InitVal->Name, InitVal->Type,
181 IMODE_LOAD_PASS2, NS_NO_UPSEARCH,
184 if (ACPI_FAILURE (Status) || (!NewNode)) /* Must be on same line for code converter */
186 ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
187 "Could not create predefined name %s, %s\n",
188 InitVal->Name, AcpiFormatException (Status)));
192 * Name entered successfully.
193 * If entry in PreDefinedNames[] specifies an
194 * initial value, create the initial value.
199 * Entry requests an initial value, allocate a
202 ObjDesc = AcpiUtCreateInternalObject (InitVal->Type);
205 Status = AE_NO_MEMORY;
210 * Convert value string from table entry to
211 * internal representation. Only types actually
212 * used for initial values are implemented here.
214 switch (InitVal->Type)
216 case ACPI_TYPE_INTEGER:
218 ObjDesc->Integer.Value =
219 (ACPI_INTEGER) STRTOUL (InitVal->Val, NULL, 10);
223 case ACPI_TYPE_STRING:
226 * Build an object around the static string
228 ObjDesc->String.Length = STRLEN (InitVal->Val);
229 ObjDesc->String.Pointer = InitVal->Val;
230 ObjDesc->Common.Flags |= AOPOBJ_STATIC_POINTER;
234 case ACPI_TYPE_MUTEX:
236 ObjDesc->Mutex.SyncLevel =
237 (UINT16) STRTOUL (InitVal->Val, NULL, 10);
239 if (STRCMP (InitVal->Name, "_GL_") == 0)
242 * Create a counting semaphore for the
245 Status = AcpiOsCreateSemaphore (ACPI_NO_UNIT_LIMIT,
246 1, &ObjDesc->Mutex.Semaphore);
247 if (ACPI_FAILURE (Status))
253 * We just created the mutex for the
254 * global lock, save it
256 AcpiGbl_GlobalLockSemaphore = ObjDesc->Mutex.Semaphore;
262 Status = AcpiOsCreateSemaphore (1, 1,
263 &ObjDesc->Mutex.Semaphore);
264 if (ACPI_FAILURE (Status))
273 REPORT_ERROR (("Unsupported initial type value %X\n",
275 AcpiUtRemoveReference (ObjDesc);
280 /* Store pointer to value descriptor in the Node */
282 AcpiNsAttachObject (NewNode, ObjDesc, ObjDesc->Common.Type);
284 /* Remove local reference to the object */
286 AcpiUtRemoveReference (ObjDesc);
292 AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);
293 return_ACPI_STATUS (Status);
297 /*******************************************************************************
299 * FUNCTION: AcpiNsLookup
301 * PARAMETERS: PrefixNode - Search scope if name is not fully qualified
302 * Pathname - Search pathname, in internal format
303 * (as represented in the AML stream)
304 * Type - Type associated with name
305 * InterpreterMode - IMODE_LOAD_PASS2 => add name if not found
306 * Flags - Flags describing the search restrictions
307 * WalkState - Current state of the walk
308 * ReturnNode - Where the Node is placed (if found
309 * or created successfully)
313 * DESCRIPTION: Find or enter the passed name in the name space.
314 * Log an error if name not found in Exec mode.
316 * MUTEX: Assumes namespace is locked.
318 ******************************************************************************/
322 ACPI_GENERIC_STATE *ScopeInfo,
323 NATIVE_CHAR *Pathname,
324 ACPI_OBJECT_TYPE8 Type,
325 OPERATING_MODE InterpreterMode,
327 ACPI_WALK_STATE *WalkState,
328 ACPI_NAMESPACE_NODE **ReturnNode)
331 ACPI_NAMESPACE_NODE *PrefixNode;
332 ACPI_NAMESPACE_NODE *CurrentNode = NULL;
333 ACPI_NAMESPACE_NODE *ThisNode = NULL;
335 ACPI_NAME SimpleName;
336 BOOLEAN NullNamePath = FALSE;
337 ACPI_OBJECT_TYPE8 TypeToCheckFor;
338 ACPI_OBJECT_TYPE8 ThisSearchType;
339 UINT32 LocalFlags = Flags & ~NS_ERROR_IF_FOUND;
342 FUNCTION_TRACE ("NsLookup");
347 return_ACPI_STATUS (AE_BAD_PARAMETER);
350 AcpiGbl_NsLookupCount++;
351 *ReturnNode = ENTRY_NOT_FOUND;
353 if (!AcpiGbl_RootNode)
355 return_ACPI_STATUS (AE_NO_NAMESPACE);
359 * Get the prefix scope.
360 * A null scope means use the root scope
363 (!ScopeInfo->Scope.Node))
365 ACPI_DEBUG_PRINT ((ACPI_DB_NAMES,
366 "Null scope prefix, using root node (%p)\n",
369 PrefixNode = AcpiGbl_RootNode;
373 PrefixNode = ScopeInfo->Scope.Node;
377 * This check is explicitly split to relax the TypeToCheckFor
378 * conditions for BankFieldDefn. Originally, both BankFieldDefn and
379 * DefFieldDefn caused TypeToCheckFor to be set to ACPI_TYPE_REGION,
380 * but the BankFieldDefn may also check for a Field definition as well
381 * as an OperationRegion.
383 if (INTERNAL_TYPE_FIELD_DEFN == Type)
385 /* DefFieldDefn defines fields in a Region */
387 TypeToCheckFor = ACPI_TYPE_REGION;
389 else if (INTERNAL_TYPE_BANK_FIELD_DEFN == Type)
391 /* BankFieldDefn defines data fields in a Field Object */
393 TypeToCheckFor = ACPI_TYPE_ANY;
397 TypeToCheckFor = Type;
401 /* Examine the pathname */
405 /* Null NamePath -- is allowed */
409 ThisNode = AcpiGbl_RootNode;
411 ACPI_DEBUG_PRINT ((ACPI_DB_NAMES,
412 "Null Pathname (Zero segments), Flags=%x\n", Flags));
418 * Valid name pointer (Internal name format)
420 * Check for prefixes. As represented in the AML stream, a
421 * Pathname consists of an optional scope prefix followed by
424 * If present, the scope prefix is either a RootPrefix (in
425 * which case the name is fully qualified), or zero or more
426 * ParentPrefixes (in which case the name's scope is relative
427 * to the current scope).
429 * The segment part consists of either:
430 * - A single 4-byte name segment, or
431 * - A DualNamePrefix followed by two 4-byte name segments, or
432 * - A MultiNamePrefixOp, followed by a byte indicating the
433 * number of segments and the segments themselves.
435 if (*Pathname == AML_ROOT_PREFIX)
437 /* Pathname is fully qualified, start from the root */
439 CurrentNode = AcpiGbl_RootNode;
441 /* Point to segment part */
445 ACPI_DEBUG_PRINT ((ACPI_DB_NAMES, "Searching from root [%p]\n",
450 /* Direct reference to root, "\" */
452 ThisNode = AcpiGbl_RootNode;
453 goto CheckForNewScopeAndExit;
458 /* Pathname is relative to current scope, start there */
460 CurrentNode = PrefixNode;
462 ACPI_DEBUG_PRINT ((ACPI_DB_NAMES,
463 "Searching relative to pfx scope [%p]\n",
467 * Handle up-prefix (carat). More than one prefix is supported
469 while (*Pathname == AML_PARENT_PREFIX)
471 /* Point to segment part or next ParentPrefix */
475 /* Backup to the parent's scope */
477 ThisNode = AcpiNsGetParentObject (CurrentNode);
480 /* Current scope has no parent scope */
483 ("Too many parent prefixes (^) - reached root\n"));
484 return_ACPI_STATUS (AE_NOT_FOUND);
487 CurrentNode = ThisNode;
492 * Examine the name prefix opcode, if any, to determine the number of
495 if (*Pathname == AML_DUAL_NAME_PREFIX)
497 /* Two segments, point to first segment */
502 ACPI_DEBUG_PRINT ((ACPI_DB_NAMES,
503 "Dual Pathname (2 segments, Flags=%X)\n", Flags));
505 else if (*Pathname == AML_MULTI_NAME_PREFIX_OP)
507 /* Extract segment count, point to first segment */
509 NumSegments = (UINT32)* (UINT8 *) ++Pathname;
512 ACPI_DEBUG_PRINT ((ACPI_DB_NAMES,
513 "Multi Pathname (%d Segments, Flags=%X) \n",
514 NumSegments, Flags));
519 * No Dual or Multi prefix, hence there is only one segment and
520 * Pathname is already pointing to it.
524 ACPI_DEBUG_PRINT ((ACPI_DB_NAMES,
525 "Simple Pathname (1 segment, Flags=%X)\n", Flags));
528 DEBUG_EXEC (AcpiNsPrintPathname (NumSegments, Pathname));
532 * Search namespace for each segment of the name. Loop through and
533 * verify/add each name segment.
535 while (NumSegments-- && CurrentNode)
538 * Search for the current name segment under the current
539 * named object. The Type is significant only at the last (topmost)
540 * level. (We don't care about the types along the path, only
541 * the type of the final target object.)
543 ThisSearchType = ACPI_TYPE_ANY;
546 ThisSearchType = Type;
550 /* Pluck one ACPI name from the front of the pathname */
552 MOVE_UNALIGNED32_TO_32 (&SimpleName, Pathname);
554 /* Try to find the ACPI name */
556 Status = AcpiNsSearchAndEnter (SimpleName, WalkState,
557 CurrentNode, InterpreterMode,
558 ThisSearchType, LocalFlags,
560 if (ACPI_FAILURE (Status))
562 if (Status == AE_NOT_FOUND)
564 /* Name not found in ACPI namespace */
566 ACPI_DEBUG_PRINT ((ACPI_DB_NAMES,
567 "Name [%4.4s] not found in scope %p\n",
568 (char*)&SimpleName, CurrentNode));
571 return_ACPI_STATUS (Status);
575 * If 1) This is the last segment (NumSegments == 0)
576 * 2) and looking for a specific type
577 * (Not checking for TYPE_ANY)
578 * 3) Which is not an alias
579 * 4) which is not a local type (TYPE_DEF_ANY)
580 * 5) which is not a local type (TYPE_SCOPE)
581 * 6) which is not a local type (TYPE_INDEX_FIELD_DEFN)
582 * 7) and type of object is known (not TYPE_ANY)
583 * 8) and object does not match request
585 * Then we have a type mismatch. Just warn and ignore it.
587 if ((NumSegments == 0) &&
588 (TypeToCheckFor != ACPI_TYPE_ANY) &&
589 (TypeToCheckFor != INTERNAL_TYPE_ALIAS) &&
590 (TypeToCheckFor != INTERNAL_TYPE_DEF_ANY) &&
591 (TypeToCheckFor != INTERNAL_TYPE_SCOPE) &&
592 (TypeToCheckFor != INTERNAL_TYPE_INDEX_FIELD_DEFN) &&
593 (ThisNode->Type != ACPI_TYPE_ANY) &&
594 (ThisNode->Type != TypeToCheckFor))
596 /* Complain about a type mismatch */
599 ("NsLookup: %4.4s, type %X, checking for type %X\n",
600 (char *) &SimpleName, ThisNode->Type, TypeToCheckFor));
604 * If this is the last name segment and we are not looking for a
605 * specific type, but the type of found object is known, use that type
606 * to see if it opens a scope.
608 if ((0 == NumSegments) && (ACPI_TYPE_ANY == Type))
610 Type = ThisNode->Type;
613 if ((NumSegments || AcpiNsOpensScope (Type)) &&
614 (ThisNode->Child == NULL))
617 * More segments or the type implies enclosed scope,
618 * and the next scope has not been allocated.
620 ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Load mode=%X ThisNode=%p\n",
621 InterpreterMode, ThisNode));
624 CurrentNode = ThisNode;
626 /* point to next name segment */
628 Pathname += ACPI_NAME_SIZE;
633 * Always check if we need to open a new scope
635 CheckForNewScopeAndExit:
637 if (!(Flags & NS_DONT_OPEN_SCOPE) && (WalkState))
640 * If entry is a type which opens a scope, push the new scope on the
643 if (AcpiNsOpensScope (TypeToCheckFor))
645 Status = AcpiDsScopeStackPush (ThisNode, Type, WalkState);
646 if (ACPI_FAILURE (Status))
648 return_ACPI_STATUS (Status);
651 ACPI_DEBUG_PRINT ((ACPI_DB_INFO,
652 "Set global scope to %p\n", ThisNode));
656 *ReturnNode = ThisNode;
657 return_ACPI_STATUS (AE_OK);