drivers/acpi/dispatcher/dswload.c

   1 /******************************************************************************
   2  *
   3  * Module Name: dswload - Dispatcher namespace load callbacks
   4  *
   5  *****************************************************************************/
   6
   7 /*
   8  * Copyright (C) 2000 - 2005, R. Byron Moore
   9  * All rights reserved.
  10  *
  11  * Redistribution and use in source and binary forms, with or without
  12  * modification, are permitted provided that the following conditions
  13  * are met:
  14  * 1. Redistributions of source code must retain the above copyright
  15  *    notice, this list of conditions, and the following disclaimer,
  16  *    without modification.
  17  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
  18  *    substantially similar to the "NO WARRANTY" disclaimer below
  19  *    ("Disclaimer") and any redistribution must be conditioned upon
  20  *    including a substantially similar Disclaimer requirement for further
  21  *    binary redistribution.
  22  * 3. Neither the names of the above-listed copyright holders nor the names
  23  *    of any contributors may be used to endorse or promote products derived
  24  *    from this software without specific prior written permission.
  25  *
  26  * Alternatively, this software may be distributed under the terms of the
  27  * GNU General Public License ("GPL") version 2 as published by the Free
  28  * Software Foundation.
  29  *
  30  * NO WARRANTY
  31  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  32  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  33  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
  34  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  35  * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  36  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  37  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  38  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  39  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
  40  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  41  * POSSIBILITY OF SUCH DAMAGES.
  42  */
  43
  44 #include <acpi/acpi.h>
  45 #include <acpi/acparser.h>
  46 #include <acpi/amlcode.h>
  47 #include <acpi/acdispat.h>
  48 #include <acpi/acinterp.h>
  49 #include <acpi/acnamesp.h>
  50 #include <acpi/acevents.h>
  51
  52 #ifdef ACPI_ASL_COMPILER
  53 #include <acpi/acdisasm.h>
  54 #endif
  55
  56 #define _COMPONENT          ACPI_DISPATCHER
  57 ACPI_MODULE_NAME("dswload")
  58
  59 /*******************************************************************************
  60  *
  61  * FUNCTION:    acpi_ds_init_callbacks
  62  *
  63  * PARAMETERS:  walk_state      - Current state of the parse tree walk
  64  *              pass_number     - 1, 2, or 3
  65  *
  66  * RETURN:      Status
  67  *
  68  * DESCRIPTION: Init walk state callbacks
  69  *
  70  ******************************************************************************/
  71 acpi_status
  72 acpi_ds_init_callbacks(struct acpi_walk_state *walk_state, u32 pass_number)
  73 {
  74
  75         switch (pass_number) {
  76         case 1:
  77                 walk_state->parse_flags = ACPI_PARSE_LOAD_PASS1 |
  78                     ACPI_PARSE_DELETE_TREE;
  79                 walk_state->descending_callback = acpi_ds_load1_begin_op;
  80                 walk_state->ascending_callback = acpi_ds_load1_end_op;
  81                 break;
  82
  83         case 2:
  84                 walk_state->parse_flags = ACPI_PARSE_LOAD_PASS1 |
  85                     ACPI_PARSE_DELETE_TREE;
  86                 walk_state->descending_callback = acpi_ds_load2_begin_op;
  87                 walk_state->ascending_callback = acpi_ds_load2_end_op;
  88                 break;
  89
  90         case 3:
  91 #ifndef ACPI_NO_METHOD_EXECUTION
  92                 walk_state->parse_flags |= ACPI_PARSE_EXECUTE |
  93                     ACPI_PARSE_DELETE_TREE;
  94                 walk_state->descending_callback = acpi_ds_exec_begin_op;
  95                 walk_state->ascending_callback = acpi_ds_exec_end_op;
  96 #endif
  97                 break;
  98
  99         default:
 100                 return (AE_BAD_PARAMETER);
 101         }
 102
 103         return (AE_OK);
 104 }
 105
 106 /*******************************************************************************
 107  *
 108  * FUNCTION:    acpi_ds_load1_begin_op
 109  *
 110  * PARAMETERS:  walk_state      - Current state of the parse tree walk
 111  *              out_op          - Where to return op if a new one is created
 112  *
 113  * RETURN:      Status
 114  *
 115  * DESCRIPTION: Descending callback used during the loading of ACPI tables.
 116  *
 117  ******************************************************************************/
 118
 119 acpi_status
 120 acpi_ds_load1_begin_op(struct acpi_walk_state * walk_state,
 121                        union acpi_parse_object ** out_op)
 122 {
 123         union acpi_parse_object *op;
 124         struct acpi_namespace_node *node;
 125         acpi_status status;
 126         acpi_object_type object_type;
 127         char *path;
 128         u32 flags;
 129
 130         ACPI_FUNCTION_TRACE("ds_load1_begin_op");
 131
 132         op = walk_state->op;
 133         ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH, "Op=%p State=%p\n", op,
 134                           walk_state));
 135
 136         /* We are only interested in opcodes that have an associated name */
 137
 138         if (op) {
 139                 if (!(walk_state->op_info->flags & AML_NAMED)) {
 140                         *out_op = op;
 141                         return_ACPI_STATUS(AE_OK);
 142                 }
 143
 144                 /* Check if this object has already been installed in the namespace */
 145
 146                 if (op->common.node) {
 147                         *out_op = op;
 148                         return_ACPI_STATUS(AE_OK);
 149                 }
 150         }
 151
 152         path = acpi_ps_get_next_namestring(&walk_state->parser_state);
 153
 154         /* Map the raw opcode into an internal object type */
 155
 156         object_type = walk_state->op_info->object_type;
 157
 158         ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
 159                           "State=%p Op=%p [%s]\n", walk_state, op,
 160                           acpi_ut_get_type_name(object_type)));
 161
 162         switch (walk_state->opcode) {
 163         case AML_SCOPE_OP:
 164
 165                 /*
 166                  * The target name of the Scope() operator must exist at this point so
 167                  * that we can actually open the scope to enter new names underneath it.
 168                  * Allow search-to-root for single namesegs.
 169                  */
 170                 status =
 171                     acpi_ns_lookup(walk_state->scope_info, path, object_type,
 172                                    ACPI_IMODE_EXECUTE, ACPI_NS_SEARCH_PARENT,
 173                                    walk_state, &(node));
 174 #ifdef ACPI_ASL_COMPILER
 175                 if (status == AE_NOT_FOUND) {
 176                         /*
 177                          * Table disassembly:
 178                          * Target of Scope() not found.  Generate an External for it, and
 179                          * insert the name into the namespace.
 180                          */
 181                         acpi_dm_add_to_external_list(path);
 182                         status =
 183                             acpi_ns_lookup(walk_state->scope_info, path,
 184                                            object_type, ACPI_IMODE_LOAD_PASS1,
 185                                            ACPI_NS_SEARCH_PARENT, walk_state,
 186                                            &(node));
 187                 }
 188 #endif
 189                 if (ACPI_FAILURE(status)) {
 190                         ACPI_REPORT_NSERROR(path, status);
 191                         return_ACPI_STATUS(status);
 192                 }
 193
 194                 /*
 195                  * Check to make sure that the target is
 196                  * one of the opcodes that actually opens a scope
 197                  */
 198                 switch (node->type) {
 199                 case ACPI_TYPE_LOCAL_SCOPE:     /* Scope  */
 200                 case ACPI_TYPE_DEVICE:
 201                 case ACPI_TYPE_POWER:
 202                 case ACPI_TYPE_PROCESSOR:
 203                 case ACPI_TYPE_THERMAL:
 204
 205                         /* These are acceptable types */
 206                         break;
 207
 208                 case ACPI_TYPE_INTEGER:
 209                 case ACPI_TYPE_STRING:
 210                 case ACPI_TYPE_BUFFER:
 211
 212                         /*
 213                          * These types we will allow, but we will change the type.  This
 214                          * enables some existing code of the form:
 215                          *
 216                          *  Name (DEB, 0)
 217                          *  Scope (DEB) { ... }
 218                          *
 219                          * Note: silently change the type here.  On the second pass, we will report
 220                          * a warning
 221                          */
 222
 223                         ACPI_DEBUG_PRINT((ACPI_DB_INFO,
 224                                           "Type override - [%4.4s] had invalid type (%s) for Scope operator, changed to (Scope)\n",
 225                                           path,
 226                                           acpi_ut_get_type_name(node->type)));
 227
 228                         node->type = ACPI_TYPE_ANY;
 229                         walk_state->scope_info->common.value = ACPI_TYPE_ANY;
 230                         break;
 231
 232                 default:
 233
 234                         /* All other types are an error */
 235
 236                         ACPI_REPORT_ERROR(("Invalid type (%s) for target of Scope operator [%4.4s] (Cannot override)\n", acpi_ut_get_type_name(node->type), path));
 237
 238                         return_ACPI_STATUS(AE_AML_OPERAND_TYPE);
 239                 }
 240                 break;
 241
 242         default:
 243
 244                 /*
 245                  * For all other named opcodes, we will enter the name into
 246                  * the namespace.
 247                  *
 248                  * Setup the search flags.
 249                  * Since we are entering a name into the namespace, we do not want to
 250                  * enable the search-to-root upsearch.
 251                  *
 252                  * There are only two conditions where it is acceptable that the name
 253                  * already exists:
 254                  *    1) the Scope() operator can reopen a scoping object that was
 255                  *       previously defined (Scope, Method, Device, etc.)
 256                  *    2) Whenever we are parsing a deferred opcode (op_region, Buffer,
 257                  *       buffer_field, or Package), the name of the object is already
 258                  *       in the namespace.
 259                  */
 260
 261                 if (walk_state->deferred_node) {
 262                         /* This name is already in the namespace, get the node */
 263
 264                         node = walk_state->deferred_node;
 265                         status = AE_OK;
 266                         break;
 267                 }
 268
 269                 /*
 270                  * If we are executing a method, do not create any namespace objects
 271                  * during the load phase, only during execution.
 272                  */
 273                 if (walk_state->method_node) {
 274                         node = NULL;
 275                         status = AE_OK;
 276                         break;
 277                 }
 278
 279                 flags = ACPI_NS_NO_UPSEARCH;
 280                 if ((walk_state->opcode != AML_SCOPE_OP) &&
 281                     (!(walk_state->parse_flags & ACPI_PARSE_DEFERRED_OP))) {
 282                         flags |= ACPI_NS_ERROR_IF_FOUND;
 283                         ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
 284                                           "[%s] Cannot already exist\n",
 285                                           acpi_ut_get_type_name(object_type)));
 286                 } else {
 287                         ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
 288                                           "[%s] Both Find or Create allowed\n",
 289                                           acpi_ut_get_type_name(object_type)));
 290                 }
 291
 292                 /*
 293                  * Enter the named type into the internal namespace.  We enter the name
 294                  * as we go downward in the parse tree.  Any necessary subobjects that
 295                  * involve arguments to the opcode must be created as we go back up the
 296                  * parse tree later.
 297                  */
 298                 status =
 299                     acpi_ns_lookup(walk_state->scope_info, path, object_type,
 300                                    ACPI_IMODE_LOAD_PASS1, flags, walk_state,
 301                                    &(node));
 302                 if (ACPI_FAILURE(status)) {
 303                         ACPI_REPORT_NSERROR(path, status);
 304                         return_ACPI_STATUS(status);
 305                 }
 306                 break;
 307         }
 308
 309         /* Common exit */
 310
 311         if (!op) {
 312                 /* Create a new op */
 313
 314                 op = acpi_ps_alloc_op(walk_state->opcode);
 315                 if (!op) {
 316                         return_ACPI_STATUS(AE_NO_MEMORY);
 317                 }
 318         }
 319
 320         /* Initialize the op */
 321
 322 #if (defined (ACPI_NO_METHOD_EXECUTION) || defined (ACPI_CONSTANT_EVAL_ONLY))
 323         op->named.path = ACPI_CAST_PTR(u8, path);
 324 #endif
 325
 326         if (node) {
 327                 /*
 328                  * Put the Node in the "op" object that the parser uses, so we
 329                  * can get it again quickly when this scope is closed
 330                  */
 331                 op->common.node = node;
 332                 op->named.name = node->name.integer;
 333         }
 334
 335         acpi_ps_append_arg(acpi_ps_get_parent_scope(&walk_state->parser_state),
 336                            op);
 337         *out_op = op;
 338         return_ACPI_STATUS(status);
 339 }
 340
 341 /*******************************************************************************
 342  *
 343  * FUNCTION:    acpi_ds_load1_end_op
 344  *
 345  * PARAMETERS:  walk_state      - Current state of the parse tree walk
 346  *
 347  * RETURN:      Status
 348  *
 349  * DESCRIPTION: Ascending callback used during the loading of the namespace,
 350  *              both control methods and everything else.
 351  *
 352  ******************************************************************************/
 353
 354 acpi_status acpi_ds_load1_end_op(struct acpi_walk_state *walk_state)
 355 {
 356         union acpi_parse_object *op;
 357         acpi_object_type object_type;
 358         acpi_status status = AE_OK;
 359
 360         ACPI_FUNCTION_TRACE("ds_load1_end_op");
 361
 362         op = walk_state->op;
 363         ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH, "Op=%p State=%p\n", op,
 364                           walk_state));
 365
 366         /* We are only interested in opcodes that have an associated name */
 367
 368         if (!(walk_state->op_info->flags & (AML_NAMED | AML_FIELD))) {
 369                 return_ACPI_STATUS(AE_OK);
 370         }
 371
 372         /* Get the object type to determine if we should pop the scope */
 373
 374         object_type = walk_state->op_info->object_type;
 375
 376 #ifndef ACPI_NO_METHOD_EXECUTION
 377         if (walk_state->op_info->flags & AML_FIELD) {
 378                 /*
 379                  * If we are executing a method, do not create any namespace objects
 380                  * during the load phase, only during execution.
 381                  */
 382                 if (!walk_state->method_node) {
 383                         if (walk_state->opcode == AML_FIELD_OP ||
 384                             walk_state->opcode == AML_BANK_FIELD_OP ||
 385                             walk_state->opcode == AML_INDEX_FIELD_OP) {
 386                                 status =
 387                                     acpi_ds_init_field_objects(op, walk_state);
 388                         }
 389                 }
 390                 return_ACPI_STATUS(status);
 391         }
 392
 393         /*
 394          * If we are executing a method, do not create any namespace objects
 395          * during the load phase, only during execution.
 396          */
 397         if (!walk_state->method_node) {
 398                 if (op->common.aml_opcode == AML_REGION_OP) {
 399                         status =
 400                             acpi_ex_create_region(op->named.data,
 401                                                   op->named.length,
 402                                                   (acpi_adr_space_type)
 403                                                   ((op->common.value.arg)->
 404                                                    common.value.integer),
 405                                                   walk_state);
 406                         if (ACPI_FAILURE(status)) {
 407                                 return_ACPI_STATUS(status);
 408                         }
 409                 }
 410         }
 411 #endif
 412
 413         if (op->common.aml_opcode == AML_NAME_OP) {
 414                 /* For Name opcode, get the object type from the argument */
 415
 416                 if (op->common.value.arg) {
 417                         object_type = (acpi_ps_get_opcode_info((op->common.
 418                                                                 value.arg)->
 419                                                                common.
 420                                                                aml_opcode))->
 421                             object_type;
 422
 423                         /* Set node type if we have a namespace node */
 424
 425                         if (op->common.node) {
 426                                 op->common.node->type = (u8) object_type;
 427                         }
 428                 }
 429         }
 430
 431         /*
 432          * If we are executing a method, do not create any namespace objects
 433          * during the load phase, only during execution.
 434          */
 435         if (!walk_state->method_node) {
 436                 if (op->common.aml_opcode == AML_METHOD_OP) {
 437                         /*
 438                          * method_op pkg_length name_string method_flags term_list
 439                          *
 440                          * Note: We must create the method node/object pair as soon as we
 441                          * see the method declaration.  This allows later pass1 parsing
 442                          * of invocations of the method (need to know the number of
 443                          * arguments.)
 444                          */
 445                         ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
 446                                           "LOADING-Method: State=%p Op=%p named_obj=%p\n",
 447                                           walk_state, op, op->named.node));
 448
 449                         if (!acpi_ns_get_attached_object(op->named.node)) {
 450                                 walk_state->operands[0] =
 451                                     ACPI_CAST_PTR(void, op->named.node);
 452                                 walk_state->num_operands = 1;
 453
 454                                 status =
 455                                     acpi_ds_create_operands(walk_state,
 456                                                             op->common.value.
 457                                                             arg);
 458                                 if (ACPI_SUCCESS(status)) {
 459                                         status =
 460                                             acpi_ex_create_method(op->named.
 461                                                                   data,
 462                                                                   op->named.
 463                                                                   length,
 464                                                                   walk_state);
 465                                 }
 466                                 walk_state->operands[0] = NULL;
 467                                 walk_state->num_operands = 0;
 468
 469                                 if (ACPI_FAILURE(status)) {
 470                                         return_ACPI_STATUS(status);
 471                                 }
 472                         }
 473                 }
 474         }
 475
 476         /* Pop the scope stack (only if loading a table) */
 477
 478         if (!walk_state->method_node && acpi_ns_opens_scope(object_type)) {
 479                 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
 480                                   "(%s): Popping scope for Op %p\n",
 481                                   acpi_ut_get_type_name(object_type), op));
 482
 483                 status = acpi_ds_scope_stack_pop(walk_state);
 484         }
 485
 486         return_ACPI_STATUS(status);
 487 }
 488
 489 /*******************************************************************************
 490  *
 491  * FUNCTION:    acpi_ds_load2_begin_op
 492  *
 493  * PARAMETERS:  walk_state      - Current state of the parse tree walk
 494  *              out_op          - Wher to return op if a new one is created
 495  *
 496  * RETURN:      Status
 497  *
 498  * DESCRIPTION: Descending callback used during the loading of ACPI tables.
 499  *
 500  ******************************************************************************/
 501
 502 acpi_status
 503 acpi_ds_load2_begin_op(struct acpi_walk_state *walk_state,
 504                        union acpi_parse_object **out_op)
 505 {
 506         union acpi_parse_object *op;
 507         struct acpi_namespace_node *node;
 508         acpi_status status;
 509         acpi_object_type object_type;
 510         char *buffer_ptr;
 511
 512         ACPI_FUNCTION_TRACE("ds_load2_begin_op");
 513
 514         op = walk_state->op;
 515         ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH, "Op=%p State=%p\n", op,
 516                           walk_state));
 517
 518         if (op) {
 519                 if ((walk_state->control_state) &&
 520                     (walk_state->control_state->common.state ==
 521                      ACPI_CONTROL_CONDITIONAL_EXECUTING)) {
 522                         /* We are executing a while loop outside of a method */
 523
 524                         status = acpi_ds_exec_begin_op(walk_state, out_op);
 525                         return_ACPI_STATUS(status);
 526                 }
 527
 528                 /* We only care about Namespace opcodes here */
 529
 530                 if ((!(walk_state->op_info->flags & AML_NSOPCODE) &&
 531                      (walk_state->opcode != AML_INT_NAMEPATH_OP)) ||
 532                     (!(walk_state->op_info->flags & AML_NAMED))) {
 533 #ifdef ACPI_ENABLE_MODULE_LEVEL_CODE
 534                         if ((walk_state->op_info->class == AML_CLASS_EXECUTE) ||
 535                             (walk_state->op_info->class == AML_CLASS_CONTROL)) {
 536
 537                                 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
 538                                                   "Begin/EXEC: %s (fl %8.8X)\n",
 539                                                   walk_state->op_info->name,
 540                                                   walk_state->op_info->flags));
 541
 542                                 /* Executing a type1 or type2 opcode outside of a method */
 543
 544                                 status =
 545                                     acpi_ds_exec_begin_op(walk_state, out_op);
 546                                 return_ACPI_STATUS(status);
 547                         }
 548 #endif
 549                         return_ACPI_STATUS(AE_OK);
 550                 }
 551
 552                 /* Get the name we are going to enter or lookup in the namespace */
 553
 554                 if (walk_state->opcode == AML_INT_NAMEPATH_OP) {
 555                         /* For Namepath op, get the path string */
 556
 557                         buffer_ptr = op->common.value.string;
 558                         if (!buffer_ptr) {
 559                                 /* No name, just exit */
 560
 561                                 return_ACPI_STATUS(AE_OK);
 562                         }
 563                 } else {
 564                         /* Get name from the op */
 565
 566                         buffer_ptr = (char *)&op->named.name;
 567                 }
 568         } else {
 569                 /* Get the namestring from the raw AML */
 570
 571                 buffer_ptr =
 572                     acpi_ps_get_next_namestring(&walk_state->parser_state);
 573         }
 574
 575         /* Map the opcode into an internal object type */
 576
 577         object_type = walk_state->op_info->object_type;
 578
 579         ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
 580                           "State=%p Op=%p Type=%X\n", walk_state, op,
 581                           object_type));
 582
 583         switch (walk_state->opcode) {
 584         case AML_FIELD_OP:
 585         case AML_BANK_FIELD_OP:
 586         case AML_INDEX_FIELD_OP:
 587
 588                 node = NULL;
 589                 status = AE_OK;
 590                 break;
 591
 592         case AML_INT_NAMEPATH_OP:
 593
 594                 /*
 595                  * The name_path is an object reference to an existing object.
 596                  * Don't enter the name into the namespace, but look it up
 597                  * for use later.
 598                  */
 599                 status =
 600                     acpi_ns_lookup(walk_state->scope_info, buffer_ptr,
 601                                    object_type, ACPI_IMODE_EXECUTE,
 602                                    ACPI_NS_SEARCH_PARENT, walk_state, &(node));
 603                 break;
 604
 605         case AML_SCOPE_OP:
 606
 607                 /*
 608                  * The Path is an object reference to an existing object.
 609                  * Don't enter the name into the namespace, but look it up
 610                  * for use later.
 611                  */
 612                 status =
 613                     acpi_ns_lookup(walk_state->scope_info, buffer_ptr,
 614                                    object_type, ACPI_IMODE_EXECUTE,
 615                                    ACPI_NS_SEARCH_PARENT, walk_state, &(node));
 616                 if (ACPI_FAILURE(status)) {
 617 #ifdef ACPI_ASL_COMPILER
 618                         if (status == AE_NOT_FOUND) {
 619                                 status = AE_OK;
 620                         } else {
 621                                 ACPI_REPORT_NSERROR(buffer_ptr, status);
 622                         }
 623 #else
 624                         ACPI_REPORT_NSERROR(buffer_ptr, status);
 625 #endif
 626                         return_ACPI_STATUS(status);
 627                 }
 628                 /*
 629                  * We must check to make sure that the target is
 630                  * one of the opcodes that actually opens a scope
 631                  */
 632                 switch (node->type) {
 633                 case ACPI_TYPE_LOCAL_SCOPE:     /* Scope */
 634                 case ACPI_TYPE_DEVICE:
 635                 case ACPI_TYPE_POWER:
 636                 case ACPI_TYPE_PROCESSOR:
 637                 case ACPI_TYPE_THERMAL:
 638
 639                         /* These are acceptable types */
 640                         break;
 641
 642                 case ACPI_TYPE_INTEGER:
 643                 case ACPI_TYPE_STRING:
 644                 case ACPI_TYPE_BUFFER:
 645
 646                         /*
 647                          * These types we will allow, but we will change the type.  This
 648                          * enables some existing code of the form:
 649                          *
 650                          *  Name (DEB, 0)
 651                          *  Scope (DEB) { ... }
 652                          */
 653
 654                         ACPI_REPORT_WARNING(("Type override - [%4.4s] had invalid type (%s) for Scope operator, changed to (Scope)\n", buffer_ptr, acpi_ut_get_type_name(node->type)));
 655
 656                         node->type = ACPI_TYPE_ANY;
 657                         walk_state->scope_info->common.value = ACPI_TYPE_ANY;
 658                         break;
 659
 660                 default:
 661
 662                         /* All other types are an error */
 663
 664                         ACPI_REPORT_ERROR(("Invalid type (%s) for target of Scope operator [%4.4s]\n", acpi_ut_get_type_name(node->type), buffer_ptr));
 665
 666                         return (AE_AML_OPERAND_TYPE);
 667                 }
 668                 break;
 669
 670         default:
 671
 672                 /* All other opcodes */
 673
 674                 if (op && op->common.node) {
 675                         /* This op/node was previously entered into the namespace */
 676
 677                         node = op->common.node;
 678
 679                         if (acpi_ns_opens_scope(object_type)) {
 680                                 status =
 681                                     acpi_ds_scope_stack_push(node, object_type,
 682                                                              walk_state);
 683                                 if (ACPI_FAILURE(status)) {
 684                                         return_ACPI_STATUS(status);
 685                                 }
 686
 687                         }
 688                         return_ACPI_STATUS(AE_OK);
 689                 }
 690
 691                 /*
 692                  * Enter the named type into the internal namespace.  We enter the name
 693                  * as we go downward in the parse tree.  Any necessary subobjects that
 694                  * involve arguments to the opcode must be created as we go back up the
 695                  * parse tree later.
 696                  *
 697                  * Note: Name may already exist if we are executing a deferred opcode.
 698                  */
 699                 if (walk_state->deferred_node) {
 700                         /* This name is already in the namespace, get the node */
 701
 702                         node = walk_state->deferred_node;
 703                         status = AE_OK;
 704                         break;
 705                 }
 706
 707                 /* Add new entry into namespace */
 708
 709                 status =
 710                     acpi_ns_lookup(walk_state->scope_info, buffer_ptr,
 711                                    object_type, ACPI_IMODE_LOAD_PASS2,
 712                                    ACPI_NS_NO_UPSEARCH, walk_state, &(node));
 713                 break;
 714         }
 715
 716         if (ACPI_FAILURE(status)) {
 717                 ACPI_REPORT_NSERROR(buffer_ptr, status);
 718                 return_ACPI_STATUS(status);
 719         }
 720
 721         if (!op) {
 722                 /* Create a new op */
 723
 724                 op = acpi_ps_alloc_op(walk_state->opcode);
 725                 if (!op) {
 726                         return_ACPI_STATUS(AE_NO_MEMORY);
 727                 }
 728
 729                 /* Initialize the new op */
 730
 731                 if (node) {
 732                         op->named.name = node->name.integer;
 733                 }
 734                 *out_op = op;
 735         }
 736
 737         /*
 738          * Put the Node in the "op" object that the parser uses, so we
 739          * can get it again quickly when this scope is closed
 740          */
 741         op->common.node = node;
 742
 743         return_ACPI_STATUS(status);
 744 }
 745
 746 /*******************************************************************************
 747  *
 748  * FUNCTION:    acpi_ds_load2_end_op
 749  *
 750  * PARAMETERS:  walk_state      - Current state of the parse tree walk
 751  *
 752  * RETURN:      Status
 753  *
 754  * DESCRIPTION: Ascending callback used during the loading of the namespace,
 755  *              both control methods and everything else.
 756  *
 757  ******************************************************************************/
 758
 759 acpi_status acpi_ds_load2_end_op(struct acpi_walk_state *walk_state)
 760 {
 761         union acpi_parse_object *op;
 762         acpi_status status = AE_OK;
 763         acpi_object_type object_type;
 764         struct acpi_namespace_node *node;
 765         union acpi_parse_object *arg;
 766         struct acpi_namespace_node *new_node;
 767 #ifndef ACPI_NO_METHOD_EXECUTION
 768         u32 i;
 769 #endif
 770
 771         ACPI_FUNCTION_TRACE("ds_load2_end_op");
 772
 773         op = walk_state->op;
 774         ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH, "Opcode [%s] Op %p State %p\n",
 775                           walk_state->op_info->name, op, walk_state));
 776
 777         /* Check if opcode had an associated namespace object */
 778
 779         if (!(walk_state->op_info->flags & AML_NSOBJECT)) {
 780 #ifndef ACPI_NO_METHOD_EXECUTION
 781 #ifdef ACPI_ENABLE_MODULE_LEVEL_CODE
 782                 /* No namespace object. Executable opcode? */
 783
 784                 if ((walk_state->op_info->class == AML_CLASS_EXECUTE) ||
 785                     (walk_state->op_info->class == AML_CLASS_CONTROL)) {
 786                         ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
 787                                           "End/EXEC:   %s (fl %8.8X)\n",
 788                                           walk_state->op_info->name,
 789                                           walk_state->op_info->flags));
 790
 791                         /* Executing a type1 or type2 opcode outside of a method */
 792
 793                         status = acpi_ds_exec_end_op(walk_state);
 794                         return_ACPI_STATUS(status);
 795                 }
 796 #endif
 797 #endif
 798                 return_ACPI_STATUS(AE_OK);
 799         }
 800
 801         if (op->common.aml_opcode == AML_SCOPE_OP) {
 802                 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
 803                                   "Ending scope Op=%p State=%p\n", op,
 804                                   walk_state));
 805         }
 806
 807         object_type = walk_state->op_info->object_type;
 808
 809         /*
 810          * Get the Node/name from the earlier lookup
 811          * (It was saved in the *op structure)
 812          */
 813         node = op->common.node;
 814
 815         /*
 816          * Put the Node on the object stack (Contains the ACPI Name of
 817          * this object)
 818          */
 819         walk_state->operands[0] = (void *)node;
 820         walk_state->num_operands = 1;
 821
 822         /* Pop the scope stack */
 823
 824         if (acpi_ns_opens_scope(object_type) &&
 825             (op->common.aml_opcode != AML_INT_METHODCALL_OP)) {
 826                 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
 827                                   "(%s) Popping scope for Op %p\n",
 828                                   acpi_ut_get_type_name(object_type), op));
 829
 830                 status = acpi_ds_scope_stack_pop(walk_state);
 831                 if (ACPI_FAILURE(status)) {
 832                         goto cleanup;
 833                 }
 834         }
 835
 836         /*
 837          * Named operations are as follows:
 838          *
 839          * AML_ALIAS
 840          * AML_BANKFIELD
 841          * AML_CREATEBITFIELD
 842          * AML_CREATEBYTEFIELD
 843          * AML_CREATEDWORDFIELD
 844          * AML_CREATEFIELD
 845          * AML_CREATEQWORDFIELD
 846          * AML_CREATEWORDFIELD
 847          * AML_DATA_REGION
 848          * AML_DEVICE
 849          * AML_EVENT
 850          * AML_FIELD
 851          * AML_INDEXFIELD
 852          * AML_METHOD
 853          * AML_METHODCALL
 854          * AML_MUTEX
 855          * AML_NAME
 856          * AML_NAMEDFIELD
 857          * AML_OPREGION
 858          * AML_POWERRES
 859          * AML_PROCESSOR
 860          * AML_SCOPE
 861          * AML_THERMALZONE
 862          */
 863
 864         ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
 865                           "Create-Load [%s] State=%p Op=%p named_obj=%p\n",
 866                           acpi_ps_get_opcode_name(op->common.aml_opcode),
 867                           walk_state, op, node));
 868
 869         /* Decode the opcode */
 870
 871         arg = op->common.value.arg;
 872
 873         switch (walk_state->op_info->type) {
 874 #ifndef ACPI_NO_METHOD_EXECUTION
 875
 876         case AML_TYPE_CREATE_FIELD:
 877
 878                 /*
 879                  * Create the field object, but the field buffer and index must
 880                  * be evaluated later during the execution phase
 881                  */
 882                 status = acpi_ds_create_buffer_field(op, walk_state);
 883                 break;
 884
 885         case AML_TYPE_NAMED_FIELD:
 886
 887                 /*
 888                  * If we are executing a method, initialize the field
 889                  */
 890                 if (walk_state->method_node) {
 891                         status = acpi_ds_init_field_objects(op, walk_state);
 892                 }
 893
 894                 switch (op->common.aml_opcode) {
 895                 case AML_INDEX_FIELD_OP:
 896
 897                         status =
 898                             acpi_ds_create_index_field(op,
 899                                                        (acpi_handle) arg->
 900                                                        common.node, walk_state);
 901                         break;
 902
 903                 case AML_BANK_FIELD_OP:
 904
 905                         status =
 906                             acpi_ds_create_bank_field(op, arg->common.node,
 907                                                       walk_state);
 908                         break;
 909
 910                 case AML_FIELD_OP:
 911
 912                         status =
 913                             acpi_ds_create_field(op, arg->common.node,
 914                                                  walk_state);
 915                         break;
 916
 917                 default:
 918                         /* All NAMED_FIELD opcodes must be handled above */
 919                         break;
 920                 }
 921                 break;
 922
 923         case AML_TYPE_NAMED_SIMPLE:
 924
 925                 status = acpi_ds_create_operands(walk_state, arg);
 926                 if (ACPI_FAILURE(status)) {
 927                         goto cleanup;
 928                 }
 929
 930                 switch (op->common.aml_opcode) {
 931                 case AML_PROCESSOR_OP:
 932
 933                         status = acpi_ex_create_processor(walk_state);
 934                         break;
 935
 936                 case AML_POWER_RES_OP:
 937
 938                         status = acpi_ex_create_power_resource(walk_state);
 939                         break;
 940
 941                 case AML_MUTEX_OP:
 942
 943                         status = acpi_ex_create_mutex(walk_state);
 944                         break;
 945
 946                 case AML_EVENT_OP:
 947
 948                         status = acpi_ex_create_event(walk_state);
 949                         break;
 950
 951                 case AML_DATA_REGION_OP:
 952
 953                         status = acpi_ex_create_table_region(walk_state);
 954                         break;
 955
 956                 case AML_ALIAS_OP:
 957
 958                         status = acpi_ex_create_alias(walk_state);
 959                         break;
 960
 961                 default:
 962                         /* Unknown opcode */
 963
 964                         status = AE_OK;
 965                         goto cleanup;
 966                 }
 967
 968                 /* Delete operands */
 969
 970                 for (i = 1; i < walk_state->num_operands; i++) {
 971                         acpi_ut_remove_reference(walk_state->operands[i]);
 972                         walk_state->operands[i] = NULL;
 973                 }
 974
 975                 break;
 976 #endif                          /* ACPI_NO_METHOD_EXECUTION */
 977
 978         case AML_TYPE_NAMED_COMPLEX:
 979
 980                 switch (op->common.aml_opcode) {
 981 #ifndef ACPI_NO_METHOD_EXECUTION
 982                 case AML_REGION_OP:
 983
 984                         /*
 985                          * If we are executing a method, initialize the region
 986                          */
 987                         if (walk_state->method_node) {
 988                                 status =
 989                                     acpi_ex_create_region(op->named.data,
 990                                                           op->named.length,
 991                                                           (acpi_adr_space_type)
 992                                                           ((op->common.value.
 993                                                             arg)->common.value.
 994                                                            integer),
 995                                                           walk_state);
 996                                 if (ACPI_FAILURE(status)) {
 997                                         return (status);
 998                                 }
 999                         }
1000
1001                         /*
1002                          * The op_region is not fully parsed at this time. Only valid
1003                          * argument is the space_id. (We must save the address of the
1004                          * AML of the address and length operands)
1005                          */
1006                         /*
1007                          * If we have a valid region, initialize it
1008                          * Namespace is NOT locked at this point.
1009                          */
1010                         status =
1011                             acpi_ev_initialize_region
1012                             (acpi_ns_get_attached_object(node), FALSE);
1013                         if (ACPI_FAILURE(status)) {
1014                                 /*
1015                                  *  If AE_NOT_EXIST is returned, it is not fatal
1016                                  *  because many regions get created before a handler
1017                                  *  is installed for said region.
1018                                  */
1019                                 if (AE_NOT_EXIST == status) {
1020                                         status = AE_OK;
1021                                 }
1022                         }
1023                         break;
1024
1025                 case AML_NAME_OP:
1026
1027                         status = acpi_ds_create_node(walk_state, node, op);
1028                         break;
1029
1030                 case AML_METHOD_OP:
1031                         /*
1032                          * method_op pkg_length name_string method_flags term_list
1033                          *
1034                          * Note: We must create the method node/object pair as soon as we
1035                          * see the method declaration.  This allows later pass1 parsing
1036                          * of invocations of the method (need to know the number of
1037                          * arguments.)
1038                          */
1039                         ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
1040                                           "LOADING-Method: State=%p Op=%p named_obj=%p\n",
1041                                           walk_state, op, op->named.node));
1042
1043                         if (!acpi_ns_get_attached_object(op->named.node)) {
1044                                 walk_state->operands[0] =
1045                                     ACPI_CAST_PTR(void, op->named.node);
1046                                 walk_state->num_operands = 1;
1047
1048                                 status =
1049                                     acpi_ds_create_operands(walk_state,
1050                                                             op->common.value.
1051                                                             arg);
1052                                 if (ACPI_SUCCESS(status)) {
1053                                         status =
1054                                             acpi_ex_create_method(op->named.
1055                                                                   data,
1056                                                                   op->named.
1057                                                                   length,
1058                                                                   walk_state);
1059                                 }
1060                                 walk_state->operands[0] = NULL;
1061                                 walk_state->num_operands = 0;
1062
1063                                 if (ACPI_FAILURE(status)) {
1064                                         return_ACPI_STATUS(status);
1065                                 }
1066                         }
1067                         break;
1068
1069 #endif                          /* ACPI_NO_METHOD_EXECUTION */
1070
1071                 default:
1072                         /* All NAMED_COMPLEX opcodes must be handled above */
1073                         break;
1074                 }
1075                 break;
1076
1077         case AML_CLASS_INTERNAL:
1078
1079                 /* case AML_INT_NAMEPATH_OP: */
1080                 break;
1081
1082         case AML_CLASS_METHOD_CALL:
1083
1084                 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
1085                                   "RESOLVING-method_call: State=%p Op=%p named_obj=%p\n",
1086                                   walk_state, op, node));
1087
1088                 /*
1089                  * Lookup the method name and save the Node
1090                  */
1091                 status =
1092                     acpi_ns_lookup(walk_state->scope_info,
1093                                    arg->common.value.string, ACPI_TYPE_ANY,
1094                                    ACPI_IMODE_LOAD_PASS2,
1095                                    ACPI_NS_SEARCH_PARENT |
1096                                    ACPI_NS_DONT_OPEN_SCOPE, walk_state,
1097                                    &(new_node));
1098                 if (ACPI_SUCCESS(status)) {
1099
1100                         /*
1101                          * Make sure that what we found is indeed a method
1102                          * We didn't search for a method on purpose, to see if the name
1103                          * would resolve
1104                          */
1105                         if (new_node->type != ACPI_TYPE_METHOD) {
1106                                 status = AE_AML_OPERAND_TYPE;
1107                         }
1108
1109                         /* We could put the returned object (Node) on the object stack for
1110                          * later, but for now, we will put it in the "op" object that the
1111                          * parser uses, so we can get it again at the end of this scope
1112                          */
1113                         op->common.node = new_node;
1114                 } else {
1115                         ACPI_REPORT_NSERROR(arg->common.value.string, status);
1116                 }
1117                 break;
1118
1119         default:
1120                 break;
1121         }
1122
1123       cleanup:
1124
1125         /* Remove the Node pushed at the very beginning */
1126
1127         walk_state->operands[0] = NULL;
1128         walk_state->num_operands = 0;
1129         return_ACPI_STATUS(status);
1130 }