drivers/acpi/dispatcher/dswload.c

   1 /******************************************************************************
   2  *
   3  * Module Name: dswload - Dispatcher namespace load callbacks
   4  *              $Revision: 24 $
   5  *
   6  *****************************************************************************/
   7
   8 /*
   9  *  Copyright (C) 2000 R. Byron Moore
  10  *
  11  *  This program is free software; you can redistribute it and/or modify
  12  *  it under the terms of the GNU General Public License as published by
  13  *  the Free Software Foundation; either version 2 of the License, or
  14  *  (at your option) any later version.
  15  *
  16  *  This program is distributed in the hope that it will be useful,
  17  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  *  GNU General Public License for more details.
  20  *
  21  *  You should have received a copy of the GNU General Public License
  22  *  along with this program; if not, write to the Free Software
  23  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  24  */
  25
  26
  27 #include "acpi.h"
  28 #include "acparser.h"
  29 #include "amlcode.h"
  30 #include "acdispat.h"
  31 #include "acinterp.h"
  32 #include "acnamesp.h"
  33 #include "acevents.h"
  34
  35
  36 #define _COMPONENT          DISPATCHER
  37          MODULE_NAME         ("dswload")
  38
  39
  40 /*****************************************************************************
  41  *
  42  * FUNCTION:    Acpi_ds_load1_begin_op
  43  *
  44  * PARAMETERS:  Walk_state      - Current state of the parse tree walk
  45  *              Op              - Op that has been just been reached in the
  46  *                                walk;  Arguments have not been evaluated yet.
  47  *
  48  * RETURN:      Status
  49  *
  50  * DESCRIPTION: Descending callback used during the loading of ACPI tables.
  51  *
  52  ****************************************************************************/
  53
  54 ACPI_STATUS
  55 acpi_ds_load1_begin_op (
  56         u16                     opcode,
  57         ACPI_PARSE_OBJECT       *op,
  58         ACPI_WALK_STATE         *walk_state,
  59         ACPI_PARSE_OBJECT       **out_op)
  60 {
  61         ACPI_NAMESPACE_NODE     *node;
  62         ACPI_STATUS             status;
  63         OBJECT_TYPE_INTERNAL    data_type;
  64         NATIVE_CHAR             *path;
  65
  66
  67         /* We are only interested in opcodes that have an associated name */
  68
  69         if (!acpi_ps_is_named_op (opcode)) {
  70                 *out_op = op;
  71                 return (AE_OK);
  72         }
  73
  74
  75         /* Check if this object has already been installed in the namespace */
  76
  77         if (op && op->node) {
  78                 *out_op = op;
  79                 return (AE_OK);
  80         }
  81
  82         path = acpi_ps_get_next_namestring (walk_state->parser_state);
  83
  84         /* Map the raw opcode into an internal object type */
  85
  86         data_type = acpi_ds_map_named_opcode_to_data_type (opcode);
  87
  88
  89
  90         /*
  91          * Enter the named type into the internal namespace.  We enter the name
  92          * as we go downward in the parse tree.  Any necessary subobjects that involve
  93          * arguments to the opcode must be created as we go back up the parse tree later.
  94          */
  95         status = acpi_ns_lookup (walk_state->scope_info, path,
  96                          data_type, IMODE_LOAD_PASS1,
  97                          NS_NO_UPSEARCH, walk_state, &(node));
  98
  99         if (ACPI_FAILURE (status)) {
 100                 return (status);
 101         }
 102
 103         if (!op) {
 104                 /* Create a new op */
 105
 106                 op = acpi_ps_alloc_op (opcode);
 107                 if (!op) {
 108                         return (AE_NO_MEMORY);
 109                 }
 110         }
 111
 112         /* Initialize */
 113
 114         ((ACPI_PARSE2_OBJECT *)op)->name = node->name;
 115
 116         /*
 117          * Put the Node in the "op" object that the parser uses, so we
 118          * can get it again quickly when this scope is closed
 119          */
 120         op->node = node;
 121
 122
 123         acpi_ps_append_arg (acpi_ps_get_parent_scope (walk_state->parser_state), op);
 124
 125         *out_op = op;
 126
 127         return (status);
 128 }
 129
 130
 131 /*****************************************************************************
 132  *
 133  * FUNCTION:    Acpi_ds_load1_end_op
 134  *
 135  * PARAMETERS:  Walk_state      - Current state of the parse tree walk
 136  *              Op              - Op that has been just been completed in the
 137  *                                walk;  Arguments have now been evaluated.
 138  *
 139  * RETURN:      Status
 140  *
 141  * DESCRIPTION: Ascending callback used during the loading of the namespace,
 142  *              both control methods and everything else.
 143  *
 144  ****************************************************************************/
 145
 146 ACPI_STATUS
 147 acpi_ds_load1_end_op (
 148         ACPI_WALK_STATE         *walk_state,
 149         ACPI_PARSE_OBJECT       *op)
 150 {
 151         OBJECT_TYPE_INTERNAL    data_type;
 152
 153
 154         /* We are only interested in opcodes that have an associated name */
 155
 156         if (!acpi_ps_is_named_op (op->opcode)) {
 157                 return (AE_OK);
 158         }
 159
 160
 161         /* Get the type to determine if we should pop the scope */
 162
 163         data_type = acpi_ds_map_named_opcode_to_data_type (op->opcode);
 164
 165         if (op->opcode == AML_NAME_OP) {
 166                 /* For Name opcode, check the argument */
 167
 168                 if (op->value.arg) {
 169                         data_type = acpi_ds_map_opcode_to_data_type (
 170                                           (op->value.arg)->opcode, NULL);
 171                         ((ACPI_NAMESPACE_NODE *)op->node)->type =
 172                                           (u8) data_type;
 173                 }
 174         }
 175
 176
 177         /* Pop the scope stack */
 178
 179         if (acpi_ns_opens_scope (data_type)) {
 180
 181                 acpi_ds_scope_stack_pop (walk_state);
 182         }
 183
 184         return (AE_OK);
 185
 186 }
 187
 188
 189 /*****************************************************************************
 190  *
 191  * FUNCTION:    Acpi_ds_load2_begin_op
 192  *
 193  * PARAMETERS:  Walk_state      - Current state of the parse tree walk
 194  *              Op              - Op that has been just been reached in the
 195  *                                walk;  Arguments have not been evaluated yet.
 196  *
 197  * RETURN:      Status
 198  *
 199  * DESCRIPTION: Descending callback used during the loading of ACPI tables.
 200  *
 201  ****************************************************************************/
 202
 203 ACPI_STATUS
 204 acpi_ds_load2_begin_op (
 205         u16                     opcode,
 206         ACPI_PARSE_OBJECT       *op,
 207         ACPI_WALK_STATE         *walk_state,
 208         ACPI_PARSE_OBJECT       **out_op)
 209 {
 210         ACPI_NAMESPACE_NODE     *node;
 211         ACPI_STATUS             status;
 212         OBJECT_TYPE_INTERNAL    data_type;
 213         NATIVE_CHAR             *buffer_ptr;
 214         void                    *original = NULL;
 215
 216
 217         /* We only care about Namespace opcodes here */
 218
 219         if (!acpi_ps_is_namespace_op (opcode) &&
 220                 opcode != AML_NAMEPATH_OP)
 221         {
 222                 return (AE_OK);
 223         }
 224
 225
 226         /* Temp! same code as in psparse */
 227
 228         if (!acpi_ps_is_named_op (opcode)) {
 229                 return (AE_OK);
 230         }
 231
 232         if (op) {
 233                 /*
 234                  * Get the name we are going to enter or lookup in the namespace
 235                  */
 236                 if (opcode == AML_NAMEPATH_OP) {
 237                         /* For Namepath op, get the path string */
 238
 239                         buffer_ptr = op->value.string;
 240                         if (!buffer_ptr) {
 241                                 /* No name, just exit */
 242
 243                                 return (AE_OK);
 244                         }
 245                 }
 246
 247                 else {
 248                         /* Get name from the op */
 249
 250                         buffer_ptr = (NATIVE_CHAR *) &((ACPI_PARSE2_OBJECT *)op)->name;
 251                 }
 252         }
 253
 254         else {
 255                 buffer_ptr = acpi_ps_get_next_namestring (walk_state->parser_state);
 256         }
 257
 258
 259         /* Map the raw opcode into an internal object type */
 260
 261         data_type = acpi_ds_map_named_opcode_to_data_type (opcode);
 262
 263
 264         if (opcode == AML_DEF_FIELD_OP      ||
 265                 opcode == AML_BANK_FIELD_OP     ||
 266                 opcode == AML_INDEX_FIELD_OP)
 267         {
 268                 node = NULL;
 269                 status = AE_OK;
 270         }
 271
 272         else if (opcode == AML_NAMEPATH_OP) {
 273                 /*
 274                  * The Name_path is an object reference to an existing object. Don't enter the
 275                  * name into the namespace, but look it up for use later
 276                  */
 277                 status = acpi_ns_lookup (walk_state->scope_info, buffer_ptr,
 278                                  data_type, IMODE_EXECUTE,
 279                                  NS_SEARCH_PARENT, walk_state,
 280                                  &(node));
 281         }
 282
 283         else {
 284                 if (op && op->node) {
 285                         original = op->node;
 286                         node = op->node;
 287
 288                         if (acpi_ns_opens_scope (data_type)) {
 289                                 status = acpi_ds_scope_stack_push (node,
 290                                                    data_type,
 291                                                    walk_state);
 292                                 if (ACPI_FAILURE (status)) {
 293                                         return (status);
 294                                 }
 295
 296                         }
 297                         return (AE_OK);
 298                 }
 299
 300                 /*
 301                  * Enter the named type into the internal namespace.  We enter the name
 302                  * as we go downward in the parse tree.  Any necessary subobjects that involve
 303                  * arguments to the opcode must be created as we go back up the parse tree later.
 304                  */
 305                 status = acpi_ns_lookup (walk_state->scope_info, buffer_ptr,
 306                                  data_type, IMODE_EXECUTE,
 307                                  NS_NO_UPSEARCH, walk_state,
 308                                  &(node));
 309         }
 310
 311         if (ACPI_SUCCESS (status)) {
 312                 if (!op) {
 313                         /* Create a new op */
 314
 315                         op = acpi_ps_alloc_op (opcode);
 316                         if (!op) {
 317                                 return (AE_NO_MEMORY);
 318                         }
 319
 320                         /* Initialize */
 321
 322                         ((ACPI_PARSE2_OBJECT *)op)->name = node->name;
 323                         *out_op = op;
 324                 }
 325
 326
 327                 /*
 328                  * Put the Node in the "op" object that the parser uses, so we
 329                  * can get it again quickly when this scope is closed
 330                  */
 331                 op->node = node;
 332
 333         }
 334
 335
 336         return (status);
 337 }
 338
 339
 340 /*****************************************************************************
 341  *
 342  * FUNCTION:    Acpi_ds_load2_end_op
 343  *
 344  * PARAMETERS:  Walk_state      - Current state of the parse tree walk
 345  *              Op              - Op that has been just been completed in the
 346  *                                walk;  Arguments have now been evaluated.
 347  *
 348  * RETURN:      Status
 349  *
 350  * DESCRIPTION: Ascending callback used during the loading of the namespace,
 351  *              both control methods and everything else.
 352  *
 353  ****************************************************************************/
 354
 355 ACPI_STATUS
 356 acpi_ds_load2_end_op (
 357         ACPI_WALK_STATE         *walk_state,
 358         ACPI_PARSE_OBJECT       *op)
 359 {
 360         ACPI_STATUS             status = AE_OK;
 361         OBJECT_TYPE_INTERNAL    data_type;
 362         ACPI_NAMESPACE_NODE     *node;
 363         ACPI_PARSE_OBJECT       *arg;
 364         ACPI_NAMESPACE_NODE     *new_node;
 365
 366
 367         if (!acpi_ps_is_namespace_object_op (op->opcode)) {
 368                 return (AE_OK);
 369         }
 370
 371         if (op->opcode == AML_SCOPE_OP) {
 372                 if (((ACPI_PARSE2_OBJECT *)op)->name == -1) {
 373                         return (AE_OK);
 374                 }
 375         }
 376
 377
 378         data_type = acpi_ds_map_named_opcode_to_data_type (op->opcode);
 379
 380         /*
 381          * Get the Node/name from the earlier lookup
 382          * (It was saved in the *op structure)
 383          */
 384         node = op->node;
 385
 386         /*
 387          * Put the Node on the object stack (Contains the ACPI Name of
 388          * this object)
 389          */
 390
 391         walk_state->operands[0] = (void *) node;
 392         walk_state->num_operands = 1;
 393
 394         /* Pop the scope stack */
 395
 396         if (acpi_ns_opens_scope (data_type)) {
 397
 398                 acpi_ds_scope_stack_pop (walk_state);
 399         }
 400
 401
 402         /*
 403          * Named operations are as follows:
 404          *
 405          * AML_SCOPE
 406          * AML_DEVICE
 407          * AML_THERMALZONE
 408          * AML_METHOD
 409          * AML_POWERRES
 410          * AML_PROCESSOR
 411          * AML_FIELD
 412          * AML_INDEXFIELD
 413          * AML_BANKFIELD
 414          * AML_NAMEDFIELD
 415          * AML_NAME
 416          * AML_ALIAS
 417          * AML_MUTEX
 418          * AML_EVENT
 419          * AML_OPREGION
 420          * AML_CREATEFIELD
 421          * AML_CREATEBITFIELD
 422          * AML_CREATEBYTEFIELD
 423          * AML_CREATEWORDFIELD
 424          * AML_CREATEDWORDFIELD
 425          * AML_METHODCALL
 426          */
 427
 428
 429         /* Decode the opcode */
 430
 431         arg = op->value.arg;
 432
 433         switch (op->opcode)
 434         {
 435
 436         case AML_CREATE_FIELD_OP:
 437         case AML_BIT_FIELD_OP:
 438         case AML_BYTE_FIELD_OP:
 439         case AML_WORD_FIELD_OP:
 440         case AML_DWORD_FIELD_OP:
 441
 442                 /*
 443                  * Create the field object, but the field buffer and index must
 444                  * be evaluated later during the execution phase
 445                  */
 446
 447                 /* Get the Name_string argument */
 448
 449                 if (op->opcode == AML_CREATE_FIELD_OP) {
 450                         arg = acpi_ps_get_arg (op, 3);
 451                 }
 452                 else {
 453                         /* Create Bit/Byte/Word/Dword field */
 454
 455                         arg = acpi_ps_get_arg (op, 2);
 456                 }
 457
 458                 /*
 459                  * Enter the Name_string into the namespace
 460                  */
 461
 462                 status = acpi_ns_lookup (walk_state->scope_info,
 463                                  arg->value.string,
 464                                  INTERNAL_TYPE_DEF_ANY,
 465                                  IMODE_LOAD_PASS1,
 466                                  NS_NO_UPSEARCH | NS_DONT_OPEN_SCOPE,
 467                                  walk_state, &(new_node));
 468
 469                 if (ACPI_SUCCESS (status)) {
 470                         /* We could put the returned object (Node) on the object stack for later, but
 471                          * for now, we will put it in the "op" object that the parser uses, so we
 472                          * can get it again at the end of this scope
 473                          */
 474                         op->node = new_node;
 475
 476                         /*
 477                          * If there is no object attached to the node, this node was just created and
 478                          * we need to create the field object.  Otherwise, this was a lookup of an
 479                          * existing node and we don't want to create the field object again.
 480                          */
 481                         if (!new_node->object) {
 482                                 /*
 483                                  * The Field definition is not fully parsed at this time.
 484                                  * (We must save the address of the AML for the buffer and index operands)
 485                                  */
 486                                 status = acpi_aml_exec_create_field (((ACPI_PARSE2_OBJECT *) op)->data,
 487                                                    ((ACPI_PARSE2_OBJECT *) op)->length,
 488                                                    new_node, walk_state);
 489                         }
 490                 }
 491
 492
 493                 break;
 494
 495
 496         case AML_METHODCALL_OP:
 497
 498                 /*
 499                  * Lookup the method name and save the Node
 500                  */
 501
 502                 status = acpi_ns_lookup (walk_state->scope_info, arg->value.string,
 503                                  ACPI_TYPE_ANY, IMODE_LOAD_PASS2,
 504                                  NS_SEARCH_PARENT | NS_DONT_OPEN_SCOPE,
 505                                  walk_state, &(new_node));
 506
 507                 if (ACPI_SUCCESS (status)) {
 508
 509 /* has name already been resolved by here ??*/
 510
 511                         /* TBD: [Restructure] Make sure that what we found is indeed a method! */
 512                         /* We didn't search for a method on purpose, to see if the name would resolve! */
 513
 514                         /* We could put the returned object (Node) on the object stack for later, but
 515                          * for now, we will put it in the "op" object that the parser uses, so we
 516                          * can get it again at the end of this scope
 517                          */
 518                         op->node = new_node;
 519                 }
 520
 521
 522                  break;
 523
 524
 525         case AML_PROCESSOR_OP:
 526
 527                 /* Nothing to do other than enter object into namespace */
 528
 529                 status = acpi_aml_exec_create_processor (op, (ACPI_HANDLE) node);
 530                 if (ACPI_FAILURE (status)) {
 531                         goto cleanup;
 532                 }
 533
 534                 break;
 535
 536
 537         case AML_POWER_RES_OP:
 538
 539                 /* Nothing to do other than enter object into namespace */
 540
 541                 status = acpi_aml_exec_create_power_resource (op, (ACPI_HANDLE) node);
 542                 if (ACPI_FAILURE (status)) {
 543                         goto cleanup;
 544                 }
 545
 546                 break;
 547
 548
 549         case AML_THERMAL_ZONE_OP:
 550
 551                 /* Nothing to do other than enter object into namespace */
 552
 553                 break;
 554
 555
 556         case AML_DEF_FIELD_OP:
 557
 558                 arg = op->value.arg;
 559
 560                 status = acpi_ds_create_field (op,
 561                                   arg->node,
 562                                   walk_state);
 563                 break;
 564
 565
 566         case AML_INDEX_FIELD_OP:
 567
 568                 arg = op->value.arg;
 569
 570                 status = acpi_ds_create_index_field (op,
 571                                    (ACPI_HANDLE) arg->node,
 572                                    walk_state);
 573                 break;
 574
 575
 576         case AML_BANK_FIELD_OP:
 577
 578                 arg = op->value.arg;
 579                 status = acpi_ds_create_bank_field (op,
 580                                    arg->node,
 581                                    walk_state);
 582                 break;
 583
 584
 585         /*
 586          * Method_op Pkg_length Names_string Method_flags Term_list
 587          */
 588         case AML_METHOD_OP:
 589
 590                 if (!node->object) {
 591                         status = acpi_aml_exec_create_method (((ACPI_PARSE2_OBJECT *) op)->data,
 592                                            ((ACPI_PARSE2_OBJECT *) op)->length,
 593                                            arg->value.integer, (ACPI_HANDLE) node);
 594                 }
 595
 596                 break;
 597
 598
 599         case AML_MUTEX_OP:
 600
 601                 status = acpi_ds_create_operands (walk_state, arg);
 602                 if (ACPI_FAILURE (status)) {
 603                         goto cleanup;
 604                 }
 605
 606                 status = acpi_aml_exec_create_mutex (walk_state);
 607                 break;
 608
 609
 610         case AML_EVENT_OP:
 611
 612                 status = acpi_ds_create_operands (walk_state, arg);
 613                 if (ACPI_FAILURE (status)) {
 614                         goto cleanup;
 615                 }
 616
 617                 status = acpi_aml_exec_create_event (walk_state);
 618                 break;
 619
 620
 621         case AML_REGION_OP:
 622
 623                 if (node->object) {
 624                         break;
 625                 }
 626
 627
 628                 /*
 629                  * The Op_region is not fully parsed at this time. Only valid argument is the Space_id.
 630                  * (We must save the address of the AML of the address and length operands)
 631                  */
 632
 633                 status = acpi_aml_exec_create_region (((ACPI_PARSE2_OBJECT *) op)->data,
 634                                    ((ACPI_PARSE2_OBJECT *) op)->length,
 635                                    (ACPI_ADDRESS_SPACE_TYPE) arg->value.integer,
 636                                    walk_state);
 637
 638                 break;
 639
 640
 641         /* Namespace Modifier Opcodes */
 642
 643         case AML_ALIAS_OP:
 644
 645                 status = acpi_ds_create_operands (walk_state, arg);
 646                 if (ACPI_FAILURE (status)) {
 647                         goto cleanup;
 648                 }
 649
 650                 status = acpi_aml_exec_create_alias (walk_state);
 651                 break;
 652
 653
 654         case AML_NAME_OP:
 655
 656                 /*
 657                  * Because of the execution pass through the non-control-method
 658                  * parts of the table, we can arrive here twice.  Only init
 659                  * the named object node the first time through
 660                  */
 661
 662                 if (!node->object) {
 663                         status = acpi_ds_create_node (walk_state, node, op);
 664                 }
 665
 666                 break;
 667
 668
 669         case AML_NAMEPATH_OP:
 670
 671                 break;
 672
 673
 674         default:
 675                 break;
 676         }
 677
 678
 679 cleanup:
 680
 681         /* Remove the Node pushed at the very beginning */
 682
 683         acpi_ds_obj_stack_pop (1, walk_state);
 684         return (status);
 685 }
 686
 687