sys/contrib/dev/acpica/dswload.c

   1 /******************************************************************************
   2  *
   3  * Module Name: dswload - Dispatcher namespace load callbacks
   4  *              $Revision: 1.117 $
   5  *
   6  *****************************************************************************/
   7
   8 /******************************************************************************
   9  *
  10  * 1. Copyright Notice
  11  *
  12  * Some or all of this work - Copyright (c) 1999 - 2007, Intel Corp.
  13  * All rights reserved.
  14  *
  15  * 2. License
  16  *
  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
  20  * property rights.
  21  *
  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
  28  *
  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;
  37  *
  38  * The above copyright and patent license is granted only if the following
  39  * conditions are met:
  40  *
  41  * 3. Conditions
  42  *
  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.
  54  *
  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
  65  * make.
  66  *
  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
  71  * distribution.
  72  *
  73  * 3.4. Intel retains all right, title, and interest in and to the Original
  74  * Intel Code.
  75  *
  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.
  80  *
  81  * 4. Disclaimer and Export Compliance
  82  *
  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
  89  * PARTICULAR PURPOSE.
  90  *
  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
  98  * LIMITED REMEDY.
  99  *
 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.
 114  *
 115  *****************************************************************************/
 116
 117 #define __DSWLOAD_C__
 118
 119 #include <contrib/dev/acpica/acpi.h>
 120 #include <contrib/dev/acpica/acparser.h>
 121 #include <contrib/dev/acpica/amlcode.h>
 122 #include <contrib/dev/acpica/acdispat.h>
 123 #include <contrib/dev/acpica/acinterp.h>
 124 #include <contrib/dev/acpica/acnamesp.h>
 125 #include <contrib/dev/acpica/acevents.h>
 126
 127 #ifdef ACPI_ASL_COMPILER
 128 #include <contrib/dev/acpica/acdisasm.h>
 129 #endif
 130
 131 #define _COMPONENT          ACPI_DISPATCHER
 132         ACPI_MODULE_NAME    ("dswload")
 133
 134
 135 /*******************************************************************************
 136  *
 137  * FUNCTION:    AcpiDsInitCallbacks
 138  *
 139  * PARAMETERS:  WalkState       - Current state of the parse tree walk
 140  *              PassNumber      - 1, 2, or 3
 141  *
 142  * RETURN:      Status
 143  *
 144  * DESCRIPTION: Init walk state callbacks
 145  *
 146  ******************************************************************************/
 147
 148 ACPI_STATUS
 149 AcpiDsInitCallbacks (
 150     ACPI_WALK_STATE         *WalkState,
 151     UINT32                  PassNumber)
 152 {
 153
 154     switch (PassNumber)
 155     {
 156     case 1:
 157         WalkState->ParseFlags         = ACPI_PARSE_LOAD_PASS1 |
 158                                         ACPI_PARSE_DELETE_TREE;
 159         WalkState->DescendingCallback = AcpiDsLoad1BeginOp;
 160         WalkState->AscendingCallback  = AcpiDsLoad1EndOp;
 161         break;
 162
 163     case 2:
 164         WalkState->ParseFlags         = ACPI_PARSE_LOAD_PASS1 |
 165                                         ACPI_PARSE_DELETE_TREE;
 166         WalkState->DescendingCallback = AcpiDsLoad2BeginOp;
 167         WalkState->AscendingCallback  = AcpiDsLoad2EndOp;
 168         break;
 169
 170     case 3:
 171 #ifndef ACPI_NO_METHOD_EXECUTION
 172         WalkState->ParseFlags        |= ACPI_PARSE_EXECUTE  |
 173                                         ACPI_PARSE_DELETE_TREE;
 174         WalkState->DescendingCallback = AcpiDsExecBeginOp;
 175         WalkState->AscendingCallback  = AcpiDsExecEndOp;
 176 #endif
 177         break;
 178
 179     default:
 180         return (AE_BAD_PARAMETER);
 181     }
 182
 183     return (AE_OK);
 184 }
 185
 186
 187 /*******************************************************************************
 188  *
 189  * FUNCTION:    AcpiDsLoad1BeginOp
 190  *
 191  * PARAMETERS:  WalkState       - Current state of the parse tree walk
 192  *              OutOp           - Where to return op if a new one is created
 193  *
 194  * RETURN:      Status
 195  *
 196  * DESCRIPTION: Descending callback used during the loading of ACPI tables.
 197  *
 198  ******************************************************************************/
 199
 200 ACPI_STATUS
 201 AcpiDsLoad1BeginOp (
 202     ACPI_WALK_STATE         *WalkState,
 203     ACPI_PARSE_OBJECT       **OutOp)
 204 {
 205     ACPI_PARSE_OBJECT       *Op;
 206     ACPI_NAMESPACE_NODE     *Node;
 207     ACPI_STATUS             Status;
 208     ACPI_OBJECT_TYPE        ObjectType;
 209     char                    *Path;
 210     UINT32                  Flags;
 211
 212
 213     ACPI_FUNCTION_TRACE (DsLoad1BeginOp);
 214
 215
 216     Op = WalkState->Op;
 217     ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "Op=%p State=%p\n", Op, WalkState));
 218
 219     /* We are only interested in opcodes that have an associated name */
 220
 221     if (Op)
 222     {
 223         if (!(WalkState->OpInfo->Flags & AML_NAMED))
 224         {
 225             *OutOp = Op;
 226             return_ACPI_STATUS (AE_OK);
 227         }
 228
 229         /* Check if this object has already been installed in the namespace */
 230
 231         if (Op->Common.Node)
 232         {
 233             *OutOp = Op;
 234             return_ACPI_STATUS (AE_OK);
 235         }
 236     }
 237
 238     Path = AcpiPsGetNextNamestring (&WalkState->ParserState);
 239
 240     /* Map the raw opcode into an internal object type */
 241
 242     ObjectType = WalkState->OpInfo->ObjectType;
 243
 244     ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
 245         "State=%p Op=%p [%s]\n", WalkState, Op, AcpiUtGetTypeName (ObjectType)));
 246
 247     switch (WalkState->Opcode)
 248     {
 249     case AML_SCOPE_OP:
 250
 251         /*
 252          * The target name of the Scope() operator must exist at this point so
 253          * that we can actually open the scope to enter new names underneath it.
 254          * Allow search-to-root for single namesegs.
 255          */
 256         Status = AcpiNsLookup (WalkState->ScopeInfo, Path, ObjectType,
 257                         ACPI_IMODE_EXECUTE, ACPI_NS_SEARCH_PARENT, WalkState, &(Node));
 258 #ifdef ACPI_ASL_COMPILER
 259         if (Status == AE_NOT_FOUND)
 260         {
 261             /*
 262              * Table disassembly:
 263              * Target of Scope() not found. Generate an External for it, and
 264              * insert the name into the namespace.
 265              */
 266             AcpiDmAddToExternalList (Path, ACPI_TYPE_DEVICE, 0);
 267             Status = AcpiNsLookup (WalkState->ScopeInfo, Path, ObjectType,
 268                        ACPI_IMODE_LOAD_PASS1, ACPI_NS_SEARCH_PARENT,
 269                        WalkState, &Node);
 270         }
 271 #endif
 272         if (ACPI_FAILURE (Status))
 273         {
 274             ACPI_ERROR_NAMESPACE (Path, Status);
 275             return_ACPI_STATUS (Status);
 276         }
 277
 278         /*
 279          * Check to make sure that the target is
 280          * one of the opcodes that actually opens a scope
 281          */
 282         switch (Node->Type)
 283         {
 284         case ACPI_TYPE_ANY:
 285         case ACPI_TYPE_LOCAL_SCOPE:         /* Scope  */
 286         case ACPI_TYPE_DEVICE:
 287         case ACPI_TYPE_POWER:
 288         case ACPI_TYPE_PROCESSOR:
 289         case ACPI_TYPE_THERMAL:
 290
 291             /* These are acceptable types */
 292             break;
 293
 294         case ACPI_TYPE_INTEGER:
 295         case ACPI_TYPE_STRING:
 296         case ACPI_TYPE_BUFFER:
 297
 298             /*
 299              * These types we will allow, but we will change the type. This
 300              * enables some existing code of the form:
 301              *
 302              *  Name (DEB, 0)
 303              *  Scope (DEB) { ... }
 304              *
 305              * Note: silently change the type here. On the second pass, we will report
 306              * a warning
 307              */
 308             ACPI_DEBUG_PRINT ((ACPI_DB_INFO,
 309                 "Type override - [%4.4s] had invalid type (%s) for Scope operator, changed to (Scope)\n",
 310                 Path, AcpiUtGetTypeName (Node->Type)));
 311
 312             Node->Type = ACPI_TYPE_ANY;
 313             WalkState->ScopeInfo->Common.Value = ACPI_TYPE_ANY;
 314             break;
 315
 316         default:
 317
 318             /* All other types are an error */
 319
 320             ACPI_ERROR ((AE_INFO,
 321                 "Invalid type (%s) for target of Scope operator [%4.4s] (Cannot override)",
 322                 AcpiUtGetTypeName (Node->Type), Path));
 323
 324             return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
 325         }
 326         break;
 327
 328
 329     default:
 330         /*
 331          * For all other named opcodes, we will enter the name into
 332          * the namespace.
 333          *
 334          * Setup the search flags.
 335          * Since we are entering a name into the namespace, we do not want to
 336          * enable the search-to-root upsearch.
 337          *
 338          * There are only two conditions where it is acceptable that the name
 339          * already exists:
 340          *    1) the Scope() operator can reopen a scoping object that was
 341          *       previously defined (Scope, Method, Device, etc.)
 342          *    2) Whenever we are parsing a deferred opcode (OpRegion, Buffer,
 343          *       BufferField, or Package), the name of the object is already
 344          *       in the namespace.
 345          */
 346         if (WalkState->DeferredNode)
 347         {
 348             /* This name is already in the namespace, get the node */
 349
 350             Node = WalkState->DeferredNode;
 351             Status = AE_OK;
 352             break;
 353         }
 354
 355         /*
 356          * If we are executing a method, do not create any namespace objects
 357          * during the load phase, only during execution.
 358          */
 359         if (WalkState->MethodNode)
 360         {
 361             Node = NULL;
 362             Status = AE_OK;
 363             break;
 364         }
 365
 366         Flags = ACPI_NS_NO_UPSEARCH;
 367         if ((WalkState->Opcode != AML_SCOPE_OP) &&
 368             (!(WalkState->ParseFlags & ACPI_PARSE_DEFERRED_OP)))
 369         {
 370             Flags |= ACPI_NS_ERROR_IF_FOUND;
 371             ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "[%s] Cannot already exist\n",
 372                     AcpiUtGetTypeName (ObjectType)));
 373         }
 374         else
 375         {
 376             ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
 377                 "[%s] Both Find or Create allowed\n",
 378                     AcpiUtGetTypeName (ObjectType)));
 379         }
 380
 381         /*
 382          * Enter the named type into the internal namespace. We enter the name
 383          * as we go downward in the parse tree. Any necessary subobjects that
 384          * involve arguments to the opcode must be created as we go back up the
 385          * parse tree later.
 386          */
 387         Status = AcpiNsLookup (WalkState->ScopeInfo, Path, ObjectType,
 388                         ACPI_IMODE_LOAD_PASS1, Flags, WalkState, &Node);
 389         if (ACPI_FAILURE (Status))
 390         {
 391             if (Status == AE_ALREADY_EXISTS)
 392             {
 393                 /* The name already exists in this scope */
 394
 395                 if (Node->Flags & ANOBJ_IS_EXTERNAL)
 396                 {
 397                     /*
 398                      * Allow one create on an object or segment that was
 399                      * previously declared External
 400                      */
 401                     Node->Flags &= ~ANOBJ_IS_EXTERNAL;
 402                     Node->Type = (UINT8) ObjectType;
 403
 404                     /* Just retyped a node, probably will need to open a scope */
 405
 406                     if (AcpiNsOpensScope (ObjectType))
 407                     {
 408                         Status = AcpiDsScopeStackPush (Node, ObjectType, WalkState);
 409                         if (ACPI_FAILURE (Status))
 410                         {
 411                             return_ACPI_STATUS (Status);
 412                         }
 413                     }
 414
 415                     Status = AE_OK;
 416                 }
 417             }
 418
 419             if (ACPI_FAILURE (Status))
 420             {
 421                 ACPI_ERROR_NAMESPACE (Path, Status);
 422                 return_ACPI_STATUS (Status);
 423             }
 424         }
 425         break;
 426     }
 427
 428     /* Common exit */
 429
 430     if (!Op)
 431     {
 432         /* Create a new op */
 433
 434         Op = AcpiPsAllocOp (WalkState->Opcode);
 435         if (!Op)
 436         {
 437             return_ACPI_STATUS (AE_NO_MEMORY);
 438         }
 439     }
 440
 441     /* Initialize the op */
 442
 443 #if (defined (ACPI_NO_METHOD_EXECUTION) || defined (ACPI_CONSTANT_EVAL_ONLY))
 444     Op->Named.Path = ACPI_CAST_PTR (UINT8, Path);
 445 #endif
 446
 447     if (Node)
 448     {
 449         /*
 450          * Put the Node in the "op" object that the parser uses, so we
 451          * can get it again quickly when this scope is closed
 452          */
 453         Op->Common.Node = Node;
 454         Op->Named.Name = Node->Name.Integer;
 455     }
 456
 457     AcpiPsAppendArg (AcpiPsGetParentScope (&WalkState->ParserState), Op);
 458     *OutOp = Op;
 459     return_ACPI_STATUS (Status);
 460 }
 461
 462
 463 /*******************************************************************************
 464  *
 465  * FUNCTION:    AcpiDsLoad1EndOp
 466  *
 467  * PARAMETERS:  WalkState       - Current state of the parse tree walk
 468  *
 469  * RETURN:      Status
 470  *
 471  * DESCRIPTION: Ascending callback used during the loading of the namespace,
 472  *              both control methods and everything else.
 473  *
 474  ******************************************************************************/
 475
 476 ACPI_STATUS
 477 AcpiDsLoad1EndOp (
 478     ACPI_WALK_STATE         *WalkState)
 479 {
 480     ACPI_PARSE_OBJECT       *Op;
 481     ACPI_OBJECT_TYPE        ObjectType;
 482     ACPI_STATUS             Status = AE_OK;
 483
 484
 485     ACPI_FUNCTION_TRACE (DsLoad1EndOp);
 486
 487
 488     Op = WalkState->Op;
 489     ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "Op=%p State=%p\n", Op, WalkState));
 490
 491     /* We are only interested in opcodes that have an associated name */
 492
 493     if (!(WalkState->OpInfo->Flags & (AML_NAMED | AML_FIELD)))
 494     {
 495         return_ACPI_STATUS (AE_OK);
 496     }
 497
 498     /* Get the object type to determine if we should pop the scope */
 499
 500     ObjectType = WalkState->OpInfo->ObjectType;
 501
 502 #ifndef ACPI_NO_METHOD_EXECUTION
 503     if (WalkState->OpInfo->Flags & AML_FIELD)
 504     {
 505         /*
 506          * If we are executing a method, do not create any namespace objects
 507          * during the load phase, only during execution.
 508          */
 509         if (!WalkState->MethodNode)
 510         {
 511             if (WalkState->Opcode == AML_FIELD_OP          ||
 512                 WalkState->Opcode == AML_BANK_FIELD_OP     ||
 513                 WalkState->Opcode == AML_INDEX_FIELD_OP)
 514             {
 515                 Status = AcpiDsInitFieldObjects (Op, WalkState);
 516             }
 517         }
 518         return_ACPI_STATUS (Status);
 519     }
 520
 521     /*
 522      * If we are executing a method, do not create any namespace objects
 523      * during the load phase, only during execution.
 524      */
 525     if (!WalkState->MethodNode)
 526     {
 527         if (Op->Common.AmlOpcode == AML_REGION_OP)
 528         {
 529             Status = AcpiExCreateRegion (Op->Named.Data, Op->Named.Length,
 530                         (ACPI_ADR_SPACE_TYPE) ((Op->Common.Value.Arg)->Common.Value.Integer),
 531                         WalkState);
 532             if (ACPI_FAILURE (Status))
 533             {
 534                 return_ACPI_STATUS (Status);
 535             }
 536         }
 537     }
 538 #endif
 539
 540     if (Op->Common.AmlOpcode == AML_NAME_OP)
 541     {
 542         /* For Name opcode, get the object type from the argument */
 543
 544         if (Op->Common.Value.Arg)
 545         {
 546             ObjectType = (AcpiPsGetOpcodeInfo (
 547                 (Op->Common.Value.Arg)->Common.AmlOpcode))->ObjectType;
 548
 549             /* Set node type if we have a namespace node */
 550
 551             if (Op->Common.Node)
 552             {
 553                 Op->Common.Node->Type = (UINT8) ObjectType;
 554             }
 555         }
 556     }
 557
 558     /*
 559      * If we are executing a method, do not create any namespace objects
 560      * during the load phase, only during execution.
 561      */
 562     if (!WalkState->MethodNode)
 563     {
 564         if (Op->Common.AmlOpcode == AML_METHOD_OP)
 565         {
 566             /*
 567              * MethodOp PkgLength NameString MethodFlags TermList
 568              *
 569              * Note: We must create the method node/object pair as soon as we
 570              * see the method declaration. This allows later pass1 parsing
 571              * of invocations of the method (need to know the number of
 572              * arguments.)
 573              */
 574             ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
 575                 "LOADING-Method: State=%p Op=%p NamedObj=%p\n",
 576                 WalkState, Op, Op->Named.Node));
 577
 578             if (!AcpiNsGetAttachedObject (Op->Named.Node))
 579             {
 580                 WalkState->Operands[0] = ACPI_CAST_PTR (void, Op->Named.Node);
 581                 WalkState->NumOperands = 1;
 582
 583                 Status = AcpiDsCreateOperands (WalkState, Op->Common.Value.Arg);
 584                 if (ACPI_SUCCESS (Status))
 585                 {
 586                     Status = AcpiExCreateMethod (Op->Named.Data,
 587                                         Op->Named.Length, WalkState);
 588                 }
 589
 590                 WalkState->Operands[0] = NULL;
 591                 WalkState->NumOperands = 0;
 592
 593                 if (ACPI_FAILURE (Status))
 594                 {
 595                     return_ACPI_STATUS (Status);
 596                 }
 597             }
 598         }
 599     }
 600
 601     /* Pop the scope stack (only if loading a table) */
 602
 603     if (!WalkState->MethodNode &&
 604         AcpiNsOpensScope (ObjectType))
 605     {
 606         ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "(%s): Popping scope for Op %p\n",
 607             AcpiUtGetTypeName (ObjectType), Op));
 608
 609         Status = AcpiDsScopeStackPop (WalkState);
 610     }
 611
 612     return_ACPI_STATUS (Status);
 613 }
 614
 615
 616 /*******************************************************************************
 617  *
 618  * FUNCTION:    AcpiDsLoad2BeginOp
 619  *
 620  * PARAMETERS:  WalkState       - Current state of the parse tree walk
 621  *              OutOp           - Wher to return op if a new one is created
 622  *
 623  * RETURN:      Status
 624  *
 625  * DESCRIPTION: Descending callback used during the loading of ACPI tables.
 626  *
 627  ******************************************************************************/
 628
 629 ACPI_STATUS
 630 AcpiDsLoad2BeginOp (
 631     ACPI_WALK_STATE         *WalkState,
 632     ACPI_PARSE_OBJECT       **OutOp)
 633 {
 634     ACPI_PARSE_OBJECT       *Op;
 635     ACPI_NAMESPACE_NODE     *Node;
 636     ACPI_STATUS             Status;
 637     ACPI_OBJECT_TYPE        ObjectType;
 638     char                    *BufferPtr;
 639     UINT32                  Flags;
 640
 641
 642     ACPI_FUNCTION_TRACE (DsLoad2BeginOp);
 643
 644
 645     Op = WalkState->Op;
 646     ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "Op=%p State=%p\n", Op, WalkState));
 647
 648     if (Op)
 649     {
 650         if ((WalkState->ControlState) &&
 651             (WalkState->ControlState->Common.State ==
 652                 ACPI_CONTROL_CONDITIONAL_EXECUTING))
 653         {
 654             /* We are executing a while loop outside of a method */
 655
 656             Status = AcpiDsExecBeginOp (WalkState, OutOp);
 657             return_ACPI_STATUS (Status);
 658         }
 659
 660         /* We only care about Namespace opcodes here */
 661
 662         if ((!(WalkState->OpInfo->Flags & AML_NSOPCODE)   &&
 663               (WalkState->Opcode != AML_INT_NAMEPATH_OP)) ||
 664             (!(WalkState->OpInfo->Flags & AML_NAMED)))
 665         {
 666 #ifdef ACPI_ENABLE_MODULE_LEVEL_CODE
 667             if ((WalkState->OpInfo->Class == AML_CLASS_EXECUTE) ||
 668                 (WalkState->OpInfo->Class == AML_CLASS_CONTROL))
 669             {
 670                 ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
 671                     "Begin/EXEC: %s (fl %8.8X)\n", WalkState->OpInfo->Name,
 672                     WalkState->OpInfo->Flags));
 673
 674                 /* Executing a type1 or type2 opcode outside of a method */
 675
 676                 Status = AcpiDsExecBeginOp (WalkState, OutOp);
 677                 return_ACPI_STATUS (Status);
 678             }
 679 #endif
 680             return_ACPI_STATUS (AE_OK);
 681         }
 682
 683         /* Get the name we are going to enter or lookup in the namespace */
 684
 685         if (WalkState->Opcode == AML_INT_NAMEPATH_OP)
 686         {
 687             /* For Namepath op, get the path string */
 688
 689             BufferPtr = Op->Common.Value.String;
 690             if (!BufferPtr)
 691             {
 692                 /* No name, just exit */
 693
 694                 return_ACPI_STATUS (AE_OK);
 695             }
 696         }
 697         else
 698         {
 699             /* Get name from the op */
 700
 701             BufferPtr = ACPI_CAST_PTR (char, &Op->Named.Name);
 702         }
 703     }
 704     else
 705     {
 706         /* Get the namestring from the raw AML */
 707
 708         BufferPtr = AcpiPsGetNextNamestring (&WalkState->ParserState);
 709     }
 710
 711     /* Map the opcode into an internal object type */
 712
 713     ObjectType = WalkState->OpInfo->ObjectType;
 714
 715     ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
 716         "State=%p Op=%p Type=%X\n", WalkState, Op, ObjectType));
 717
 718     switch (WalkState->Opcode)
 719     {
 720     case AML_FIELD_OP:
 721     case AML_BANK_FIELD_OP:
 722     case AML_INDEX_FIELD_OP:
 723
 724         Node = NULL;
 725         Status = AE_OK;
 726         break;
 727
 728     case AML_INT_NAMEPATH_OP:
 729         /*
 730          * The NamePath is an object reference to an existing object.
 731          * Don't enter the name into the namespace, but look it up
 732          * for use later.
 733          */
 734         Status = AcpiNsLookup (WalkState->ScopeInfo, BufferPtr, ObjectType,
 735                         ACPI_IMODE_EXECUTE, ACPI_NS_SEARCH_PARENT,
 736                         WalkState, &(Node));
 737         break;
 738
 739     case AML_SCOPE_OP:
 740         /*
 741          * The Path is an object reference to an existing object.
 742          * Don't enter the name into the namespace, but look it up
 743          * for use later.
 744          */
 745         Status = AcpiNsLookup (WalkState->ScopeInfo, BufferPtr, ObjectType,
 746                         ACPI_IMODE_EXECUTE, ACPI_NS_SEARCH_PARENT,
 747                         WalkState, &(Node));
 748         if (ACPI_FAILURE (Status))
 749         {
 750 #ifdef ACPI_ASL_COMPILER
 751             if (Status == AE_NOT_FOUND)
 752             {
 753                 Status = AE_OK;
 754             }
 755             else
 756             {
 757                 ACPI_ERROR_NAMESPACE (BufferPtr, Status);
 758             }
 759 #else
 760             ACPI_ERROR_NAMESPACE (BufferPtr, Status);
 761 #endif
 762             return_ACPI_STATUS (Status);
 763         }
 764
 765         /*
 766          * We must check to make sure that the target is
 767          * one of the opcodes that actually opens a scope
 768          */
 769         switch (Node->Type)
 770         {
 771         case ACPI_TYPE_ANY:
 772         case ACPI_TYPE_LOCAL_SCOPE:         /* Scope */
 773         case ACPI_TYPE_DEVICE:
 774         case ACPI_TYPE_POWER:
 775         case ACPI_TYPE_PROCESSOR:
 776         case ACPI_TYPE_THERMAL:
 777
 778             /* These are acceptable types */
 779             break;
 780
 781         case ACPI_TYPE_INTEGER:
 782         case ACPI_TYPE_STRING:
 783         case ACPI_TYPE_BUFFER:
 784
 785             /*
 786              * These types we will allow, but we will change the type. This
 787              * enables some existing code of the form:
 788              *
 789              *  Name (DEB, 0)
 790              *  Scope (DEB) { ... }
 791              */
 792             ACPI_WARNING ((AE_INFO,
 793                 "Type override - [%4.4s] had invalid type (%s) for Scope operator, changed to (Scope)",
 794                 BufferPtr, AcpiUtGetTypeName (Node->Type)));
 795
 796             Node->Type = ACPI_TYPE_ANY;
 797             WalkState->ScopeInfo->Common.Value = ACPI_TYPE_ANY;
 798             break;
 799
 800         default:
 801
 802             /* All other types are an error */
 803
 804             ACPI_ERROR ((AE_INFO,
 805                 "Invalid type (%s) for target of Scope operator [%4.4s]",
 806                 AcpiUtGetTypeName (Node->Type), BufferPtr));
 807
 808             return (AE_AML_OPERAND_TYPE);
 809         }
 810         break;
 811
 812     default:
 813
 814         /* All other opcodes */
 815
 816         if (Op && Op->Common.Node)
 817         {
 818             /* This op/node was previously entered into the namespace */
 819
 820             Node = Op->Common.Node;
 821
 822             if (AcpiNsOpensScope (ObjectType))
 823             {
 824                 Status = AcpiDsScopeStackPush (Node, ObjectType, WalkState);
 825                 if (ACPI_FAILURE (Status))
 826                 {
 827                     return_ACPI_STATUS (Status);
 828                 }
 829             }
 830
 831             return_ACPI_STATUS (AE_OK);
 832         }
 833
 834         /*
 835          * Enter the named type into the internal namespace. We enter the name
 836          * as we go downward in the parse tree. Any necessary subobjects that
 837          * involve arguments to the opcode must be created as we go back up the
 838          * parse tree later.
 839          *
 840          * Note: Name may already exist if we are executing a deferred opcode.
 841          */
 842         if (WalkState->DeferredNode)
 843         {
 844             /* This name is already in the namespace, get the node */
 845
 846             Node = WalkState->DeferredNode;
 847             Status = AE_OK;
 848             break;
 849         }
 850
 851         Flags = ACPI_NS_NO_UPSEARCH;
 852         if (WalkState->PassNumber == ACPI_IMODE_EXECUTE)
 853         {
 854             /* Execution mode, node cannot already exist, node is temporary */
 855
 856             Flags |= (ACPI_NS_ERROR_IF_FOUND | ACPI_NS_TEMPORARY);
 857         }
 858
 859         /* Add new entry or lookup existing entry */
 860
 861         Status = AcpiNsLookup (WalkState->ScopeInfo, BufferPtr, ObjectType,
 862                     ACPI_IMODE_LOAD_PASS2, Flags, WalkState, &Node);
 863         break;
 864     }
 865
 866     if (ACPI_FAILURE (Status))
 867     {
 868         ACPI_ERROR_NAMESPACE (BufferPtr, Status);
 869         return_ACPI_STATUS (Status);
 870     }
 871
 872     if (!Op)
 873     {
 874         /* Create a new op */
 875
 876         Op = AcpiPsAllocOp (WalkState->Opcode);
 877         if (!Op)
 878         {
 879             return_ACPI_STATUS (AE_NO_MEMORY);
 880         }
 881
 882         /* Initialize the new op */
 883
 884         if (Node)
 885         {
 886             Op->Named.Name = Node->Name.Integer;
 887         }
 888         *OutOp = Op;
 889     }
 890
 891     /*
 892      * Put the Node in the "op" object that the parser uses, so we
 893      * can get it again quickly when this scope is closed
 894      */
 895     Op->Common.Node = Node;
 896     return_ACPI_STATUS (Status);
 897 }
 898
 899
 900 /*******************************************************************************
 901  *
 902  * FUNCTION:    AcpiDsLoad2EndOp
 903  *
 904  * PARAMETERS:  WalkState       - Current state of the parse tree walk
 905  *
 906  * RETURN:      Status
 907  *
 908  * DESCRIPTION: Ascending callback used during the loading of the namespace,
 909  *              both control methods and everything else.
 910  *
 911  ******************************************************************************/
 912
 913 ACPI_STATUS
 914 AcpiDsLoad2EndOp (
 915     ACPI_WALK_STATE         *WalkState)
 916 {
 917     ACPI_PARSE_OBJECT       *Op;
 918     ACPI_STATUS             Status = AE_OK;
 919     ACPI_OBJECT_TYPE        ObjectType;
 920     ACPI_NAMESPACE_NODE     *Node;
 921     ACPI_PARSE_OBJECT       *Arg;
 922     ACPI_NAMESPACE_NODE     *NewNode;
 923 #ifndef ACPI_NO_METHOD_EXECUTION
 924     UINT32                  i;
 925 #endif
 926
 927
 928     ACPI_FUNCTION_TRACE (DsLoad2EndOp);
 929
 930     Op = WalkState->Op;
 931     ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "Opcode [%s] Op %p State %p\n",
 932             WalkState->OpInfo->Name, Op, WalkState));
 933
 934     /* Check if opcode had an associated namespace object */
 935
 936     if (!(WalkState->OpInfo->Flags & AML_NSOBJECT))
 937     {
 938 #ifndef ACPI_NO_METHOD_EXECUTION
 939 #ifdef ACPI_ENABLE_MODULE_LEVEL_CODE
 940         /* No namespace object. Executable opcode? */
 941
 942         if ((WalkState->OpInfo->Class == AML_CLASS_EXECUTE) ||
 943             (WalkState->OpInfo->Class == AML_CLASS_CONTROL))
 944         {
 945             ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
 946                 "End/EXEC:   %s (fl %8.8X)\n", WalkState->OpInfo->Name,
 947                 WalkState->OpInfo->Flags));
 948
 949             /* Executing a type1 or type2 opcode outside of a method */
 950
 951             Status = AcpiDsExecEndOp (WalkState);
 952             return_ACPI_STATUS (Status);
 953         }
 954 #endif
 955 #endif
 956         return_ACPI_STATUS (AE_OK);
 957     }
 958
 959     if (Op->Common.AmlOpcode == AML_SCOPE_OP)
 960     {
 961         ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
 962             "Ending scope Op=%p State=%p\n", Op, WalkState));
 963     }
 964
 965     ObjectType = WalkState->OpInfo->ObjectType;
 966
 967     /*
 968      * Get the Node/name from the earlier lookup
 969      * (It was saved in the *op structure)
 970      */
 971     Node = Op->Common.Node;
 972
 973     /*
 974      * Put the Node on the object stack (Contains the ACPI Name of
 975      * this object)
 976      */
 977     WalkState->Operands[0] = (void *) Node;
 978     WalkState->NumOperands = 1;
 979
 980     /* Pop the scope stack */
 981
 982     if (AcpiNsOpensScope (ObjectType) &&
 983        (Op->Common.AmlOpcode != AML_INT_METHODCALL_OP))
 984     {
 985         ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "(%s) Popping scope for Op %p\n",
 986             AcpiUtGetTypeName (ObjectType), Op));
 987
 988         Status = AcpiDsScopeStackPop (WalkState);
 989         if (ACPI_FAILURE (Status))
 990         {
 991             goto Cleanup;
 992         }
 993     }
 994
 995     /*
 996      * Named operations are as follows:
 997      *
 998      * AML_ALIAS
 999      * AML_BANKFIELD
1000      * AML_CREATEBITFIELD
1001      * AML_CREATEBYTEFIELD
1002      * AML_CREATEDWORDFIELD
1003      * AML_CREATEFIELD
1004      * AML_CREATEQWORDFIELD
1005      * AML_CREATEWORDFIELD
1006      * AML_DATA_REGION
1007      * AML_DEVICE
1008      * AML_EVENT
1009      * AML_FIELD
1010      * AML_INDEXFIELD
1011      * AML_METHOD
1012      * AML_METHODCALL
1013      * AML_MUTEX
1014      * AML_NAME
1015      * AML_NAMEDFIELD
1016      * AML_OPREGION
1017      * AML_POWERRES
1018      * AML_PROCESSOR
1019      * AML_SCOPE
1020      * AML_THERMALZONE
1021      */
1022
1023     ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
1024         "Create-Load [%s] State=%p Op=%p NamedObj=%p\n",
1025         AcpiPsGetOpcodeName (Op->Common.AmlOpcode), WalkState, Op, Node));
1026
1027     /* Decode the opcode */
1028
1029     Arg = Op->Common.Value.Arg;
1030
1031     switch (WalkState->OpInfo->Type)
1032     {
1033 #ifndef ACPI_NO_METHOD_EXECUTION
1034
1035     case AML_TYPE_CREATE_FIELD:
1036         /*
1037          * Create the field object, but the field buffer and index must
1038          * be evaluated later during the execution phase
1039          */
1040         Status = AcpiDsCreateBufferField (Op, WalkState);
1041         break;
1042
1043
1044      case AML_TYPE_NAMED_FIELD:
1045         /*
1046          * If we are executing a method, initialize the field
1047          */
1048         if (WalkState->MethodNode)
1049         {
1050             Status = AcpiDsInitFieldObjects (Op, WalkState);
1051         }
1052
1053         switch (Op->Common.AmlOpcode)
1054         {
1055         case AML_INDEX_FIELD_OP:
1056
1057             Status = AcpiDsCreateIndexField (Op, (ACPI_HANDLE) Arg->Common.Node,
1058                         WalkState);
1059             break;
1060
1061         case AML_BANK_FIELD_OP:
1062
1063             Status = AcpiDsCreateBankField (Op, Arg->Common.Node, WalkState);
1064             break;
1065
1066         case AML_FIELD_OP:
1067
1068             Status = AcpiDsCreateField (Op, Arg->Common.Node, WalkState);
1069             break;
1070
1071         default:
1072             /* All NAMED_FIELD opcodes must be handled above */
1073             break;
1074         }
1075         break;
1076
1077
1078      case AML_TYPE_NAMED_SIMPLE:
1079
1080         Status = AcpiDsCreateOperands (WalkState, Arg);
1081         if (ACPI_FAILURE (Status))
1082         {
1083             goto Cleanup;
1084         }
1085
1086         switch (Op->Common.AmlOpcode)
1087         {
1088         case AML_PROCESSOR_OP:
1089
1090             Status = AcpiExCreateProcessor (WalkState);
1091             break;
1092
1093         case AML_POWER_RES_OP:
1094
1095             Status = AcpiExCreatePowerResource (WalkState);
1096             break;
1097
1098         case AML_MUTEX_OP:
1099
1100             Status = AcpiExCreateMutex (WalkState);
1101             break;
1102
1103         case AML_EVENT_OP:
1104
1105             Status = AcpiExCreateEvent (WalkState);
1106             break;
1107
1108         case AML_DATA_REGION_OP:
1109
1110             Status = AcpiExCreateTableRegion (WalkState);
1111             break;
1112
1113         case AML_ALIAS_OP:
1114
1115             Status = AcpiExCreateAlias (WalkState);
1116             break;
1117
1118         default:
1119             /* Unknown opcode */
1120
1121             Status = AE_OK;
1122             goto Cleanup;
1123         }
1124
1125         /* Delete operands */
1126
1127         for (i = 1; i < WalkState->NumOperands; i++)
1128         {
1129             AcpiUtRemoveReference (WalkState->Operands[i]);
1130             WalkState->Operands[i] = NULL;
1131         }
1132
1133         break;
1134 #endif /* ACPI_NO_METHOD_EXECUTION */
1135
1136     case AML_TYPE_NAMED_COMPLEX:
1137
1138         switch (Op->Common.AmlOpcode)
1139         {
1140 #ifndef ACPI_NO_METHOD_EXECUTION
1141         case AML_REGION_OP:
1142
1143             /*
1144              * If we are executing a method, initialize the region
1145              */
1146             if (WalkState->MethodNode)
1147             {
1148                 Status = AcpiExCreateRegion (Op->Named.Data, Op->Named.Length,
1149                             (ACPI_ADR_SPACE_TYPE)
1150                                 ((Op->Common.Value.Arg)->Common.Value.Integer),
1151                             WalkState);
1152                 if (ACPI_FAILURE (Status))
1153                 {
1154                     return (Status);
1155                 }
1156             }
1157
1158             /*
1159              * The OpRegion is not fully parsed at this time. Only valid
1160              * argument is the SpaceId. (We must save the address of the
1161              * AML of the address and length operands)
1162              */
1163
1164             /*
1165              * If we have a valid region, initialize it
1166              * Namespace is NOT locked at this point.
1167              *
1168              * TBD: need to unlock interpreter if it is locked, in order
1169              * to allow _REG methods to be run.
1170              */
1171             Status = AcpiEvInitializeRegion (AcpiNsGetAttachedObject (Node),
1172                         FALSE);
1173             if (ACPI_FAILURE (Status))
1174             {
1175                 /*
1176                  *  If AE_NOT_EXIST is returned, it is not fatal
1177                  *  because many regions get created before a handler
1178                  *  is installed for said region.
1179                  */
1180                 if (AE_NOT_EXIST == Status)
1181                 {
1182                     Status = AE_OK;
1183                 }
1184             }
1185             break;
1186
1187
1188         case AML_NAME_OP:
1189
1190             Status = AcpiDsCreateNode (WalkState, Node, Op);
1191             break;
1192
1193
1194         case AML_METHOD_OP:
1195             /*
1196              * MethodOp PkgLength NameString MethodFlags TermList
1197              *
1198              * Note: We must create the method node/object pair as soon as we
1199              * see the method declaration. This allows later pass1 parsing
1200              * of invocations of the method (need to know the number of
1201              * arguments.)
1202              */
1203             ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
1204                 "LOADING-Method: State=%p Op=%p NamedObj=%p\n",
1205                 WalkState, Op, Op->Named.Node));
1206
1207             if (!AcpiNsGetAttachedObject (Op->Named.Node))
1208             {
1209                 WalkState->Operands[0] = ACPI_CAST_PTR (void, Op->Named.Node);
1210                 WalkState->NumOperands = 1;
1211
1212                 Status = AcpiDsCreateOperands (WalkState, Op->Common.Value.Arg);
1213                 if (ACPI_SUCCESS (Status))
1214                 {
1215                     Status = AcpiExCreateMethod (Op->Named.Data,
1216                                         Op->Named.Length, WalkState);
1217                 }
1218                 WalkState->Operands[0] = NULL;
1219                 WalkState->NumOperands = 0;
1220
1221                 if (ACPI_FAILURE (Status))
1222                 {
1223                     return_ACPI_STATUS (Status);
1224                 }
1225             }
1226             break;
1227
1228 #endif /* ACPI_NO_METHOD_EXECUTION */
1229
1230         default:
1231             /* All NAMED_COMPLEX opcodes must be handled above */
1232             break;
1233         }
1234         break;
1235
1236
1237     case AML_CLASS_INTERNAL:
1238
1239         /* case AML_INT_NAMEPATH_OP: */
1240         break;
1241
1242
1243     case AML_CLASS_METHOD_CALL:
1244
1245         ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
1246             "RESOLVING-MethodCall: State=%p Op=%p NamedObj=%p\n",
1247             WalkState, Op, Node));
1248
1249         /*
1250          * Lookup the method name and save the Node
1251          */
1252         Status = AcpiNsLookup (WalkState->ScopeInfo, Arg->Common.Value.String,
1253                         ACPI_TYPE_ANY, ACPI_IMODE_LOAD_PASS2,
1254                         ACPI_NS_SEARCH_PARENT | ACPI_NS_DONT_OPEN_SCOPE,
1255                         WalkState, &(NewNode));
1256         if (ACPI_SUCCESS (Status))
1257         {
1258             /*
1259              * Make sure that what we found is indeed a method
1260              * We didn't search for a method on purpose, to see if the name
1261              * would resolve
1262              */
1263             if (NewNode->Type != ACPI_TYPE_METHOD)
1264             {
1265                 Status = AE_AML_OPERAND_TYPE;
1266             }
1267
1268             /* We could put the returned object (Node) on the object stack for
1269              * later, but for now, we will put it in the "op" object that the
1270              * parser uses, so we can get it again at the end of this scope
1271              */
1272             Op->Common.Node = NewNode;
1273         }
1274         else
1275         {
1276             ACPI_ERROR_NAMESPACE (Arg->Common.Value.String, Status);
1277         }
1278         break;
1279
1280
1281     default:
1282         break;
1283     }
1284
1285 Cleanup:
1286
1287     /* Remove the Node pushed at the very beginning */
1288
1289     WalkState->Operands[0] = NULL;
1290     WalkState->NumOperands = 0;
1291     return_ACPI_STATUS (Status);
1292 }
1293
1294