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