drivers/bus/acpi/parser/psparse.c

   1 /******************************************************************************
   2  *
   3  * Module Name: psparse - Parser top level AML parse routines
   4  *              $Revision$
   5  *
   6  *****************************************************************************/
   7
   8 /*
   9  *  Copyright (C) 2000, 2001 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 /*
  28  * Parse the AML and build an operation tree as most interpreters,
  29  * like Perl, do.  Parsing is done by hand rather than with a YACC
  30  * generated parser to tightly constrain stack and dynamic memory
  31  * usage.  At the same time, parsing is kept flexible and the code
  32  * fairly compact by parsing based on a list of AML opcode
  33  * templates in Aml_op_info[]
  34  */
  35
  36 #include "acpi.h"
  37 #include "acparser.h"
  38 #include "acdispat.h"
  39 #include "amlcode.h"
  40 #include "acnamesp.h"
  41 #include "acdebug.h"
  42 #include "acinterp.h"
  43
  44 #define _COMPONENT          ACPI_PARSER
  45          MODULE_NAME         ("psparse")
  46
  47
  48 u32                         acpi_gbl_depth = 0;
  49 extern u32                  acpi_gbl_scope_depth;
  50
  51
  52 /*******************************************************************************
  53  *
  54  * FUNCTION:    Acpi_ps_peek_opcode
  55  *
  56  * PARAMETERS:  None
  57  *
  58  * RETURN:      Status
  59  *
  60  * DESCRIPTION: Get next AML opcode (without incrementing AML pointer)
  61  *
  62  ******************************************************************************/
  63
  64 static u32
  65 acpi_ps_get_opcode_size (
  66         u32                     opcode)
  67 {
  68
  69         /* Extended (2-byte) opcode if > 255 */
  70
  71         if (opcode > 0x00FF) {
  72                 return (2);
  73         }
  74
  75         /* Otherwise, just a single byte opcode */
  76
  77         return (1);
  78 }
  79
  80
  81 /*******************************************************************************
  82  *
  83  * FUNCTION:    Acpi_ps_peek_opcode
  84  *
  85  * PARAMETERS:  Parser_state        - A parser state object
  86  *
  87  * RETURN:      Status
  88  *
  89  * DESCRIPTION: Get next AML opcode (without incrementing AML pointer)
  90  *
  91  ******************************************************************************/
  92
  93 u16
  94 acpi_ps_peek_opcode (
  95         ACPI_PARSE_STATE        *parser_state)
  96 {
  97         u8                      *aml;
  98         u16                     opcode;
  99
 100
 101         aml = parser_state->aml;
 102         opcode = (u16) GET8 (aml);
 103
 104         aml++;
 105
 106
 107         /*
 108          * Original code special cased LNOTEQUAL, LLESSEQUAL, LGREATEREQUAL.
 109          * These opcodes are no longer recognized. Instead, they are broken into
 110          * two opcodes.
 111          *
 112          *
 113          *    if (Opcode == AML_EXTOP
 114          *       || (Opcode == AML_LNOT
 115          *          && (GET8 (Acpi_aml) == AML_LEQUAL
 116          *               || GET8 (Acpi_aml) == AML_LGREATER
 117          *               || GET8 (Acpi_aml) == AML_LLESS)))
 118          *
 119          *     extended Opcode, !=, <=, or >=
 120          */
 121
 122         if (opcode == AML_EXTOP) {
 123                 /* Extended opcode */
 124
 125                 opcode = (u16) ((opcode << 8) | GET8 (aml));
 126                 aml++;
 127         }
 128
 129         /* don't convert bare name to a namepath */
 130
 131         return (opcode);
 132 }
 133
 134
 135 /*******************************************************************************
 136  *
 137  * FUNCTION:    Acpi_ps_create_state
 138  *
 139  * PARAMETERS:  Acpi_aml            - Acpi_aml code pointer
 140  *              Acpi_aml_size       - Length of AML code
 141  *
 142  * RETURN:      A new parser state object
 143  *
 144  * DESCRIPTION: Create and initialize a new parser state object
 145  *
 146  ******************************************************************************/
 147
 148 ACPI_PARSE_STATE *
 149 acpi_ps_create_state (
 150         u8                      *aml,
 151         u32                     aml_size)
 152 {
 153         ACPI_PARSE_STATE        *parser_state;
 154
 155
 156         parser_state = acpi_cm_callocate (sizeof (ACPI_PARSE_STATE));
 157         if (!parser_state) {
 158                 return (NULL);
 159         }
 160
 161         parser_state->aml      = aml;
 162         parser_state->aml_end  = aml + aml_size;
 163         parser_state->pkg_end  = parser_state->aml_end;
 164         parser_state->aml_start = aml;
 165
 166
 167         return (parser_state);
 168 }
 169
 170
 171 /*******************************************************************************
 172  *
 173  * FUNCTION:    Acpi_ps_find_object
 174  *
 175  * PARAMETERS:  Opcode          - Current opcode
 176  *              Parser_state    - Current state
 177  *              Walk_state      - Current state
 178  *              *Op             - Where found/new op is returned
 179  *
 180  * RETURN:      Status
 181  *
 182  * DESCRIPTION: Find a named object.  Two versions - one to search the parse
 183  *              tree (for parser-only applications such as acpidump), another
 184  *              to search the ACPI internal namespace (the parse tree may no
 185  *              longer exist)
 186  *
 187  ******************************************************************************/
 188
 189 #ifdef PARSER_ONLY
 190
 191 ACPI_STATUS
 192 acpi_ps_find_object (
 193         u16                     opcode,
 194         ACPI_PARSE_OBJECT       *op,
 195         ACPI_WALK_STATE         *walk_state,
 196         ACPI_PARSE_OBJECT       **out_op)
 197 {
 198         NATIVE_CHAR             *path;
 199
 200
 201         /* We are only interested in opcodes that have an associated name */
 202
 203         if (!acpi_ps_is_named_op (opcode)) {
 204                 *out_op = op;
 205                 return (AE_OK);
 206         }
 207
 208         /* Find the name in the parse tree */
 209
 210         path = acpi_ps_get_next_namestring (walk_state->parser_state);
 211
 212         *out_op = acpi_ps_find (acpi_ps_get_parent_scope (walk_state->parser_state),
 213                           path, opcode, 1);
 214
 215         if (!(*out_op)) {
 216                 return (AE_NOT_FOUND);
 217         }
 218
 219         return (AE_OK);
 220 }
 221
 222 #endif
 223
 224
 225 /*******************************************************************************
 226  *
 227  * FUNCTION:    Acpi_ps_complete_this_op
 228  *
 229  * PARAMETERS:  Walk_state      - Current State
 230  *              Op              - Op to complete
 231  *
 232  * RETURN:      TRUE if Op and subtree was deleted
 233  *
 234  * DESCRIPTION: Perform any cleanup at the completion of an Op.
 235  *
 236  ******************************************************************************/
 237
 238 static u8
 239 acpi_ps_complete_this_op (
 240         ACPI_WALK_STATE         *walk_state,
 241         ACPI_PARSE_OBJECT       *op)
 242 {
 243 #ifndef PARSER_ONLY
 244         ACPI_PARSE_OBJECT       *prev;
 245         ACPI_PARSE_OBJECT       *next;
 246         ACPI_OPCODE_INFO        *op_info;
 247         ACPI_OPCODE_INFO        *parent_info;
 248         u32                     opcode_class;
 249         ACPI_PARSE_OBJECT       *replacement_op = NULL;
 250
 251
 252         op_info     = acpi_ps_get_opcode_info (op->opcode);
 253         opcode_class = ACPI_GET_OP_CLASS (op_info);
 254
 255
 256         /* Delete this op and the subtree below it if asked to */
 257
 258         if (((walk_state->parse_flags & ACPI_PARSE_TREE_MASK) == ACPI_PARSE_DELETE_TREE) &&
 259                 (opcode_class != OPTYPE_CONSTANT)       &&
 260                 (opcode_class != OPTYPE_LITERAL)        &&
 261                 (opcode_class != OPTYPE_LOCAL_VARIABLE) &&
 262                 (opcode_class != OPTYPE_METHOD_ARGUMENT) &&
 263                 (opcode_class != OPTYPE_DATA_TERM)      &&
 264                 (op->opcode  != AML_NAMEPATH_OP)) {
 265                 /* Make sure that we only delete this subtree */
 266
 267                 if (op->parent) {
 268                         /*
 269                          * Check if we need to replace the operator and its subtree
 270                          * with a return value op (placeholder op)
 271                          */
 272
 273                         parent_info = acpi_ps_get_opcode_info (op->parent->opcode);
 274
 275                         switch (ACPI_GET_OP_CLASS (parent_info)) {
 276                         case OPTYPE_CONTROL:        /* IF, ELSE, WHILE only */
 277                                 break;
 278
 279                         case OPTYPE_NAMED_OBJECT:   /* Scope, method, etc. */
 280
 281                                 /*
 282                                  * These opcodes contain Term_arg operands. The current
 283                                  * op must be replace by a placeholder return op
 284                                  */
 285
 286                                 if ((op->parent->opcode == AML_REGION_OP)       ||
 287                                         (op->parent->opcode == AML_CREATE_FIELD_OP) ||
 288                                         (op->parent->opcode == AML_BIT_FIELD_OP)    ||
 289                                         (op->parent->opcode == AML_BYTE_FIELD_OP)   ||
 290                                         (op->parent->opcode == AML_WORD_FIELD_OP)   ||
 291                                         (op->parent->opcode == AML_DWORD_FIELD_OP)  ||
 292                                         (op->parent->opcode == AML_QWORD_FIELD_OP)) {
 293                                         replacement_op = acpi_ps_alloc_op (AML_RETURN_VALUE_OP);
 294                                         if (!replacement_op) {
 295                                                 return (FALSE);
 296                                         }
 297                                 }
 298
 299                                 break;
 300
 301                         default:
 302                                 replacement_op = acpi_ps_alloc_op (AML_RETURN_VALUE_OP);
 303                                 if (!replacement_op) {
 304                                         return (FALSE);
 305                                 }
 306                         }
 307
 308                         /* We must unlink this op from the parent tree */
 309
 310                         prev = op->parent->value.arg;
 311                         if (prev == op) {
 312                                 /* This op is the first in the list */
 313
 314                                 if (replacement_op) {
 315                                         replacement_op->parent   = op->parent;
 316                                         replacement_op->value.arg = NULL;
 317                                         op->parent->value.arg    = replacement_op;
 318                                         replacement_op->next     = op->next;
 319                                 }
 320                                 else {
 321                                         op->parent->value.arg    = op->next;
 322                                 }
 323                         }
 324
 325                         /* Search the parent list */
 326
 327                         else while (prev) {
 328                                 /* Traverse all siblings in the parent's argument list */
 329
 330                                 next = prev->next;
 331                                 if (next == op) {
 332                                         if (replacement_op) {
 333                                                 replacement_op->parent = op->parent;
 334                                                 replacement_op->value.arg = NULL;
 335                                                 prev->next = replacement_op;
 336                                                 replacement_op->next = op->next;
 337                                                 next = NULL;
 338                                         }
 339                                         else {
 340                                                 prev->next = op->next;
 341                                                 next = NULL;
 342                                         }
 343                                 }
 344
 345                                 prev = next;
 346                         }
 347
 348                 }
 349
 350                 /* Now we can actually delete the subtree rooted at op */
 351
 352                 acpi_ps_delete_parse_tree (op);
 353
 354                 return (TRUE);
 355         }
 356
 357         return (FALSE);
 358
 359 #else
 360         return (FALSE);
 361 #endif
 362 }
 363
 364
 365 /*******************************************************************************
 366  *
 367  * FUNCTION:    Acpi_ps_next_parse_state
 368  *
 369  * PARAMETERS:  Parser_state        - Current parser state object
 370  *
 371  * RETURN:
 372  *
 373  * DESCRIPTION:
 374  *
 375  ******************************************************************************/
 376
 377 static ACPI_STATUS
 378 acpi_ps_next_parse_state (
 379         ACPI_WALK_STATE         *walk_state,
 380         ACPI_PARSE_OBJECT       *op,
 381         ACPI_STATUS             callback_status)
 382 {
 383         ACPI_PARSE_STATE        *parser_state = walk_state->parser_state;
 384         ACPI_STATUS             status = AE_CTRL_PENDING;
 385         u8                      *start;
 386         u32                     package_length;
 387
 388
 389         switch (callback_status) {
 390         case AE_CTRL_TERMINATE:
 391
 392                 /*
 393                  * A control method was terminated via a RETURN statement.
 394                  * The walk of this method is complete.
 395                  */
 396
 397                 parser_state->aml = parser_state->aml_end;
 398                 status = AE_CTRL_TERMINATE;
 399                 break;
 400
 401
 402         case AE_CTRL_PENDING:
 403
 404                         /*
 405                          * Predicate of a WHILE was true and the loop just completed an
 406                          * execution.  Go back to the start of the loop and reevaluate the
 407                          * predicate.
 408                          */
 409 /*            Walk_state->Control_state->Common.State =
 410                                         CONTROL_PREDICATE_EXECUTING;*/
 411
 412                 /* TBD: How to handle a break within a while. */
 413                 /* This code attempts it */
 414
 415                 parser_state->aml = walk_state->aml_last_while;
 416                 break;
 417
 418
 419         case AE_CTRL_TRUE:
 420                         /*
 421                          * Predicate of an IF was true, and we are at the matching ELSE.
 422                          * Just close out this package
 423                          *
 424                          * Note: Parser_state->Aml is modified by the package length procedure
 425                          * TBD: [Investigate] perhaps it shouldn't, too much trouble
 426                          */
 427                 start = parser_state->aml;
 428                 package_length = acpi_ps_get_next_package_length (parser_state);
 429                 parser_state->aml = start + package_length;
 430                 break;
 431
 432
 433         case AE_CTRL_FALSE:
 434
 435                 /*
 436                  * Either an IF/WHILE Predicate was false or we encountered a BREAK
 437                  * opcode.  In both cases, we do not execute the rest of the
 438                  * package;  We simply close out the parent (finishing the walk of
 439                  * this branch of the tree) and continue execution at the parent
 440                  * level.
 441                  */
 442
 443                 parser_state->aml = parser_state->scope->parse_scope.pkg_end;
 444
 445                 /* In the case of a BREAK, just force a predicate (if any) to FALSE */
 446
 447                 walk_state->control_state->common.value = FALSE;
 448                 status = AE_CTRL_END;
 449                 break;
 450
 451
 452         case AE_CTRL_TRANSFER:
 453
 454                 /*
 455                  * A method call (invocation) -- transfer control
 456                  */
 457                 status = AE_CTRL_TRANSFER;
 458                 walk_state->prev_op = op;
 459                 walk_state->method_call_op = op;
 460                 walk_state->method_call_node = (op->value.arg)->node;
 461
 462                 /* Will return value (if any) be used by the caller? */
 463
 464                 walk_state->return_used = acpi_ds_is_result_used (op, walk_state);
 465                 break;
 466
 467
 468         default:
 469                 status = callback_status;
 470                 if ((callback_status & AE_CODE_MASK) == AE_CODE_CONTROL) {
 471                         status = AE_OK;
 472                 }
 473                 break;
 474         }
 475
 476
 477         return (status);
 478 }
 479
 480
 481 /*******************************************************************************
 482  *
 483  * FUNCTION:    Acpi_ps_parse_loop
 484  *
 485  * PARAMETERS:  Parser_state        - Current parser state object
 486  *
 487  * RETURN:      Status
 488  *
 489  * DESCRIPTION: Parse AML (pointed to by the current parser state) and return
 490  *              a tree of ops.
 491  *
 492  ******************************************************************************/
 493
 494 ACPI_STATUS
 495 acpi_ps_parse_loop (
 496         ACPI_WALK_STATE         *walk_state)
 497 {
 498         ACPI_STATUS             status = AE_OK;
 499         ACPI_PARSE_OBJECT       *op = NULL;     /* current op */
 500         ACPI_OPCODE_INFO        *op_info;
 501         ACPI_PARSE_OBJECT       *arg = NULL;
 502         ACPI_PARSE2_OBJECT      *deferred_op;
 503         u32                     arg_count;      /* push for fixed or var args */
 504         u32                     arg_types = 0;
 505         ACPI_PTRDIFF            aml_offset;
 506         u16                     opcode;
 507         ACPI_PARSE_OBJECT       pre_op;
 508         ACPI_PARSE_STATE        *parser_state;
 509         u8                      *aml_op_start;
 510
 511
 512         parser_state = walk_state->parser_state;
 513
 514 #ifndef PARSER_ONLY
 515         if (walk_state->walk_type & WALK_METHOD_RESTART) {
 516                 /* We are restarting a preempted control method */
 517
 518                 if (acpi_ps_has_completed_scope (parser_state)) {
 519                         /*
 520                          * We must check if a predicate to an IF or WHILE statement
 521                          * was just completed
 522                          */
 523                         if ((parser_state->scope->parse_scope.op) &&
 524                                 ((parser_state->scope->parse_scope.op->opcode == AML_IF_OP) ||
 525                                 (parser_state->scope->parse_scope.op->opcode == AML_WHILE_OP)) &&
 526                                 (walk_state->control_state) &&
 527                                 (walk_state->control_state->common.state ==
 528                                         CONTROL_PREDICATE_EXECUTING)) {
 529
 530                                 /*
 531                                  * A predicate was just completed, get the value of the
 532                                  * predicate and branch based on that value
 533                                  */
 534
 535                                 status = acpi_ds_get_predicate_value (walk_state, NULL, TRUE);
 536                                 if (ACPI_FAILURE (status) &&
 537                                         ((status & AE_CODE_MASK) != AE_CODE_CONTROL)) {
 538                                         return (status);
 539                                 }
 540
 541                                 status = acpi_ps_next_parse_state (walk_state, op, status);
 542                         }
 543
 544                         acpi_ps_pop_scope (parser_state, &op, &arg_types, &arg_count);
 545                 }
 546
 547                 else if (walk_state->prev_op) {
 548                         /* We were in the middle of an op */
 549
 550                         op = walk_state->prev_op;
 551                         arg_types = walk_state->prev_arg_types;
 552                 }
 553         }
 554 #endif
 555
 556         /*
 557          * Iterative parsing loop, while there is more aml to process:
 558          */
 559         while ((parser_state->aml < parser_state->aml_end) || (op)) {
 560                 if (!op) {
 561                         /* Get the next opcode from the AML stream */
 562
 563                         aml_op_start = parser_state->aml;
 564                         aml_offset = parser_state->aml - parser_state->aml_start;
 565                         opcode     = acpi_ps_peek_opcode (parser_state);
 566
 567                         /*
 568                          * First cut to determine what we have found:
 569                          * 1) A valid AML opcode
 570                          * 2) A name string
 571                          * 3) An unknown/invalid opcode
 572                          */
 573
 574                         op_info = acpi_ps_get_opcode_info (opcode);
 575                         switch (ACPI_GET_OP_TYPE (op_info)) {
 576                         case ACPI_OP_TYPE_OPCODE:
 577
 578                                 /* Found opcode info, this is a normal opcode */
 579
 580                                 parser_state->aml += acpi_ps_get_opcode_size (opcode);
 581                                 arg_types = op_info->parse_args;
 582                                 break;
 583
 584                         case ACPI_OP_TYPE_ASCII:
 585                         case ACPI_OP_TYPE_PREFIX:
 586                                 /*
 587                                  * Starts with a valid prefix or ASCII char, this is a name
 588                                  * string.  Convert the bare name string to a namepath.
 589                                  */
 590
 591                                 opcode = AML_NAMEPATH_OP;
 592                                 arg_types = ARGP_NAMESTRING;
 593                                 break;
 594
 595                         case ACPI_OP_TYPE_UNKNOWN:
 596
 597                                 /* The opcode is unrecognized.  Just skip unknown opcodes */
 598
 599                                 /* Assume one-byte bad opcode */
 600
 601                                 parser_state->aml++;
 602                                 continue;
 603                         }
 604
 605
 606                         /* Create Op structure and append to parent's argument list */
 607
 608                         if (acpi_ps_is_named_op (opcode)) {
 609                                 pre_op.value.arg = NULL;
 610                                 pre_op.opcode = opcode;
 611
 612                                 while (GET_CURRENT_ARG_TYPE (arg_types) != ARGP_NAME) {
 613                                         arg = acpi_ps_get_next_arg (parser_state,
 614                                                          GET_CURRENT_ARG_TYPE (arg_types),
 615                                                          &arg_count);
 616                                         acpi_ps_append_arg (&pre_op, arg);
 617                                         INCREMENT_ARG_LIST (arg_types);
 618                                 }
 619
 620
 621                                 /* We know that this arg is a name, move to next arg */
 622
 623                                 INCREMENT_ARG_LIST (arg_types);
 624
 625                                 if (walk_state->descending_callback != NULL) {
 626                                         /*
 627                                          * Find the object.  This will either insert the object into
 628                                          * the namespace or simply look it up
 629                                          */
 630                                         status = walk_state->descending_callback (opcode, NULL, walk_state, &op);
 631                                         if (op == NULL) {
 632                                                 continue;
 633                                         }
 634                                         status = acpi_ps_next_parse_state (walk_state, op, status);
 635                                         if (status == AE_CTRL_PENDING) {
 636                                                 status = AE_OK;
 637                                                 goto close_this_op;
 638                                         }
 639
 640                                         if (ACPI_FAILURE (status)) {
 641                                                 goto close_this_op;
 642                                         }
 643                                 }
 644
 645                                 acpi_ps_append_arg (op, pre_op.value.arg);
 646                                 acpi_gbl_depth++;
 647
 648
 649                                 if (op->opcode == AML_REGION_OP) {
 650                                         deferred_op = acpi_ps_to_extended_op (op);
 651                                         if (deferred_op) {
 652                                                 /*
 653                                                  * Defer final parsing of an Operation_region body,
 654                                                  * because we don't have enough info in the first pass
 655                                                  * to parse it correctly (i.e., there may be method
 656                                                  * calls within the Term_arg elements of the body.
 657                                                  *
 658                                                  * However, we must continue parsing because
 659                                                  * the opregion is not a standalone package --
 660                                                  * we don't know where the end is at this point.
 661                                                  *
 662                                                  * (Length is unknown until parse of the body complete)
 663                                                  */
 664
 665                                                 deferred_op->data   = aml_op_start;
 666                                                 deferred_op->length = 0;
 667                                         }
 668                                 }
 669                         }
 670
 671
 672                         else {
 673                                 /* Not a named opcode, just allocate Op and append to parent */
 674
 675                                 op = acpi_ps_alloc_op (opcode);
 676                                 if (!op) {
 677                                         return (AE_NO_MEMORY);
 678                                 }
 679
 680
 681                                 if ((op->opcode == AML_CREATE_FIELD_OP) ||
 682                                         (op->opcode == AML_BIT_FIELD_OP)    ||
 683                                         (op->opcode == AML_BYTE_FIELD_OP)   ||
 684                                         (op->opcode == AML_WORD_FIELD_OP)   ||
 685                                         (op->opcode == AML_DWORD_FIELD_OP)) {
 686                                         /*
 687                                          * Backup to beginning of Create_xXXfield declaration
 688                                          * Body_length is unknown until we parse the body
 689                                          */
 690                                         deferred_op = (ACPI_PARSE2_OBJECT *) op;
 691
 692                                         deferred_op->data   = aml_op_start;
 693                                         deferred_op->length = 0;
 694                                 }
 695
 696                                 acpi_ps_append_arg (acpi_ps_get_parent_scope (parser_state), op);
 697
 698                                 if ((walk_state->descending_callback != NULL)) {
 699                                         /*
 700                                          * Find the object.  This will either insert the object into
 701                                          * the namespace or simply look it up
 702                                          */
 703                                         status = walk_state->descending_callback (opcode, op, walk_state, &op);
 704                                         status = acpi_ps_next_parse_state (walk_state, op, status);
 705                                         if (status == AE_CTRL_PENDING) {
 706                                                 status = AE_OK;
 707                                                 goto close_this_op;
 708                                         }
 709
 710                                         if (ACPI_FAILURE (status)) {
 711                                                 goto close_this_op;
 712                                         }
 713                                 }
 714                         }
 715
 716                         op->aml_offset = aml_offset;
 717
 718                 }
 719
 720
 721                 /* Start Arg_count at zero because we don't know if there are any args yet */
 722
 723                 arg_count = 0;
 724
 725
 726                 if (arg_types)  /* Are there any arguments that must be processed? */ {
 727                         /* get arguments */
 728
 729                         switch (op->opcode) {
 730                         case AML_BYTE_OP:       /* AML_BYTEDATA_ARG */
 731                         case AML_WORD_OP:       /* AML_WORDDATA_ARG */
 732                         case AML_DWORD_OP:      /* AML_DWORDATA_ARG */
 733                         case AML_STRING_OP:     /* AML_ASCIICHARLIST_ARG */
 734
 735                                 /* fill in constant or string argument directly */
 736
 737                                 acpi_ps_get_next_simple_arg (parser_state,
 738                                                  GET_CURRENT_ARG_TYPE (arg_types), op);
 739                                 break;
 740
 741                         case AML_NAMEPATH_OP:   /* AML_NAMESTRING_ARG */
 742
 743                                 acpi_ps_get_next_namepath (parser_state, op, &arg_count, 1);
 744                                 arg_types = 0;
 745                                 break;
 746
 747
 748                         default:
 749
 750                                 /* Op is not a constant or string, append each argument */
 751
 752                                 while (GET_CURRENT_ARG_TYPE (arg_types) && !arg_count) {
 753                                         aml_offset = parser_state->aml - parser_state->aml_start;
 754                                         arg = acpi_ps_get_next_arg (parser_state,
 755                                                          GET_CURRENT_ARG_TYPE (arg_types),
 756                                                          &arg_count);
 757                                         if (arg) {
 758                                                 arg->aml_offset = aml_offset;
 759                                                 acpi_ps_append_arg (op, arg);
 760                                         }
 761
 762                                         INCREMENT_ARG_LIST (arg_types);
 763                                 }
 764
 765
 766                                 /* For a method, save the length and address of the body */
 767
 768                                 if (op->opcode == AML_METHOD_OP) {
 769                                         deferred_op = acpi_ps_to_extended_op (op);
 770                                         if (deferred_op) {
 771                                                 /*
 772                                                  * Skip parsing of control method or opregion body,
 773                                                  * because we don't have enough info in the first pass
 774                                                  * to parse them correctly.
 775                                                  */
 776
 777                                                 deferred_op->data   = parser_state->aml;
 778                                                 deferred_op->length = parser_state->pkg_end -
 779                                                                   parser_state->aml;
 780
 781                                                 /*
 782                                                  * Skip body of method.  For Op_regions, we must continue
 783                                                  * parsing because the opregion is not a standalone
 784                                                  * package (We don't know where the end is).
 785                                                  */
 786                                                 parser_state->aml   = parser_state->pkg_end;
 787                                                 arg_count           = 0;
 788                                         }
 789                                 }
 790
 791                                 break;
 792                         }
 793                 }
 794
 795
 796                 /*
 797                  * Zero Arg_count means that all arguments for this op have been processed
 798                  */
 799                 if (!arg_count) {
 800                         /* completed Op, prepare for next */
 801
 802                         if (acpi_ps_is_named_op (op->opcode)) {
 803                                 if (acpi_gbl_depth) {
 804                                         acpi_gbl_depth--;
 805                                 }
 806
 807                                 if (op->opcode == AML_REGION_OP) {
 808                                         deferred_op = acpi_ps_to_extended_op (op);
 809                                         if (deferred_op) {
 810                                                 /*
 811                                                  * Skip parsing of control method or opregion body,
 812                                                  * because we don't have enough info in the first pass
 813                                                  * to parse them correctly.
 814                                                  *
 815                                                  * Completed parsing an Op_region declaration, we now
 816                                                  * know the length.
 817                                                  */
 818
 819                                                 deferred_op->length = parser_state->aml -
 820                                                                  deferred_op->data;
 821                                         }
 822                                 }
 823                         }
 824
 825                         if ((op->opcode == AML_CREATE_FIELD_OP) ||
 826                                 (op->opcode == AML_BIT_FIELD_OP)    ||
 827                                 (op->opcode == AML_BYTE_FIELD_OP)   ||
 828                                 (op->opcode == AML_WORD_FIELD_OP)   ||
 829                                 (op->opcode == AML_DWORD_FIELD_OP)  ||
 830                                 (op->opcode == AML_QWORD_FIELD_OP)) {
 831                                 /*
 832                                  * Backup to beginning of Create_xXXfield declaration (1 for
 833                                  * Opcode)
 834                                  *
 835                                  * Body_length is unknown until we parse the body
 836                                  */
 837                                 deferred_op = (ACPI_PARSE2_OBJECT *) op;
 838                                 deferred_op->length = parser_state->aml - deferred_op->data;
 839                         }
 840
 841                         /* This op complete, notify the dispatcher */
 842
 843                         if (walk_state->ascending_callback != NULL) {
 844                                 status = walk_state->ascending_callback (walk_state, op);
 845                                 status = acpi_ps_next_parse_state (walk_state, op, status);
 846                                 if (status == AE_CTRL_PENDING) {
 847                                         status = AE_OK;
 848                                         goto close_this_op;
 849                                 }
 850                         }
 851
 852
 853 close_this_op:
 854
 855                         /*
 856                          * Finished one argument of the containing scope
 857                          */
 858                         parser_state->scope->parse_scope.arg_count--;
 859
 860                         /* Close this Op (may result in parse subtree deletion) */
 861
 862                         if (acpi_ps_complete_this_op (walk_state, op)) {
 863                                 op = NULL;
 864                         }
 865
 866
 867                         switch (status) {
 868                         case AE_OK:
 869                                 break;
 870
 871
 872                         case AE_CTRL_TRANSFER:
 873
 874                                 /*
 875                                  * We are about to transfer to a called method.
 876                                  */
 877                                 walk_state->prev_op = op;
 878                                 walk_state->prev_arg_types = arg_types;
 879                                 return (status);
 880                                 break;
 881
 882
 883                         case AE_CTRL_END:
 884
 885                                 acpi_ps_pop_scope (parser_state, &op, &arg_types, &arg_count);
 886
 887                                 status = walk_state->ascending_callback (walk_state, op);
 888                                 status = acpi_ps_next_parse_state (walk_state, op, status);
 889
 890                                 acpi_ps_complete_this_op (walk_state, op);
 891                                 op = NULL;
 892                                 status = AE_OK;
 893                                 break;
 894
 895
 896                         case AE_CTRL_TERMINATE:
 897
 898                                 status = AE_OK;
 899
 900                                 /* Clean up */
 901                                 do {
 902                                         if (op) {
 903                                                 acpi_ps_complete_this_op (walk_state, op);
 904                                         }
 905
 906                                         acpi_ps_pop_scope (parser_state, &op, &arg_types, &arg_count);
 907                                 } while (op);
 908
 909                                 return (status);
 910                                 break;
 911
 912
 913                         default:  /* All other non-AE_OK status */
 914
 915                                 if (op == NULL) {
 916                                         acpi_ps_pop_scope (parser_state, &op, &arg_types, &arg_count);
 917                                 }
 918                                 walk_state->prev_op = op;
 919                                 walk_state->prev_arg_types = arg_types;
 920
 921                                 /*
 922                                  * TEMP:
 923                                  */
 924
 925                                 return (status);
 926                                 break;
 927                         }
 928
 929
 930                         /* This scope complete? */
 931
 932                         if (acpi_ps_has_completed_scope (parser_state)) {
 933                                 acpi_ps_pop_scope (parser_state, &op, &arg_types, &arg_count);
 934                         }
 935
 936                         else {
 937                                 op = NULL;
 938                         }
 939
 940                 }
 941
 942
 943                 /* Arg_count is non-zero */
 944
 945                 else {
 946                         /* complex argument, push Op and prepare for argument */
 947
 948                         acpi_ps_push_scope (parser_state, op, arg_types, arg_count);
 949                         op = NULL;
 950                 }
 951
 952         } /* while Parser_state->Aml */
 953
 954
 955         /*
 956          * Complete the last Op (if not completed), and clear the scope stack.
 957          * It is easily possible to end an AML "package" with an unbounded number
 958          * of open scopes (such as when several AML blocks are closed with
 959          * sequential closing braces).  We want to terminate each one cleanly.
 960          */
 961
 962         do {
 963                 if (op) {
 964                         if (walk_state->ascending_callback != NULL) {
 965                                 status = walk_state->ascending_callback (walk_state, op);
 966                                 status = acpi_ps_next_parse_state (walk_state, op, status);
 967                                 if (status == AE_CTRL_PENDING) {
 968                                         status = AE_OK;
 969                                         goto close_this_op;
 970                                 }
 971
 972                                 if (status == AE_CTRL_TERMINATE) {
 973                                         status = AE_OK;
 974
 975                                         /* Clean up */
 976                                         do {
 977                                                 if (op) {
 978                                                         acpi_ps_complete_this_op (walk_state, op);
 979                                                 }
 980
 981                                                 acpi_ps_pop_scope (parser_state, &op, &arg_types, &arg_count);
 982
 983                                         } while (op);
 984
 985                                         return (status);
 986                                 }
 987
 988                                 else if (ACPI_FAILURE (status)) {
 989                                         acpi_ps_complete_this_op (walk_state, op);
 990                                         return (status);
 991                                 }
 992                         }
 993
 994                         acpi_ps_complete_this_op (walk_state, op);
 995                 }
 996
 997                 acpi_ps_pop_scope (parser_state, &op, &arg_types, &arg_count);
 998
 999         } while (op);
1000
1001         return (status);
1002 }
1003
1004
1005 /*******************************************************************************
1006  *
1007  * FUNCTION:    Acpi_ps_parse_aml
1008  *
1009  * PARAMETERS:  Start_scope     - The starting point of the parse.  Becomes the
1010  *                                root of the parsed op tree.
1011  *              Aml             - Pointer to the raw AML code to parse
1012  *              Aml_size        - Length of the AML to parse
1013  *
1014  * RETURN:      Status
1015  *
1016  * DESCRIPTION: Parse raw AML and return a tree of ops
1017  *
1018  ******************************************************************************/
1019
1020 ACPI_STATUS
1021 acpi_ps_parse_aml (
1022         ACPI_PARSE_OBJECT       *start_scope,
1023         u8                      *aml,
1024         u32                     aml_size,
1025         u32                     parse_flags,
1026         ACPI_NAMESPACE_NODE     *method_node,
1027         ACPI_OPERAND_OBJECT     **params,
1028         ACPI_OPERAND_OBJECT     **caller_return_desc,
1029         ACPI_PARSE_DOWNWARDS    descending_callback,
1030         ACPI_PARSE_UPWARDS      ascending_callback)
1031 {
1032         ACPI_STATUS             status;
1033         ACPI_PARSE_STATE        *parser_state;
1034         ACPI_WALK_STATE         *walk_state;
1035         ACPI_WALK_LIST          walk_list;
1036         ACPI_NAMESPACE_NODE     *node = NULL;
1037         ACPI_WALK_LIST          *prev_walk_list = acpi_gbl_current_walk_list;
1038         ACPI_OPERAND_OBJECT     *return_desc;
1039         ACPI_OPERAND_OBJECT     *mth_desc = NULL;
1040
1041
1042         /* Create and initialize a new parser state */
1043
1044         parser_state = acpi_ps_create_state (aml, aml_size);
1045         if (!parser_state) {
1046                 return (AE_NO_MEMORY);
1047         }
1048
1049         acpi_ps_init_scope (parser_state, start_scope);
1050
1051         if (method_node) {
1052                 mth_desc = acpi_ns_get_attached_object (method_node);
1053         }
1054
1055         /* Create and initialize a new walk list */
1056
1057         walk_list.walk_state = NULL;
1058         walk_list.acquired_mutex_list.prev = NULL;
1059         walk_list.acquired_mutex_list.next = NULL;
1060
1061         walk_state = acpi_ds_create_walk_state (TABLE_ID_DSDT, parser_state->start_op, mth_desc, &walk_list);
1062         if (!walk_state) {
1063                 status = AE_NO_MEMORY;
1064                 goto cleanup;
1065         }
1066
1067         walk_state->method_node         = method_node;
1068         walk_state->parser_state        = parser_state;
1069         walk_state->parse_flags         = parse_flags;
1070         walk_state->descending_callback = descending_callback;
1071         walk_state->ascending_callback  = ascending_callback;
1072
1073         /* TBD: [Restructure] TEMP until we pass Walk_state to the interpreter
1074          */
1075         acpi_gbl_current_walk_list = &walk_list;
1076
1077
1078         if (method_node) {
1079                 parser_state->start_node = method_node;
1080                 walk_state->walk_type   = WALK_METHOD;
1081
1082                 /* Push start scope on scope stack and make it current  */
1083
1084                 status = acpi_ds_scope_stack_push (method_node, ACPI_TYPE_METHOD, walk_state);
1085                 if (ACPI_FAILURE (status)) {
1086                         return (status);
1087                 }
1088
1089                 /* Init arguments if this is a control method */
1090                 /* TBD: [Restructure] add walkstate as a param */
1091
1092                 acpi_ds_method_data_init_args (params, MTH_NUM_ARGS, walk_state);
1093         }
1094
1095         else {
1096                 /* Setup the current scope */
1097
1098                 node = parser_state->start_op->node;
1099                 parser_state->start_node = node;
1100
1101                 if (node) {
1102                         /* Push start scope on scope stack and make it current  */
1103
1104                         status = acpi_ds_scope_stack_push (node, node->type,
1105                                            walk_state);
1106                         if (ACPI_FAILURE (status)) {
1107                                 goto cleanup;
1108                         }
1109
1110                 }
1111         }
1112
1113
1114         status = AE_OK;
1115
1116         /*
1117          * Execute the walk loop as long as there is a valid Walk State.  This
1118          * handles nested control method invocations without recursion.
1119          */
1120
1121         while (walk_state) {
1122                 if (ACPI_SUCCESS (status)) {
1123                         status = acpi_ps_parse_loop (walk_state);
1124                 }
1125
1126                 if (status == AE_CTRL_TRANSFER) {
1127                         /*
1128                          * A method call was detected.
1129                          * Transfer control to the called control method
1130                          */
1131
1132                         status = acpi_ds_call_control_method (&walk_list, walk_state, NULL);
1133
1134                         /*
1135                          * If the transfer to the new method method call worked, a new walk
1136                          * state was created -- get it
1137                          */
1138
1139                         walk_state = acpi_ds_get_current_walk_state (&walk_list);
1140                         continue;
1141                 }
1142
1143                 else if (status == AE_CTRL_TERMINATE) {
1144                         status = AE_OK;
1145                 }
1146
1147                 /* We are done with this walk, move on to the parent if any */
1148
1149
1150                 walk_state = acpi_ds_pop_walk_state (&walk_list);
1151
1152                 /* Extract return value before we delete Walk_state */
1153
1154                 return_desc = walk_state->return_desc;
1155
1156                 /* Reset the current scope to the beginning of scope stack */
1157
1158                 acpi_ds_scope_stack_clear (walk_state);
1159
1160                 /*
1161                  * If we just returned from the execution of a control method,
1162                  * there's lots of cleanup to do
1163                  */
1164
1165                 if ((walk_state->parse_flags & ACPI_PARSE_MODE_MASK) == ACPI_PARSE_EXECUTE) {
1166                         acpi_ds_terminate_control_method (walk_state);
1167                 }
1168
1169                  /* Delete this walk state and all linked control states */
1170
1171                 acpi_ps_cleanup_scope (walk_state->parser_state);
1172                 acpi_cm_free (walk_state->parser_state);
1173                 acpi_ds_delete_walk_state (walk_state);
1174
1175            /* Check if we have restarted a preempted walk */
1176
1177                 walk_state = acpi_ds_get_current_walk_state (&walk_list);
1178                 if (walk_state &&
1179                         ACPI_SUCCESS (status)) {
1180                         /* There is another walk state, restart it */
1181
1182                         /*
1183                          * If the method returned value is not used by the parent,
1184                          * The object is deleted
1185                          */
1186
1187                         acpi_ds_restart_control_method (walk_state, return_desc);
1188                         walk_state->walk_type |= WALK_METHOD_RESTART;
1189                 }
1190
1191                 /*
1192                  * Just completed a 1st-level method, save the final internal return
1193                  * value (if any)
1194                  */
1195
1196                 else if (caller_return_desc) {
1197                         *caller_return_desc = return_desc; /* NULL if no return value */
1198                 }
1199
1200                 else if (return_desc) {
1201                         /* Caller doesn't want it, must delete it */
1202
1203                         acpi_cm_remove_reference (return_desc);
1204                 }
1205         }
1206
1207
1208         /* Normal exit */
1209
1210         acpi_aml_release_all_mutexes ((ACPI_OPERAND_OBJECT *) &walk_list.acquired_mutex_list);
1211         acpi_gbl_current_walk_list = prev_walk_list;
1212         return (status);
1213
1214
1215 cleanup:
1216
1217         /* Cleanup */
1218
1219         acpi_ds_delete_walk_state (walk_state);
1220         acpi_ps_cleanup_scope (parser_state);
1221         acpi_cm_free (parser_state);
1222
1223         acpi_aml_release_all_mutexes ((ACPI_OPERAND_OBJECT *)&walk_list.acquired_mutex_list);
1224         acpi_gbl_current_walk_list = prev_walk_list;
1225
1226         return (status);
1227 }
1228
1229