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