SAFE public projects git trees. - safe/jmp/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 - 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         if (op->common.aml_opcode == AML_METHOD_OP) {
 432                 /*
 433                  * method_op pkg_length name_string method_flags term_list
 434                  *
 435                  * Note: We must create the method node/object pair as soon as we
 436                  * see the method declaration.  This allows later pass1 parsing
 437                  * of invocations of the method (need to know the number of
 438                  * arguments.)
 439                  */
 440                 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
 441                                   "LOADING-Method: State=%p Op=%p named_obj=%p\n",
 442                                   walk_state, op, op->named.node));
 443
 444                 if (!acpi_ns_get_attached_object(op->named.node)) {
 445                         walk_state->operands[0] = (void *)op->named.node;
 446                         walk_state->num_operands = 1;
 447
 448                         status =
 449                             acpi_ds_create_operands(walk_state,
 450                                                     op->common.value.arg);
 451                         if (ACPI_SUCCESS(status)) {
 452                                 status = acpi_ex_create_method(op->named.data,
 453                                                                op->named.length,
 454                                                                walk_state);
 455                         }
 456                         walk_state->operands[0] = NULL;
 457                         walk_state->num_operands = 0;
 458
 459                         if (ACPI_FAILURE(status)) {
 460                                 return_ACPI_STATUS(status);
 461                         }
 462                 }
 463         }
 464
 465         /* Pop the scope stack */
 466
 467         if (acpi_ns_opens_scope(object_type)) {
 468                 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
 469                                   "(%s): Popping scope for Op %p\n",
 470                                   acpi_ut_get_type_name(object_type), op));
 471
 472                 status = acpi_ds_scope_stack_pop(walk_state);
 473         }
 474
 475         return_ACPI_STATUS(status);
 476 }
 477
 478 /*******************************************************************************
 479  *
 480  * FUNCTION:    acpi_ds_load2_begin_op
 481  *
 482  * PARAMETERS:  walk_state      - Current state of the parse tree walk
 483  *              out_op          - Wher to return op if a new one is created
 484  *
 485  * RETURN:      Status
 486  *
 487  * DESCRIPTION: Descending callback used during the loading of ACPI tables.
 488  *
 489  ******************************************************************************/
 490
 491 acpi_status
 492 acpi_ds_load2_begin_op(struct acpi_walk_state *walk_state,
 493                        union acpi_parse_object **out_op)
 494 {
 495         union acpi_parse_object *op;
 496         struct acpi_namespace_node *node;
 497         acpi_status status;
 498         acpi_object_type object_type;
 499         char *buffer_ptr;
 500
 501         ACPI_FUNCTION_TRACE("ds_load2_begin_op");
 502
 503         op = walk_state->op;
 504         ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH, "Op=%p State=%p\n", op,
 505                           walk_state));
 506
 507         if (op) {
 508                 if ((walk_state->control_state) &&
 509                     (walk_state->control_state->common.state ==
 510                      ACPI_CONTROL_CONDITIONAL_EXECUTING)) {
 511                         /* We are executing a while loop outside of a method */
 512
 513                         status = acpi_ds_exec_begin_op(walk_state, out_op);
 514                         return_ACPI_STATUS(status);
 515                 }
 516
 517                 /* We only care about Namespace opcodes here */
 518
 519                 if ((!(walk_state->op_info->flags & AML_NSOPCODE) &&
 520                      (walk_state->opcode != AML_INT_NAMEPATH_OP)) ||
 521                     (!(walk_state->op_info->flags & AML_NAMED))) {
 522 #ifdef ACPI_ENABLE_MODULE_LEVEL_CODE
 523                         if ((walk_state->op_info->class == AML_CLASS_EXECUTE) ||
 524                             (walk_state->op_info->class == AML_CLASS_CONTROL)) {
 525
 526                                 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
 527                                                   "Begin/EXEC: %s (fl %8.8X)\n",
 528                                                   walk_state->op_info->name,
 529                                                   walk_state->op_info->flags));
 530
 531                                 /* Executing a type1 or type2 opcode outside of a method */
 532
 533                                 status =
 534                                     acpi_ds_exec_begin_op(walk_state, out_op);
 535                                 return_ACPI_STATUS(status);
 536                         }
 537 #endif
 538                         return_ACPI_STATUS(AE_OK);
 539                 }
 540
 541                 /* Get the name we are going to enter or lookup in the namespace */
 542
 543                 if (walk_state->opcode == AML_INT_NAMEPATH_OP) {
 544                         /* For Namepath op, get the path string */
 545
 546                         buffer_ptr = op->common.value.string;
 547                         if (!buffer_ptr) {
 548                                 /* No name, just exit */
 549
 550                                 return_ACPI_STATUS(AE_OK);
 551                         }
 552                 } else {
 553                         /* Get name from the op */
 554
 555                         buffer_ptr = (char *)&op->named.name;
 556                 }
 557         } else {
 558                 /* Get the namestring from the raw AML */
 559
 560                 buffer_ptr =
 561                     acpi_ps_get_next_namestring(&walk_state->parser_state);
 562         }
 563
 564         /* Map the opcode into an internal object type */
 565
 566         object_type = walk_state->op_info->object_type;
 567
 568         ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
 569                           "State=%p Op=%p Type=%X\n", walk_state, op,
 570                           object_type));
 571
 572         switch (walk_state->opcode) {
 573         case AML_FIELD_OP:
 574         case AML_BANK_FIELD_OP:
 575         case AML_INDEX_FIELD_OP:
 576
 577                 node = NULL;
 578                 status = AE_OK;
 579                 break;
 580
 581         case AML_INT_NAMEPATH_OP:
 582
 583                 /*
 584                  * The name_path is an object reference to an existing object.
 585                  * Don't enter the name into the namespace, but look it up
 586                  * for use later.
 587                  */
 588                 status =
 589                     acpi_ns_lookup(walk_state->scope_info, buffer_ptr,
 590                                    object_type, ACPI_IMODE_EXECUTE,
 591                                    ACPI_NS_SEARCH_PARENT, walk_state, &(node));
 592                 break;
 593
 594         case AML_SCOPE_OP:
 595
 596                 /*
 597                  * The 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                 if (ACPI_FAILURE(status)) {
 606 #ifdef ACPI_ASL_COMPILER
 607                         if (status == AE_NOT_FOUND) {
 608                                 status = AE_OK;
 609                         } else {
 610                                 ACPI_REPORT_NSERROR(buffer_ptr, status);
 611                         }
 612 #else
 613                         ACPI_REPORT_NSERROR(buffer_ptr, status);
 614 #endif
 615                         return_ACPI_STATUS(status);
 616                 }
 617                 /*
 618                  * We must check to make sure that the target is
 619                  * one of the opcodes that actually opens a scope
 620                  */
 621                 switch (node->type) {
 622                 case ACPI_TYPE_LOCAL_SCOPE:     /* Scope */
 623                 case ACPI_TYPE_DEVICE:
 624                 case ACPI_TYPE_POWER:
 625                 case ACPI_TYPE_PROCESSOR:
 626                 case ACPI_TYPE_THERMAL:
 627
 628                         /* These are acceptable types */
 629                         break;
 630
 631                 case ACPI_TYPE_INTEGER:
 632                 case ACPI_TYPE_STRING:
 633                 case ACPI_TYPE_BUFFER:
 634
 635                         /*
 636                          * These types we will allow, but we will change the type.  This
 637                          * enables some existing code of the form:
 638                          *
 639                          *  Name (DEB, 0)
 640                          *  Scope (DEB) { ... }
 641                          */
 642
 643                         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)));
 644
 645                         node->type = ACPI_TYPE_ANY;
 646                         walk_state->scope_info->common.value = ACPI_TYPE_ANY;
 647                         break;
 648
 649                 default:
 650
 651                         /* All other types are an error */
 652
 653                         ACPI_REPORT_ERROR(("Invalid type (%s) for target of Scope operator [%4.4s]\n", acpi_ut_get_type_name(node->type), buffer_ptr));
 654
 655                         return (AE_AML_OPERAND_TYPE);
 656                 }
 657                 break;
 658
 659         default:
 660
 661                 /* All other opcodes */
 662
 663                 if (op && op->common.node) {
 664                         /* This op/node was previously entered into the namespace */
 665
 666                         node = op->common.node;
 667
 668                         if (acpi_ns_opens_scope(object_type)) {
 669                                 status =
 670                                     acpi_ds_scope_stack_push(node, object_type,
 671                                                              walk_state);
 672                                 if (ACPI_FAILURE(status)) {
 673                                         return_ACPI_STATUS(status);
 674                                 }
 675
 676                         }
 677                         return_ACPI_STATUS(AE_OK);
 678                 }
 679
 680                 /*
 681                  * Enter the named type into the internal namespace.  We enter the name
 682                  * as we go downward in the parse tree.  Any necessary subobjects that
 683                  * involve arguments to the opcode must be created as we go back up the
 684                  * parse tree later.
 685                  *
 686                  * Note: Name may already exist if we are executing a deferred opcode.
 687                  */
 688                 if (walk_state->deferred_node) {
 689                         /* This name is already in the namespace, get the node */
 690
 691                         node = walk_state->deferred_node;
 692                         status = AE_OK;
 693                         break;
 694                 }
 695
 696                 /* Add new entry into namespace */
 697
 698                 status =
 699                     acpi_ns_lookup(walk_state->scope_info, buffer_ptr,
 700                                    object_type, ACPI_IMODE_LOAD_PASS2,
 701                                    ACPI_NS_NO_UPSEARCH, walk_state, &(node));
 702                 break;
 703         }
 704
 705         if (ACPI_FAILURE(status)) {
 706                 ACPI_REPORT_NSERROR(buffer_ptr, status);
 707                 return_ACPI_STATUS(status);
 708         }
 709
 710         if (!op) {
 711                 /* Create a new op */
 712
 713                 op = acpi_ps_alloc_op(walk_state->opcode);
 714                 if (!op) {
 715                         return_ACPI_STATUS(AE_NO_MEMORY);
 716                 }
 717
 718                 /* Initialize the new op */
 719
 720                 if (node) {
 721                         op->named.name = node->name.integer;
 722                 }
 723                 *out_op = op;
 724         }
 725
 726         /*
 727          * Put the Node in the "op" object that the parser uses, so we
 728          * can get it again quickly when this scope is closed
 729          */
 730         op->common.node = node;
 731
 732         return_ACPI_STATUS(status);
 733 }
 734
 735 /*******************************************************************************
 736  *
 737  * FUNCTION:    acpi_ds_load2_end_op
 738  *
 739  * PARAMETERS:  walk_state      - Current state of the parse tree walk
 740  *
 741  * RETURN:      Status
 742  *
 743  * DESCRIPTION: Ascending callback used during the loading of the namespace,
 744  *              both control methods and everything else.
 745  *
 746  ******************************************************************************/
 747
 748 acpi_status acpi_ds_load2_end_op(struct acpi_walk_state *walk_state)
 749 {
 750         union acpi_parse_object *op;
 751         acpi_status status = AE_OK;
 752         acpi_object_type object_type;
 753         struct acpi_namespace_node *node;
 754         union acpi_parse_object *arg;
 755         struct acpi_namespace_node *new_node;
 756 #ifndef ACPI_NO_METHOD_EXECUTION
 757         u32 i;
 758 #endif
 759
 760         ACPI_FUNCTION_TRACE("ds_load2_end_op");
 761
 762         op = walk_state->op;
 763         ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH, "Opcode [%s] Op %p State %p\n",
 764                           walk_state->op_info->name, op, walk_state));
 765
 766         /* Check if opcode had an associated namespace object */
 767
 768         if (!(walk_state->op_info->flags & AML_NSOBJECT)) {
 769 #ifndef ACPI_NO_METHOD_EXECUTION
 770 #ifdef ACPI_ENABLE_MODULE_LEVEL_CODE
 771                 /* No namespace object. Executable opcode? */
 772
 773                 if ((walk_state->op_info->class == AML_CLASS_EXECUTE) ||
 774                     (walk_state->op_info->class == AML_CLASS_CONTROL)) {
 775                         ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
 776                                           "End/EXEC:   %s (fl %8.8X)\n",
 777                                           walk_state->op_info->name,
 778                                           walk_state->op_info->flags));
 779
 780                         /* Executing a type1 or type2 opcode outside of a method */
 781
 782                         status = acpi_ds_exec_end_op(walk_state);
 783                         return_ACPI_STATUS(status);
 784                 }
 785 #endif
 786 #endif
 787                 return_ACPI_STATUS(AE_OK);
 788         }
 789
 790         if (op->common.aml_opcode == AML_SCOPE_OP) {
 791                 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
 792                                   "Ending scope Op=%p State=%p\n", op,
 793                                   walk_state));
 794         }
 795
 796         object_type = walk_state->op_info->object_type;
 797
 798         /*
 799          * Get the Node/name from the earlier lookup
 800          * (It was saved in the *op structure)
 801          */
 802         node = op->common.node;
 803
 804         /*
 805          * Put the Node on the object stack (Contains the ACPI Name of
 806          * this object)
 807          */
 808         walk_state->operands[0] = (void *)node;
 809         walk_state->num_operands = 1;
 810
 811         /* Pop the scope stack */
 812
 813         if (acpi_ns_opens_scope(object_type) &&
 814             (op->common.aml_opcode != AML_INT_METHODCALL_OP)) {
 815                 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
 816                                   "(%s) Popping scope for Op %p\n",
 817                                   acpi_ut_get_type_name(object_type), op));
 818
 819                 status = acpi_ds_scope_stack_pop(walk_state);
 820                 if (ACPI_FAILURE(status)) {
 821                         goto cleanup;
 822                 }
 823         }
 824
 825         /*
 826          * Named operations are as follows:
 827          *
 828          * AML_ALIAS
 829          * AML_BANKFIELD
 830          * AML_CREATEBITFIELD
 831          * AML_CREATEBYTEFIELD
 832          * AML_CREATEDWORDFIELD
 833          * AML_CREATEFIELD
 834          * AML_CREATEQWORDFIELD
 835          * AML_CREATEWORDFIELD
 836          * AML_DATA_REGION
 837          * AML_DEVICE
 838          * AML_EVENT
 839          * AML_FIELD
 840          * AML_INDEXFIELD
 841          * AML_METHOD
 842          * AML_METHODCALL
 843          * AML_MUTEX
 844          * AML_NAME
 845          * AML_NAMEDFIELD
 846          * AML_OPREGION
 847          * AML_POWERRES
 848          * AML_PROCESSOR
 849          * AML_SCOPE
 850          * AML_THERMALZONE
 851          */
 852
 853         ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
 854                           "Create-Load [%s] State=%p Op=%p named_obj=%p\n",
 855                           acpi_ps_get_opcode_name(op->common.aml_opcode),
 856                           walk_state, op, node));
 857
 858         /* Decode the opcode */
 859
 860         arg = op->common.value.arg;
 861
 862         switch (walk_state->op_info->type) {
 863 #ifndef ACPI_NO_METHOD_EXECUTION
 864
 865         case AML_TYPE_CREATE_FIELD:
 866
 867                 /*
 868                  * Create the field object, but the field buffer and index must
 869                  * be evaluated later during the execution phase
 870                  */
 871                 status = acpi_ds_create_buffer_field(op, walk_state);
 872                 break;
 873
 874         case AML_TYPE_NAMED_FIELD:
 875
 876                 /*
 877                  * If we are executing a method, initialize the field
 878                  */
 879                 if (walk_state->method_node) {
 880                         status = acpi_ds_init_field_objects(op, walk_state);
 881                 }
 882
 883                 switch (op->common.aml_opcode) {
 884                 case AML_INDEX_FIELD_OP:
 885
 886                         status =
 887                             acpi_ds_create_index_field(op,
 888                                                        (acpi_handle) arg->
 889                                                        common.node, walk_state);
 890                         break;
 891
 892                 case AML_BANK_FIELD_OP:
 893
 894                         status =
 895                             acpi_ds_create_bank_field(op, arg->common.node,
 896                                                       walk_state);
 897                         break;
 898
 899                 case AML_FIELD_OP:
 900
 901                         status =
 902                             acpi_ds_create_field(op, arg->common.node,
 903                                                  walk_state);
 904                         break;
 905
 906                 default:
 907                         /* All NAMED_FIELD opcodes must be handled above */
 908                         break;
 909                 }
 910                 break;
 911
 912         case AML_TYPE_NAMED_SIMPLE:
 913
 914                 status = acpi_ds_create_operands(walk_state, arg);
 915                 if (ACPI_FAILURE(status)) {
 916                         goto cleanup;
 917                 }
 918
 919                 switch (op->common.aml_opcode) {
 920                 case AML_PROCESSOR_OP:
 921
 922                         status = acpi_ex_create_processor(walk_state);
 923                         break;
 924
 925                 case AML_POWER_RES_OP:
 926
 927                         status = acpi_ex_create_power_resource(walk_state);
 928                         break;
 929
 930                 case AML_MUTEX_OP:
 931
 932                         status = acpi_ex_create_mutex(walk_state);
 933                         break;
 934
 935                 case AML_EVENT_OP:
 936
 937                         status = acpi_ex_create_event(walk_state);
 938                         break;
 939
 940                 case AML_DATA_REGION_OP:
 941
 942                         status = acpi_ex_create_table_region(walk_state);
 943                         break;
 944
 945                 case AML_ALIAS_OP:
 946
 947                         status = acpi_ex_create_alias(walk_state);
 948                         break;
 949
 950                 default:
 951                         /* Unknown opcode */
 952
 953                         status = AE_OK;
 954                         goto cleanup;
 955                 }
 956
 957                 /* Delete operands */
 958
 959                 for (i = 1; i < walk_state->num_operands; i++) {
 960                         acpi_ut_remove_reference(walk_state->operands[i]);
 961                         walk_state->operands[i] = NULL;
 962                 }
 963
 964                 break;
 965 #endif                          /* ACPI_NO_METHOD_EXECUTION */
 966
 967         case AML_TYPE_NAMED_COMPLEX:
 968
 969                 switch (op->common.aml_opcode) {
 970 #ifndef ACPI_NO_METHOD_EXECUTION
 971                 case AML_REGION_OP:
 972
 973                         /*
 974                          * If we are executing a method, initialize the region
 975                          */
 976                         if (walk_state->method_node) {
 977                                 status =
 978                                     acpi_ex_create_region(op->named.data,
 979                                                           op->named.length,
 980                                                           (acpi_adr_space_type)
 981                                                           ((op->common.value.
 982                                                             arg)->common.value.
 983                                                            integer),
 984                                                           walk_state);
 985                                 if (ACPI_FAILURE(status)) {
 986                                         return (status);
 987                                 }
 988                         }
 989
 990                         /*
 991                          * The op_region is not fully parsed at this time. Only valid
 992                          * argument is the space_id. (We must save the address of the
 993                          * AML of the address and length operands)
 994                          */
 995                         /*
 996                          * If we have a valid region, initialize it
 997                          * Namespace is NOT locked at this point.
 998                          */
 999                         status =
1000                             acpi_ev_initialize_region
1001                             (acpi_ns_get_attached_object(node), FALSE);
1002                         if (ACPI_FAILURE(status)) {
1003                                 /*
1004                                  *  If AE_NOT_EXIST is returned, it is not fatal
1005                                  *  because many regions get created before a handler
1006                                  *  is installed for said region.
1007                                  */
1008                                 if (AE_NOT_EXIST == status) {
1009                                         status = AE_OK;
1010                                 }
1011                         }
1012                         break;
1013
1014                 case AML_NAME_OP:
1015
1016                         status = acpi_ds_create_node(walk_state, node, op);
1017                         break;
1018 #endif                          /* ACPI_NO_METHOD_EXECUTION */
1019
1020                 default:
1021                         /* All NAMED_COMPLEX opcodes must be handled above */
1022                         /* Note: Method objects were already created in Pass 1 */
1023                         break;
1024                 }
1025                 break;
1026
1027         case AML_CLASS_INTERNAL:
1028
1029                 /* case AML_INT_NAMEPATH_OP: */
1030                 break;
1031
1032         case AML_CLASS_METHOD_CALL:
1033
1034                 ACPI_DEBUG_PRINT((ACPI_DB_DISPATCH,
1035                                   "RESOLVING-method_call: State=%p Op=%p named_obj=%p\n",
1036                                   walk_state, op, node));
1037
1038                 /*
1039                  * Lookup the method name and save the Node
1040                  */
1041                 status =
1042                     acpi_ns_lookup(walk_state->scope_info,
1043                                    arg->common.value.string, ACPI_TYPE_ANY,
1044                                    ACPI_IMODE_LOAD_PASS2,
1045                                    ACPI_NS_SEARCH_PARENT |
1046                                    ACPI_NS_DONT_OPEN_SCOPE, walk_state,
1047                                    &(new_node));
1048                 if (ACPI_SUCCESS(status)) {
1049
1050                         /*
1051                          * Make sure that what we found is indeed a method
1052                          * We didn't search for a method on purpose, to see if the name
1053                          * would resolve
1054                          */
1055                         if (new_node->type != ACPI_TYPE_METHOD) {
1056                                 status = AE_AML_OPERAND_TYPE;
1057                         }
1058
1059                         /* We could put the returned object (Node) on the object stack for
1060                          * later, but for now, we will put it in the "op" object that the
1061                          * parser uses, so we can get it again at the end of this scope
1062                          */
1063                         op->common.node = new_node;
1064                 } else {
1065                         ACPI_REPORT_NSERROR(arg->common.value.string, status);
1066                 }
1067                 break;
1068
1069         default:
1070                 break;
1071         }
1072
1073       cleanup:
1074
1075         /* Remove the Node pushed at the very beginning */
1076
1077         walk_state->operands[0] = NULL;
1078         walk_state->num_operands = 0;
1079         return_ACPI_STATUS(status);
1080 }