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