10d02842fSSascha Wildner /******************************************************************************
20d02842fSSascha Wildner *
30d02842fSSascha Wildner * Module Name: psloop - Main AML parse loop
40d02842fSSascha Wildner *
50d02842fSSascha Wildner *****************************************************************************/
60d02842fSSascha Wildner
7b4315fc7SSascha Wildner /******************************************************************************
8b4315fc7SSascha Wildner *
9b4315fc7SSascha Wildner * 1. Copyright Notice
10b4315fc7SSascha Wildner *
11*383048acSSascha Wildner * Some or all of this work - Copyright (c) 1999 - 2021, Intel Corp.
120d02842fSSascha Wildner * All rights reserved.
130d02842fSSascha Wildner *
14b4315fc7SSascha Wildner * 2. License
15b4315fc7SSascha Wildner *
16b4315fc7SSascha Wildner * 2.1. This is your license from Intel Corp. under its intellectual property
17b4315fc7SSascha Wildner * rights. You may have additional license terms from the party that provided
18b4315fc7SSascha Wildner * you this software, covering your right to use that party's intellectual
19b4315fc7SSascha Wildner * property rights.
20b4315fc7SSascha Wildner *
21b4315fc7SSascha Wildner * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
22b4315fc7SSascha Wildner * copy of the source code appearing in this file ("Covered Code") an
23b4315fc7SSascha Wildner * irrevocable, perpetual, worldwide license under Intel's copyrights in the
24b4315fc7SSascha Wildner * base code distributed originally by Intel ("Original Intel Code") to copy,
25b4315fc7SSascha Wildner * make derivatives, distribute, use and display any portion of the Covered
26b4315fc7SSascha Wildner * Code in any form, with the right to sublicense such rights; and
27b4315fc7SSascha Wildner *
28b4315fc7SSascha Wildner * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
29b4315fc7SSascha Wildner * license (with the right to sublicense), under only those claims of Intel
30b4315fc7SSascha Wildner * patents that are infringed by the Original Intel Code, to make, use, sell,
31b4315fc7SSascha Wildner * offer to sell, and import the Covered Code and derivative works thereof
32b4315fc7SSascha Wildner * solely to the minimum extent necessary to exercise the above copyright
33b4315fc7SSascha Wildner * license, and in no event shall the patent license extend to any additions
34b4315fc7SSascha Wildner * to or modifications of the Original Intel Code. No other license or right
35b4315fc7SSascha Wildner * is granted directly or by implication, estoppel or otherwise;
36b4315fc7SSascha Wildner *
37b4315fc7SSascha Wildner * The above copyright and patent license is granted only if the following
38b4315fc7SSascha Wildner * conditions are met:
39b4315fc7SSascha Wildner *
40b4315fc7SSascha Wildner * 3. Conditions
41b4315fc7SSascha Wildner *
42b4315fc7SSascha Wildner * 3.1. Redistribution of Source with Rights to Further Distribute Source.
43b4315fc7SSascha Wildner * Redistribution of source code of any substantial portion of the Covered
44b4315fc7SSascha Wildner * Code or modification with rights to further distribute source must include
45b4315fc7SSascha Wildner * the above Copyright Notice, the above License, this list of Conditions,
46b4315fc7SSascha Wildner * and the following Disclaimer and Export Compliance provision. In addition,
47b4315fc7SSascha Wildner * Licensee must cause all Covered Code to which Licensee contributes to
48b4315fc7SSascha Wildner * contain a file documenting the changes Licensee made to create that Covered
49b4315fc7SSascha Wildner * Code and the date of any change. Licensee must include in that file the
50b4315fc7SSascha Wildner * documentation of any changes made by any predecessor Licensee. Licensee
51b4315fc7SSascha Wildner * must include a prominent statement that the modification is derived,
52b4315fc7SSascha Wildner * directly or indirectly, from Original Intel Code.
53b4315fc7SSascha Wildner *
54b4315fc7SSascha Wildner * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
55b4315fc7SSascha Wildner * Redistribution of source code of any substantial portion of the Covered
56b4315fc7SSascha Wildner * Code or modification without rights to further distribute source must
57b4315fc7SSascha Wildner * include the following Disclaimer and Export Compliance provision in the
58b4315fc7SSascha Wildner * documentation and/or other materials provided with distribution. In
59b4315fc7SSascha Wildner * addition, Licensee may not authorize further sublicense of source of any
60b4315fc7SSascha Wildner * portion of the Covered Code, and must include terms to the effect that the
61b4315fc7SSascha Wildner * license from Licensee to its licensee is limited to the intellectual
62b4315fc7SSascha Wildner * property embodied in the software Licensee provides to its licensee, and
63b4315fc7SSascha Wildner * not to intellectual property embodied in modifications its licensee may
64b4315fc7SSascha Wildner * make.
65b4315fc7SSascha Wildner *
66b4315fc7SSascha Wildner * 3.3. Redistribution of Executable. Redistribution in executable form of any
67b4315fc7SSascha Wildner * substantial portion of the Covered Code or modification must reproduce the
68b4315fc7SSascha Wildner * above Copyright Notice, and the following Disclaimer and Export Compliance
69b4315fc7SSascha Wildner * provision in the documentation and/or other materials provided with the
70b4315fc7SSascha Wildner * distribution.
71b4315fc7SSascha Wildner *
72b4315fc7SSascha Wildner * 3.4. Intel retains all right, title, and interest in and to the Original
73b4315fc7SSascha Wildner * Intel Code.
74b4315fc7SSascha Wildner *
75b4315fc7SSascha Wildner * 3.5. Neither the name Intel nor any other trademark owned or controlled by
76b4315fc7SSascha Wildner * Intel shall be used in advertising or otherwise to promote the sale, use or
77b4315fc7SSascha Wildner * other dealings in products derived from or relating to the Covered Code
78b4315fc7SSascha Wildner * without prior written authorization from Intel.
79b4315fc7SSascha Wildner *
80b4315fc7SSascha Wildner * 4. Disclaimer and Export Compliance
81b4315fc7SSascha Wildner *
82b4315fc7SSascha Wildner * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
83b4315fc7SSascha Wildner * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
84b4315fc7SSascha Wildner * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE,
85b4315fc7SSascha Wildner * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY
86b4315fc7SSascha Wildner * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY
87b4315fc7SSascha Wildner * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
88b4315fc7SSascha Wildner * PARTICULAR PURPOSE.
89b4315fc7SSascha Wildner *
90b4315fc7SSascha Wildner * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
91b4315fc7SSascha Wildner * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
92b4315fc7SSascha Wildner * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
93b4315fc7SSascha Wildner * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
94b4315fc7SSascha Wildner * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
95b4315fc7SSascha Wildner * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS
96b4315fc7SSascha Wildner * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
97b4315fc7SSascha Wildner * LIMITED REMEDY.
98b4315fc7SSascha Wildner *
99b4315fc7SSascha Wildner * 4.3. Licensee shall not export, either directly or indirectly, any of this
100b4315fc7SSascha Wildner * software or system incorporating such software without first obtaining any
101b4315fc7SSascha Wildner * required license or other approval from the U. S. Department of Commerce or
102b4315fc7SSascha Wildner * any other agency or department of the United States Government. In the
103b4315fc7SSascha Wildner * event Licensee exports any such software from the United States or
104b4315fc7SSascha Wildner * re-exports any such software from a foreign destination, Licensee shall
105b4315fc7SSascha Wildner * ensure that the distribution and export/re-export of the software is in
106b4315fc7SSascha Wildner * compliance with all laws, regulations, orders, or other restrictions of the
107b4315fc7SSascha Wildner * U.S. Export Administration Regulations. Licensee agrees that neither it nor
108b4315fc7SSascha Wildner * any of its subsidiaries will export/re-export any technical data, process,
109b4315fc7SSascha Wildner * software, or service, directly or indirectly, to any country for which the
110b4315fc7SSascha Wildner * United States government or any agency thereof requires an export license,
111b4315fc7SSascha Wildner * other governmental approval, or letter of assurance, without first obtaining
112b4315fc7SSascha Wildner * such license, approval or letter.
113b4315fc7SSascha Wildner *
114b4315fc7SSascha Wildner *****************************************************************************
115b4315fc7SSascha Wildner *
116b4315fc7SSascha Wildner * Alternatively, you may choose to be licensed under the terms of the
117b4315fc7SSascha Wildner * following license:
118b4315fc7SSascha Wildner *
1190d02842fSSascha Wildner * Redistribution and use in source and binary forms, with or without
1200d02842fSSascha Wildner * modification, are permitted provided that the following conditions
1210d02842fSSascha Wildner * are met:
1220d02842fSSascha Wildner * 1. Redistributions of source code must retain the above copyright
1230d02842fSSascha Wildner * notice, this list of conditions, and the following disclaimer,
1240d02842fSSascha Wildner * without modification.
1250d02842fSSascha Wildner * 2. Redistributions in binary form must reproduce at minimum a disclaimer
1260d02842fSSascha Wildner * substantially similar to the "NO WARRANTY" disclaimer below
1270d02842fSSascha Wildner * ("Disclaimer") and any redistribution must be conditioned upon
1280d02842fSSascha Wildner * including a substantially similar Disclaimer requirement for further
1290d02842fSSascha Wildner * binary redistribution.
1300d02842fSSascha Wildner * 3. Neither the names of the above-listed copyright holders nor the names
1310d02842fSSascha Wildner * of any contributors may be used to endorse or promote products derived
1320d02842fSSascha Wildner * from this software without specific prior written permission.
1330d02842fSSascha Wildner *
134b4315fc7SSascha Wildner * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
135b4315fc7SSascha Wildner * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
136b4315fc7SSascha Wildner * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
137b4315fc7SSascha Wildner * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
138b4315fc7SSascha Wildner * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
139b4315fc7SSascha Wildner * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
140b4315fc7SSascha Wildner * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
141b4315fc7SSascha Wildner * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
142b4315fc7SSascha Wildner * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
143b4315fc7SSascha Wildner * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
144b4315fc7SSascha Wildner * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
145b4315fc7SSascha Wildner *
146b4315fc7SSascha Wildner * Alternatively, you may choose to be licensed under the terms of the
1470d02842fSSascha Wildner * GNU General Public License ("GPL") version 2 as published by the Free
1480d02842fSSascha Wildner * Software Foundation.
1490d02842fSSascha Wildner *
150b4315fc7SSascha Wildner *****************************************************************************/
1510d02842fSSascha Wildner
1520d02842fSSascha Wildner /*
1530d02842fSSascha Wildner * Parse the AML and build an operation tree as most interpreters, (such as
1540d02842fSSascha Wildner * Perl) do. Parsing is done by hand rather than with a YACC generated parser
1550d02842fSSascha Wildner * to tightly constrain stack and dynamic memory usage. Parsing is kept
1560d02842fSSascha Wildner * flexible and the code fairly compact by parsing based on a list of AML
1570d02842fSSascha Wildner * opcode templates in AmlOpInfo[].
1580d02842fSSascha Wildner */
1590d02842fSSascha Wildner
1600d02842fSSascha Wildner #include "acpi.h"
1610d02842fSSascha Wildner #include "accommon.h"
162267c04fdSSascha Wildner #include "acinterp.h"
1630d02842fSSascha Wildner #include "acparser.h"
1640d02842fSSascha Wildner #include "acdispat.h"
1650d02842fSSascha Wildner #include "amlcode.h"
166d638c6eeSSascha Wildner #include "acconvert.h"
1672afeb59bSSascha Wildner #include "acnamesp.h"
1680d02842fSSascha Wildner
1690d02842fSSascha Wildner #define _COMPONENT ACPI_PARSER
1700d02842fSSascha Wildner ACPI_MODULE_NAME ("psloop")
1710d02842fSSascha Wildner
1720d02842fSSascha Wildner
1730d02842fSSascha Wildner /* Local prototypes */
1740d02842fSSascha Wildner
1750d02842fSSascha Wildner static ACPI_STATUS
1760d02842fSSascha Wildner AcpiPsGetArguments (
1770d02842fSSascha Wildner ACPI_WALK_STATE *WalkState,
1780d02842fSSascha Wildner UINT8 *AmlOpStart,
1790d02842fSSascha Wildner ACPI_PARSE_OBJECT *Op);
1800d02842fSSascha Wildner
1810d02842fSSascha Wildner
1820d02842fSSascha Wildner /*******************************************************************************
1830d02842fSSascha Wildner *
1840d02842fSSascha Wildner * FUNCTION: AcpiPsGetArguments
1850d02842fSSascha Wildner *
1860d02842fSSascha Wildner * PARAMETERS: WalkState - Current state
1870d02842fSSascha Wildner * AmlOpStart - Op start in AML
1880d02842fSSascha Wildner * Op - Current Op
1890d02842fSSascha Wildner *
1900d02842fSSascha Wildner * RETURN: Status
1910d02842fSSascha Wildner *
1920d02842fSSascha Wildner * DESCRIPTION: Get arguments for passed Op.
1930d02842fSSascha Wildner *
1940d02842fSSascha Wildner ******************************************************************************/
1950d02842fSSascha Wildner
1960d02842fSSascha Wildner static ACPI_STATUS
AcpiPsGetArguments(ACPI_WALK_STATE * WalkState,UINT8 * AmlOpStart,ACPI_PARSE_OBJECT * Op)1970d02842fSSascha Wildner AcpiPsGetArguments (
1980d02842fSSascha Wildner ACPI_WALK_STATE *WalkState,
1990d02842fSSascha Wildner UINT8 *AmlOpStart,
2000d02842fSSascha Wildner ACPI_PARSE_OBJECT *Op)
2010d02842fSSascha Wildner {
2020d02842fSSascha Wildner ACPI_STATUS Status = AE_OK;
2030d02842fSSascha Wildner ACPI_PARSE_OBJECT *Arg = NULL;
2040d02842fSSascha Wildner
2050d02842fSSascha Wildner
2060d02842fSSascha Wildner ACPI_FUNCTION_TRACE_PTR (PsGetArguments, WalkState);
2070d02842fSSascha Wildner
2080d02842fSSascha Wildner
20938b5d46cSSascha Wildner ACPI_DEBUG_PRINT ((ACPI_DB_PARSE,
21038b5d46cSSascha Wildner "Get arguments for opcode [%s]\n", Op->Common.AmlOpName));
21138b5d46cSSascha Wildner
2120d02842fSSascha Wildner switch (Op->Common.AmlOpcode)
2130d02842fSSascha Wildner {
2140d02842fSSascha Wildner case AML_BYTE_OP: /* AML_BYTEDATA_ARG */
2150d02842fSSascha Wildner case AML_WORD_OP: /* AML_WORDDATA_ARG */
2160d02842fSSascha Wildner case AML_DWORD_OP: /* AML_DWORDATA_ARG */
2170d02842fSSascha Wildner case AML_QWORD_OP: /* AML_QWORDATA_ARG */
2180d02842fSSascha Wildner case AML_STRING_OP: /* AML_ASCIICHARLIST_ARG */
2190d02842fSSascha Wildner
2200d02842fSSascha Wildner /* Fill in constant or string argument directly */
2210d02842fSSascha Wildner
2220d02842fSSascha Wildner AcpiPsGetNextSimpleArg (&(WalkState->ParserState),
2230d02842fSSascha Wildner GET_CURRENT_ARG_TYPE (WalkState->ArgTypes), Op);
2240d02842fSSascha Wildner break;
2250d02842fSSascha Wildner
2260d02842fSSascha Wildner case AML_INT_NAMEPATH_OP: /* AML_NAMESTRING_ARG */
2270d02842fSSascha Wildner
228f5f76cf2SSascha Wildner Status = AcpiPsGetNextNamepath (WalkState,
229f5f76cf2SSascha Wildner &(WalkState->ParserState), Op, ACPI_POSSIBLE_METHOD_CALL);
2300d02842fSSascha Wildner if (ACPI_FAILURE (Status))
2310d02842fSSascha Wildner {
2320d02842fSSascha Wildner return_ACPI_STATUS (Status);
2330d02842fSSascha Wildner }
2340d02842fSSascha Wildner
2350d02842fSSascha Wildner WalkState->ArgTypes = 0;
2360d02842fSSascha Wildner break;
2370d02842fSSascha Wildner
2380d02842fSSascha Wildner default:
2390d02842fSSascha Wildner /*
2400d02842fSSascha Wildner * Op is not a constant or string, append each argument to the Op
2410d02842fSSascha Wildner */
242820c5b08SSascha Wildner while (GET_CURRENT_ARG_TYPE (WalkState->ArgTypes) &&
243820c5b08SSascha Wildner !WalkState->ArgCount)
2440d02842fSSascha Wildner {
245267c04fdSSascha Wildner WalkState->Aml = WalkState->ParserState.Aml;
2460d02842fSSascha Wildner
247d638c6eeSSascha Wildner switch (Op->Common.AmlOpcode)
248d638c6eeSSascha Wildner {
249d638c6eeSSascha Wildner case AML_METHOD_OP:
250d638c6eeSSascha Wildner case AML_BUFFER_OP:
251d638c6eeSSascha Wildner case AML_PACKAGE_OP:
252d638c6eeSSascha Wildner case AML_VARIABLE_PACKAGE_OP:
253d638c6eeSSascha Wildner case AML_WHILE_OP:
254d638c6eeSSascha Wildner
255d638c6eeSSascha Wildner break;
256d638c6eeSSascha Wildner
257d638c6eeSSascha Wildner default:
258d638c6eeSSascha Wildner
259d638c6eeSSascha Wildner ASL_CV_CAPTURE_COMMENTS (WalkState);
260d638c6eeSSascha Wildner break;
261d638c6eeSSascha Wildner }
262d638c6eeSSascha Wildner
2630d02842fSSascha Wildner Status = AcpiPsGetNextArg (WalkState, &(WalkState->ParserState),
2640d02842fSSascha Wildner GET_CURRENT_ARG_TYPE (WalkState->ArgTypes), &Arg);
2650d02842fSSascha Wildner if (ACPI_FAILURE (Status))
2660d02842fSSascha Wildner {
2670d02842fSSascha Wildner return_ACPI_STATUS (Status);
2680d02842fSSascha Wildner }
2690d02842fSSascha Wildner
2700d02842fSSascha Wildner if (Arg)
2710d02842fSSascha Wildner {
2720d02842fSSascha Wildner AcpiPsAppendArg (Op, Arg);
2730d02842fSSascha Wildner }
2740d02842fSSascha Wildner
2750d02842fSSascha Wildner INCREMENT_ARG_LIST (WalkState->ArgTypes);
2760d02842fSSascha Wildner }
2770d02842fSSascha Wildner
2783c639e0cSSascha Wildner ACPI_DEBUG_PRINT ((ACPI_DB_PARSE,
2797bcb6cafSSascha Wildner "Final argument count: %8.8X pass %u\n",
2803c639e0cSSascha Wildner WalkState->ArgCount, WalkState->PassNumber));
2810d02842fSSascha Wildner
2820d02842fSSascha Wildner /* Special processing for certain opcodes */
2830d02842fSSascha Wildner
2840d02842fSSascha Wildner switch (Op->Common.AmlOpcode)
2850d02842fSSascha Wildner {
2860d02842fSSascha Wildner case AML_METHOD_OP:
2870d02842fSSascha Wildner /*
2880d02842fSSascha Wildner * Skip parsing of control method because we don't have enough
2890d02842fSSascha Wildner * info in the first pass to parse it correctly.
2900d02842fSSascha Wildner *
2910d02842fSSascha Wildner * Save the length and address of the body
2920d02842fSSascha Wildner */
2930d02842fSSascha Wildner Op->Named.Data = WalkState->ParserState.Aml;
2940d02842fSSascha Wildner Op->Named.Length = (UINT32)
2950d02842fSSascha Wildner (WalkState->ParserState.PkgEnd - WalkState->ParserState.Aml);
2960d02842fSSascha Wildner
2970d02842fSSascha Wildner /* Skip body of method */
2980d02842fSSascha Wildner
2990d02842fSSascha Wildner WalkState->ParserState.Aml = WalkState->ParserState.PkgEnd;
3000d02842fSSascha Wildner WalkState->ArgCount = 0;
3010d02842fSSascha Wildner break;
3020d02842fSSascha Wildner
3030d02842fSSascha Wildner case AML_BUFFER_OP:
3040d02842fSSascha Wildner case AML_PACKAGE_OP:
305d638c6eeSSascha Wildner case AML_VARIABLE_PACKAGE_OP:
3060d02842fSSascha Wildner
3070d02842fSSascha Wildner if ((Op->Common.Parent) &&
3080d02842fSSascha Wildner (Op->Common.Parent->Common.AmlOpcode == AML_NAME_OP) &&
3090d02842fSSascha Wildner (WalkState->PassNumber <= ACPI_IMODE_LOAD_PASS2))
3100d02842fSSascha Wildner {
3113c639e0cSSascha Wildner ACPI_DEBUG_PRINT ((ACPI_DB_PARSE,
3123c639e0cSSascha Wildner "Setup Package/Buffer: Pass %u, AML Ptr: %p\n",
3133c639e0cSSascha Wildner WalkState->PassNumber, AmlOpStart));
3143c639e0cSSascha Wildner
3150d02842fSSascha Wildner /*
3160d02842fSSascha Wildner * Skip parsing of Buffers and Packages because we don't have
3170d02842fSSascha Wildner * enough info in the first pass to parse them correctly.
3180d02842fSSascha Wildner */
3190d02842fSSascha Wildner Op->Named.Data = AmlOpStart;
3200d02842fSSascha Wildner Op->Named.Length = (UINT32)
3210d02842fSSascha Wildner (WalkState->ParserState.PkgEnd - AmlOpStart);
3220d02842fSSascha Wildner
3230d02842fSSascha Wildner /* Skip body */
3240d02842fSSascha Wildner
3250d02842fSSascha Wildner WalkState->ParserState.Aml = WalkState->ParserState.PkgEnd;
3260d02842fSSascha Wildner WalkState->ArgCount = 0;
3270d02842fSSascha Wildner }
3280d02842fSSascha Wildner break;
3290d02842fSSascha Wildner
3300d02842fSSascha Wildner case AML_WHILE_OP:
3310d02842fSSascha Wildner
3320d02842fSSascha Wildner if (WalkState->ControlState)
3330d02842fSSascha Wildner {
3340d02842fSSascha Wildner WalkState->ControlState->Control.PackageEnd =
3350d02842fSSascha Wildner WalkState->ParserState.PkgEnd;
3360d02842fSSascha Wildner }
3370d02842fSSascha Wildner break;
3380d02842fSSascha Wildner
3390d02842fSSascha Wildner default:
3400d02842fSSascha Wildner
3410d02842fSSascha Wildner /* No action for all other opcodes */
3420d02842fSSascha Wildner
3430d02842fSSascha Wildner break;
3440d02842fSSascha Wildner }
3450d02842fSSascha Wildner
3460d02842fSSascha Wildner break;
3470d02842fSSascha Wildner }
3480d02842fSSascha Wildner
3490d02842fSSascha Wildner return_ACPI_STATUS (AE_OK);
3500d02842fSSascha Wildner }
3510d02842fSSascha Wildner
3520d02842fSSascha Wildner
3530d02842fSSascha Wildner /*******************************************************************************
3540d02842fSSascha Wildner *
3550d02842fSSascha Wildner * FUNCTION: AcpiPsParseLoop
3560d02842fSSascha Wildner *
3570d02842fSSascha Wildner * PARAMETERS: WalkState - Current state
3580d02842fSSascha Wildner *
3590d02842fSSascha Wildner * RETURN: Status
3600d02842fSSascha Wildner *
3610d02842fSSascha Wildner * DESCRIPTION: Parse AML (pointed to by the current parser state) and return
3620d02842fSSascha Wildner * a tree of ops.
3630d02842fSSascha Wildner *
3640d02842fSSascha Wildner ******************************************************************************/
3650d02842fSSascha Wildner
366d9bb5dfdSMatthew Dillon #ifdef _KERNEL
367d9bb5dfdSMatthew Dillon #define TDTRACKER mycpu->gd_curthread->td_tracker
368d9bb5dfdSMatthew Dillon #define TDTRACKER_INC ++mycpu->gd_curthread->td_tracker
369d9bb5dfdSMatthew Dillon #define TDTRACKER_DEC --mycpu->gd_curthread->td_tracker
370d9bb5dfdSMatthew Dillon #else
371d9bb5dfdSMatthew Dillon #define TDTRACKER 0
372d9bb5dfdSMatthew Dillon #define TDTRACKER_INC
373d9bb5dfdSMatthew Dillon #define TDTRACKER_DEC
374d9bb5dfdSMatthew Dillon #endif
375d9bb5dfdSMatthew Dillon
3760d02842fSSascha Wildner ACPI_STATUS
AcpiPsParseLoop(ACPI_WALK_STATE * WalkState)3770d02842fSSascha Wildner AcpiPsParseLoop (
3780d02842fSSascha Wildner ACPI_WALK_STATE *WalkState)
3790d02842fSSascha Wildner {
3800d02842fSSascha Wildner ACPI_STATUS Status = AE_OK;
3810d02842fSSascha Wildner ACPI_PARSE_OBJECT *Op = NULL; /* current op */
3820d02842fSSascha Wildner ACPI_PARSE_STATE *ParserState;
3830d02842fSSascha Wildner UINT8 *AmlOpStart = NULL;
3846721db86SSascha Wildner UINT8 OpcodeLength;
3850d02842fSSascha Wildner
3860d02842fSSascha Wildner
3870d02842fSSascha Wildner ACPI_FUNCTION_TRACE_PTR (PsParseLoop, WalkState);
3880d02842fSSascha Wildner
3890d02842fSSascha Wildner
3900d02842fSSascha Wildner if (WalkState->DescendingCallback == NULL)
3910d02842fSSascha Wildner {
3920d02842fSSascha Wildner return_ACPI_STATUS (AE_BAD_PARAMETER);
3930d02842fSSascha Wildner }
394d9bb5dfdSMatthew Dillon if (TDTRACKER > 5) {
395d9bb5dfdSMatthew Dillon #ifdef _KERNEL
396d9bb5dfdSMatthew Dillon kprintf("AcpiPsParseLoop - Recursed too deep\n");
397d9bb5dfdSMatthew Dillon #else
398d9bb5dfdSMatthew Dillon printf("AcpiPsParseLoop - Recursed too deep\n");
399d9bb5dfdSMatthew Dillon #endif
400d9bb5dfdSMatthew Dillon return_ACPI_STATUS (AE_BAD_PARAMETER);
401d9bb5dfdSMatthew Dillon }
402d9bb5dfdSMatthew Dillon TDTRACKER_INC;
4030d02842fSSascha Wildner
4040d02842fSSascha Wildner ParserState = &WalkState->ParserState;
4050d02842fSSascha Wildner WalkState->ArgTypes = 0;
4060d02842fSSascha Wildner
407ef944814SSascha Wildner #ifndef ACPI_CONSTANT_EVAL_ONLY
4080d02842fSSascha Wildner
4090d02842fSSascha Wildner if (WalkState->WalkType & ACPI_WALK_METHOD_RESTART)
4100d02842fSSascha Wildner {
4110d02842fSSascha Wildner /* We are restarting a preempted control method */
4120d02842fSSascha Wildner
4130d02842fSSascha Wildner if (AcpiPsHasCompletedScope (ParserState))
4140d02842fSSascha Wildner {
4150d02842fSSascha Wildner /*
4160d02842fSSascha Wildner * We must check if a predicate to an IF or WHILE statement
4170d02842fSSascha Wildner * was just completed
4180d02842fSSascha Wildner */
4190d02842fSSascha Wildner if ((ParserState->Scope->ParseScope.Op) &&
4200d02842fSSascha Wildner ((ParserState->Scope->ParseScope.Op->Common.AmlOpcode == AML_IF_OP) ||
4210d02842fSSascha Wildner (ParserState->Scope->ParseScope.Op->Common.AmlOpcode == AML_WHILE_OP)) &&
4220d02842fSSascha Wildner (WalkState->ControlState) &&
4230d02842fSSascha Wildner (WalkState->ControlState->Common.State ==
4240d02842fSSascha Wildner ACPI_CONTROL_PREDICATE_EXECUTING))
4250d02842fSSascha Wildner {
4260d02842fSSascha Wildner /*
4270d02842fSSascha Wildner * A predicate was just completed, get the value of the
4280d02842fSSascha Wildner * predicate and branch based on that value
4290d02842fSSascha Wildner */
4300d02842fSSascha Wildner WalkState->Op = NULL;
4310d02842fSSascha Wildner Status = AcpiDsGetPredicateValue (WalkState, ACPI_TO_POINTER (TRUE));
43208343eafSSascha Wildner if (ACPI_FAILURE (Status) && !ACPI_CNTL_EXCEPTION (Status))
4330d02842fSSascha Wildner {
4340d02842fSSascha Wildner if (Status == AE_AML_NO_RETURN_VALUE)
4350d02842fSSascha Wildner {
4360d02842fSSascha Wildner ACPI_EXCEPTION ((AE_INFO, Status,
4370d02842fSSascha Wildner "Invoked method did not return a value"));
4380d02842fSSascha Wildner }
4390d02842fSSascha Wildner
4400d02842fSSascha Wildner ACPI_EXCEPTION ((AE_INFO, Status, "GetPredicate Failed"));
441d9bb5dfdSMatthew Dillon TDTRACKER_DEC;
4420d02842fSSascha Wildner return_ACPI_STATUS (Status);
4430d02842fSSascha Wildner }
4440d02842fSSascha Wildner
4450d02842fSSascha Wildner Status = AcpiPsNextParseState (WalkState, Op, Status);
4460d02842fSSascha Wildner }
4470d02842fSSascha Wildner
4480d02842fSSascha Wildner AcpiPsPopScope (ParserState, &Op,
4490d02842fSSascha Wildner &WalkState->ArgTypes, &WalkState->ArgCount);
4500d02842fSSascha Wildner ACPI_DEBUG_PRINT ((ACPI_DB_PARSE, "Popped scope, Op=%p\n", Op));
4510d02842fSSascha Wildner }
4520d02842fSSascha Wildner else if (WalkState->PrevOp)
4530d02842fSSascha Wildner {
4540d02842fSSascha Wildner /* We were in the middle of an op */
4550d02842fSSascha Wildner
4560d02842fSSascha Wildner Op = WalkState->PrevOp;
4570d02842fSSascha Wildner WalkState->ArgTypes = WalkState->PrevArgTypes;
4580d02842fSSascha Wildner }
4590d02842fSSascha Wildner }
4600d02842fSSascha Wildner #endif
4610d02842fSSascha Wildner
4620d02842fSSascha Wildner /* Iterative parsing loop, while there is more AML to process: */
4630d02842fSSascha Wildner
4640d02842fSSascha Wildner while ((ParserState->Aml < ParserState->AmlEnd) || (Op))
4650d02842fSSascha Wildner {
466d638c6eeSSascha Wildner ASL_CV_CAPTURE_COMMENTS (WalkState);
467d638c6eeSSascha Wildner
4680d02842fSSascha Wildner AmlOpStart = ParserState->Aml;
4690d02842fSSascha Wildner if (!Op)
4700d02842fSSascha Wildner {
4710d02842fSSascha Wildner Status = AcpiPsCreateOp (WalkState, AmlOpStart, &Op);
4720d02842fSSascha Wildner if (ACPI_FAILURE (Status))
4730d02842fSSascha Wildner {
4742afeb59bSSascha Wildner /*
4752afeb59bSSascha Wildner * ACPI_PARSE_MODULE_LEVEL means that we are loading a table by
4762afeb59bSSascha Wildner * executing it as a control method. However, if we encounter
4772afeb59bSSascha Wildner * an error while loading the table, we need to keep trying to
4782afeb59bSSascha Wildner * load the table rather than aborting the table load. Set the
4792afeb59bSSascha Wildner * status to AE_OK to proceed with the table load.
4802afeb59bSSascha Wildner */
4812afeb59bSSascha Wildner if ((WalkState->ParseFlags & ACPI_PARSE_MODULE_LEVEL) &&
4826721db86SSascha Wildner ((Status == AE_ALREADY_EXISTS) || (Status == AE_NOT_FOUND)))
4832afeb59bSSascha Wildner {
4842afeb59bSSascha Wildner Status = AE_OK;
4852afeb59bSSascha Wildner }
4860d02842fSSascha Wildner if (Status == AE_CTRL_PARSE_CONTINUE)
4870d02842fSSascha Wildner {
4880d02842fSSascha Wildner continue;
4890d02842fSSascha Wildner }
4900d02842fSSascha Wildner
4910d02842fSSascha Wildner if (Status == AE_CTRL_PARSE_PENDING)
4920d02842fSSascha Wildner {
4930d02842fSSascha Wildner Status = AE_OK;
4940d02842fSSascha Wildner }
4950d02842fSSascha Wildner
4966a0135c2SSascha Wildner if (Status == AE_CTRL_TERMINATE)
4976a0135c2SSascha Wildner {
498d9bb5dfdSMatthew Dillon TDTRACKER_DEC;
4996a0135c2SSascha Wildner return_ACPI_STATUS (Status);
5006a0135c2SSascha Wildner }
5016a0135c2SSascha Wildner
5020d02842fSSascha Wildner Status = AcpiPsCompleteOp (WalkState, &Op, Status);
5030d02842fSSascha Wildner if (ACPI_FAILURE (Status))
5040d02842fSSascha Wildner {
505d9bb5dfdSMatthew Dillon TDTRACKER_DEC;
5060d02842fSSascha Wildner return_ACPI_STATUS (Status);
5070d02842fSSascha Wildner }
5082afeb59bSSascha Wildner if (AcpiNsOpensScope (
5092afeb59bSSascha Wildner AcpiPsGetOpcodeInfo (WalkState->Opcode)->ObjectType))
510e416ee21SSascha Wildner {
511e416ee21SSascha Wildner /*
5122afeb59bSSascha Wildner * If the scope/device op fails to parse, skip the body of
5132afeb59bSSascha Wildner * the scope op because the parse failure indicates that
5142afeb59bSSascha Wildner * the device may not exist.
515e416ee21SSascha Wildner */
5166721db86SSascha Wildner ACPI_INFO (("Skipping parse of AML opcode: %s (0x%4.4X)",
5176721db86SSascha Wildner AcpiPsGetOpcodeName (WalkState->Opcode), WalkState->Opcode));
5186721db86SSascha Wildner
5196721db86SSascha Wildner /*
5206721db86SSascha Wildner * Determine the opcode length before skipping the opcode.
5216721db86SSascha Wildner * An opcode can be 1 byte or 2 bytes in length.
5226721db86SSascha Wildner */
5236721db86SSascha Wildner OpcodeLength = 1;
5246721db86SSascha Wildner if ((WalkState->Opcode & 0xFF00) == AML_EXTENDED_OPCODE)
5256721db86SSascha Wildner {
5266721db86SSascha Wildner OpcodeLength = 2;
5276721db86SSascha Wildner }
5286721db86SSascha Wildner WalkState->ParserState.Aml = WalkState->Aml + OpcodeLength;
5296721db86SSascha Wildner
530e416ee21SSascha Wildner WalkState->ParserState.Aml =
531e416ee21SSascha Wildner AcpiPsGetNextPackageEnd(&WalkState->ParserState);
532e416ee21SSascha Wildner WalkState->Aml = WalkState->ParserState.Aml;
533e416ee21SSascha Wildner }
5340d02842fSSascha Wildner
5350d02842fSSascha Wildner continue;
5360d02842fSSascha Wildner }
5370d02842fSSascha Wildner
538267c04fdSSascha Wildner AcpiExStartTraceOpcode (Op, WalkState);
5390d02842fSSascha Wildner }
5400d02842fSSascha Wildner
5410d02842fSSascha Wildner /*
5420d02842fSSascha Wildner * Start ArgCount at zero because we don't know if there are
5430d02842fSSascha Wildner * any args yet
5440d02842fSSascha Wildner */
5450d02842fSSascha Wildner WalkState->ArgCount = 0;
5460d02842fSSascha Wildner
547d638c6eeSSascha Wildner switch (Op->Common.AmlOpcode)
548d638c6eeSSascha Wildner {
549d638c6eeSSascha Wildner case AML_BYTE_OP:
550d638c6eeSSascha Wildner case AML_WORD_OP:
551d638c6eeSSascha Wildner case AML_DWORD_OP:
552d638c6eeSSascha Wildner case AML_QWORD_OP:
553d638c6eeSSascha Wildner
554d638c6eeSSascha Wildner break;
555d638c6eeSSascha Wildner
556d638c6eeSSascha Wildner default:
557d638c6eeSSascha Wildner
558d638c6eeSSascha Wildner ASL_CV_CAPTURE_COMMENTS (WalkState);
559d638c6eeSSascha Wildner break;
560d638c6eeSSascha Wildner }
561d638c6eeSSascha Wildner
5620d02842fSSascha Wildner /* Are there any arguments that must be processed? */
5630d02842fSSascha Wildner
5640d02842fSSascha Wildner if (WalkState->ArgTypes)
5650d02842fSSascha Wildner {
5660d02842fSSascha Wildner /* Get arguments */
5670d02842fSSascha Wildner
5680d02842fSSascha Wildner Status = AcpiPsGetArguments (WalkState, AmlOpStart, Op);
5690d02842fSSascha Wildner if (ACPI_FAILURE (Status))
5700d02842fSSascha Wildner {
5710d02842fSSascha Wildner Status = AcpiPsCompleteOp (WalkState, &Op, Status);
5720d02842fSSascha Wildner if (ACPI_FAILURE (Status))
5730d02842fSSascha Wildner {
574d9bb5dfdSMatthew Dillon TDTRACKER_DEC;
5750d02842fSSascha Wildner return_ACPI_STATUS (Status);
5760d02842fSSascha Wildner }
577e416ee21SSascha Wildner if ((WalkState->ControlState) &&
578e416ee21SSascha Wildner ((WalkState->ControlState->Control.Opcode == AML_IF_OP) ||
579e416ee21SSascha Wildner (WalkState->ControlState->Control.Opcode == AML_WHILE_OP)))
580e416ee21SSascha Wildner {
581e416ee21SSascha Wildner /*
582e416ee21SSascha Wildner * If the if/while op fails to parse, we will skip parsing
583e416ee21SSascha Wildner * the body of the op.
584e416ee21SSascha Wildner */
585e416ee21SSascha Wildner ParserState->Aml =
586e416ee21SSascha Wildner WalkState->ControlState->Control.AmlPredicateStart + 1;
587e416ee21SSascha Wildner ParserState->Aml =
588e416ee21SSascha Wildner AcpiPsGetNextPackageEnd (ParserState);
589e416ee21SSascha Wildner WalkState->Aml = ParserState->Aml;
5900d02842fSSascha Wildner
591e416ee21SSascha Wildner ACPI_ERROR ((AE_INFO, "Skipping While/If block"));
592e416ee21SSascha Wildner if (*WalkState->Aml == AML_ELSE_OP)
593e416ee21SSascha Wildner {
594e416ee21SSascha Wildner ACPI_ERROR ((AE_INFO, "Skipping Else block"));
595e416ee21SSascha Wildner WalkState->ParserState.Aml = WalkState->Aml + 1;
596e416ee21SSascha Wildner WalkState->ParserState.Aml =
597e416ee21SSascha Wildner AcpiPsGetNextPackageEnd (ParserState);
598e416ee21SSascha Wildner WalkState->Aml = ParserState->Aml;
599e416ee21SSascha Wildner }
600e416ee21SSascha Wildner ACPI_FREE(AcpiUtPopGenericState (&WalkState->ControlState));
601e416ee21SSascha Wildner }
602e416ee21SSascha Wildner Op = NULL;
6030d02842fSSascha Wildner continue;
6040d02842fSSascha Wildner }
6050d02842fSSascha Wildner }
6060d02842fSSascha Wildner
6070d02842fSSascha Wildner /* Check for arguments that need to be processed */
6080d02842fSSascha Wildner
6093c639e0cSSascha Wildner ACPI_DEBUG_PRINT ((ACPI_DB_PARSE,
6107bcb6cafSSascha Wildner "Parseloop: argument count: %8.8X\n", WalkState->ArgCount));
6113c639e0cSSascha Wildner
6120d02842fSSascha Wildner if (WalkState->ArgCount)
6130d02842fSSascha Wildner {
6140d02842fSSascha Wildner /*
6150d02842fSSascha Wildner * There are arguments (complex ones), push Op and
6160d02842fSSascha Wildner * prepare for argument
6170d02842fSSascha Wildner */
6180d02842fSSascha Wildner Status = AcpiPsPushScope (ParserState, Op,
6190d02842fSSascha Wildner WalkState->ArgTypes, WalkState->ArgCount);
6200d02842fSSascha Wildner if (ACPI_FAILURE (Status))
6210d02842fSSascha Wildner {
6220d02842fSSascha Wildner Status = AcpiPsCompleteOp (WalkState, &Op, Status);
6230d02842fSSascha Wildner if (ACPI_FAILURE (Status))
6240d02842fSSascha Wildner {
625d9bb5dfdSMatthew Dillon TDTRACKER_DEC;
6260d02842fSSascha Wildner return_ACPI_STATUS (Status);
6270d02842fSSascha Wildner }
6280d02842fSSascha Wildner
6290d02842fSSascha Wildner continue;
6300d02842fSSascha Wildner }
6310d02842fSSascha Wildner
6320d02842fSSascha Wildner Op = NULL;
6330d02842fSSascha Wildner continue;
6340d02842fSSascha Wildner }
6350d02842fSSascha Wildner
6360d02842fSSascha Wildner /*
6370d02842fSSascha Wildner * All arguments have been processed -- Op is complete,
6380d02842fSSascha Wildner * prepare for next
6390d02842fSSascha Wildner */
6400d02842fSSascha Wildner WalkState->OpInfo = AcpiPsGetOpcodeInfo (Op->Common.AmlOpcode);
6410d02842fSSascha Wildner if (WalkState->OpInfo->Flags & AML_NAMED)
6420d02842fSSascha Wildner {
6430d02842fSSascha Wildner if (Op->Common.AmlOpcode == AML_REGION_OP ||
6440d02842fSSascha Wildner Op->Common.AmlOpcode == AML_DATA_REGION_OP)
6450d02842fSSascha Wildner {
6460d02842fSSascha Wildner /*
6470d02842fSSascha Wildner * Skip parsing of control method or opregion body,
6480d02842fSSascha Wildner * because we don't have enough info in the first pass
6490d02842fSSascha Wildner * to parse them correctly.
6500d02842fSSascha Wildner *
6510d02842fSSascha Wildner * Completed parsing an OpRegion declaration, we now
6520d02842fSSascha Wildner * know the length.
6530d02842fSSascha Wildner */
6540d02842fSSascha Wildner Op->Named.Length = (UINT32) (ParserState->Aml - Op->Named.Data);
6550d02842fSSascha Wildner }
6560d02842fSSascha Wildner }
6570d02842fSSascha Wildner
6580d02842fSSascha Wildner if (WalkState->OpInfo->Flags & AML_CREATE)
6590d02842fSSascha Wildner {
6600d02842fSSascha Wildner /*
6610d02842fSSascha Wildner * Backup to beginning of CreateXXXfield declaration (1 for
6620d02842fSSascha Wildner * Opcode)
6630d02842fSSascha Wildner *
6640d02842fSSascha Wildner * BodyLength is unknown until we parse the body
6650d02842fSSascha Wildner */
6660d02842fSSascha Wildner Op->Named.Length = (UINT32) (ParserState->Aml - Op->Named.Data);
6670d02842fSSascha Wildner }
6680d02842fSSascha Wildner
6690d02842fSSascha Wildner if (Op->Common.AmlOpcode == AML_BANK_FIELD_OP)
6700d02842fSSascha Wildner {
6710d02842fSSascha Wildner /*
6720d02842fSSascha Wildner * Backup to beginning of BankField declaration
6730d02842fSSascha Wildner *
6740d02842fSSascha Wildner * BodyLength is unknown until we parse the body
6750d02842fSSascha Wildner */
6760d02842fSSascha Wildner Op->Named.Length = (UINT32) (ParserState->Aml - Op->Named.Data);
6770d02842fSSascha Wildner }
6780d02842fSSascha Wildner
6790d02842fSSascha Wildner /* This op complete, notify the dispatcher */
6800d02842fSSascha Wildner
6810d02842fSSascha Wildner if (WalkState->AscendingCallback != NULL)
6820d02842fSSascha Wildner {
6830d02842fSSascha Wildner WalkState->Op = Op;
6840d02842fSSascha Wildner WalkState->Opcode = Op->Common.AmlOpcode;
6850d02842fSSascha Wildner
6860d02842fSSascha Wildner Status = WalkState->AscendingCallback (WalkState);
6870d02842fSSascha Wildner Status = AcpiPsNextParseState (WalkState, Op, Status);
6880d02842fSSascha Wildner if (Status == AE_CTRL_PENDING)
6890d02842fSSascha Wildner {
6900d02842fSSascha Wildner Status = AE_OK;
6910d02842fSSascha Wildner }
6922afeb59bSSascha Wildner else if ((WalkState->ParseFlags & ACPI_PARSE_MODULE_LEVEL) &&
6932afeb59bSSascha Wildner (ACPI_AML_EXCEPTION(Status) || Status == AE_ALREADY_EXISTS ||
6942afeb59bSSascha Wildner Status == AE_NOT_FOUND))
6952afeb59bSSascha Wildner {
6962afeb59bSSascha Wildner /*
6972afeb59bSSascha Wildner * ACPI_PARSE_MODULE_LEVEL flag means that we are currently
6982afeb59bSSascha Wildner * loading a table by executing it as a control method.
6992afeb59bSSascha Wildner * However, if we encounter an error while loading the table,
7002afeb59bSSascha Wildner * we need to keep trying to load the table rather than
7012afeb59bSSascha Wildner * aborting the table load (setting the status to AE_OK
7022afeb59bSSascha Wildner * continues the table load). If we get a failure at this
7032afeb59bSSascha Wildner * point, it means that the dispatcher got an error while
7042afeb59bSSascha Wildner * trying to execute the Op.
7052afeb59bSSascha Wildner */
7062afeb59bSSascha Wildner Status = AE_OK;
7072afeb59bSSascha Wildner }
7080d02842fSSascha Wildner }
7090d02842fSSascha Wildner
7100d02842fSSascha Wildner Status = AcpiPsCompleteOp (WalkState, &Op, Status);
7110d02842fSSascha Wildner if (ACPI_FAILURE (Status))
7120d02842fSSascha Wildner {
713d9bb5dfdSMatthew Dillon TDTRACKER_DEC;
7140d02842fSSascha Wildner return_ACPI_STATUS (Status);
7150d02842fSSascha Wildner }
7160d02842fSSascha Wildner
7170d02842fSSascha Wildner } /* while ParserState->Aml */
7180d02842fSSascha Wildner
7190d02842fSSascha Wildner Status = AcpiPsCompleteFinalOp (WalkState, Op, Status);
720d9bb5dfdSMatthew Dillon TDTRACKER_DEC;
7210d02842fSSascha Wildner return_ACPI_STATUS (Status);
7220d02842fSSascha Wildner }
723