sys/contrib/dev/acpica/exresolv.c

   1
   2 /******************************************************************************
   3  *
   4  * Module Name: exresolv - AML Interpreter object resolution
   5  *              $Revision: 109 $
   6  *
   7  *****************************************************************************/
   8
   9 /******************************************************************************
  10  *
  11  * 1. Copyright Notice
  12  *
  13  * Some or all of this work - Copyright (c) 1999 - 2002, Intel Corp.
  14  * All rights reserved.
  15  *
  16  * 2. License
  17  *
  18  * 2.1. This is your license from Intel Corp. under its intellectual property
  19  * rights.  You may have additional license terms from the party that provided
  20  * you this software, covering your right to use that party's intellectual
  21  * property rights.
  22  *
  23  * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
  24  * copy of the source code appearing in this file ("Covered Code") an
  25  * irrevocable, perpetual, worldwide license under Intel's copyrights in the
  26  * base code distributed originally by Intel ("Original Intel Code") to copy,
  27  * make derivatives, distribute, use and display any portion of the Covered
  28  * Code in any form, with the right to sublicense such rights; and
  29  *
  30  * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
  31  * license (with the right to sublicense), under only those claims of Intel
  32  * patents that are infringed by the Original Intel Code, to make, use, sell,
  33  * offer to sell, and import the Covered Code and derivative works thereof
  34  * solely to the minimum extent necessary to exercise the above copyright
  35  * license, and in no event shall the patent license extend to any additions
  36  * to or modifications of the Original Intel Code.  No other license or right
  37  * is granted directly or by implication, estoppel or otherwise;
  38  *
  39  * The above copyright and patent license is granted only if the following
  40  * conditions are met:
  41  *
  42  * 3. Conditions
  43  *
  44  * 3.1. Redistribution of Source with Rights to Further Distribute Source.
  45  * Redistribution of source code of any substantial portion of the Covered
  46  * Code or modification with rights to further distribute source must include
  47  * the above Copyright Notice, the above License, this list of Conditions,
  48  * and the following Disclaimer and Export Compliance provision.  In addition,
  49  * Licensee must cause all Covered Code to which Licensee contributes to
  50  * contain a file documenting the changes Licensee made to create that Covered
  51  * Code and the date of any change.  Licensee must include in that file the
  52  * documentation of any changes made by any predecessor Licensee.  Licensee
  53  * must include a prominent statement that the modification is derived,
  54  * directly or indirectly, from Original Intel Code.
  55  *
  56  * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
  57  * Redistribution of source code of any substantial portion of the Covered
  58  * Code or modification without rights to further distribute source must
  59  * include the following Disclaimer and Export Compliance provision in the
  60  * documentation and/or other materials provided with distribution.  In
  61  * addition, Licensee may not authorize further sublicense of source of any
  62  * portion of the Covered Code, and must include terms to the effect that the
  63  * license from Licensee to its licensee is limited to the intellectual
  64  * property embodied in the software Licensee provides to its licensee, and
  65  * not to intellectual property embodied in modifications its licensee may
  66  * make.
  67  *
  68  * 3.3. Redistribution of Executable. Redistribution in executable form of any
  69  * substantial portion of the Covered Code or modification must reproduce the
  70  * above Copyright Notice, and the following Disclaimer and Export Compliance
  71  * provision in the documentation and/or other materials provided with the
  72  * distribution.
  73  *
  74  * 3.4. Intel retains all right, title, and interest in and to the Original
  75  * Intel Code.
  76  *
  77  * 3.5. Neither the name Intel nor any other trademark owned or controlled by
  78  * Intel shall be used in advertising or otherwise to promote the sale, use or
  79  * other dealings in products derived from or relating to the Covered Code
  80  * without prior written authorization from Intel.
  81  *
  82  * 4. Disclaimer and Export Compliance
  83  *
  84  * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
  85  * HERE.  ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
  86  * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT,  ASSISTANCE,
  87  * INSTALLATION, TRAINING OR OTHER SERVICES.  INTEL WILL NOT PROVIDE ANY
  88  * UPDATES, ENHANCEMENTS OR EXTENSIONS.  INTEL SPECIFICALLY DISCLAIMS ANY
  89  * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
  90  * PARTICULAR PURPOSE.
  91  *
  92  * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
  93  * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
  94  * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
  95  * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
  96  * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
  97  * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES.  THESE LIMITATIONS
  98  * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
  99  * LIMITED REMEDY.
 100  *
 101  * 4.3. Licensee shall not export, either directly or indirectly, any of this
 102  * software or system incorporating such software without first obtaining any
 103  * required license or other approval from the U. S. Department of Commerce or
 104  * any other agency or department of the United States Government.  In the
 105  * event Licensee exports any such software from the United States or
 106  * re-exports any such software from a foreign destination, Licensee shall
 107  * ensure that the distribution and export/re-export of the software is in
 108  * compliance with all laws, regulations, orders, or other restrictions of the
 109  * U.S. Export Administration Regulations. Licensee agrees that neither it nor
 110  * any of its subsidiaries will export/re-export any technical data, process,
 111  * software, or service, directly or indirectly, to any country for which the
 112  * United States government or any agency thereof requires an export license,
 113  * other governmental approval, or letter of assurance, without first obtaining
 114  * such license, approval or letter.
 115  *
 116  *****************************************************************************/
 117
 118 #define __EXRESOLV_C__
 119
 120 #include "acpi.h"
 121 #include "amlcode.h"
 122 #include "acparser.h"
 123 #include "acdispat.h"
 124 #include "acinterp.h"
 125 #include "acnamesp.h"
 126 #include "actables.h"
 127 #include "acevents.h"
 128
 129
 130 #define _COMPONENT          ACPI_EXECUTER
 131         ACPI_MODULE_NAME    ("exresolv")
 132
 133
 134 /*******************************************************************************
 135  *
 136  * FUNCTION:    AcpiExResolveToValue
 137  *
 138  * PARAMETERS:  **StackPtr          - Points to entry on ObjStack, which can
 139  *                                    be either an (ACPI_OPERAND_OBJECT *)
 140  *                                    or an ACPI_HANDLE.
 141  *              WalkState           - Current method state
 142  *
 143  * RETURN:      Status
 144  *
 145  * DESCRIPTION: Convert Reference objects to values
 146  *
 147  ******************************************************************************/
 148
 149 ACPI_STATUS
 150 AcpiExResolveToValue (
 151     ACPI_OPERAND_OBJECT     **StackPtr,
 152     ACPI_WALK_STATE         *WalkState)
 153 {
 154     ACPI_STATUS             Status;
 155
 156
 157     ACPI_FUNCTION_TRACE_PTR ("ExResolveToValue", StackPtr);
 158
 159
 160     if (!StackPtr || !*StackPtr)
 161     {
 162         ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Internal - null pointer\n"));
 163         return_ACPI_STATUS (AE_AML_NO_OPERAND);
 164     }
 165
 166     /*
 167      * The entity pointed to by the StackPtr can be either
 168      * 1) A valid ACPI_OPERAND_OBJECT, or
 169      * 2) A ACPI_NAMESPACE_NODE (NamedObj)
 170      */
 171     if (ACPI_GET_DESCRIPTOR_TYPE (*StackPtr) == ACPI_DESC_TYPE_INTERNAL)
 172     {
 173         Status = AcpiExResolveObjectToValue (StackPtr, WalkState);
 174         if (ACPI_FAILURE (Status))
 175         {
 176             return_ACPI_STATUS (Status);
 177         }
 178     }
 179
 180     /*
 181      * Object on the stack may have changed if AcpiExResolveObjectToValue()
 182      * was called (i.e., we can't use an _else_ here.)
 183      */
 184     if (ACPI_GET_DESCRIPTOR_TYPE (*StackPtr) == ACPI_DESC_TYPE_NAMED)
 185     {
 186         Status = AcpiExResolveNodeToValue ((ACPI_NAMESPACE_NODE **) StackPtr,
 187                         WalkState);
 188         if (ACPI_FAILURE (Status))
 189         {
 190             return_ACPI_STATUS (Status);
 191         }
 192     }
 193
 194     ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Resolved object %p\n", *StackPtr));
 195     return_ACPI_STATUS (AE_OK);
 196 }
 197
 198
 199 /*******************************************************************************
 200  *
 201  * FUNCTION:    AcpiExResolveObjectToValue
 202  *
 203  * PARAMETERS:  StackPtr        - Pointer to a stack location that contains a
 204  *                                ptr to an internal object.
 205  *              WalkState       - Current method state
 206  *
 207  * RETURN:      Status
 208  *
 209  * DESCRIPTION: Retrieve the value from an internal object.  The Reference type
 210  *              uses the associated AML opcode to determine the value.
 211  *
 212  ******************************************************************************/
 213
 214 ACPI_STATUS
 215 AcpiExResolveObjectToValue (
 216     ACPI_OPERAND_OBJECT     **StackPtr,
 217     ACPI_WALK_STATE         *WalkState)
 218 {
 219     ACPI_STATUS             Status = AE_OK;
 220     ACPI_OPERAND_OBJECT     *StackDesc;
 221     void                    *TempNode;
 222     ACPI_OPERAND_OBJECT     *ObjDesc;
 223     UINT16                  Opcode;
 224
 225
 226     ACPI_FUNCTION_TRACE ("ExResolveObjectToValue");
 227
 228
 229     StackDesc = *StackPtr;
 230
 231     /* This is an ACPI_OPERAND_OBJECT  */
 232
 233     switch (StackDesc->Common.Type)
 234     {
 235     case INTERNAL_TYPE_REFERENCE:
 236
 237         Opcode = StackDesc->Reference.Opcode;
 238
 239         switch (Opcode)
 240         {
 241         case AML_NAME_OP:
 242
 243             /*
 244              * Convert indirect name ptr to a direct name ptr.
 245              * Then, AcpiExResolveNodeToValue can be used to get the value
 246              */
 247             TempNode = StackDesc->Reference.Object;
 248
 249             /* Delete the Reference Object */
 250
 251             AcpiUtRemoveReference (StackDesc);
 252
 253             /* Put direct name pointer onto stack and exit */
 254
 255             (*StackPtr) = TempNode;
 256             break;
 257
 258
 259         case AML_LOCAL_OP:
 260         case AML_ARG_OP:
 261
 262             /*
 263              * Get the local from the method's state info
 264              * Note: this increments the local's object reference count
 265              */
 266             Status = AcpiDsMethodDataGetValue (Opcode,
 267                             StackDesc->Reference.Offset, WalkState, &ObjDesc);
 268             if (ACPI_FAILURE (Status))
 269             {
 270                 return_ACPI_STATUS (Status);
 271             }
 272
 273             /*
 274              * Now we can delete the original Reference Object and
 275              * replace it with the resolve value
 276              */
 277             AcpiUtRemoveReference (StackDesc);
 278             *StackPtr = ObjDesc;
 279
 280             ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "[Arg/Local %d] ValueObj is %p\n",
 281                 StackDesc->Reference.Offset, ObjDesc));
 282             break;
 283
 284         /*
 285          * For constants, we must change the reference/constant object
 286          * to a real integer object
 287          */
 288         case AML_ZERO_OP:
 289         case AML_ONE_OP:
 290         case AML_ONES_OP:
 291         case AML_REVISION_OP:
 292
 293             /* Create a new integer object */
 294
 295             ObjDesc = AcpiUtCreateInternalObject (ACPI_TYPE_INTEGER);
 296             if (!ObjDesc)
 297             {
 298                 return_ACPI_STATUS (AE_NO_MEMORY);
 299             }
 300
 301             switch (Opcode)
 302             {
 303             case AML_ZERO_OP:
 304                 ObjDesc->Integer.Value = 0;
 305                 break;
 306
 307             case AML_ONE_OP:
 308                 ObjDesc->Integer.Value = 1;
 309                 break;
 310
 311             case AML_ONES_OP:
 312                 ObjDesc->Integer.Value = ACPI_INTEGER_MAX;
 313
 314                 /* Truncate value if we are executing from a 32-bit ACPI table */
 315
 316                 AcpiExTruncateFor32bitTable (ObjDesc, WalkState);
 317                 break;
 318
 319             case AML_REVISION_OP:
 320                 ObjDesc->Integer.Value = ACPI_CA_SUPPORT_LEVEL;
 321                 break;
 322             }
 323
 324             /*
 325              * Remove a reference from the original reference object
 326              * and put the new object in its place
 327              */
 328             AcpiUtRemoveReference (StackDesc);
 329             *StackPtr = ObjDesc;
 330             break;
 331
 332
 333         case AML_INDEX_OP:
 334
 335             switch (StackDesc->Reference.TargetType)
 336             {
 337             case ACPI_TYPE_BUFFER_FIELD:
 338
 339                 /* Just return - leave the Reference on the stack */
 340                 break;
 341
 342
 343             case ACPI_TYPE_PACKAGE:
 344                 ObjDesc = *StackDesc->Reference.Where;
 345                 if (ObjDesc)
 346                 {
 347                     /*
 348                      * Valid obj descriptor, copy pointer to return value
 349                      * (i.e., dereference the package index)
 350                      * Delete the ref object, increment the returned object
 351                      */
 352                     AcpiUtRemoveReference (StackDesc);
 353                     AcpiUtAddReference (ObjDesc);
 354                     *StackPtr = ObjDesc;
 355                 }
 356                 else
 357                 {
 358                     /*
 359                      * A NULL object descriptor means an unitialized element of
 360                      * the package, can't dereference it
 361                      */
 362                     ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
 363                         "Attempt to deref an Index to NULL pkg element Idx=%p\n",
 364                         StackDesc));
 365                     Status = AE_AML_UNINITIALIZED_ELEMENT;
 366                 }
 367                 break;
 368
 369             default:
 370                 /* Invalid reference object */
 371
 372                 ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
 373                     "Unknown TargetType %X in Index/Reference obj %p\n",
 374                     StackDesc->Reference.TargetType, StackDesc));
 375                 Status = AE_AML_INTERNAL;
 376                 break;
 377             }
 378             break;
 379
 380
 381         case AML_DEBUG_OP:
 382
 383             /* Just leave the object as-is */
 384             break;
 385
 386
 387         default:
 388
 389             ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Unknown Reference object subtype %02X in %p\n",
 390                 Opcode, StackDesc));
 391             Status = AE_AML_INTERNAL;
 392             break;
 393
 394         }   /* switch (Opcode) */
 395
 396         break; /* case INTERNAL_TYPE_REFERENCE */
 397
 398
 399     case ACPI_TYPE_BUFFER:
 400
 401         Status = AcpiDsGetBufferArguments (StackDesc);
 402         break;
 403
 404
 405     case ACPI_TYPE_PACKAGE:
 406
 407         Status = AcpiDsGetPackageArguments (StackDesc);
 408         break;
 409
 410
 411     /*
 412      * These cases may never happen here, but just in case..
 413      */
 414     case ACPI_TYPE_BUFFER_FIELD:
 415     case INTERNAL_TYPE_REGION_FIELD:
 416     case INTERNAL_TYPE_BANK_FIELD:
 417     case INTERNAL_TYPE_INDEX_FIELD:
 418
 419         ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "FieldRead SourceDesc=%p Type=%X\n",
 420             StackDesc, StackDesc->Common.Type));
 421
 422         Status = AcpiExReadDataFromField (WalkState, StackDesc, &ObjDesc);
 423         *StackPtr = (void *) ObjDesc;
 424         break;
 425
 426     default:
 427         break;
 428     }
 429
 430     return_ACPI_STATUS (Status);
 431 }
 432
 433