xref: /freebsd-src/sys/contrib/dev/acpica/components/parser/psargs.c (revision 92f570c32e9b9b9b4db9b6921c4ab79be686a498)
1a159c266SJung-uk Kim /******************************************************************************
2a159c266SJung-uk Kim  *
3a159c266SJung-uk Kim  * Module Name: psargs - Parse AML opcode arguments
4a159c266SJung-uk Kim  *
5a159c266SJung-uk Kim  *****************************************************************************/
6a159c266SJung-uk Kim 
70d84335fSJung-uk Kim /******************************************************************************
80d84335fSJung-uk Kim  *
90d84335fSJung-uk Kim  * 1. Copyright Notice
100d84335fSJung-uk Kim  *
11804fe266SJung-uk Kim  * Some or all of this work - Copyright (c) 1999 - 2024, Intel Corp.
12a159c266SJung-uk Kim  * All rights reserved.
13a159c266SJung-uk Kim  *
140d84335fSJung-uk Kim  * 2. License
150d84335fSJung-uk Kim  *
160d84335fSJung-uk Kim  * 2.1. This is your license from Intel Corp. under its intellectual property
170d84335fSJung-uk Kim  * rights. You may have additional license terms from the party that provided
180d84335fSJung-uk Kim  * you this software, covering your right to use that party's intellectual
190d84335fSJung-uk Kim  * property rights.
200d84335fSJung-uk Kim  *
210d84335fSJung-uk Kim  * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
220d84335fSJung-uk Kim  * copy of the source code appearing in this file ("Covered Code") an
230d84335fSJung-uk Kim  * irrevocable, perpetual, worldwide license under Intel's copyrights in the
240d84335fSJung-uk Kim  * base code distributed originally by Intel ("Original Intel Code") to copy,
250d84335fSJung-uk Kim  * make derivatives, distribute, use and display any portion of the Covered
260d84335fSJung-uk Kim  * Code in any form, with the right to sublicense such rights; and
270d84335fSJung-uk Kim  *
280d84335fSJung-uk Kim  * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
290d84335fSJung-uk Kim  * license (with the right to sublicense), under only those claims of Intel
300d84335fSJung-uk Kim  * patents that are infringed by the Original Intel Code, to make, use, sell,
310d84335fSJung-uk Kim  * offer to sell, and import the Covered Code and derivative works thereof
320d84335fSJung-uk Kim  * solely to the minimum extent necessary to exercise the above copyright
330d84335fSJung-uk Kim  * license, and in no event shall the patent license extend to any additions
340d84335fSJung-uk Kim  * to or modifications of the Original Intel Code. No other license or right
350d84335fSJung-uk Kim  * is granted directly or by implication, estoppel or otherwise;
360d84335fSJung-uk Kim  *
370d84335fSJung-uk Kim  * The above copyright and patent license is granted only if the following
380d84335fSJung-uk Kim  * conditions are met:
390d84335fSJung-uk Kim  *
400d84335fSJung-uk Kim  * 3. Conditions
410d84335fSJung-uk Kim  *
420d84335fSJung-uk Kim  * 3.1. Redistribution of Source with Rights to Further Distribute Source.
430d84335fSJung-uk Kim  * Redistribution of source code of any substantial portion of the Covered
440d84335fSJung-uk Kim  * Code or modification with rights to further distribute source must include
450d84335fSJung-uk Kim  * the above Copyright Notice, the above License, this list of Conditions,
460d84335fSJung-uk Kim  * and the following Disclaimer and Export Compliance provision. In addition,
470d84335fSJung-uk Kim  * Licensee must cause all Covered Code to which Licensee contributes to
480d84335fSJung-uk Kim  * contain a file documenting the changes Licensee made to create that Covered
490d84335fSJung-uk Kim  * Code and the date of any change. Licensee must include in that file the
500d84335fSJung-uk Kim  * documentation of any changes made by any predecessor Licensee. Licensee
510d84335fSJung-uk Kim  * must include a prominent statement that the modification is derived,
520d84335fSJung-uk Kim  * directly or indirectly, from Original Intel Code.
530d84335fSJung-uk Kim  *
540d84335fSJung-uk Kim  * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
550d84335fSJung-uk Kim  * Redistribution of source code of any substantial portion of the Covered
560d84335fSJung-uk Kim  * Code or modification without rights to further distribute source must
570d84335fSJung-uk Kim  * include the following Disclaimer and Export Compliance provision in the
580d84335fSJung-uk Kim  * documentation and/or other materials provided with distribution. In
590d84335fSJung-uk Kim  * addition, Licensee may not authorize further sublicense of source of any
600d84335fSJung-uk Kim  * portion of the Covered Code, and must include terms to the effect that the
610d84335fSJung-uk Kim  * license from Licensee to its licensee is limited to the intellectual
620d84335fSJung-uk Kim  * property embodied in the software Licensee provides to its licensee, and
630d84335fSJung-uk Kim  * not to intellectual property embodied in modifications its licensee may
640d84335fSJung-uk Kim  * make.
650d84335fSJung-uk Kim  *
660d84335fSJung-uk Kim  * 3.3. Redistribution of Executable. Redistribution in executable form of any
670d84335fSJung-uk Kim  * substantial portion of the Covered Code or modification must reproduce the
680d84335fSJung-uk Kim  * above Copyright Notice, and the following Disclaimer and Export Compliance
690d84335fSJung-uk Kim  * provision in the documentation and/or other materials provided with the
700d84335fSJung-uk Kim  * distribution.
710d84335fSJung-uk Kim  *
720d84335fSJung-uk Kim  * 3.4. Intel retains all right, title, and interest in and to the Original
730d84335fSJung-uk Kim  * Intel Code.
740d84335fSJung-uk Kim  *
750d84335fSJung-uk Kim  * 3.5. Neither the name Intel nor any other trademark owned or controlled by
760d84335fSJung-uk Kim  * Intel shall be used in advertising or otherwise to promote the sale, use or
770d84335fSJung-uk Kim  * other dealings in products derived from or relating to the Covered Code
780d84335fSJung-uk Kim  * without prior written authorization from Intel.
790d84335fSJung-uk Kim  *
800d84335fSJung-uk Kim  * 4. Disclaimer and Export Compliance
810d84335fSJung-uk Kim  *
820d84335fSJung-uk Kim  * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
830d84335fSJung-uk Kim  * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
840d84335fSJung-uk Kim  * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE,
850d84335fSJung-uk Kim  * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY
860d84335fSJung-uk Kim  * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY
870d84335fSJung-uk Kim  * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
880d84335fSJung-uk Kim  * PARTICULAR PURPOSE.
890d84335fSJung-uk Kim  *
900d84335fSJung-uk Kim  * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
910d84335fSJung-uk Kim  * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
920d84335fSJung-uk Kim  * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
930d84335fSJung-uk Kim  * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
940d84335fSJung-uk Kim  * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
950d84335fSJung-uk Kim  * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS
960d84335fSJung-uk Kim  * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
970d84335fSJung-uk Kim  * LIMITED REMEDY.
980d84335fSJung-uk Kim  *
990d84335fSJung-uk Kim  * 4.3. Licensee shall not export, either directly or indirectly, any of this
1000d84335fSJung-uk Kim  * software or system incorporating such software without first obtaining any
1010d84335fSJung-uk Kim  * required license or other approval from the U. S. Department of Commerce or
1020d84335fSJung-uk Kim  * any other agency or department of the United States Government. In the
1030d84335fSJung-uk Kim  * event Licensee exports any such software from the United States or
1040d84335fSJung-uk Kim  * re-exports any such software from a foreign destination, Licensee shall
1050d84335fSJung-uk Kim  * ensure that the distribution and export/re-export of the software is in
1060d84335fSJung-uk Kim  * compliance with all laws, regulations, orders, or other restrictions of the
1070d84335fSJung-uk Kim  * U.S. Export Administration Regulations. Licensee agrees that neither it nor
1080d84335fSJung-uk Kim  * any of its subsidiaries will export/re-export any technical data, process,
1090d84335fSJung-uk Kim  * software, or service, directly or indirectly, to any country for which the
1100d84335fSJung-uk Kim  * United States government or any agency thereof requires an export license,
1110d84335fSJung-uk Kim  * other governmental approval, or letter of assurance, without first obtaining
1120d84335fSJung-uk Kim  * such license, approval or letter.
1130d84335fSJung-uk Kim  *
1140d84335fSJung-uk Kim  *****************************************************************************
1150d84335fSJung-uk Kim  *
1160d84335fSJung-uk Kim  * Alternatively, you may choose to be licensed under the terms of the
1170d84335fSJung-uk Kim  * following license:
1180d84335fSJung-uk Kim  *
119a159c266SJung-uk Kim  * Redistribution and use in source and binary forms, with or without
120a159c266SJung-uk Kim  * modification, are permitted provided that the following conditions
121a159c266SJung-uk Kim  * are met:
122a159c266SJung-uk Kim  * 1. Redistributions of source code must retain the above copyright
123a159c266SJung-uk Kim  *    notice, this list of conditions, and the following disclaimer,
124a159c266SJung-uk Kim  *    without modification.
125a159c266SJung-uk Kim  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
126a159c266SJung-uk Kim  *    substantially similar to the "NO WARRANTY" disclaimer below
127a159c266SJung-uk Kim  *    ("Disclaimer") and any redistribution must be conditioned upon
128a159c266SJung-uk Kim  *    including a substantially similar Disclaimer requirement for further
129a159c266SJung-uk Kim  *    binary redistribution.
130a159c266SJung-uk Kim  * 3. Neither the names of the above-listed copyright holders nor the names
131a159c266SJung-uk Kim  *    of any contributors may be used to endorse or promote products derived
132a159c266SJung-uk Kim  *    from this software without specific prior written permission.
133a159c266SJung-uk Kim  *
1340d84335fSJung-uk Kim  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
1350d84335fSJung-uk Kim  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
1360d84335fSJung-uk Kim  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
1370d84335fSJung-uk Kim  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
1380d84335fSJung-uk Kim  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
1390d84335fSJung-uk Kim  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
1400d84335fSJung-uk Kim  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
1410d84335fSJung-uk Kim  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
1420d84335fSJung-uk Kim  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
1430d84335fSJung-uk Kim  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
1440d84335fSJung-uk Kim  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
1450d84335fSJung-uk Kim  *
1460d84335fSJung-uk Kim  * Alternatively, you may choose to be licensed under the terms of the
147a159c266SJung-uk Kim  * GNU General Public License ("GPL") version 2 as published by the Free
148a159c266SJung-uk Kim  * Software Foundation.
149a159c266SJung-uk Kim  *
1500d84335fSJung-uk Kim  *****************************************************************************/
151a159c266SJung-uk Kim 
152a159c266SJung-uk Kim #include <contrib/dev/acpica/include/acpi.h>
153a159c266SJung-uk Kim #include <contrib/dev/acpica/include/accommon.h>
154a159c266SJung-uk Kim #include <contrib/dev/acpica/include/acparser.h>
155a159c266SJung-uk Kim #include <contrib/dev/acpica/include/amlcode.h>
156a159c266SJung-uk Kim #include <contrib/dev/acpica/include/acnamesp.h>
157a159c266SJung-uk Kim #include <contrib/dev/acpica/include/acdispat.h>
1580d84335fSJung-uk Kim #include <contrib/dev/acpica/include/acconvert.h>
159a159c266SJung-uk Kim 
160a159c266SJung-uk Kim #define _COMPONENT          ACPI_PARSER
161a159c266SJung-uk Kim         ACPI_MODULE_NAME    ("psargs")
162a159c266SJung-uk Kim 
163a159c266SJung-uk Kim /* Local prototypes */
164a159c266SJung-uk Kim 
165a159c266SJung-uk Kim static UINT32
166a159c266SJung-uk Kim AcpiPsGetNextPackageLength (
167a159c266SJung-uk Kim     ACPI_PARSE_STATE        *ParserState);
168a159c266SJung-uk Kim 
169a159c266SJung-uk Kim static ACPI_PARSE_OBJECT *
170a159c266SJung-uk Kim AcpiPsGetNextField (
171a159c266SJung-uk Kim     ACPI_PARSE_STATE        *ParserState);
172a159c266SJung-uk Kim 
173*92f570c3SJung-uk Kim static void
174*92f570c3SJung-uk Kim AcpiPsFreeFieldList (
175*92f570c3SJung-uk Kim     ACPI_PARSE_OBJECT       *Start);
176*92f570c3SJung-uk Kim 
177a159c266SJung-uk Kim 
178a159c266SJung-uk Kim /*******************************************************************************
179a159c266SJung-uk Kim  *
180a159c266SJung-uk Kim  * FUNCTION:    AcpiPsGetNextPackageLength
181a159c266SJung-uk Kim  *
182a159c266SJung-uk Kim  * PARAMETERS:  ParserState         - Current parser state object
183a159c266SJung-uk Kim  *
184a159c266SJung-uk Kim  * RETURN:      Decoded package length. On completion, the AML pointer points
185a159c266SJung-uk Kim  *              past the length byte or bytes.
186a159c266SJung-uk Kim  *
187a159c266SJung-uk Kim  * DESCRIPTION: Decode and return a package length field.
188a159c266SJung-uk Kim  *              Note: Largest package length is 28 bits, from ACPI specification
189a159c266SJung-uk Kim  *
190a159c266SJung-uk Kim  ******************************************************************************/
191a159c266SJung-uk Kim 
192a159c266SJung-uk Kim static UINT32
193a159c266SJung-uk Kim AcpiPsGetNextPackageLength (
194a159c266SJung-uk Kim     ACPI_PARSE_STATE        *ParserState)
195a159c266SJung-uk Kim {
196a159c266SJung-uk Kim     UINT8                   *Aml = ParserState->Aml;
197a159c266SJung-uk Kim     UINT32                  PackageLength = 0;
198a159c266SJung-uk Kim     UINT32                  ByteCount;
199a159c266SJung-uk Kim     UINT8                   ByteZeroMask = 0x3F; /* Default [0:5] */
200a159c266SJung-uk Kim 
201a159c266SJung-uk Kim 
202a159c266SJung-uk Kim     ACPI_FUNCTION_TRACE (PsGetNextPackageLength);
203a159c266SJung-uk Kim 
204a159c266SJung-uk Kim 
205a159c266SJung-uk Kim     /*
206a159c266SJung-uk Kim      * Byte 0 bits [6:7] contain the number of additional bytes
207a159c266SJung-uk Kim      * used to encode the package length, either 0,1,2, or 3
208a159c266SJung-uk Kim      */
209a159c266SJung-uk Kim     ByteCount = (Aml[0] >> 6);
210a159c266SJung-uk Kim     ParserState->Aml += ((ACPI_SIZE) ByteCount + 1);
211a159c266SJung-uk Kim 
212a159c266SJung-uk Kim     /* Get bytes 3, 2, 1 as needed */
213a159c266SJung-uk Kim 
214a159c266SJung-uk Kim     while (ByteCount)
215a159c266SJung-uk Kim     {
216a159c266SJung-uk Kim         /*
217a159c266SJung-uk Kim          * Final bit positions for the package length bytes:
218a159c266SJung-uk Kim          *      Byte3->[20:27]
219a159c266SJung-uk Kim          *      Byte2->[12:19]
220a159c266SJung-uk Kim          *      Byte1->[04:11]
221a159c266SJung-uk Kim          *      Byte0->[00:03]
222a159c266SJung-uk Kim          */
223a159c266SJung-uk Kim         PackageLength |= (Aml[ByteCount] << ((ByteCount << 3) - 4));
224a159c266SJung-uk Kim 
225a159c266SJung-uk Kim         ByteZeroMask = 0x0F; /* Use bits [0:3] of byte 0 */
226a159c266SJung-uk Kim         ByteCount--;
227a159c266SJung-uk Kim     }
228a159c266SJung-uk Kim 
229a159c266SJung-uk Kim     /* Byte 0 is a special case, either bits [0:3] or [0:5] are used */
230a159c266SJung-uk Kim 
231a159c266SJung-uk Kim     PackageLength |= (Aml[0] & ByteZeroMask);
2329c48c75eSJung-uk Kim     return_UINT32 (PackageLength);
233a159c266SJung-uk Kim }
234a159c266SJung-uk Kim 
235a159c266SJung-uk Kim 
236a159c266SJung-uk Kim /*******************************************************************************
237a159c266SJung-uk Kim  *
238a159c266SJung-uk Kim  * FUNCTION:    AcpiPsGetNextPackageEnd
239a159c266SJung-uk Kim  *
240a159c266SJung-uk Kim  * PARAMETERS:  ParserState         - Current parser state object
241a159c266SJung-uk Kim  *
242a159c266SJung-uk Kim  * RETURN:      Pointer to end-of-package +1
243a159c266SJung-uk Kim  *
244a159c266SJung-uk Kim  * DESCRIPTION: Get next package length and return a pointer past the end of
245a159c266SJung-uk Kim  *              the package. Consumes the package length field
246a159c266SJung-uk Kim  *
247a159c266SJung-uk Kim  ******************************************************************************/
248a159c266SJung-uk Kim 
249a159c266SJung-uk Kim UINT8 *
250a159c266SJung-uk Kim AcpiPsGetNextPackageEnd (
251a159c266SJung-uk Kim     ACPI_PARSE_STATE        *ParserState)
252a159c266SJung-uk Kim {
253a159c266SJung-uk Kim     UINT8                   *Start = ParserState->Aml;
254a159c266SJung-uk Kim     UINT32                  PackageLength;
255a159c266SJung-uk Kim 
256a159c266SJung-uk Kim 
257a159c266SJung-uk Kim     ACPI_FUNCTION_TRACE (PsGetNextPackageEnd);
258a159c266SJung-uk Kim 
259a159c266SJung-uk Kim 
260a159c266SJung-uk Kim     /* Function below updates ParserState->Aml */
261a159c266SJung-uk Kim 
262a159c266SJung-uk Kim     PackageLength = AcpiPsGetNextPackageLength (ParserState);
263a159c266SJung-uk Kim 
264a159c266SJung-uk Kim     return_PTR (Start + PackageLength); /* end of package */
265a159c266SJung-uk Kim }
266a159c266SJung-uk Kim 
267a159c266SJung-uk Kim 
268a159c266SJung-uk Kim /*******************************************************************************
269a159c266SJung-uk Kim  *
270a159c266SJung-uk Kim  * FUNCTION:    AcpiPsGetNextNamestring
271a159c266SJung-uk Kim  *
272a159c266SJung-uk Kim  * PARAMETERS:  ParserState         - Current parser state object
273a159c266SJung-uk Kim  *
274a159c266SJung-uk Kim  * RETURN:      Pointer to the start of the name string (pointer points into
275a159c266SJung-uk Kim  *              the AML.
276a159c266SJung-uk Kim  *
277a159c266SJung-uk Kim  * DESCRIPTION: Get next raw namestring within the AML stream. Handles all name
278a159c266SJung-uk Kim  *              prefix characters. Set parser state to point past the string.
279a159c266SJung-uk Kim  *              (Name is consumed from the AML.)
280a159c266SJung-uk Kim  *
281a159c266SJung-uk Kim  ******************************************************************************/
282a159c266SJung-uk Kim 
283a159c266SJung-uk Kim char *
284a159c266SJung-uk Kim AcpiPsGetNextNamestring (
285a159c266SJung-uk Kim     ACPI_PARSE_STATE        *ParserState)
286a159c266SJung-uk Kim {
287a159c266SJung-uk Kim     UINT8                   *Start = ParserState->Aml;
288a159c266SJung-uk Kim     UINT8                   *End = ParserState->Aml;
289a159c266SJung-uk Kim 
290a159c266SJung-uk Kim 
291a159c266SJung-uk Kim     ACPI_FUNCTION_TRACE (PsGetNextNamestring);
292a159c266SJung-uk Kim 
293a159c266SJung-uk Kim 
294a159c266SJung-uk Kim     /* Point past any namestring prefix characters (backslash or carat) */
295a159c266SJung-uk Kim 
296efcc2a30SJung-uk Kim     while (ACPI_IS_ROOT_PREFIX (*End) ||
297efcc2a30SJung-uk Kim            ACPI_IS_PARENT_PREFIX (*End))
298a159c266SJung-uk Kim     {
299a159c266SJung-uk Kim         End++;
300a159c266SJung-uk Kim     }
301a159c266SJung-uk Kim 
302a159c266SJung-uk Kim     /* Decode the path prefix character */
303a159c266SJung-uk Kim 
304a159c266SJung-uk Kim     switch (*End)
305a159c266SJung-uk Kim     {
306a159c266SJung-uk Kim     case 0:
307a159c266SJung-uk Kim 
308a159c266SJung-uk Kim         /* NullName */
309a159c266SJung-uk Kim 
310a159c266SJung-uk Kim         if (End == Start)
311a159c266SJung-uk Kim         {
312a159c266SJung-uk Kim             Start = NULL;
313a159c266SJung-uk Kim         }
314a159c266SJung-uk Kim         End++;
315a159c266SJung-uk Kim         break;
316a159c266SJung-uk Kim 
317a159c266SJung-uk Kim     case AML_DUAL_NAME_PREFIX:
318a159c266SJung-uk Kim 
319a159c266SJung-uk Kim         /* Two name segments */
320a159c266SJung-uk Kim 
321278f0de6SJung-uk Kim         End += 1 + (2 * ACPI_NAMESEG_SIZE);
322a159c266SJung-uk Kim         break;
323a159c266SJung-uk Kim 
3240d84335fSJung-uk Kim     case AML_MULTI_NAME_PREFIX:
325a159c266SJung-uk Kim 
326a159c266SJung-uk Kim         /* Multiple name segments, 4 chars each, count in next byte */
327a159c266SJung-uk Kim 
328278f0de6SJung-uk Kim         End += 2 + (*(End + 1) * ACPI_NAMESEG_SIZE);
329a159c266SJung-uk Kim         break;
330a159c266SJung-uk Kim 
331a159c266SJung-uk Kim     default:
332a159c266SJung-uk Kim 
333a159c266SJung-uk Kim         /* Single name segment */
334a159c266SJung-uk Kim 
335278f0de6SJung-uk Kim         End += ACPI_NAMESEG_SIZE;
336a159c266SJung-uk Kim         break;
337a159c266SJung-uk Kim     }
338a159c266SJung-uk Kim 
339a159c266SJung-uk Kim     ParserState->Aml = End;
340a159c266SJung-uk Kim     return_PTR ((char *) Start);
341a159c266SJung-uk Kim }
342a159c266SJung-uk Kim 
343a159c266SJung-uk Kim 
344a159c266SJung-uk Kim /*******************************************************************************
345a159c266SJung-uk Kim  *
346a159c266SJung-uk Kim  * FUNCTION:    AcpiPsGetNextNamepath
347a159c266SJung-uk Kim  *
348a159c266SJung-uk Kim  * PARAMETERS:  ParserState         - Current parser state object
349a159c266SJung-uk Kim  *              Arg                 - Where the namepath will be stored
350a159c266SJung-uk Kim  *              ArgCount            - If the namepath points to a control method
351a159c266SJung-uk Kim  *                                    the method's argument is returned here.
352a159c266SJung-uk Kim  *              PossibleMethodCall  - Whether the namepath can possibly be the
353a159c266SJung-uk Kim  *                                    start of a method call
354a159c266SJung-uk Kim  *
355a159c266SJung-uk Kim  * RETURN:      Status
356a159c266SJung-uk Kim  *
357a159c266SJung-uk Kim  * DESCRIPTION: Get next name (if method call, return # of required args).
358a159c266SJung-uk Kim  *              Names are looked up in the internal namespace to determine
359a159c266SJung-uk Kim  *              if the name represents a control method. If a method
360a159c266SJung-uk Kim  *              is found, the number of arguments to the method is returned.
361a159c266SJung-uk Kim  *              This information is critical for parsing to continue correctly.
362a159c266SJung-uk Kim  *
363a159c266SJung-uk Kim  ******************************************************************************/
364a159c266SJung-uk Kim 
365a159c266SJung-uk Kim ACPI_STATUS
366a159c266SJung-uk Kim AcpiPsGetNextNamepath (
367a159c266SJung-uk Kim     ACPI_WALK_STATE         *WalkState,
368a159c266SJung-uk Kim     ACPI_PARSE_STATE        *ParserState,
369a159c266SJung-uk Kim     ACPI_PARSE_OBJECT       *Arg,
370a159c266SJung-uk Kim     BOOLEAN                 PossibleMethodCall)
371a159c266SJung-uk Kim {
372a159c266SJung-uk Kim     ACPI_STATUS             Status;
373a159c266SJung-uk Kim     char                    *Path;
374a159c266SJung-uk Kim     ACPI_PARSE_OBJECT       *NameOp;
375a159c266SJung-uk Kim     ACPI_OPERAND_OBJECT     *MethodDesc;
376a159c266SJung-uk Kim     ACPI_NAMESPACE_NODE     *Node;
377a159c266SJung-uk Kim     UINT8                   *Start = ParserState->Aml;
378a159c266SJung-uk Kim 
379a159c266SJung-uk Kim 
380a159c266SJung-uk Kim     ACPI_FUNCTION_TRACE (PsGetNextNamepath);
381a159c266SJung-uk Kim 
382a159c266SJung-uk Kim 
383a159c266SJung-uk Kim     Path = AcpiPsGetNextNamestring (ParserState);
384a159c266SJung-uk Kim     AcpiPsInitOp (Arg, AML_INT_NAMEPATH_OP);
385a159c266SJung-uk Kim 
386a159c266SJung-uk Kim     /* Null path case is allowed, just exit */
387a159c266SJung-uk Kim 
388a159c266SJung-uk Kim     if (!Path)
389a159c266SJung-uk Kim     {
390a159c266SJung-uk Kim         Arg->Common.Value.Name = Path;
391a159c266SJung-uk Kim         return_ACPI_STATUS (AE_OK);
392a159c266SJung-uk Kim     }
393a159c266SJung-uk Kim 
394a159c266SJung-uk Kim     /*
395a159c266SJung-uk Kim      * Lookup the name in the internal namespace, starting with the current
396a159c266SJung-uk Kim      * scope. We don't want to add anything new to the namespace here,
397a159c266SJung-uk Kim      * however, so we use MODE_EXECUTE.
398a159c266SJung-uk Kim      * Allow searching of the parent tree, but don't open a new scope -
399a159c266SJung-uk Kim      * we just want to lookup the object (must be mode EXECUTE to perform
400a159c266SJung-uk Kim      * the upsearch)
401a159c266SJung-uk Kim      */
402a159c266SJung-uk Kim     Status = AcpiNsLookup (WalkState->ScopeInfo, Path,
403a159c266SJung-uk Kim         ACPI_TYPE_ANY, ACPI_IMODE_EXECUTE,
404a159c266SJung-uk Kim         ACPI_NS_SEARCH_PARENT | ACPI_NS_DONT_OPEN_SCOPE, NULL, &Node);
405a159c266SJung-uk Kim 
406a159c266SJung-uk Kim     /*
407a159c266SJung-uk Kim      * If this name is a control method invocation, we must
408a159c266SJung-uk Kim      * setup the method call
409a159c266SJung-uk Kim      */
410a159c266SJung-uk Kim     if (ACPI_SUCCESS (Status) &&
411a159c266SJung-uk Kim         PossibleMethodCall &&
412a159c266SJung-uk Kim         (Node->Type == ACPI_TYPE_METHOD))
413a159c266SJung-uk Kim     {
41428482948SJung-uk Kim         if ((GET_CURRENT_ARG_TYPE (WalkState->ArgTypes) == ARGP_SUPERNAME) ||
41528482948SJung-uk Kim             (GET_CURRENT_ARG_TYPE (WalkState->ArgTypes) == ARGP_TARGET))
41628482948SJung-uk Kim         {
41728482948SJung-uk Kim             /*
41828482948SJung-uk Kim              * AcpiPsGetNextNamestring has increased the AML pointer past
41928482948SJung-uk Kim              * the method invocation namestring, so we need to restore the
42028482948SJung-uk Kim              * saved AML pointer back to the original method invocation
42128482948SJung-uk Kim              * namestring.
42228482948SJung-uk Kim              */
42328482948SJung-uk Kim             WalkState->ParserState.Aml = Start;
42428482948SJung-uk Kim             WalkState->ArgCount = 1;
42528482948SJung-uk Kim             AcpiPsInitOp (Arg, AML_INT_METHODCALL_OP);
42628482948SJung-uk Kim         }
42728482948SJung-uk Kim 
428a159c266SJung-uk Kim         /* This name is actually a control method invocation */
429a159c266SJung-uk Kim 
430a159c266SJung-uk Kim         MethodDesc = AcpiNsGetAttachedObject (Node);
431a159c266SJung-uk Kim         ACPI_DEBUG_PRINT ((ACPI_DB_PARSE,
4321cc50d6bSJung-uk Kim             "Control Method invocation %4.4s - %p Desc %p Path=%p\n",
4331cc50d6bSJung-uk Kim             Node->Name.Ascii, Node, MethodDesc, Path));
434a159c266SJung-uk Kim 
435fe0f0bbbSJung-uk Kim         NameOp = AcpiPsAllocOp (AML_INT_NAMEPATH_OP, Start);
436a159c266SJung-uk Kim         if (!NameOp)
437a159c266SJung-uk Kim         {
438a159c266SJung-uk Kim             return_ACPI_STATUS (AE_NO_MEMORY);
439a159c266SJung-uk Kim         }
440a159c266SJung-uk Kim 
441a159c266SJung-uk Kim         /* Change Arg into a METHOD CALL and attach name to it */
442a159c266SJung-uk Kim 
443a159c266SJung-uk Kim         AcpiPsInitOp (Arg, AML_INT_METHODCALL_OP);
444a159c266SJung-uk Kim         NameOp->Common.Value.Name = Path;
445a159c266SJung-uk Kim 
446a159c266SJung-uk Kim         /* Point METHODCALL/NAME to the METHOD Node */
447a159c266SJung-uk Kim 
448a159c266SJung-uk Kim         NameOp->Common.Node = Node;
449a159c266SJung-uk Kim         AcpiPsAppendArg (Arg, NameOp);
450a159c266SJung-uk Kim 
451a159c266SJung-uk Kim         if (!MethodDesc)
452a159c266SJung-uk Kim         {
453a159c266SJung-uk Kim             ACPI_ERROR ((AE_INFO,
454a159c266SJung-uk Kim                 "Control Method %p has no attached object",
455a159c266SJung-uk Kim                 Node));
456a159c266SJung-uk Kim             return_ACPI_STATUS (AE_AML_INTERNAL);
457a159c266SJung-uk Kim         }
458a159c266SJung-uk Kim 
459a159c266SJung-uk Kim         ACPI_DEBUG_PRINT ((ACPI_DB_PARSE,
460a159c266SJung-uk Kim             "Control Method - %p Args %X\n",
461a159c266SJung-uk Kim             Node, MethodDesc->Method.ParamCount));
462a159c266SJung-uk Kim 
463a159c266SJung-uk Kim         /* Get the number of arguments to expect */
464a159c266SJung-uk Kim 
465a159c266SJung-uk Kim         WalkState->ArgCount = MethodDesc->Method.ParamCount;
466a159c266SJung-uk Kim         return_ACPI_STATUS (AE_OK);
467a159c266SJung-uk Kim     }
468a159c266SJung-uk Kim 
469a159c266SJung-uk Kim     /*
470a159c266SJung-uk Kim      * Special handling if the name was not found during the lookup -
471a159c266SJung-uk Kim      * some NotFound cases are allowed
472a159c266SJung-uk Kim      */
473a159c266SJung-uk Kim     if (Status == AE_NOT_FOUND)
474a159c266SJung-uk Kim     {
475a159c266SJung-uk Kim         /* 1) NotFound is ok during load pass 1/2 (allow forward references) */
476a159c266SJung-uk Kim 
477a159c266SJung-uk Kim         if ((WalkState->ParseFlags & ACPI_PARSE_MODE_MASK) !=
478a159c266SJung-uk Kim             ACPI_PARSE_EXECUTE)
479a159c266SJung-uk Kim         {
480a159c266SJung-uk Kim             Status = AE_OK;
481a159c266SJung-uk Kim         }
482a159c266SJung-uk Kim 
483a159c266SJung-uk Kim         /* 2) NotFound during a CondRefOf(x) is ok by definition */
484a159c266SJung-uk Kim 
4850d84335fSJung-uk Kim         else if (WalkState->Op->Common.AmlOpcode == AML_CONDITIONAL_REF_OF_OP)
486a159c266SJung-uk Kim         {
487a159c266SJung-uk Kim             Status = AE_OK;
488a159c266SJung-uk Kim         }
489a159c266SJung-uk Kim 
490a159c266SJung-uk Kim         /*
491a159c266SJung-uk Kim          * 3) NotFound while building a Package is ok at this point, we
492a159c266SJung-uk Kim          * may flag as an error later if slack mode is not enabled.
493a159c266SJung-uk Kim          * (Some ASL code depends on allowing this behavior)
494a159c266SJung-uk Kim          */
495a159c266SJung-uk Kim         else if ((Arg->Common.Parent) &&
496a159c266SJung-uk Kim             ((Arg->Common.Parent->Common.AmlOpcode == AML_PACKAGE_OP) ||
4970d84335fSJung-uk Kim              (Arg->Common.Parent->Common.AmlOpcode == AML_VARIABLE_PACKAGE_OP)))
498a159c266SJung-uk Kim         {
499a159c266SJung-uk Kim             Status = AE_OK;
500a159c266SJung-uk Kim         }
501a159c266SJung-uk Kim     }
502a159c266SJung-uk Kim 
503a159c266SJung-uk Kim     /* Final exception check (may have been changed from code above) */
504a159c266SJung-uk Kim 
505a159c266SJung-uk Kim     if (ACPI_FAILURE (Status))
506a159c266SJung-uk Kim     {
507b7b7e711SJung-uk Kim         ACPI_ERROR_NAMESPACE (WalkState->ScopeInfo, Path, Status);
508a159c266SJung-uk Kim 
509a159c266SJung-uk Kim         if ((WalkState->ParseFlags & ACPI_PARSE_MODE_MASK) ==
510a159c266SJung-uk Kim             ACPI_PARSE_EXECUTE)
511a159c266SJung-uk Kim         {
512a159c266SJung-uk Kim             /* Report a control method execution error */
513a159c266SJung-uk Kim 
514a159c266SJung-uk Kim             Status = AcpiDsMethodError (Status, WalkState);
515a159c266SJung-uk Kim         }
516a159c266SJung-uk Kim     }
517a159c266SJung-uk Kim 
518a159c266SJung-uk Kim     /* Save the namepath */
519a159c266SJung-uk Kim 
520a159c266SJung-uk Kim     Arg->Common.Value.Name = Path;
521a159c266SJung-uk Kim     return_ACPI_STATUS (Status);
522a159c266SJung-uk Kim }
523a159c266SJung-uk Kim 
524a159c266SJung-uk Kim 
525a159c266SJung-uk Kim /*******************************************************************************
526a159c266SJung-uk Kim  *
527a159c266SJung-uk Kim  * FUNCTION:    AcpiPsGetNextSimpleArg
528a159c266SJung-uk Kim  *
529a159c266SJung-uk Kim  * PARAMETERS:  ParserState         - Current parser state object
530a159c266SJung-uk Kim  *              ArgType             - The argument type (AML_*_ARG)
531a159c266SJung-uk Kim  *              Arg                 - Where the argument is returned
532a159c266SJung-uk Kim  *
533a159c266SJung-uk Kim  * RETURN:      None
534a159c266SJung-uk Kim  *
535a159c266SJung-uk Kim  * DESCRIPTION: Get the next simple argument (constant, string, or namestring)
536a159c266SJung-uk Kim  *
537a159c266SJung-uk Kim  ******************************************************************************/
538a159c266SJung-uk Kim 
539a159c266SJung-uk Kim void
540a159c266SJung-uk Kim AcpiPsGetNextSimpleArg (
541a159c266SJung-uk Kim     ACPI_PARSE_STATE        *ParserState,
542a159c266SJung-uk Kim     UINT32                  ArgType,
543a159c266SJung-uk Kim     ACPI_PARSE_OBJECT       *Arg)
544a159c266SJung-uk Kim {
545a159c266SJung-uk Kim     UINT32                  Length;
546a159c266SJung-uk Kim     UINT16                  Opcode;
547a159c266SJung-uk Kim     UINT8                   *Aml = ParserState->Aml;
548a159c266SJung-uk Kim 
549a159c266SJung-uk Kim 
550a159c266SJung-uk Kim     ACPI_FUNCTION_TRACE_U32 (PsGetNextSimpleArg, ArgType);
551a159c266SJung-uk Kim 
552a159c266SJung-uk Kim 
553a159c266SJung-uk Kim     switch (ArgType)
554a159c266SJung-uk Kim     {
555a159c266SJung-uk Kim     case ARGP_BYTEDATA:
556a159c266SJung-uk Kim 
557a159c266SJung-uk Kim         /* Get 1 byte from the AML stream */
558a159c266SJung-uk Kim 
559a159c266SJung-uk Kim         Opcode = AML_BYTE_OP;
560a159c266SJung-uk Kim         Arg->Common.Value.Integer = (UINT64) *Aml;
561a159c266SJung-uk Kim         Length = 1;
562a159c266SJung-uk Kim         break;
563a159c266SJung-uk Kim 
564a159c266SJung-uk Kim     case ARGP_WORDDATA:
565a159c266SJung-uk Kim 
566a159c266SJung-uk Kim         /* Get 2 bytes from the AML stream */
567a159c266SJung-uk Kim 
568a159c266SJung-uk Kim         Opcode = AML_WORD_OP;
569a159c266SJung-uk Kim         ACPI_MOVE_16_TO_64 (&Arg->Common.Value.Integer, Aml);
570a159c266SJung-uk Kim         Length = 2;
571a159c266SJung-uk Kim         break;
572a159c266SJung-uk Kim 
573a159c266SJung-uk Kim     case ARGP_DWORDDATA:
574a159c266SJung-uk Kim 
575a159c266SJung-uk Kim         /* Get 4 bytes from the AML stream */
576a159c266SJung-uk Kim 
577a159c266SJung-uk Kim         Opcode = AML_DWORD_OP;
578a159c266SJung-uk Kim         ACPI_MOVE_32_TO_64 (&Arg->Common.Value.Integer, Aml);
579a159c266SJung-uk Kim         Length = 4;
580a159c266SJung-uk Kim         break;
581a159c266SJung-uk Kim 
582a159c266SJung-uk Kim     case ARGP_QWORDDATA:
583a159c266SJung-uk Kim 
584a159c266SJung-uk Kim         /* Get 8 bytes from the AML stream */
585a159c266SJung-uk Kim 
586a159c266SJung-uk Kim         Opcode = AML_QWORD_OP;
587a159c266SJung-uk Kim         ACPI_MOVE_64_TO_64 (&Arg->Common.Value.Integer, Aml);
588a159c266SJung-uk Kim         Length = 8;
589a159c266SJung-uk Kim         break;
590a159c266SJung-uk Kim 
591a159c266SJung-uk Kim     case ARGP_CHARLIST:
592a159c266SJung-uk Kim 
593a159c266SJung-uk Kim         /* Get a pointer to the string, point past the string */
594a159c266SJung-uk Kim 
595a159c266SJung-uk Kim         Opcode = AML_STRING_OP;
596a159c266SJung-uk Kim         Arg->Common.Value.String = ACPI_CAST_PTR (char, Aml);
597a159c266SJung-uk Kim 
598a159c266SJung-uk Kim         /* Find the null terminator */
599a159c266SJung-uk Kim 
600a159c266SJung-uk Kim         Length = 0;
601a159c266SJung-uk Kim         while (Aml[Length])
602a159c266SJung-uk Kim         {
603a159c266SJung-uk Kim             Length++;
604a159c266SJung-uk Kim         }
605a159c266SJung-uk Kim         Length++;
606a159c266SJung-uk Kim         break;
607a159c266SJung-uk Kim 
608a159c266SJung-uk Kim     case ARGP_NAME:
609a159c266SJung-uk Kim     case ARGP_NAMESTRING:
610a159c266SJung-uk Kim 
611a159c266SJung-uk Kim         AcpiPsInitOp (Arg, AML_INT_NAMEPATH_OP);
612a159c266SJung-uk Kim         Arg->Common.Value.Name = AcpiPsGetNextNamestring (ParserState);
613a159c266SJung-uk Kim         return_VOID;
614a159c266SJung-uk Kim 
615a159c266SJung-uk Kim     default:
616a159c266SJung-uk Kim 
617a159c266SJung-uk Kim         ACPI_ERROR ((AE_INFO, "Invalid ArgType 0x%X", ArgType));
618a159c266SJung-uk Kim         return_VOID;
619a159c266SJung-uk Kim     }
620a159c266SJung-uk Kim 
621a159c266SJung-uk Kim     AcpiPsInitOp (Arg, Opcode);
622a159c266SJung-uk Kim     ParserState->Aml += Length;
623a159c266SJung-uk Kim     return_VOID;
624a159c266SJung-uk Kim }
625a159c266SJung-uk Kim 
626a159c266SJung-uk Kim 
627a159c266SJung-uk Kim /*******************************************************************************
628a159c266SJung-uk Kim  *
629a159c266SJung-uk Kim  * FUNCTION:    AcpiPsGetNextField
630a159c266SJung-uk Kim  *
631a159c266SJung-uk Kim  * PARAMETERS:  ParserState         - Current parser state object
632a159c266SJung-uk Kim  *
633a159c266SJung-uk Kim  * RETURN:      A newly allocated FIELD op
634a159c266SJung-uk Kim  *
635a159c266SJung-uk Kim  * DESCRIPTION: Get next field (NamedField, ReservedField, or AccessField)
636a159c266SJung-uk Kim  *
637a159c266SJung-uk Kim  ******************************************************************************/
638a159c266SJung-uk Kim 
639a159c266SJung-uk Kim static ACPI_PARSE_OBJECT *
640a159c266SJung-uk Kim AcpiPsGetNextField (
641a159c266SJung-uk Kim     ACPI_PARSE_STATE        *ParserState)
642a159c266SJung-uk Kim {
643fe0f0bbbSJung-uk Kim     UINT8                   *Aml;
644a159c266SJung-uk Kim     ACPI_PARSE_OBJECT       *Field;
645a159c266SJung-uk Kim     ACPI_PARSE_OBJECT       *Arg = NULL;
646a159c266SJung-uk Kim     UINT16                  Opcode;
647a159c266SJung-uk Kim     UINT32                  Name;
648a159c266SJung-uk Kim     UINT8                   AccessType;
649a159c266SJung-uk Kim     UINT8                   AccessAttribute;
650a159c266SJung-uk Kim     UINT8                   AccessLength;
651a159c266SJung-uk Kim     UINT32                  PkgLength;
652a159c266SJung-uk Kim     UINT8                   *PkgEnd;
653a159c266SJung-uk Kim     UINT32                  BufferLength;
654a159c266SJung-uk Kim 
655a159c266SJung-uk Kim 
656a159c266SJung-uk Kim     ACPI_FUNCTION_TRACE (PsGetNextField);
657a159c266SJung-uk Kim 
658a159c266SJung-uk Kim 
6590d84335fSJung-uk Kim     ASL_CV_CAPTURE_COMMENTS_ONLY (ParserState);
660fe0f0bbbSJung-uk Kim     Aml = ParserState->Aml;
661a159c266SJung-uk Kim 
662a159c266SJung-uk Kim     /* Determine field type */
663a159c266SJung-uk Kim 
664a159c266SJung-uk Kim     switch (ACPI_GET8 (ParserState->Aml))
665a159c266SJung-uk Kim     {
666a159c266SJung-uk Kim     case AML_FIELD_OFFSET_OP:
667a159c266SJung-uk Kim 
668a159c266SJung-uk Kim         Opcode = AML_INT_RESERVEDFIELD_OP;
669a159c266SJung-uk Kim         ParserState->Aml++;
670a159c266SJung-uk Kim         break;
671a159c266SJung-uk Kim 
672a159c266SJung-uk Kim     case AML_FIELD_ACCESS_OP:
673a159c266SJung-uk Kim 
674a159c266SJung-uk Kim         Opcode = AML_INT_ACCESSFIELD_OP;
675a159c266SJung-uk Kim         ParserState->Aml++;
676a159c266SJung-uk Kim         break;
677a159c266SJung-uk Kim 
678a159c266SJung-uk Kim     case AML_FIELD_CONNECTION_OP:
679a159c266SJung-uk Kim 
680a159c266SJung-uk Kim         Opcode = AML_INT_CONNECTION_OP;
681a159c266SJung-uk Kim         ParserState->Aml++;
682a159c266SJung-uk Kim         break;
683a159c266SJung-uk Kim 
684a159c266SJung-uk Kim     case AML_FIELD_EXT_ACCESS_OP:
685a159c266SJung-uk Kim 
686a159c266SJung-uk Kim         Opcode = AML_INT_EXTACCESSFIELD_OP;
687a159c266SJung-uk Kim         ParserState->Aml++;
688a159c266SJung-uk Kim         break;
689a159c266SJung-uk Kim 
690a159c266SJung-uk Kim     default:
691a159c266SJung-uk Kim 
692a159c266SJung-uk Kim         Opcode = AML_INT_NAMEDFIELD_OP;
693a159c266SJung-uk Kim         break;
694a159c266SJung-uk Kim     }
695a159c266SJung-uk Kim 
696a159c266SJung-uk Kim     /* Allocate a new field op */
697a159c266SJung-uk Kim 
698fe0f0bbbSJung-uk Kim     Field = AcpiPsAllocOp (Opcode, Aml);
699a159c266SJung-uk Kim     if (!Field)
700a159c266SJung-uk Kim     {
701a159c266SJung-uk Kim         return_PTR (NULL);
702a159c266SJung-uk Kim     }
703a159c266SJung-uk Kim 
704a159c266SJung-uk Kim     /* Decode the field type */
705a159c266SJung-uk Kim 
7060d84335fSJung-uk Kim     ASL_CV_CAPTURE_COMMENTS_ONLY (ParserState);
707a159c266SJung-uk Kim     switch (Opcode)
708a159c266SJung-uk Kim     {
709a159c266SJung-uk Kim     case AML_INT_NAMEDFIELD_OP:
710a159c266SJung-uk Kim 
711a159c266SJung-uk Kim         /* Get the 4-character name */
712a159c266SJung-uk Kim 
713a159c266SJung-uk Kim         ACPI_MOVE_32_TO_32 (&Name, ParserState->Aml);
714a159c266SJung-uk Kim         AcpiPsSetName (Field, Name);
715278f0de6SJung-uk Kim         ParserState->Aml += ACPI_NAMESEG_SIZE;
716a159c266SJung-uk Kim 
7170d84335fSJung-uk Kim 
7180d84335fSJung-uk Kim         ASL_CV_CAPTURE_COMMENTS_ONLY (ParserState);
7190d84335fSJung-uk Kim 
7200d84335fSJung-uk Kim #ifdef ACPI_ASL_COMPILER
7210d84335fSJung-uk Kim         /*
7220d84335fSJung-uk Kim          * Because the package length isn't represented as a parse tree object,
7230d84335fSJung-uk Kim          * take comments surrounding this and add to the previously created
7240d84335fSJung-uk Kim          * parse node.
7250d84335fSJung-uk Kim          */
7260d84335fSJung-uk Kim         if (Field->Common.InlineComment)
7270d84335fSJung-uk Kim         {
7280d84335fSJung-uk Kim             Field->Common.NameComment = Field->Common.InlineComment;
7290d84335fSJung-uk Kim         }
7300d84335fSJung-uk Kim         Field->Common.InlineComment  = AcpiGbl_CurrentInlineComment;
7310d84335fSJung-uk Kim         AcpiGbl_CurrentInlineComment = NULL;
7320d84335fSJung-uk Kim #endif
7330d84335fSJung-uk Kim 
734a159c266SJung-uk Kim         /* Get the length which is encoded as a package length */
735a159c266SJung-uk Kim 
736a159c266SJung-uk Kim         Field->Common.Value.Size = AcpiPsGetNextPackageLength (ParserState);
737a159c266SJung-uk Kim         break;
738a159c266SJung-uk Kim 
739a159c266SJung-uk Kim 
740a159c266SJung-uk Kim     case AML_INT_RESERVEDFIELD_OP:
741a159c266SJung-uk Kim 
742a159c266SJung-uk Kim         /* Get the length which is encoded as a package length */
743a159c266SJung-uk Kim 
744a159c266SJung-uk Kim         Field->Common.Value.Size = AcpiPsGetNextPackageLength (ParserState);
745a159c266SJung-uk Kim         break;
746a159c266SJung-uk Kim 
747a159c266SJung-uk Kim 
748a159c266SJung-uk Kim     case AML_INT_ACCESSFIELD_OP:
749a159c266SJung-uk Kim     case AML_INT_EXTACCESSFIELD_OP:
750a159c266SJung-uk Kim 
751a159c266SJung-uk Kim         /*
752a159c266SJung-uk Kim          * Get AccessType and AccessAttrib and merge into the field Op
753a159c266SJung-uk Kim          * AccessType is first operand, AccessAttribute is second. stuff
754a159c266SJung-uk Kim          * these bytes into the node integer value for convenience.
755a159c266SJung-uk Kim          */
756a159c266SJung-uk Kim 
757a159c266SJung-uk Kim         /* Get the two bytes (Type/Attribute) */
758a159c266SJung-uk Kim 
759a159c266SJung-uk Kim         AccessType = ACPI_GET8 (ParserState->Aml);
760a159c266SJung-uk Kim         ParserState->Aml++;
761a159c266SJung-uk Kim         AccessAttribute = ACPI_GET8 (ParserState->Aml);
762a159c266SJung-uk Kim         ParserState->Aml++;
763a159c266SJung-uk Kim 
764a159c266SJung-uk Kim         Field->Common.Value.Integer = (UINT8) AccessType;
765a159c266SJung-uk Kim         Field->Common.Value.Integer |= (UINT16) (AccessAttribute << 8);
766a159c266SJung-uk Kim 
767a159c266SJung-uk Kim         /* This opcode has a third byte, AccessLength */
768a159c266SJung-uk Kim 
769a159c266SJung-uk Kim         if (Opcode == AML_INT_EXTACCESSFIELD_OP)
770a159c266SJung-uk Kim         {
771a159c266SJung-uk Kim             AccessLength = ACPI_GET8 (ParserState->Aml);
772a159c266SJung-uk Kim             ParserState->Aml++;
773a159c266SJung-uk Kim 
774a159c266SJung-uk Kim             Field->Common.Value.Integer |= (UINT32) (AccessLength << 16);
775a159c266SJung-uk Kim         }
776a159c266SJung-uk Kim         break;
777a159c266SJung-uk Kim 
778a159c266SJung-uk Kim 
779a159c266SJung-uk Kim     case AML_INT_CONNECTION_OP:
780a159c266SJung-uk Kim 
781a159c266SJung-uk Kim         /*
782a159c266SJung-uk Kim          * Argument for Connection operator can be either a Buffer
783a159c266SJung-uk Kim          * (resource descriptor), or a NameString.
784a159c266SJung-uk Kim          */
785fe0f0bbbSJung-uk Kim         Aml = ParserState->Aml;
786a159c266SJung-uk Kim         if (ACPI_GET8 (ParserState->Aml) == AML_BUFFER_OP)
787a159c266SJung-uk Kim         {
788a159c266SJung-uk Kim             ParserState->Aml++;
789a159c266SJung-uk Kim 
7900d84335fSJung-uk Kim             ASL_CV_CAPTURE_COMMENTS_ONLY (ParserState);
791a159c266SJung-uk Kim             PkgEnd = ParserState->Aml;
792a159c266SJung-uk Kim             PkgLength = AcpiPsGetNextPackageLength (ParserState);
793a159c266SJung-uk Kim             PkgEnd += PkgLength;
794a159c266SJung-uk Kim 
7950d84335fSJung-uk Kim             ASL_CV_CAPTURE_COMMENTS_ONLY (ParserState);
796a159c266SJung-uk Kim             if (ParserState->Aml < PkgEnd)
797a159c266SJung-uk Kim             {
798a159c266SJung-uk Kim                 /* Non-empty list */
799a159c266SJung-uk Kim 
800fe0f0bbbSJung-uk Kim                 Arg = AcpiPsAllocOp (AML_INT_BYTELIST_OP, Aml);
801a159c266SJung-uk Kim                 if (!Arg)
802a159c266SJung-uk Kim                 {
803c708f80eSJung-uk Kim                     AcpiPsFreeOp (Field);
804a159c266SJung-uk Kim                     return_PTR (NULL);
805a159c266SJung-uk Kim                 }
806a159c266SJung-uk Kim 
807a159c266SJung-uk Kim                 /* Get the actual buffer length argument */
808a159c266SJung-uk Kim 
809a159c266SJung-uk Kim                 Opcode = ACPI_GET8 (ParserState->Aml);
810a159c266SJung-uk Kim                 ParserState->Aml++;
811a159c266SJung-uk Kim 
8120d84335fSJung-uk Kim                 ASL_CV_CAPTURE_COMMENTS_ONLY (ParserState);
813a159c266SJung-uk Kim                 switch (Opcode)
814a159c266SJung-uk Kim                 {
815a159c266SJung-uk Kim                 case AML_BYTE_OP:       /* AML_BYTEDATA_ARG */
816a9d8d09cSJung-uk Kim 
817a159c266SJung-uk Kim                     BufferLength = ACPI_GET8 (ParserState->Aml);
818a159c266SJung-uk Kim                     ParserState->Aml += 1;
819a159c266SJung-uk Kim                     break;
820a159c266SJung-uk Kim 
821a159c266SJung-uk Kim                 case AML_WORD_OP:       /* AML_WORDDATA_ARG */
822a9d8d09cSJung-uk Kim 
823a159c266SJung-uk Kim                     BufferLength = ACPI_GET16 (ParserState->Aml);
824a159c266SJung-uk Kim                     ParserState->Aml += 2;
825a159c266SJung-uk Kim                     break;
826a159c266SJung-uk Kim 
827a159c266SJung-uk Kim                 case AML_DWORD_OP:      /* AML_DWORDATA_ARG */
828a9d8d09cSJung-uk Kim 
829a159c266SJung-uk Kim                     BufferLength = ACPI_GET32 (ParserState->Aml);
830a159c266SJung-uk Kim                     ParserState->Aml += 4;
831a159c266SJung-uk Kim                     break;
832a159c266SJung-uk Kim 
833a159c266SJung-uk Kim                 default:
834a9d8d09cSJung-uk Kim 
835a159c266SJung-uk Kim                     BufferLength = 0;
836a159c266SJung-uk Kim                     break;
837a159c266SJung-uk Kim                 }
838a159c266SJung-uk Kim 
839a159c266SJung-uk Kim                 /* Fill in bytelist data */
840a159c266SJung-uk Kim 
8410d84335fSJung-uk Kim                 ASL_CV_CAPTURE_COMMENTS_ONLY (ParserState);
842a159c266SJung-uk Kim                 Arg->Named.Value.Size = BufferLength;
843a159c266SJung-uk Kim                 Arg->Named.Data = ParserState->Aml;
844a159c266SJung-uk Kim             }
845a159c266SJung-uk Kim 
846a159c266SJung-uk Kim             /* Skip to End of byte data */
847a159c266SJung-uk Kim 
848a159c266SJung-uk Kim             ParserState->Aml = PkgEnd;
849a159c266SJung-uk Kim         }
850a159c266SJung-uk Kim         else
851a159c266SJung-uk Kim         {
852fe0f0bbbSJung-uk Kim             Arg = AcpiPsAllocOp (AML_INT_NAMEPATH_OP, Aml);
853a159c266SJung-uk Kim             if (!Arg)
854a159c266SJung-uk Kim             {
855c708f80eSJung-uk Kim                 AcpiPsFreeOp (Field);
856a159c266SJung-uk Kim                 return_PTR (NULL);
857a159c266SJung-uk Kim             }
858a159c266SJung-uk Kim 
859a159c266SJung-uk Kim             /* Get the Namestring argument */
860a159c266SJung-uk Kim 
861a159c266SJung-uk Kim             Arg->Common.Value.Name = AcpiPsGetNextNamestring (ParserState);
862a159c266SJung-uk Kim         }
863a159c266SJung-uk Kim 
864a159c266SJung-uk Kim         /* Link the buffer/namestring to parent (CONNECTION_OP) */
865a159c266SJung-uk Kim 
866a159c266SJung-uk Kim         AcpiPsAppendArg (Field, Arg);
867a159c266SJung-uk Kim         break;
868a159c266SJung-uk Kim 
869a159c266SJung-uk Kim 
870a159c266SJung-uk Kim     default:
871a159c266SJung-uk Kim 
872a159c266SJung-uk Kim         /* Opcode was set in previous switch */
873a159c266SJung-uk Kim         break;
874a159c266SJung-uk Kim     }
875a159c266SJung-uk Kim 
876a159c266SJung-uk Kim     return_PTR (Field);
877a159c266SJung-uk Kim }
878a159c266SJung-uk Kim 
879*92f570c3SJung-uk Kim /*******************************************************************************
880*92f570c3SJung-uk Kim  *
881*92f570c3SJung-uk Kim  * FUNCTION:    AcpiPsFreeFieldList
882*92f570c3SJung-uk Kim  *
883*92f570c3SJung-uk Kim  * PARAMETERS:  Start               - First Op in field list
884*92f570c3SJung-uk Kim  *
885*92f570c3SJung-uk Kim  * RETURN:      None.
886*92f570c3SJung-uk Kim  *
887*92f570c3SJung-uk Kim  * DESCRIPTION: Free all Op objects inside a field list.
888*92f570c3SJung-uk Kim  *
889*92f570c3SJung-uk Kim  ******************************************************************************/
890*92f570c3SJung-uk Kim 
891*92f570c3SJung-uk Kim static void
892*92f570c3SJung-uk Kim AcpiPsFreeFieldList (
893*92f570c3SJung-uk Kim     ACPI_PARSE_OBJECT	*Start)
894*92f570c3SJung-uk Kim {
895*92f570c3SJung-uk Kim     ACPI_PARSE_OBJECT *Current = Start;
896*92f570c3SJung-uk Kim     ACPI_PARSE_OBJECT *Next;
897*92f570c3SJung-uk Kim     ACPI_PARSE_OBJECT *Arg;
898*92f570c3SJung-uk Kim 
899*92f570c3SJung-uk Kim     while (Current)
900*92f570c3SJung-uk Kim     {
901*92f570c3SJung-uk Kim         Next = Current->Common.Next;
902*92f570c3SJung-uk Kim 
903*92f570c3SJung-uk Kim         /* AML_INT_CONNECTION_OP can have a single argument */
904*92f570c3SJung-uk Kim 
905*92f570c3SJung-uk Kim         Arg = AcpiPsGetArg (Current, 0);
906*92f570c3SJung-uk Kim         if (Arg)
907*92f570c3SJung-uk Kim         {
908*92f570c3SJung-uk Kim             AcpiPsFreeOp (Arg);
909*92f570c3SJung-uk Kim         }
910*92f570c3SJung-uk Kim 
911*92f570c3SJung-uk Kim         AcpiPsFreeOp(Current);
912*92f570c3SJung-uk Kim         Current = Next;
913*92f570c3SJung-uk Kim     }
914*92f570c3SJung-uk Kim }
915*92f570c3SJung-uk Kim 
916a159c266SJung-uk Kim 
917a159c266SJung-uk Kim /*******************************************************************************
918a159c266SJung-uk Kim  *
919a159c266SJung-uk Kim  * FUNCTION:    AcpiPsGetNextArg
920a159c266SJung-uk Kim  *
921a159c266SJung-uk Kim  * PARAMETERS:  WalkState           - Current state
922a159c266SJung-uk Kim  *              ParserState         - Current parser state object
923a159c266SJung-uk Kim  *              ArgType             - The argument type (AML_*_ARG)
924a159c266SJung-uk Kim  *              ReturnArg           - Where the next arg is returned
925a159c266SJung-uk Kim  *
926a159c266SJung-uk Kim  * RETURN:      Status, and an op object containing the next argument.
927a159c266SJung-uk Kim  *
928a159c266SJung-uk Kim  * DESCRIPTION: Get next argument (including complex list arguments that require
929a159c266SJung-uk Kim  *              pushing the parser stack)
930a159c266SJung-uk Kim  *
931a159c266SJung-uk Kim  ******************************************************************************/
932a159c266SJung-uk Kim 
933a159c266SJung-uk Kim ACPI_STATUS
934a159c266SJung-uk Kim AcpiPsGetNextArg (
935a159c266SJung-uk Kim     ACPI_WALK_STATE         *WalkState,
936a159c266SJung-uk Kim     ACPI_PARSE_STATE        *ParserState,
937a159c266SJung-uk Kim     UINT32                  ArgType,
938a159c266SJung-uk Kim     ACPI_PARSE_OBJECT       **ReturnArg)
939a159c266SJung-uk Kim {
940a159c266SJung-uk Kim     ACPI_PARSE_OBJECT       *Arg = NULL;
941a159c266SJung-uk Kim     ACPI_PARSE_OBJECT       *Prev = NULL;
942a159c266SJung-uk Kim     ACPI_PARSE_OBJECT       *Field;
943a159c266SJung-uk Kim     UINT32                  Subop;
944a159c266SJung-uk Kim     ACPI_STATUS             Status = AE_OK;
945a159c266SJung-uk Kim 
946a159c266SJung-uk Kim 
947a159c266SJung-uk Kim     ACPI_FUNCTION_TRACE_PTR (PsGetNextArg, ParserState);
948a159c266SJung-uk Kim 
949a159c266SJung-uk Kim 
9501cc50d6bSJung-uk Kim     ACPI_DEBUG_PRINT ((ACPI_DB_PARSE,
9511cc50d6bSJung-uk Kim         "Expected argument type ARGP: %s (%2.2X)\n",
9521cc50d6bSJung-uk Kim         AcpiUtGetArgumentTypeName (ArgType), ArgType));
9531cc50d6bSJung-uk Kim 
954a159c266SJung-uk Kim     switch (ArgType)
955a159c266SJung-uk Kim     {
956a159c266SJung-uk Kim     case ARGP_BYTEDATA:
957a159c266SJung-uk Kim     case ARGP_WORDDATA:
958a159c266SJung-uk Kim     case ARGP_DWORDDATA:
959a159c266SJung-uk Kim     case ARGP_CHARLIST:
960a159c266SJung-uk Kim     case ARGP_NAME:
961a159c266SJung-uk Kim     case ARGP_NAMESTRING:
962a159c266SJung-uk Kim 
963a159c266SJung-uk Kim         /* Constants, strings, and namestrings are all the same size */
964a159c266SJung-uk Kim 
965fe0f0bbbSJung-uk Kim         Arg = AcpiPsAllocOp (AML_BYTE_OP, ParserState->Aml);
966a159c266SJung-uk Kim         if (!Arg)
967a159c266SJung-uk Kim         {
968a159c266SJung-uk Kim             return_ACPI_STATUS (AE_NO_MEMORY);
969a159c266SJung-uk Kim         }
970f8146b88SJung-uk Kim 
971a159c266SJung-uk Kim         AcpiPsGetNextSimpleArg (ParserState, ArgType, Arg);
972a159c266SJung-uk Kim         break;
973a159c266SJung-uk Kim 
974a159c266SJung-uk Kim     case ARGP_PKGLENGTH:
975a159c266SJung-uk Kim 
976a159c266SJung-uk Kim         /* Package length, nothing returned */
977a159c266SJung-uk Kim 
978a159c266SJung-uk Kim         ParserState->PkgEnd = AcpiPsGetNextPackageEnd (ParserState);
979a159c266SJung-uk Kim         break;
980a159c266SJung-uk Kim 
981a159c266SJung-uk Kim     case ARGP_FIELDLIST:
982a159c266SJung-uk Kim 
983a159c266SJung-uk Kim         if (ParserState->Aml < ParserState->PkgEnd)
984a159c266SJung-uk Kim         {
985a159c266SJung-uk Kim             /* Non-empty list */
986a159c266SJung-uk Kim 
987a159c266SJung-uk Kim             while (ParserState->Aml < ParserState->PkgEnd)
988a159c266SJung-uk Kim             {
989a159c266SJung-uk Kim                 Field = AcpiPsGetNextField (ParserState);
990a159c266SJung-uk Kim                 if (!Field)
991a159c266SJung-uk Kim                 {
992*92f570c3SJung-uk Kim                     if (Arg)
993*92f570c3SJung-uk Kim                     {
994*92f570c3SJung-uk Kim                         AcpiPsFreeFieldList(Arg);
995*92f570c3SJung-uk Kim                     }
996*92f570c3SJung-uk Kim 
997a159c266SJung-uk Kim                     return_ACPI_STATUS (AE_NO_MEMORY);
998a159c266SJung-uk Kim                 }
999a159c266SJung-uk Kim 
1000a159c266SJung-uk Kim                 if (Prev)
1001a159c266SJung-uk Kim                 {
1002a159c266SJung-uk Kim                     Prev->Common.Next = Field;
1003a159c266SJung-uk Kim                 }
1004a159c266SJung-uk Kim                 else
1005a159c266SJung-uk Kim                 {
1006a159c266SJung-uk Kim                     Arg = Field;
1007a159c266SJung-uk Kim                 }
1008a159c266SJung-uk Kim                 Prev = Field;
1009a159c266SJung-uk Kim             }
1010a159c266SJung-uk Kim 
1011a159c266SJung-uk Kim             /* Skip to End of byte data */
1012a159c266SJung-uk Kim 
1013a159c266SJung-uk Kim             ParserState->Aml = ParserState->PkgEnd;
1014a159c266SJung-uk Kim         }
1015a159c266SJung-uk Kim         break;
1016a159c266SJung-uk Kim 
1017a159c266SJung-uk Kim     case ARGP_BYTELIST:
1018a159c266SJung-uk Kim 
1019a159c266SJung-uk Kim         if (ParserState->Aml < ParserState->PkgEnd)
1020a159c266SJung-uk Kim         {
1021a159c266SJung-uk Kim             /* Non-empty list */
1022a159c266SJung-uk Kim 
1023fe0f0bbbSJung-uk Kim             Arg = AcpiPsAllocOp (AML_INT_BYTELIST_OP,
1024fe0f0bbbSJung-uk Kim                 ParserState->Aml);
1025a159c266SJung-uk Kim             if (!Arg)
1026a159c266SJung-uk Kim             {
1027a159c266SJung-uk Kim                 return_ACPI_STATUS (AE_NO_MEMORY);
1028a159c266SJung-uk Kim             }
1029a159c266SJung-uk Kim 
1030a159c266SJung-uk Kim             /* Fill in bytelist data */
1031a159c266SJung-uk Kim 
1032a159c266SJung-uk Kim             Arg->Common.Value.Size = (UINT32)
1033a159c266SJung-uk Kim                 ACPI_PTR_DIFF (ParserState->PkgEnd, ParserState->Aml);
1034a159c266SJung-uk Kim             Arg->Named.Data = ParserState->Aml;
1035a159c266SJung-uk Kim 
1036a159c266SJung-uk Kim             /* Skip to End of byte data */
1037a159c266SJung-uk Kim 
1038a159c266SJung-uk Kim             ParserState->Aml = ParserState->PkgEnd;
1039a159c266SJung-uk Kim         }
1040a159c266SJung-uk Kim         break;
1041a159c266SJung-uk Kim 
1042a159c266SJung-uk Kim     case ARGP_SIMPLENAME:
1043f8146b88SJung-uk Kim     case ARGP_NAME_OR_REF:
1044a159c266SJung-uk Kim 
10451cc50d6bSJung-uk Kim         ACPI_DEBUG_PRINT ((ACPI_DB_PARSE,
10461cc50d6bSJung-uk Kim             "**** SimpleName/NameOrRef: %s (%2.2X)\n",
10471cc50d6bSJung-uk Kim             AcpiUtGetArgumentTypeName (ArgType), ArgType));
10481cc50d6bSJung-uk Kim 
1049a159c266SJung-uk Kim         Subop = AcpiPsPeekOpcode (ParserState);
1050a159c266SJung-uk Kim         if (Subop == 0                  ||
1051a159c266SJung-uk Kim             AcpiPsIsLeadingChar (Subop) ||
1052efcc2a30SJung-uk Kim             ACPI_IS_ROOT_PREFIX (Subop) ||
1053efcc2a30SJung-uk Kim             ACPI_IS_PARENT_PREFIX (Subop))
1054a159c266SJung-uk Kim         {
1055a159c266SJung-uk Kim             /* NullName or NameString */
1056a159c266SJung-uk Kim 
1057fe0f0bbbSJung-uk Kim             Arg = AcpiPsAllocOp (AML_INT_NAMEPATH_OP, ParserState->Aml);
1058a159c266SJung-uk Kim             if (!Arg)
1059a159c266SJung-uk Kim             {
1060a159c266SJung-uk Kim                 return_ACPI_STATUS (AE_NO_MEMORY);
1061a159c266SJung-uk Kim             }
1062a159c266SJung-uk Kim 
1063f8146b88SJung-uk Kim             Status = AcpiPsGetNextNamepath (WalkState, ParserState,
1064f8146b88SJung-uk Kim                 Arg, ACPI_NOT_METHOD_CALL);
1065*92f570c3SJung-uk Kim             if (ACPI_FAILURE(Status))
1066*92f570c3SJung-uk Kim             {
1067*92f570c3SJung-uk Kim                 AcpiPsFreeOp (Arg);
1068*92f570c3SJung-uk Kim                 return_ACPI_STATUS (Status);
1069*92f570c3SJung-uk Kim             }
1070a159c266SJung-uk Kim         }
10711cc50d6bSJung-uk Kim         else
10721cc50d6bSJung-uk Kim         {
10731cc50d6bSJung-uk Kim             /* Single complex argument, nothing returned */
10741cc50d6bSJung-uk Kim 
10751cc50d6bSJung-uk Kim             WalkState->ArgCount = 1;
10761cc50d6bSJung-uk Kim         }
10771cc50d6bSJung-uk Kim         break;
10781cc50d6bSJung-uk Kim 
10791cc50d6bSJung-uk Kim     case ARGP_TARGET:
10801cc50d6bSJung-uk Kim     case ARGP_SUPERNAME:
10811cc50d6bSJung-uk Kim 
10821cc50d6bSJung-uk Kim         ACPI_DEBUG_PRINT ((ACPI_DB_PARSE,
10831cc50d6bSJung-uk Kim             "**** Target/Supername: %s (%2.2X)\n",
10841cc50d6bSJung-uk Kim             AcpiUtGetArgumentTypeName (ArgType), ArgType));
10851cc50d6bSJung-uk Kim 
10861cc50d6bSJung-uk Kim         Subop = AcpiPsPeekOpcode (ParserState);
108728482948SJung-uk Kim         if (Subop == 0                  ||
108828482948SJung-uk Kim             AcpiPsIsLeadingChar (Subop) ||
108928482948SJung-uk Kim             ACPI_IS_ROOT_PREFIX (Subop) ||
109028482948SJung-uk Kim             ACPI_IS_PARENT_PREFIX (Subop))
10911cc50d6bSJung-uk Kim         {
10921cc50d6bSJung-uk Kim             /* NULL target (zero). Convert to a NULL namepath */
10931cc50d6bSJung-uk Kim 
10941cc50d6bSJung-uk Kim             Arg = AcpiPsAllocOp (AML_INT_NAMEPATH_OP, ParserState->Aml);
10951cc50d6bSJung-uk Kim             if (!Arg)
10961cc50d6bSJung-uk Kim             {
10971cc50d6bSJung-uk Kim                 return_ACPI_STATUS (AE_NO_MEMORY);
10981cc50d6bSJung-uk Kim             }
10991cc50d6bSJung-uk Kim 
11001cc50d6bSJung-uk Kim             Status = AcpiPsGetNextNamepath (WalkState, ParserState,
11011cc50d6bSJung-uk Kim                 Arg, ACPI_POSSIBLE_METHOD_CALL);
1102*92f570c3SJung-uk Kim             if (ACPI_FAILURE(Status))
1103*92f570c3SJung-uk Kim             {
1104*92f570c3SJung-uk Kim                 AcpiPsFreeOp (Arg);
1105*92f570c3SJung-uk Kim                 return_ACPI_STATUS (Status);
1106*92f570c3SJung-uk Kim             }
110728482948SJung-uk Kim 
110828482948SJung-uk Kim             if (Arg->Common.AmlOpcode == AML_INT_METHODCALL_OP)
110928482948SJung-uk Kim             {
11108438a7a8SJung-uk Kim                 /* Free method call op and corresponding namestring sub-ob */
11118438a7a8SJung-uk Kim 
11128438a7a8SJung-uk Kim                 AcpiPsFreeOp (Arg->Common.Value.Arg);
111328482948SJung-uk Kim                 AcpiPsFreeOp (Arg);
111428482948SJung-uk Kim                 Arg = NULL;
111528482948SJung-uk Kim                 WalkState->ArgCount = 1;
111628482948SJung-uk Kim             }
1117a159c266SJung-uk Kim         }
1118a159c266SJung-uk Kim         else
1119a159c266SJung-uk Kim         {
1120a159c266SJung-uk Kim             /* Single complex argument, nothing returned */
1121a159c266SJung-uk Kim 
1122a159c266SJung-uk Kim             WalkState->ArgCount = 1;
1123a159c266SJung-uk Kim         }
1124a159c266SJung-uk Kim         break;
1125a159c266SJung-uk Kim 
1126a159c266SJung-uk Kim     case ARGP_DATAOBJ:
1127a159c266SJung-uk Kim     case ARGP_TERMARG:
1128a159c266SJung-uk Kim 
11291cc50d6bSJung-uk Kim         ACPI_DEBUG_PRINT ((ACPI_DB_PARSE,
11301cc50d6bSJung-uk Kim             "**** TermArg/DataObj: %s (%2.2X)\n",
11311cc50d6bSJung-uk Kim             AcpiUtGetArgumentTypeName (ArgType), ArgType));
11321cc50d6bSJung-uk Kim 
1133a159c266SJung-uk Kim         /* Single complex argument, nothing returned */
1134a159c266SJung-uk Kim 
1135a159c266SJung-uk Kim         WalkState->ArgCount = 1;
1136a159c266SJung-uk Kim         break;
1137a159c266SJung-uk Kim 
1138a159c266SJung-uk Kim     case ARGP_DATAOBJLIST:
1139a159c266SJung-uk Kim     case ARGP_TERMLIST:
1140a159c266SJung-uk Kim     case ARGP_OBJLIST:
1141a159c266SJung-uk Kim 
1142a159c266SJung-uk Kim         if (ParserState->Aml < ParserState->PkgEnd)
1143a159c266SJung-uk Kim         {
1144a159c266SJung-uk Kim             /* Non-empty list of variable arguments, nothing returned */
1145a159c266SJung-uk Kim 
1146a159c266SJung-uk Kim             WalkState->ArgCount = ACPI_VAR_ARGS;
1147a159c266SJung-uk Kim         }
1148a159c266SJung-uk Kim         break;
1149a159c266SJung-uk Kim 
1150a159c266SJung-uk Kim     default:
1151a159c266SJung-uk Kim 
1152a159c266SJung-uk Kim         ACPI_ERROR ((AE_INFO, "Invalid ArgType: 0x%X", ArgType));
1153a159c266SJung-uk Kim         Status = AE_AML_OPERAND_TYPE;
1154a159c266SJung-uk Kim         break;
1155a159c266SJung-uk Kim     }
1156a159c266SJung-uk Kim 
1157a159c266SJung-uk Kim     *ReturnArg = Arg;
1158a159c266SJung-uk Kim     return_ACPI_STATUS (Status);
1159a159c266SJung-uk Kim }
1160