git.oblomov.eu Git - linux-2.6/blob - drivers/acpi/dispatcher/dswload.c

   1 /******************************************************************************
   2  *
   3  * Module Name: dswload - Dispatcher namespace load callbacks
   4  *
   5  *****************************************************************************/
   6
   7 /*
   8  * Copyright (C) 2000 - 2006, 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_ERROR_NAMESPACE(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_ERROR((AE_INFO,
 237                                     "Invalid type (%s) for target of Scope operator [%4.4s] (Cannot override)",
 238                                     acpi_ut_get_type_name(node->type), path));
 239
 240                         return_ACPI_STATUS(AE_AML_OPERAND_TYPE);
 241                 }
 242                 break;
 243
 244         default:
 245
 246                 /*
 247                  * For all other named opcodes, we will enter the name into
 248                  * the namespace.
 249                  *
 250                  * Setup the search flags.
 251                  * Since we are entering a name into the namespace, we do not want to
 252                  * enable the search-to-root upsearch.
 253                  *
 254                  * There are only two conditions where it is acceptable that the name
 255                  * already exists:
 256                  *    1) the Scope() operator can reopen a scoping object that was
 257                  *       previously defined (Scope, Method, Device, etc.)
 258                  *    2) Whenever we are parsing a deferred opcode (op_region, Buffer,
 259                  *       buffer_field, or Package), the name of the object is already
 260                  *       in the namespace.
 261                  */
 262
 263                 if (walk_state->deferred_node) {
 264                         /* This name is already in the namespace, get the node */
 265
 266                         node = walk_state->deferred_node;
 267                         status = AE_OK;
 268                         break;
 269                 }
 270
 271                 /*
 272                  * If we are executing a method, do not create any namespace objects
 273                  * during the load phase, only during execution.
 274                  */
 275                 if (walk_state->method_node) {
 276                         node = NULL;
 277                         status = AE_OK;
 278                         break;
 279                 }
 280
 281                 flags = ACPI_NS_NO_UPSEARCH;
 282                 if ((walk_state->opcode != AML_SCOPE_OP) &&
 283                     (!(walk_state->parse_flags & ACPI_PARSE_DEFERRED_OP))) {
 284                         flags |= ACPI_NS_ERROR_IF_FOUND;
 285                         ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
 286                                           "[%s] Cannot already exist\n",
 287                                           acpi_ut_get_type_name(object_type)));
 288                 } else {
 289                         ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
 290                                           "[%s] Both Find or Create allowed\n",
 291                                           acpi_ut_get_type_name(object_type)));
 292                 }
 293
 294                 /*
 295                  * Enter the named type into the internal namespace.  We enter the name
 296                  * as we go downward in the parse tree.  Any necessary subobjects that
 297                  * involve arguments to the opcode must be created as we go back up the
 298                  * parse tree later.
 299                  */
 300                 status =
 301                     acpi_ns_lookup(walk_state->scope_info, path, object_type,
 302                                    ACPI_IMODE_LOAD_PASS1, flags, walk_state,
 303                                    &(node));
 304                 if (ACPI_FAILURE(status)) {
 305                         ACPI_ERROR_NAMESPACE(path, status);
 306                         return_ACPI_STATUS(status);
 307                 }
 308                 break;
 309         }
 310
 311         /* Common exit */
 312
 313         if (!op) {
 314                 /* Create a new op */
 315
 316                 op = acpi_ps_alloc_op(walk_state->opcode);
 317                 if (!op) {
 318                         return_ACPI_STATUS(AE_NO_MEMORY);
 319                 }
 320         }
 321
 322         /* Initialize the op */
 323
 324 #if (defined (ACPI_NO_METHOD_EXECUTION) || defined (ACPI_CONSTANT_EVAL_ONLY))
 325         op->named.path = ACPI_CAST_PTR(u8, path);
 326 #endif
 327
 328         if (node) {
 329                 /*
 330                  * Put the Node in the "op" object that the parser uses, so we
 331                  * can get it again quickly when this scope is closed
 332                  */
 333                 op->common.node = node;
 334                 op->named.name = node->name.integer;
 335         }
 336
 337         acpi_ps_append_arg(acpi_ps_get_parent_scope(&walk_state->parser_state),
 338                            op);
 339         *out_op = op;
 340         return_ACPI_STATUS(status);
 341 }
 342
 343 /*******************************************************************************
 344  *
 345  * FUNCTION:    acpi_ds_load1_end_op
 346  *
 347  * PARAMETERS:  walk_state      - Current state of the parse tree walk
 348  *
 349  * RETURN:      Status
 350  *
 351  * DESCRIPTION: Ascending callback used during the loading of the namespace,
 352  *              both control methods and everything else.
 353  *
 354  ******************************************************************************/
 355
 356 acpi_status acpi_ds_load1_end_op(struct acpi_walk_state *walk_state)
 357 {
 358         union acpi_parse_object *op;
 359         acpi_object_type object_type;
 360         acpi_status status = AE_OK;
 361
 362         ACPI_FUNCTION_TRACE("ds_load1_end_op");
 363
 364         op = walk_state->op;
 365         ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH, "Op=%p State=%p\n", op,
 366                           walk_state));
 367
 368         /* We are only interested in opcodes that have an associated name */
 369
 370         if (!(walk_state->op_info->flags & (AML_NAMED | AML_FIELD))) {
 371                 return_ACPI_STATUS(AE_OK);
 372         }
 373
 374         /* Get the object type to determine if we should pop the scope */
 375
 376         object_type = walk_state->op_info->object_type;
 377
 378 #ifndef ACPI_NO_METHOD_EXECUTION
 379         if (walk_state->op_info->flags & AML_FIELD) {
 380                 /*
 381                  * If we are executing a method, do not create any namespace objects
 382                  * during the load phase, only during execution.
 383                  */
 384                 if (!walk_state->method_node) {
 385                         if (walk_state->opcode == AML_FIELD_OP ||
 386                             walk_state->opcode == AML_BANK_FIELD_OP ||
 387                             walk_state->opcode == AML_INDEX_FIELD_OP) {
 388                                 status =
 389                                     acpi_ds_init_field_objects(op, walk_state);
 390                         }
 391                 }
 392                 return_ACPI_STATUS(status);
 393         }
 394
 395         /*
 396          * If we are executing a method, do not create any namespace objects
 397          * during the load phase, only during execution.
 398          */
 399         if (!walk_state->method_node) {
 400                 if (op->common.aml_opcode == AML_REGION_OP) {
 401                         status =
 402                             acpi_ex_create_region(op->named.data,
 403                                                   op->named.length,
 404                                                   (acpi_adr_space_type)
 405                                                   ((op->common.value.arg)->
 406                                                    common.value.integer),
 407                                                   walk_state);
 408                         if (ACPI_FAILURE(status)) {
 409                                 return_ACPI_STATUS(status);
 410                         }
 411                 }
 412         }
 413 #endif
 414
 415         if (op->common.aml_opcode == AML_NAME_OP) {
 416                 /* For Name opcode, get the object type from the argument */
 417
 418                 if (op->common.value.arg) {
 419                         object_type = (acpi_ps_get_opcode_info((op->common.
 420                                                                 value.arg)->
 421                                                                common.
 422                                                                aml_opcode))->
 423                             object_type;
 424
 425                         /* Set node type if we have a namespace node */
 426
 427                         if (op->common.node) {
 428                                 op->common.node->type = (u8) object_type;
 429                         }
 430                 }
 431         }
 432
 433         /*
 434          * If we are executing a method, do not create any namespace objects
 435          * during the load phase, only during execution.
 436          */
 437         if (!walk_state->method_node) {
 438                 if (op->common.aml_opcode == AML_METHOD_OP) {
 439                         /*
 440                          * method_op pkg_length name_string method_flags term_list
 441                          *
 442                          * Note: We must create the method node/object pair as soon as we
 443                          * see the method declaration.  This allows later pass1 parsing
 444                          * of invocations of the method (need to know the number of
 445                          * arguments.)
 446                          */
 447                         ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
 448                                           "LOADING-Method: State=%p Op=%p named_obj=%p\n",
 449                                           walk_state, op, op->named.node));
 450
 451                         if (!acpi_ns_get_attached_object(op->named.node)) {
 452                                 walk_state->operands[0] =
 453                                     ACPI_CAST_PTR(void, op->named.node);
 454                                 walk_state->num_operands = 1;
 455
 456                                 status =
 457                                     acpi_ds_create_operands(walk_state,
 458                                                             op->common.value.
 459                                                             arg);
 460                                 if (ACPI_SUCCESS(status)) {
 461                                         status =
 462                                             acpi_ex_create_method(op->named.
 463                                                                   data,
 464                                                                   op->named.
 465                                                                   length,
 466                                                                   walk_state);
 467                                 }
 468                                 walk_state->operands[0] = NULL;
 469                                 walk_state->num_operands = 0;
 470
 471                                 if (ACPI_FAILURE(status)) {
 472                                         return_ACPI_STATUS(status);
 473                                 }
 474                         }
 475                 }
 476         }
 477
 478         /* Pop the scope stack (only if loading a table) */
 479
 480         if (!walk_state->method_node && acpi_ns_opens_scope(object_type)) {
 481                 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
 482                                   "(%s): Popping scope for Op %p\n",
 483                                   acpi_ut_get_type_name(object_type), op));
 484
 485                 status = acpi_ds_scope_stack_pop(walk_state);
 486         }
 487
 488         return_ACPI_STATUS(status);
 489 }
 490
 491 /*******************************************************************************
 492  *
 493  * FUNCTION:    acpi_ds_load2_begin_op
 494  *
 495  * PARAMETERS:  walk_state      - Current state of the parse tree walk
 496  *              out_op          - Wher to return op if a new one is created
 497  *
 498  * RETURN:      Status
 499  *
 500  * DESCRIPTION: Descending callback used during the loading of ACPI tables.
 501  *
 502  ******************************************************************************/
 503
 504 acpi_status
 505 acpi_ds_load2_begin_op(struct acpi_walk_state *walk_state,
 506                        union acpi_parse_object **out_op)
 507 {
 508         union acpi_parse_object *op;
 509         struct acpi_namespace_node *node;
 510         acpi_status status;
 511         acpi_object_type object_type;
 512         char *buffer_ptr;
 513
 514         ACPI_FUNCTION_TRACE("ds_load2_begin_op");
 515
 516         op = walk_state->op;
 517         ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH, "Op=%p State=%p\n", op,
 518                           walk_state));
 519
 520         if (op) {
 521                 if ((walk_state->control_state) &&
 522                     (walk_state->control_state->common.state ==
 523                      ACPI_CONTROL_CONDITIONAL_EXECUTING)) {
 524                         /* We are executing a while loop outside of a method */
 525
 526                         status = acpi_ds_exec_begin_op(walk_state, out_op);
 527                         return_ACPI_STATUS(status);
 528                 }
 529
 530                 /* We only care about Namespace opcodes here */
 531
 532                 if ((!(walk_state->op_info->flags & AML_NSOPCODE) &&
 533                      (walk_state->opcode != AML_INT_NAMEPATH_OP)) ||
 534                     (!(walk_state->op_info->flags & AML_NAMED))) {
 535 #ifdef ACPI_ENABLE_MODULE_LEVEL_CODE
 536                         if ((walk_state->op_info->class == AML_CLASS_EXECUTE) ||
 537                             (walk_state->op_info->class == AML_CLASS_CONTROL)) {
 538
 539                                 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
 540                                                   "Begin/EXEC: %s (fl %8.8X)\n",
 541                                                   walk_state->op_info->name,
 542                                                   walk_state->op_info->flags));
 543
 544                                 /* Executing a type1 or type2 opcode outside of a method */
 545
 546                                 status =
 547                                     acpi_ds_exec_begin_op(walk_state, out_op);
 548                                 return_ACPI_STATUS(status);
 549                         }
 550 #endif
 551                         return_ACPI_STATUS(AE_OK);
 552                 }
 553
 554                 /* Get the name we are going to enter or lookup in the namespace */
 555
 556                 if (walk_state->opcode == AML_INT_NAMEPATH_OP) {
 557                         /* For Namepath op, get the path string */
 558
 559                         buffer_ptr = op->common.value.string;
 560                         if (!buffer_ptr) {
 561                                 /* No name, just exit */
 562
 563                                 return_ACPI_STATUS(AE_OK);
 564                         }
 565                 } else {
 566                         /* Get name from the op */
 567
 568                         buffer_ptr = (char *)&op->named.name;
 569                 }
 570         } else {
 571                 /* Get the namestring from the raw AML */
 572
 573                 buffer_ptr =
 574                     acpi_ps_get_next_namestring(&walk_state->parser_state);
 575         }
 576
 577         /* Map the opcode into an internal object type */
 578
 579         object_type = walk_state->op_info->object_type;
 580
 581         ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
 582                           "State=%p Op=%p Type=%X\n", walk_state, op,
 583                           object_type));
 584
 585         switch (walk_state->opcode) {
 586         case AML_FIELD_OP:
 587         case AML_BANK_FIELD_OP:
 588         case AML_INDEX_FIELD_OP:
 589
 590                 node = NULL;
 591                 status = AE_OK;
 592                 break;
 593
 594         case AML_INT_NAMEPATH_OP:
 595
 596                 /*
 597                  * The name_path is an object reference to an existing object.
 598                  * Don't enter the name into the namespace, but look it up
 599                  * for use later.
 600                  */
 601                 status =
 602                     acpi_ns_lookup(walk_state->scope_info, buffer_ptr,
 603                                    object_type, ACPI_IMODE_EXECUTE,
 604                                    ACPI_NS_SEARCH_PARENT, walk_state, &(node));
 605                 break;
 606
 607         case AML_SCOPE_OP:
 608
 609                 /*
 610                  * The Path is an object reference to an existing object.
 611                  * Don't enter the name into the namespace, but look it up
 612                  * for use later.
 613                  */
 614                 status =
 615                     acpi_ns_lookup(walk_state->scope_info, buffer_ptr,
 616                                    object_type, ACPI_IMODE_EXECUTE,
 617                                    ACPI_NS_SEARCH_PARENT, walk_state, &(node));
 618                 if (ACPI_FAILURE(status)) {
 619 #ifdef ACPI_ASL_COMPILER
 620                         if (status == AE_NOT_FOUND) {
 621                                 status = AE_OK;
 622                         } else {
 623                                 ACPI_ERROR_NAMESPACE(buffer_ptr, status);
 624                         }
 625 #else
 626                         ACPI_ERROR_NAMESPACE(buffer_ptr, status);
 627 #endif
 628                         return_ACPI_STATUS(status);
 629                 }
 630                 /*
 631                  * We must check to make sure that the target is
 632                  * one of the opcodes that actually opens a scope
 633                  */
 634                 switch (node->type) {
 635                 case ACPI_TYPE_LOCAL_SCOPE:     /* Scope */
 636                 case ACPI_TYPE_DEVICE:
 637                 case ACPI_TYPE_POWER:
 638                 case ACPI_TYPE_PROCESSOR:
 639                 case ACPI_TYPE_THERMAL:
 640
 641                         /* These are acceptable types */
 642                         break;
 643
 644                 case ACPI_TYPE_INTEGER:
 645                 case ACPI_TYPE_STRING:
 646                 case ACPI_TYPE_BUFFER:
 647
 648                         /*
 649                          * These types we will allow, but we will change the type.  This
 650                          * enables some existing code of the form:
 651                          *
 652                          *  Name (DEB, 0)
 653                          *  Scope (DEB) { ... }
 654                          */
 655
 656                         ACPI_WARNING((AE_INFO,
 657                                       "Type override - [%4.4s] had invalid type (%s) for Scope operator, changed to (Scope)",
 658                                       buffer_ptr,
 659                                       acpi_ut_get_type_name(node->type)));
 660
 661                         node->type = ACPI_TYPE_ANY;
 662                         walk_state->scope_info->common.value = ACPI_TYPE_ANY;
 663                         break;
 664
 665                 default:
 666
 667                         /* All other types are an error */
 668
 669                         ACPI_ERROR((AE_INFO,
 670                                     "Invalid type (%s) for target of Scope operator [%4.4s]",
 671                                     acpi_ut_get_type_name(node->type),
 672                                     buffer_ptr));
 673
 674                         return (AE_AML_OPERAND_TYPE);
 675                 }
 676                 break;
 677
 678         default:
 679
 680                 /* All other opcodes */
 681
 682                 if (op && op->common.node) {
 683                         /* This op/node was previously entered into the namespace */
 684
 685                         node = op->common.node;
 686
 687                         if (acpi_ns_opens_scope(object_type)) {
 688                                 status =
 689                                     acpi_ds_scope_stack_push(node, object_type,
 690                                                              walk_state);
 691                                 if (ACPI_FAILURE(status)) {
 692                                         return_ACPI_STATUS(status);
 693                                 }
 694
 695                         }
 696                         return_ACPI_STATUS(AE_OK);
 697                 }
 698
 699                 /*
 700                  * Enter the named type into the internal namespace.  We enter the name
 701                  * as we go downward in the parse tree.  Any necessary subobjects that
 702                  * involve arguments to the opcode must be created as we go back up the
 703                  * parse tree later.
 704                  *
 705                  * Note: Name may already exist if we are executing a deferred opcode.
 706                  */
 707                 if (walk_state->deferred_node) {
 708                         /* This name is already in the namespace, get the node */
 709
 710                         node = walk_state->deferred_node;
 711                         status = AE_OK;
 712                         break;
 713                 }
 714
 715                 /* Add new entry into namespace */
 716
 717                 status =
 718                     acpi_ns_lookup(walk_state->scope_info, buffer_ptr,
 719                                    object_type, ACPI_IMODE_LOAD_PASS2,
 720                                    ACPI_NS_NO_UPSEARCH, walk_state, &(node));
 721                 break;
 722         }
 723
 724         if (ACPI_FAILURE(status)) {
 725                 ACPI_ERROR_NAMESPACE(buffer_ptr, status);
 726                 return_ACPI_STATUS(status);
 727         }
 728
 729         if (!op) {
 730                 /* Create a new op */
 731
 732                 op = acpi_ps_alloc_op(walk_state->opcode);
 733                 if (!op) {
 734                         return_ACPI_STATUS(AE_NO_MEMORY);
 735                 }
 736
 737                 /* Initialize the new op */
 738
 739                 if (node) {
 740                         op->named.name = node->name.integer;
 741                 }
 742                 *out_op = op;
 743         }
 744
 745         /*
 746          * Put the Node in the "op" object that the parser uses, so we
 747          * can get it again quickly when this scope is closed
 748          */
 749         op->common.node = node;
 750
 751         return_ACPI_STATUS(status);
 752 }
 753
 754 /*******************************************************************************
 755  *
 756  * FUNCTION:    acpi_ds_load2_end_op
 757  *
 758  * PARAMETERS:  walk_state      - Current state of the parse tree walk
 759  *
 760  * RETURN:      Status
 761  *
 762  * DESCRIPTION: Ascending callback used during the loading of the namespace,
 763  *              both control methods and everything else.
 764  *
 765  ******************************************************************************/
 766
 767 acpi_status acpi_ds_load2_end_op(struct acpi_walk_state *walk_state)
 768 {
 769         union acpi_parse_object *op;
 770         acpi_status status = AE_OK;
 771         acpi_object_type object_type;
 772         struct acpi_namespace_node *node;
 773         union acpi_parse_object *arg;
 774         struct acpi_namespace_node *new_node;
 775 #ifndef ACPI_NO_METHOD_EXECUTION
 776         u32 i;
 777 #endif
 778
 779         ACPI_FUNCTION_TRACE("ds_load2_end_op");
 780
 781         op = walk_state->op;
 782         ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH, "Opcode [%s] Op %p State %p\n",
 783                           walk_state->op_info->name, op, walk_state));
 784
 785         /* Check if opcode had an associated namespace object */
 786
 787         if (!(walk_state->op_info->flags & AML_NSOBJECT)) {
 788 #ifndef ACPI_NO_METHOD_EXECUTION
 789 #ifdef ACPI_ENABLE_MODULE_LEVEL_CODE
 790                 /* No namespace object. Executable opcode? */
 791
 792                 if ((walk_state->op_info->class == AML_CLASS_EXECUTE) ||
 793                     (walk_state->op_info->class == AML_CLASS_CONTROL)) {
 794                         ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
 795                                           "End/EXEC:   %s (fl %8.8X)\n",
 796                                           walk_state->op_info->name,
 797                                           walk_state->op_info->flags));
 798
 799                         /* Executing a type1 or type2 opcode outside of a method */
 800
 801                         status = acpi_ds_exec_end_op(walk_state);
 802                         return_ACPI_STATUS(status);
 803                 }
 804 #endif
 805 #endif
 806                 return_ACPI_STATUS(AE_OK);
 807         }
 808
 809         if (op->common.aml_opcode == AML_SCOPE_OP) {
 810                 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
 811                                   "Ending scope Op=%p State=%p\n", op,
 812                                   walk_state));
 813         }
 814
 815         object_type = walk_state->op_info->object_type;
 816
 817         /*
 818          * Get the Node/name from the earlier lookup
 819          * (It was saved in the *op structure)
 820          */
 821         node = op->common.node;
 822
 823         /*
 824          * Put the Node on the object stack (Contains the ACPI Name of
 825          * this object)
 826          */
 827         walk_state->operands[0] = (void *)node;
 828         walk_state->num_operands = 1;
 829
 830         /* Pop the scope stack */
 831
 832         if (acpi_ns_opens_scope(object_type) &&
 833             (op->common.aml_opcode != AML_INT_METHODCALL_OP)) {
 834                 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
 835                                   "(%s) Popping scope for Op %p\n",
 836                                   acpi_ut_get_type_name(object_type), op));
 837
 838                 status = acpi_ds_scope_stack_pop(walk_state);
 839                 if (ACPI_FAILURE(status)) {
 840                         goto cleanup;
 841                 }
 842         }
 843
 844         /*
 845          * Named operations are as follows:
 846          *
 847          * AML_ALIAS
 848          * AML_BANKFIELD
 849          * AML_CREATEBITFIELD
 850          * AML_CREATEBYTEFIELD
 851          * AML_CREATEDWORDFIELD
 852          * AML_CREATEFIELD
 853          * AML_CREATEQWORDFIELD
 854          * AML_CREATEWORDFIELD
 855          * AML_DATA_REGION
 856          * AML_DEVICE
 857          * AML_EVENT
 858          * AML_FIELD
 859          * AML_INDEXFIELD
 860          * AML_METHOD
 861          * AML_METHODCALL
 862          * AML_MUTEX
 863          * AML_NAME
 864          * AML_NAMEDFIELD
 865          * AML_OPREGION
 866          * AML_POWERRES
 867          * AML_PROCESSOR
 868          * AML_SCOPE
 869          * AML_THERMALZONE
 870          */
 871
 872         ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
 873                           "Create-Load [%s] State=%p Op=%p named_obj=%p\n",
 874                           acpi_ps_get_opcode_name(op->common.aml_opcode),
 875                           walk_state, op, node));
 876
 877         /* Decode the opcode */
 878
 879         arg = op->common.value.arg;
 880
 881         switch (walk_state->op_info->type) {
 882 #ifndef ACPI_NO_METHOD_EXECUTION
 883
 884         case AML_TYPE_CREATE_FIELD:
 885
 886                 /*
 887                  * Create the field object, but the field buffer and index must
 888                  * be evaluated later during the execution phase
 889                  */
 890                 status = acpi_ds_create_buffer_field(op, walk_state);
 891                 break;
 892
 893         case AML_TYPE_NAMED_FIELD:
 894
 895                 /*
 896                  * If we are executing a method, initialize the field
 897                  */
 898                 if (walk_state->method_node) {
 899                         status = acpi_ds_init_field_objects(op, walk_state);
 900                 }
 901
 902                 switch (op->common.aml_opcode) {
 903                 case AML_INDEX_FIELD_OP:
 904
 905                         status =
 906                             acpi_ds_create_index_field(op,
 907                                                        (acpi_handle) arg->
 908                                                        common.node, walk_state);
 909                         break;
 910
 911                 case AML_BANK_FIELD_OP:
 912
 913                         status =
 914                             acpi_ds_create_bank_field(op, arg->common.node,
 915                                                       walk_state);
 916                         break;
 917
 918                 case AML_FIELD_OP:
 919
 920                         status =
 921                             acpi_ds_create_field(op, arg->common.node,
 922                                                  walk_state);
 923                         break;
 924
 925                 default:
 926                         /* All NAMED_FIELD opcodes must be handled above */
 927                         break;
 928                 }
 929                 break;
 930
 931         case AML_TYPE_NAMED_SIMPLE:
 932
 933                 status = acpi_ds_create_operands(walk_state, arg);
 934                 if (ACPI_FAILURE(status)) {
 935                         goto cleanup;
 936                 }
 937
 938                 switch (op->common.aml_opcode) {
 939                 case AML_PROCESSOR_OP:
 940
 941                         status = acpi_ex_create_processor(walk_state);
 942                         break;
 943
 944                 case AML_POWER_RES_OP:
 945
 946                         status = acpi_ex_create_power_resource(walk_state);
 947                         break;
 948
 949                 case AML_MUTEX_OP:
 950
 951                         status = acpi_ex_create_mutex(walk_state);
 952                         break;
 953
 954                 case AML_EVENT_OP:
 955
 956                         status = acpi_ex_create_event(walk_state);
 957                         break;
 958
 959                 case AML_DATA_REGION_OP:
 960
 961                         status = acpi_ex_create_table_region(walk_state);
 962                         break;
 963
 964                 case AML_ALIAS_OP:
 965
 966                         status = acpi_ex_create_alias(walk_state);
 967                         break;
 968
 969                 default:
 970                         /* Unknown opcode */
 971
 972                         status = AE_OK;
 973                         goto cleanup;
 974                 }
 975
 976                 /* Delete operands */
 977
 978                 for (i = 1; i < walk_state->num_operands; i++) {
 979                         acpi_ut_remove_reference(walk_state->operands[i]);
 980                         walk_state->operands[i] = NULL;
 981                 }
 982
 983                 break;
 984 #endif                          /* ACPI_NO_METHOD_EXECUTION */
 985
 986         case AML_TYPE_NAMED_COMPLEX:
 987
 988                 switch (op->common.aml_opcode) {
 989 #ifndef ACPI_NO_METHOD_EXECUTION
 990                 case AML_REGION_OP:
 991
 992                         /*
 993                          * If we are executing a method, initialize the region
 994                          */
 995                         if (walk_state->method_node) {
 996                                 status =
 997                                     acpi_ex_create_region(op->named.data,
 998                                                           op->named.length,
 999                                                           (acpi_adr_space_type)
1000                                                           ((op->common.value.
1001                                                             arg)->common.value.
1002                                                            integer),
1003                                                           walk_state);
1004                                 if (ACPI_FAILURE(status)) {
1005                                         return (status);
1006                                 }
1007                         }
1008
1009                         /*
1010                          * The op_region is not fully parsed at this time. Only valid
1011                          * argument is the space_id. (We must save the address of the
1012                          * AML of the address and length operands)
1013                          */
1014                         /*
1015                          * If we have a valid region, initialize it
1016                          * Namespace is NOT locked at this point.
1017                          */
1018                         status =
1019                             acpi_ev_initialize_region
1020                             (acpi_ns_get_attached_object(node), FALSE);
1021                         if (ACPI_FAILURE(status)) {
1022                                 /*
1023                                  *  If AE_NOT_EXIST is returned, it is not fatal
1024                                  *  because many regions get created before a handler
1025                                  *  is installed for said region.
1026                                  */
1027                                 if (AE_NOT_EXIST == status) {
1028                                         status = AE_OK;
1029                                 }
1030                         }
1031                         break;
1032
1033                 case AML_NAME_OP:
1034
1035                         status = acpi_ds_create_node(walk_state, node, op);
1036                         break;
1037
1038                 case AML_METHOD_OP:
1039                         /*
1040                          * method_op pkg_length name_string method_flags term_list
1041                          *
1042                          * Note: We must create the method node/object pair as soon as we
1043                          * see the method declaration.  This allows later pass1 parsing
1044                          * of invocations of the method (need to know the number of
1045                          * arguments.)
1046                          */
1047                         ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
1048                                           "LOADING-Method: State=%p Op=%p named_obj=%p\n",
1049                                           walk_state, op, op->named.node));
1050
1051                         if (!acpi_ns_get_attached_object(op->named.node)) {
1052                                 walk_state->operands[0] =
1053                                     ACPI_CAST_PTR(void, op->named.node);
1054                                 walk_state->num_operands = 1;
1055
1056                                 status =
1057                                     acpi_ds_create_operands(walk_state,
1058                                                             op->common.value.
1059                                                             arg);
1060                                 if (ACPI_SUCCESS(status)) {
1061                                         status =
1062                                             acpi_ex_create_method(op->named.
1063                                                                   data,
1064                                                                   op->named.
1065                                                                   length,
1066                                                                   walk_state);
1067                                 }
1068                                 walk_state->operands[0] = NULL;
1069                                 walk_state->num_operands = 0;
1070
1071                                 if (ACPI_FAILURE(status)) {
1072                                         return_ACPI_STATUS(status);
1073                                 }
1074                         }
1075                         break;
1076
1077 #endif                          /* ACPI_NO_METHOD_EXECUTION */
1078
1079                 default:
1080                         /* All NAMED_COMPLEX opcodes must be handled above */
1081                         break;
1082                 }
1083                 break;
1084
1085         case AML_CLASS_INTERNAL:
1086
1087                 /* case AML_INT_NAMEPATH_OP: */
1088                 break;
1089
1090         case AML_CLASS_METHOD_CALL:
1091
1092                 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
1093                                   "RESOLVING-method_call: State=%p Op=%p named_obj=%p\n",
1094                                   walk_state, op, node));
1095
1096                 /*
1097                  * Lookup the method name and save the Node
1098                  */
1099                 status =
1100                     acpi_ns_lookup(walk_state->scope_info,
1101                                    arg->common.value.string, ACPI_TYPE_ANY,
1102                                    ACPI_IMODE_LOAD_PASS2,
1103                                    ACPI_NS_SEARCH_PARENT |
1104                                    ACPI_NS_DONT_OPEN_SCOPE, walk_state,
1105                                    &(new_node));
1106                 if (ACPI_SUCCESS(status)) {
1107
1108                         /*
1109                          * Make sure that what we found is indeed a method
1110                          * We didn't search for a method on purpose, to see if the name
1111                          * would resolve
1112                          */
1113                         if (new_node->type != ACPI_TYPE_METHOD) {
1114                                 status = AE_AML_OPERAND_TYPE;
1115                         }
1116
1117                         /* We could put the returned object (Node) on the object stack for
1118                          * later, but for now, we will put it in the "op" object that the
1119                          * parser uses, so we can get it again at the end of this scope
1120                          */
1121                         op->common.node = new_node;
1122                 } else {
1123                         ACPI_ERROR_NAMESPACE(arg->common.value.string, status);
1124                 }
1125                 break;
1126
1127         default:
1128                 break;
1129         }
1130
1131       cleanup:
1132
1133         /* Remove the Node pushed at the very beginning */
1134
1135         walk_state->operands[0] = NULL;
1136         walk_state->num_operands = 0;
1137         return_ACPI_STATUS(status);
1138 }