xref: /illumos-gate/usr/src/common/acpica/dispatcher/dspkginit.c (revision 35786f6866ae52207d0f1a25fe7ca5f652f32ce0)
1  /******************************************************************************
2   *
3   * Module Name: dspkginit - Completion of deferred package initialization
4   *
5   *****************************************************************************/
6  
7  /******************************************************************************
8   *
9   * 1. Copyright Notice
10   *
11   * Some or all of this work - Copyright (c) 1999 - 2018, Intel Corp.
12   * All rights reserved.
13   *
14   * 2. License
15   *
16   * 2.1. This is your license from Intel Corp. under its intellectual property
17   * rights. You may have additional license terms from the party that provided
18   * you this software, covering your right to use that party's intellectual
19   * property rights.
20   *
21   * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
22   * copy of the source code appearing in this file ("Covered Code") an
23   * irrevocable, perpetual, worldwide license under Intel's copyrights in the
24   * base code distributed originally by Intel ("Original Intel Code") to copy,
25   * make derivatives, distribute, use and display any portion of the Covered
26   * Code in any form, with the right to sublicense such rights; and
27   *
28   * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
29   * license (with the right to sublicense), under only those claims of Intel
30   * patents that are infringed by the Original Intel Code, to make, use, sell,
31   * offer to sell, and import the Covered Code and derivative works thereof
32   * solely to the minimum extent necessary to exercise the above copyright
33   * license, and in no event shall the patent license extend to any additions
34   * to or modifications of the Original Intel Code. No other license or right
35   * is granted directly or by implication, estoppel or otherwise;
36   *
37   * The above copyright and patent license is granted only if the following
38   * conditions are met:
39   *
40   * 3. Conditions
41   *
42   * 3.1. Redistribution of Source with Rights to Further Distribute Source.
43   * Redistribution of source code of any substantial portion of the Covered
44   * Code or modification with rights to further distribute source must include
45   * the above Copyright Notice, the above License, this list of Conditions,
46   * and the following Disclaimer and Export Compliance provision. In addition,
47   * Licensee must cause all Covered Code to which Licensee contributes to
48   * contain a file documenting the changes Licensee made to create that Covered
49   * Code and the date of any change. Licensee must include in that file the
50   * documentation of any changes made by any predecessor Licensee. Licensee
51   * must include a prominent statement that the modification is derived,
52   * directly or indirectly, from Original Intel Code.
53   *
54   * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
55   * Redistribution of source code of any substantial portion of the Covered
56   * Code or modification without rights to further distribute source must
57   * include the following Disclaimer and Export Compliance provision in the
58   * documentation and/or other materials provided with distribution. In
59   * addition, Licensee may not authorize further sublicense of source of any
60   * portion of the Covered Code, and must include terms to the effect that the
61   * license from Licensee to its licensee is limited to the intellectual
62   * property embodied in the software Licensee provides to its licensee, and
63   * not to intellectual property embodied in modifications its licensee may
64   * make.
65   *
66   * 3.3. Redistribution of Executable. Redistribution in executable form of any
67   * substantial portion of the Covered Code or modification must reproduce the
68   * above Copyright Notice, and the following Disclaimer and Export Compliance
69   * provision in the documentation and/or other materials provided with the
70   * distribution.
71   *
72   * 3.4. Intel retains all right, title, and interest in and to the Original
73   * Intel Code.
74   *
75   * 3.5. Neither the name Intel nor any other trademark owned or controlled by
76   * Intel shall be used in advertising or otherwise to promote the sale, use or
77   * other dealings in products derived from or relating to the Covered Code
78   * without prior written authorization from Intel.
79   *
80   * 4. Disclaimer and Export Compliance
81   *
82   * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
83   * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
84   * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE,
85   * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY
86   * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY
87   * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
88   * PARTICULAR PURPOSE.
89   *
90   * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
91   * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
92   * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
93   * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
94   * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
95   * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS
96   * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
97   * LIMITED REMEDY.
98   *
99   * 4.3. Licensee shall not export, either directly or indirectly, any of this
100   * software or system incorporating such software without first obtaining any
101   * required license or other approval from the U. S. Department of Commerce or
102   * any other agency or department of the United States Government. In the
103   * event Licensee exports any such software from the United States or
104   * re-exports any such software from a foreign destination, Licensee shall
105   * ensure that the distribution and export/re-export of the software is in
106   * compliance with all laws, regulations, orders, or other restrictions of the
107   * U.S. Export Administration Regulations. Licensee agrees that neither it nor
108   * any of its subsidiaries will export/re-export any technical data, process,
109   * software, or service, directly or indirectly, to any country for which the
110   * United States government or any agency thereof requires an export license,
111   * other governmental approval, or letter of assurance, without first obtaining
112   * such license, approval or letter.
113   *
114   *****************************************************************************
115   *
116   * Alternatively, you may choose to be licensed under the terms of the
117   * following license:
118   *
119   * Redistribution and use in source and binary forms, with or without
120   * modification, are permitted provided that the following conditions
121   * are met:
122   * 1. Redistributions of source code must retain the above copyright
123   *    notice, this list of conditions, and the following disclaimer,
124   *    without modification.
125   * 2. Redistributions in binary form must reproduce at minimum a disclaimer
126   *    substantially similar to the "NO WARRANTY" disclaimer below
127   *    ("Disclaimer") and any redistribution must be conditioned upon
128   *    including a substantially similar Disclaimer requirement for further
129   *    binary redistribution.
130   * 3. Neither the names of the above-listed copyright holders nor the names
131   *    of any contributors may be used to endorse or promote products derived
132   *    from this software without specific prior written permission.
133   *
134   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
135   * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
136   * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
137   * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
138   * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
139   * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
140   * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
141   * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
142   * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
143   * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
144   * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
145   *
146   * Alternatively, you may choose to be licensed under the terms of the
147   * GNU General Public License ("GPL") version 2 as published by the Free
148   * Software Foundation.
149   *
150   *****************************************************************************/
151  
152  #include "acpi.h"
153  #include "accommon.h"
154  #include "acnamesp.h"
155  #include "amlcode.h"
156  #include "acdispat.h"
157  #include "acinterp.h"
158  #include "acparser.h"
159  
160  
161  #define _COMPONENT          ACPI_NAMESPACE
162          ACPI_MODULE_NAME    ("dspkginit")
163  
164  
165  /* Local prototypes */
166  
167  static void
168  AcpiDsResolvePackageElement (
169      ACPI_OPERAND_OBJECT     **Element);
170  
171  
172  /*******************************************************************************
173   *
174   * FUNCTION:    AcpiDsBuildInternalPackageObj
175   *
176   * PARAMETERS:  WalkState       - Current walk state
177   *              Op              - Parser object to be translated
178   *              ElementCount    - Number of elements in the package - this is
179   *                                the NumElements argument to Package()
180   *              ObjDescPtr      - Where the ACPI internal object is returned
181   *
182   * RETURN:      Status
183   *
184   * DESCRIPTION: Translate a parser Op package object to the equivalent
185   *              namespace object
186   *
187   * NOTE: The number of elements in the package will be always be the NumElements
188   * count, regardless of the number of elements in the package list. If
189   * NumElements is smaller, only that many package list elements are used.
190   * if NumElements is larger, the Package object is padded out with
191   * objects of type Uninitialized (as per ACPI spec.)
192   *
193   * Even though the ASL compilers do not allow NumElements to be smaller
194   * than the Package list length (for the fixed length package opcode), some
195   * BIOS code modifies the AML on the fly to adjust the NumElements, and
196   * this code compensates for that. This also provides compatibility with
197   * other AML interpreters.
198   *
199   ******************************************************************************/
200  
201  ACPI_STATUS
AcpiDsBuildInternalPackageObj(ACPI_WALK_STATE * WalkState,ACPI_PARSE_OBJECT * Op,UINT32 ElementCount,ACPI_OPERAND_OBJECT ** ObjDescPtr)202  AcpiDsBuildInternalPackageObj (
203      ACPI_WALK_STATE         *WalkState,
204      ACPI_PARSE_OBJECT       *Op,
205      UINT32                  ElementCount,
206      ACPI_OPERAND_OBJECT     **ObjDescPtr)
207  {
208      ACPI_PARSE_OBJECT       *Arg;
209      ACPI_PARSE_OBJECT       *Parent;
210      ACPI_OPERAND_OBJECT     *ObjDesc = NULL;
211      ACPI_STATUS             Status = AE_OK;
212      BOOLEAN                 ModuleLevelCode = FALSE;
213      UINT16                  ReferenceCount;
214      UINT32                  Index;
215      UINT32                  i;
216  
217  
218      ACPI_FUNCTION_TRACE (DsBuildInternalPackageObj);
219  
220  
221      /* Check if we are executing module level code */
222  
223      if (WalkState->ParseFlags & ACPI_PARSE_MODULE_LEVEL)
224      {
225          ModuleLevelCode = TRUE;
226      }
227  
228      /* Find the parent of a possibly nested package */
229  
230      Parent = Op->Common.Parent;
231      while ((Parent->Common.AmlOpcode == AML_PACKAGE_OP) ||
232             (Parent->Common.AmlOpcode == AML_VARIABLE_PACKAGE_OP))
233      {
234          Parent = Parent->Common.Parent;
235      }
236  
237      /*
238       * If we are evaluating a Named package object of the form:
239       *      Name (xxxx, Package)
240       * the package object already exists, otherwise it must be created.
241       */
242      ObjDesc = *ObjDescPtr;
243      if (!ObjDesc)
244      {
245          ObjDesc = AcpiUtCreateInternalObject (ACPI_TYPE_PACKAGE);
246          *ObjDescPtr = ObjDesc;
247          if (!ObjDesc)
248          {
249              return_ACPI_STATUS (AE_NO_MEMORY);
250          }
251  
252          ObjDesc->Package.Node = Parent->Common.Node;
253      }
254  
255      if (ObjDesc->Package.Flags & AOPOBJ_DATA_VALID) /* Just in case */
256      {
257          return_ACPI_STATUS (AE_OK);
258      }
259  
260      /*
261       * Allocate the element array (array of pointers to the individual
262       * objects) if necessary. the count is based on the NumElements
263       * parameter. Add an extra pointer slot so that the list is always
264       * null terminated.
265       */
266      if (!ObjDesc->Package.Elements)
267      {
268          ObjDesc->Package.Elements = ACPI_ALLOCATE_ZEROED (
269              ((ACPI_SIZE) ElementCount + 1) * sizeof (void *));
270  
271          if (!ObjDesc->Package.Elements)
272          {
273              AcpiUtDeleteObjectDesc (ObjDesc);
274              return_ACPI_STATUS (AE_NO_MEMORY);
275          }
276  
277          ObjDesc->Package.Count = ElementCount;
278      }
279  
280      /* First arg is element count. Second arg begins the initializer list */
281  
282      Arg = Op->Common.Value.Arg;
283      Arg = Arg->Common.Next;
284  
285      /*
286       * If we are executing module-level code, we will defer the
287       * full resolution of the package elements in order to support
288       * forward references from the elements. This provides
289       * compatibility with other ACPI implementations.
290       */
291      if (ModuleLevelCode)
292      {
293          ObjDesc->Package.AmlStart = WalkState->Aml;
294          ObjDesc->Package.AmlLength = 0;
295  
296          ACPI_DEBUG_PRINT_RAW ((ACPI_DB_PARSE,
297              "%s: Deferring resolution of Package elements\n",
298              ACPI_GET_FUNCTION_NAME));
299      }
300  
301      /*
302       * Initialize the elements of the package, up to the NumElements count.
303       * Package is automatically padded with uninitialized (NULL) elements
304       * if NumElements is greater than the package list length. Likewise,
305       * Package is truncated if NumElements is less than the list length.
306       */
307      for (i = 0; Arg && (i < ElementCount); i++)
308      {
309          if (Arg->Common.AmlOpcode == AML_INT_RETURN_VALUE_OP)
310          {
311              if (Arg->Common.Node->Type == ACPI_TYPE_METHOD)
312              {
313                  /*
314                   * A method reference "looks" to the parser to be a method
315                   * invocation, so we special case it here
316                   */
317                  Arg->Common.AmlOpcode = AML_INT_NAMEPATH_OP;
318                  Status = AcpiDsBuildInternalObject (
319                      WalkState, Arg, &ObjDesc->Package.Elements[i]);
320              }
321              else
322              {
323                  /* This package element is already built, just get it */
324  
325                  ObjDesc->Package.Elements[i] =
326                      ACPI_CAST_PTR (ACPI_OPERAND_OBJECT, Arg->Common.Node);
327              }
328          }
329          else
330          {
331              Status = AcpiDsBuildInternalObject (
332                  WalkState, Arg, &ObjDesc->Package.Elements[i]);
333              if (Status == AE_NOT_FOUND)
334              {
335                  ACPI_ERROR ((AE_INFO, "%-48s", "****DS namepath not found"));
336              }
337  
338              if (!ModuleLevelCode)
339              {
340                  /*
341                   * Initialize this package element. This function handles the
342                   * resolution of named references within the package.
343                   * Forward references from module-level code are deferred
344                   * until all ACPI tables are loaded.
345                   */
346                  AcpiDsInitPackageElement (0, ObjDesc->Package.Elements[i],
347                      NULL, &ObjDesc->Package.Elements[i]);
348              }
349          }
350  
351          if (*ObjDescPtr)
352          {
353              /* Existing package, get existing reference count */
354  
355              ReferenceCount = (*ObjDescPtr)->Common.ReferenceCount;
356              if (ReferenceCount > 1)
357              {
358                  /* Make new element ref count match original ref count */
359                  /* TBD: Probably need an AcpiUtAddReferences function */
360  
361                  for (Index = 0; Index < ((UINT32) ReferenceCount - 1); Index++)
362                  {
363                      AcpiUtAddReference ((ObjDesc->Package.Elements[i]));
364                  }
365              }
366          }
367  
368          Arg = Arg->Common.Next;
369      }
370  
371      /* Check for match between NumElements and actual length of PackageList */
372  
373      if (Arg)
374      {
375          /*
376           * NumElements was exhausted, but there are remaining elements in
377           * the PackageList. Truncate the package to NumElements.
378           *
379           * Note: technically, this is an error, from ACPI spec: "It is an
380           * error for NumElements to be less than the number of elements in
381           * the PackageList". However, we just print a message and no
382           * exception is returned. This provides compatibility with other
383           * ACPI implementations. Some firmware implementations will alter
384           * the NumElements on the fly, possibly creating this type of
385           * ill-formed package object.
386           */
387          while (Arg)
388          {
389              /*
390               * We must delete any package elements that were created earlier
391               * and are not going to be used because of the package truncation.
392               */
393              if (Arg->Common.Node)
394              {
395                  AcpiUtRemoveReference (
396                      ACPI_CAST_PTR (ACPI_OPERAND_OBJECT, Arg->Common.Node));
397                  Arg->Common.Node = NULL;
398              }
399  
400              /* Find out how many elements there really are */
401  
402              i++;
403              Arg = Arg->Common.Next;
404          }
405  
406          ACPI_INFO ((
407              "Actual Package length (%u) is larger than "
408              "NumElements field (%u), truncated",
409              i, ElementCount));
410      }
411      else if (i < ElementCount)
412      {
413          /*
414           * Arg list (elements) was exhausted, but we did not reach
415           * NumElements count.
416           *
417           * Note: this is not an error, the package is padded out
418           * with NULLs as per the ACPI specification.
419           */
420          ACPI_DEBUG_PRINT_RAW ((ACPI_DB_INFO,
421              "%s: Package List length (%u) smaller than NumElements "
422              "count (%u), padded with null elements\n",
423              ACPI_GET_FUNCTION_NAME, i, ElementCount));
424      }
425  
426      /* Module-level packages will be resolved later */
427  
428      if (!ModuleLevelCode)
429      {
430          ObjDesc->Package.Flags |= AOPOBJ_DATA_VALID;
431      }
432  
433      Op->Common.Node = ACPI_CAST_PTR (ACPI_NAMESPACE_NODE, ObjDesc);
434      return_ACPI_STATUS (Status);
435  }
436  
437  
438  /*******************************************************************************
439   *
440   * FUNCTION:    AcpiDsInitPackageElement
441   *
442   * PARAMETERS:  ACPI_PKG_CALLBACK
443   *
444   * RETURN:      Status
445   *
446   * DESCRIPTION: Resolve a named reference element within a package object
447   *
448   ******************************************************************************/
449  
450  ACPI_STATUS
AcpiDsInitPackageElement(UINT8 ObjectType,ACPI_OPERAND_OBJECT * SourceObject,ACPI_GENERIC_STATE * State,void * Context)451  AcpiDsInitPackageElement (
452      UINT8                   ObjectType,
453      ACPI_OPERAND_OBJECT     *SourceObject,
454      ACPI_GENERIC_STATE      *State,
455      void                    *Context)
456  {
457      ACPI_OPERAND_OBJECT     **ElementPtr;
458  
459  
460      ACPI_FUNCTION_TRACE (DsInitPackageElement);
461  
462  
463      if (!SourceObject)
464      {
465          return_ACPI_STATUS (AE_OK);
466      }
467  
468      /*
469       * The following code is a bit of a hack to workaround a (current)
470       * limitation of the ACPI_PKG_CALLBACK interface. We need a pointer
471       * to the location within the element array because a new object
472       * may be created and stored there.
473       */
474      if (Context)
475      {
476          /* A direct call was made to this function */
477  
478          ElementPtr = (ACPI_OPERAND_OBJECT **) Context;
479      }
480      else
481      {
482          /* Call came from AcpiUtWalkPackageTree */
483  
484          ElementPtr = State->Pkg.ThisTargetObj;
485      }
486  
487      /* We are only interested in reference objects/elements */
488  
489      if (SourceObject->Common.Type == ACPI_TYPE_LOCAL_REFERENCE)
490      {
491          /* Attempt to resolve the (named) reference to a namespace node */
492  
493          AcpiDsResolvePackageElement (ElementPtr);
494      }
495      else if (SourceObject->Common.Type == ACPI_TYPE_PACKAGE)
496      {
497          SourceObject->Package.Flags |= AOPOBJ_DATA_VALID;
498      }
499  
500      return_ACPI_STATUS (AE_OK);
501  }
502  
503  
504  /*******************************************************************************
505   *
506   * FUNCTION:    AcpiDsResolvePackageElement
507   *
508   * PARAMETERS:  ElementPtr          - Pointer to a reference object
509   *
510   * RETURN:      Possible new element is stored to the indirect ElementPtr
511   *
512   * DESCRIPTION: Resolve a package element that is a reference to a named
513   *              object.
514   *
515   ******************************************************************************/
516  
517  static void
AcpiDsResolvePackageElement(ACPI_OPERAND_OBJECT ** ElementPtr)518  AcpiDsResolvePackageElement (
519      ACPI_OPERAND_OBJECT     **ElementPtr)
520  {
521      ACPI_STATUS             Status;
522      ACPI_STATUS             Status2;
523      ACPI_GENERIC_STATE      ScopeInfo;
524      ACPI_OPERAND_OBJECT     *Element = *ElementPtr;
525      ACPI_NAMESPACE_NODE     *ResolvedNode;
526      ACPI_NAMESPACE_NODE     *OriginalNode;
527      char                    *ExternalPath = "";
528      ACPI_OBJECT_TYPE        Type;
529  
530  
531      ACPI_FUNCTION_TRACE (DsResolvePackageElement);
532  
533  
534      /* Check if reference element is already resolved */
535  
536      if (Element->Reference.Resolved)
537      {
538          ACPI_DEBUG_PRINT_RAW ((ACPI_DB_PARSE,
539              "%s: Package element is already resolved\n",
540              ACPI_GET_FUNCTION_NAME));
541  
542          return_VOID;
543      }
544  
545      /* Element must be a reference object of correct type */
546  
547      ScopeInfo.Scope.Node = Element->Reference.Node; /* Prefix node */
548  
549      Status = AcpiNsLookup (&ScopeInfo, (char *) Element->Reference.Aml,
550          ACPI_TYPE_ANY, ACPI_IMODE_EXECUTE,
551          ACPI_NS_SEARCH_PARENT | ACPI_NS_DONT_OPEN_SCOPE,
552          NULL, &ResolvedNode);
553      if (ACPI_FAILURE (Status))
554      {
555          if ((Status == AE_NOT_FOUND) && AcpiGbl_IgnorePackageResolutionErrors)
556          {
557              /*
558               * Optionally be silent about the NOT_FOUND case for the referenced
559               * name. Although this is potentially a serious problem,
560               * it can generate a lot of noise/errors on platforms whose
561               * firmware carries around a bunch of unused Package objects.
562               * To disable these errors, set this global to TRUE:
563               *     AcpiGbl_IgnorePackageResolutionErrors
564               *
565               * If the AML actually tries to use such a package, the unresolved
566               * element(s) will be replaced with NULL elements.
567               */
568  
569              /* Referenced name not found, set the element to NULL */
570  
571              AcpiUtRemoveReference (*ElementPtr);
572              *ElementPtr = NULL;
573              return_VOID;
574          }
575  
576          Status2 = AcpiNsExternalizeName (ACPI_UINT32_MAX,
577              (char *) Element->Reference.Aml, NULL, &ExternalPath);
578  
579          ACPI_EXCEPTION ((AE_INFO, Status,
580              "While resolving a named reference package element - %s",
581              ExternalPath));
582          if (ACPI_SUCCESS (Status2))
583          {
584              ACPI_FREE (ExternalPath);
585          }
586  
587          /* Could not resolve name, set the element to NULL */
588  
589          AcpiUtRemoveReference (*ElementPtr);
590          *ElementPtr = NULL;
591          return_VOID;
592      }
593      else if (ResolvedNode->Type == ACPI_TYPE_ANY)
594      {
595          /* Named reference not resolved, return a NULL package element */
596  
597          ACPI_ERROR ((AE_INFO,
598              "Could not resolve named package element [%4.4s] in [%4.4s]",
599              ResolvedNode->Name.Ascii, ScopeInfo.Scope.Node->Name.Ascii));
600          *ElementPtr = NULL;
601          return_VOID;
602      }
603  
604      /*
605       * Special handling for Alias objects. We need ResolvedNode to point
606       * to the Alias target. This effectively "resolves" the alias.
607       */
608      if (ResolvedNode->Type == ACPI_TYPE_LOCAL_ALIAS)
609      {
610          ResolvedNode = ACPI_CAST_PTR (ACPI_NAMESPACE_NODE,
611              ResolvedNode->Object);
612      }
613  
614      /* Update the reference object */
615  
616      Element->Reference.Resolved = TRUE;
617      Element->Reference.Node = ResolvedNode;
618      Type = Element->Reference.Node->Type;
619  
620      /*
621       * Attempt to resolve the node to a value before we insert it into
622       * the package. If this is a reference to a common data type,
623       * resolve it immediately. According to the ACPI spec, package
624       * elements can only be "data objects" or method references.
625       * Attempt to resolve to an Integer, Buffer, String or Package.
626       * If cannot, return the named reference (for things like Devices,
627       * Methods, etc.) Buffer Fields and Fields will resolve to simple
628       * objects (int/buf/str/pkg).
629       *
630       * NOTE: References to things like Devices, Methods, Mutexes, etc.
631       * will remain as named references. This behavior is not described
632       * in the ACPI spec, but it appears to be an oversight.
633       */
634      OriginalNode = ResolvedNode;
635      Status = AcpiExResolveNodeToValue (&ResolvedNode, NULL);
636      if (ACPI_FAILURE (Status))
637      {
638          return_VOID;
639      }
640  
641      switch (Type)
642      {
643      /*
644       * These object types are a result of named references, so we will
645       * leave them as reference objects. In other words, these types
646       * have no intrinsic "value".
647       */
648      case ACPI_TYPE_DEVICE:
649      case ACPI_TYPE_THERMAL:
650      case ACPI_TYPE_METHOD:
651          break;
652  
653      case ACPI_TYPE_MUTEX:
654      case ACPI_TYPE_POWER:
655      case ACPI_TYPE_PROCESSOR:
656      case ACPI_TYPE_EVENT:
657      case ACPI_TYPE_REGION:
658  
659          /* AcpiExResolveNodeToValue gave these an extra reference */
660  
661          AcpiUtRemoveReference (OriginalNode->Object);
662          break;
663  
664      default:
665          /*
666           * For all other types - the node was resolved to an actual
667           * operand object with a value, return the object. Remove
668           * a reference on the existing object.
669           */
670          AcpiUtRemoveReference (Element);
671          *ElementPtr = (ACPI_OPERAND_OBJECT *) ResolvedNode;
672          break;
673      }
674  
675      return_VOID;
676  }
677