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 *
11722b1667SJung-uk Kim * Some or all of this work - Copyright (c) 1999 - 2023, 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
173a159c266SJung-uk Kim
174a159c266SJung-uk Kim /*******************************************************************************
175a159c266SJung-uk Kim *
176a159c266SJung-uk Kim * FUNCTION: AcpiPsGetNextPackageLength
177a159c266SJung-uk Kim *
178a159c266SJung-uk Kim * PARAMETERS: ParserState - Current parser state object
179a159c266SJung-uk Kim *
180a159c266SJung-uk Kim * RETURN: Decoded package length. On completion, the AML pointer points
181a159c266SJung-uk Kim * past the length byte or bytes.
182a159c266SJung-uk Kim *
183a159c266SJung-uk Kim * DESCRIPTION: Decode and return a package length field.
184a159c266SJung-uk Kim * Note: Largest package length is 28 bits, from ACPI specification
185a159c266SJung-uk Kim *
186a159c266SJung-uk Kim ******************************************************************************/
187a159c266SJung-uk Kim
188a159c266SJung-uk Kim static UINT32
AcpiPsGetNextPackageLength(ACPI_PARSE_STATE * ParserState)189a159c266SJung-uk Kim AcpiPsGetNextPackageLength (
190a159c266SJung-uk Kim ACPI_PARSE_STATE *ParserState)
191a159c266SJung-uk Kim {
192a159c266SJung-uk Kim UINT8 *Aml = ParserState->Aml;
193a159c266SJung-uk Kim UINT32 PackageLength = 0;
194a159c266SJung-uk Kim UINT32 ByteCount;
195a159c266SJung-uk Kim UINT8 ByteZeroMask = 0x3F; /* Default [0:5] */
196a159c266SJung-uk Kim
197a159c266SJung-uk Kim
198a159c266SJung-uk Kim ACPI_FUNCTION_TRACE (PsGetNextPackageLength);
199a159c266SJung-uk Kim
200a159c266SJung-uk Kim
201a159c266SJung-uk Kim /*
202a159c266SJung-uk Kim * Byte 0 bits [6:7] contain the number of additional bytes
203a159c266SJung-uk Kim * used to encode the package length, either 0,1,2, or 3
204a159c266SJung-uk Kim */
205a159c266SJung-uk Kim ByteCount = (Aml[0] >> 6);
206a159c266SJung-uk Kim ParserState->Aml += ((ACPI_SIZE) ByteCount + 1);
207a159c266SJung-uk Kim
208a159c266SJung-uk Kim /* Get bytes 3, 2, 1 as needed */
209a159c266SJung-uk Kim
210a159c266SJung-uk Kim while (ByteCount)
211a159c266SJung-uk Kim {
212a159c266SJung-uk Kim /*
213a159c266SJung-uk Kim * Final bit positions for the package length bytes:
214a159c266SJung-uk Kim * Byte3->[20:27]
215a159c266SJung-uk Kim * Byte2->[12:19]
216a159c266SJung-uk Kim * Byte1->[04:11]
217a159c266SJung-uk Kim * Byte0->[00:03]
218a159c266SJung-uk Kim */
219a159c266SJung-uk Kim PackageLength |= (Aml[ByteCount] << ((ByteCount << 3) - 4));
220a159c266SJung-uk Kim
221a159c266SJung-uk Kim ByteZeroMask = 0x0F; /* Use bits [0:3] of byte 0 */
222a159c266SJung-uk Kim ByteCount--;
223a159c266SJung-uk Kim }
224a159c266SJung-uk Kim
225a159c266SJung-uk Kim /* Byte 0 is a special case, either bits [0:3] or [0:5] are used */
226a159c266SJung-uk Kim
227a159c266SJung-uk Kim PackageLength |= (Aml[0] & ByteZeroMask);
2289c48c75eSJung-uk Kim return_UINT32 (PackageLength);
229a159c266SJung-uk Kim }
230a159c266SJung-uk Kim
231a159c266SJung-uk Kim
232a159c266SJung-uk Kim /*******************************************************************************
233a159c266SJung-uk Kim *
234a159c266SJung-uk Kim * FUNCTION: AcpiPsGetNextPackageEnd
235a159c266SJung-uk Kim *
236a159c266SJung-uk Kim * PARAMETERS: ParserState - Current parser state object
237a159c266SJung-uk Kim *
238a159c266SJung-uk Kim * RETURN: Pointer to end-of-package +1
239a159c266SJung-uk Kim *
240a159c266SJung-uk Kim * DESCRIPTION: Get next package length and return a pointer past the end of
241a159c266SJung-uk Kim * the package. Consumes the package length field
242a159c266SJung-uk Kim *
243a159c266SJung-uk Kim ******************************************************************************/
244a159c266SJung-uk Kim
245a159c266SJung-uk Kim UINT8 *
AcpiPsGetNextPackageEnd(ACPI_PARSE_STATE * ParserState)246a159c266SJung-uk Kim AcpiPsGetNextPackageEnd (
247a159c266SJung-uk Kim ACPI_PARSE_STATE *ParserState)
248a159c266SJung-uk Kim {
249a159c266SJung-uk Kim UINT8 *Start = ParserState->Aml;
250a159c266SJung-uk Kim UINT32 PackageLength;
251a159c266SJung-uk Kim
252a159c266SJung-uk Kim
253a159c266SJung-uk Kim ACPI_FUNCTION_TRACE (PsGetNextPackageEnd);
254a159c266SJung-uk Kim
255a159c266SJung-uk Kim
256a159c266SJung-uk Kim /* Function below updates ParserState->Aml */
257a159c266SJung-uk Kim
258a159c266SJung-uk Kim PackageLength = AcpiPsGetNextPackageLength (ParserState);
259a159c266SJung-uk Kim
260a159c266SJung-uk Kim return_PTR (Start + PackageLength); /* end of package */
261a159c266SJung-uk Kim }
262a159c266SJung-uk Kim
263a159c266SJung-uk Kim
264a159c266SJung-uk Kim /*******************************************************************************
265a159c266SJung-uk Kim *
266a159c266SJung-uk Kim * FUNCTION: AcpiPsGetNextNamestring
267a159c266SJung-uk Kim *
268a159c266SJung-uk Kim * PARAMETERS: ParserState - Current parser state object
269a159c266SJung-uk Kim *
270a159c266SJung-uk Kim * RETURN: Pointer to the start of the name string (pointer points into
271a159c266SJung-uk Kim * the AML.
272a159c266SJung-uk Kim *
273a159c266SJung-uk Kim * DESCRIPTION: Get next raw namestring within the AML stream. Handles all name
274a159c266SJung-uk Kim * prefix characters. Set parser state to point past the string.
275a159c266SJung-uk Kim * (Name is consumed from the AML.)
276a159c266SJung-uk Kim *
277a159c266SJung-uk Kim ******************************************************************************/
278a159c266SJung-uk Kim
279a159c266SJung-uk Kim char *
AcpiPsGetNextNamestring(ACPI_PARSE_STATE * ParserState)280a159c266SJung-uk Kim AcpiPsGetNextNamestring (
281a159c266SJung-uk Kim ACPI_PARSE_STATE *ParserState)
282a159c266SJung-uk Kim {
283a159c266SJung-uk Kim UINT8 *Start = ParserState->Aml;
284a159c266SJung-uk Kim UINT8 *End = ParserState->Aml;
285a159c266SJung-uk Kim
286a159c266SJung-uk Kim
287a159c266SJung-uk Kim ACPI_FUNCTION_TRACE (PsGetNextNamestring);
288a159c266SJung-uk Kim
289a159c266SJung-uk Kim
290a159c266SJung-uk Kim /* Point past any namestring prefix characters (backslash or carat) */
291a159c266SJung-uk Kim
292efcc2a30SJung-uk Kim while (ACPI_IS_ROOT_PREFIX (*End) ||
293efcc2a30SJung-uk Kim ACPI_IS_PARENT_PREFIX (*End))
294a159c266SJung-uk Kim {
295a159c266SJung-uk Kim End++;
296a159c266SJung-uk Kim }
297a159c266SJung-uk Kim
298a159c266SJung-uk Kim /* Decode the path prefix character */
299a159c266SJung-uk Kim
300a159c266SJung-uk Kim switch (*End)
301a159c266SJung-uk Kim {
302a159c266SJung-uk Kim case 0:
303a159c266SJung-uk Kim
304a159c266SJung-uk Kim /* NullName */
305a159c266SJung-uk Kim
306a159c266SJung-uk Kim if (End == Start)
307a159c266SJung-uk Kim {
308a159c266SJung-uk Kim Start = NULL;
309a159c266SJung-uk Kim }
310a159c266SJung-uk Kim End++;
311a159c266SJung-uk Kim break;
312a159c266SJung-uk Kim
313a159c266SJung-uk Kim case AML_DUAL_NAME_PREFIX:
314a159c266SJung-uk Kim
315a159c266SJung-uk Kim /* Two name segments */
316a159c266SJung-uk Kim
317278f0de6SJung-uk Kim End += 1 + (2 * ACPI_NAMESEG_SIZE);
318a159c266SJung-uk Kim break;
319a159c266SJung-uk Kim
3200d84335fSJung-uk Kim case AML_MULTI_NAME_PREFIX:
321a159c266SJung-uk Kim
322a159c266SJung-uk Kim /* Multiple name segments, 4 chars each, count in next byte */
323a159c266SJung-uk Kim
324278f0de6SJung-uk Kim End += 2 + (*(End + 1) * ACPI_NAMESEG_SIZE);
325a159c266SJung-uk Kim break;
326a159c266SJung-uk Kim
327a159c266SJung-uk Kim default:
328a159c266SJung-uk Kim
329a159c266SJung-uk Kim /* Single name segment */
330a159c266SJung-uk Kim
331278f0de6SJung-uk Kim End += ACPI_NAMESEG_SIZE;
332a159c266SJung-uk Kim break;
333a159c266SJung-uk Kim }
334a159c266SJung-uk Kim
335a159c266SJung-uk Kim ParserState->Aml = End;
336a159c266SJung-uk Kim return_PTR ((char *) Start);
337a159c266SJung-uk Kim }
338a159c266SJung-uk Kim
339a159c266SJung-uk Kim
340a159c266SJung-uk Kim /*******************************************************************************
341a159c266SJung-uk Kim *
342a159c266SJung-uk Kim * FUNCTION: AcpiPsGetNextNamepath
343a159c266SJung-uk Kim *
344a159c266SJung-uk Kim * PARAMETERS: ParserState - Current parser state object
345a159c266SJung-uk Kim * Arg - Where the namepath will be stored
346a159c266SJung-uk Kim * ArgCount - If the namepath points to a control method
347a159c266SJung-uk Kim * the method's argument is returned here.
348a159c266SJung-uk Kim * PossibleMethodCall - Whether the namepath can possibly be the
349a159c266SJung-uk Kim * start of a method call
350a159c266SJung-uk Kim *
351a159c266SJung-uk Kim * RETURN: Status
352a159c266SJung-uk Kim *
353a159c266SJung-uk Kim * DESCRIPTION: Get next name (if method call, return # of required args).
354a159c266SJung-uk Kim * Names are looked up in the internal namespace to determine
355a159c266SJung-uk Kim * if the name represents a control method. If a method
356a159c266SJung-uk Kim * is found, the number of arguments to the method is returned.
357a159c266SJung-uk Kim * This information is critical for parsing to continue correctly.
358a159c266SJung-uk Kim *
359a159c266SJung-uk Kim ******************************************************************************/
360a159c266SJung-uk Kim
361a159c266SJung-uk Kim ACPI_STATUS
AcpiPsGetNextNamepath(ACPI_WALK_STATE * WalkState,ACPI_PARSE_STATE * ParserState,ACPI_PARSE_OBJECT * Arg,BOOLEAN PossibleMethodCall)362a159c266SJung-uk Kim AcpiPsGetNextNamepath (
363a159c266SJung-uk Kim ACPI_WALK_STATE *WalkState,
364a159c266SJung-uk Kim ACPI_PARSE_STATE *ParserState,
365a159c266SJung-uk Kim ACPI_PARSE_OBJECT *Arg,
366a159c266SJung-uk Kim BOOLEAN PossibleMethodCall)
367a159c266SJung-uk Kim {
368a159c266SJung-uk Kim ACPI_STATUS Status;
369a159c266SJung-uk Kim char *Path;
370a159c266SJung-uk Kim ACPI_PARSE_OBJECT *NameOp;
371a159c266SJung-uk Kim ACPI_OPERAND_OBJECT *MethodDesc;
372a159c266SJung-uk Kim ACPI_NAMESPACE_NODE *Node;
373a159c266SJung-uk Kim UINT8 *Start = ParserState->Aml;
374a159c266SJung-uk Kim
375a159c266SJung-uk Kim
376a159c266SJung-uk Kim ACPI_FUNCTION_TRACE (PsGetNextNamepath);
377a159c266SJung-uk Kim
378a159c266SJung-uk Kim
379a159c266SJung-uk Kim Path = AcpiPsGetNextNamestring (ParserState);
380a159c266SJung-uk Kim AcpiPsInitOp (Arg, AML_INT_NAMEPATH_OP);
381a159c266SJung-uk Kim
382a159c266SJung-uk Kim /* Null path case is allowed, just exit */
383a159c266SJung-uk Kim
384a159c266SJung-uk Kim if (!Path)
385a159c266SJung-uk Kim {
386a159c266SJung-uk Kim Arg->Common.Value.Name = Path;
387a159c266SJung-uk Kim return_ACPI_STATUS (AE_OK);
388a159c266SJung-uk Kim }
389a159c266SJung-uk Kim
390a159c266SJung-uk Kim /*
391a159c266SJung-uk Kim * Lookup the name in the internal namespace, starting with the current
392a159c266SJung-uk Kim * scope. We don't want to add anything new to the namespace here,
393a159c266SJung-uk Kim * however, so we use MODE_EXECUTE.
394a159c266SJung-uk Kim * Allow searching of the parent tree, but don't open a new scope -
395a159c266SJung-uk Kim * we just want to lookup the object (must be mode EXECUTE to perform
396a159c266SJung-uk Kim * the upsearch)
397a159c266SJung-uk Kim */
398a159c266SJung-uk Kim Status = AcpiNsLookup (WalkState->ScopeInfo, Path,
399a159c266SJung-uk Kim ACPI_TYPE_ANY, ACPI_IMODE_EXECUTE,
400a159c266SJung-uk Kim ACPI_NS_SEARCH_PARENT | ACPI_NS_DONT_OPEN_SCOPE, NULL, &Node);
401a159c266SJung-uk Kim
402a159c266SJung-uk Kim /*
403a159c266SJung-uk Kim * If this name is a control method invocation, we must
404a159c266SJung-uk Kim * setup the method call
405a159c266SJung-uk Kim */
406a159c266SJung-uk Kim if (ACPI_SUCCESS (Status) &&
407a159c266SJung-uk Kim PossibleMethodCall &&
408a159c266SJung-uk Kim (Node->Type == ACPI_TYPE_METHOD))
409a159c266SJung-uk Kim {
41028482948SJung-uk Kim if ((GET_CURRENT_ARG_TYPE (WalkState->ArgTypes) == ARGP_SUPERNAME) ||
41128482948SJung-uk Kim (GET_CURRENT_ARG_TYPE (WalkState->ArgTypes) == ARGP_TARGET))
41228482948SJung-uk Kim {
41328482948SJung-uk Kim /*
41428482948SJung-uk Kim * AcpiPsGetNextNamestring has increased the AML pointer past
41528482948SJung-uk Kim * the method invocation namestring, so we need to restore the
41628482948SJung-uk Kim * saved AML pointer back to the original method invocation
41728482948SJung-uk Kim * namestring.
41828482948SJung-uk Kim */
41928482948SJung-uk Kim WalkState->ParserState.Aml = Start;
42028482948SJung-uk Kim WalkState->ArgCount = 1;
42128482948SJung-uk Kim AcpiPsInitOp (Arg, AML_INT_METHODCALL_OP);
42228482948SJung-uk Kim }
42328482948SJung-uk Kim
424a159c266SJung-uk Kim /* This name is actually a control method invocation */
425a159c266SJung-uk Kim
426a159c266SJung-uk Kim MethodDesc = AcpiNsGetAttachedObject (Node);
427a159c266SJung-uk Kim ACPI_DEBUG_PRINT ((ACPI_DB_PARSE,
4281cc50d6bSJung-uk Kim "Control Method invocation %4.4s - %p Desc %p Path=%p\n",
4291cc50d6bSJung-uk Kim Node->Name.Ascii, Node, MethodDesc, Path));
430a159c266SJung-uk Kim
431fe0f0bbbSJung-uk Kim NameOp = AcpiPsAllocOp (AML_INT_NAMEPATH_OP, Start);
432a159c266SJung-uk Kim if (!NameOp)
433a159c266SJung-uk Kim {
434a159c266SJung-uk Kim return_ACPI_STATUS (AE_NO_MEMORY);
435a159c266SJung-uk Kim }
436a159c266SJung-uk Kim
437a159c266SJung-uk Kim /* Change Arg into a METHOD CALL and attach name to it */
438a159c266SJung-uk Kim
439a159c266SJung-uk Kim AcpiPsInitOp (Arg, AML_INT_METHODCALL_OP);
440a159c266SJung-uk Kim NameOp->Common.Value.Name = Path;
441a159c266SJung-uk Kim
442a159c266SJung-uk Kim /* Point METHODCALL/NAME to the METHOD Node */
443a159c266SJung-uk Kim
444a159c266SJung-uk Kim NameOp->Common.Node = Node;
445a159c266SJung-uk Kim AcpiPsAppendArg (Arg, NameOp);
446a159c266SJung-uk Kim
447a159c266SJung-uk Kim if (!MethodDesc)
448a159c266SJung-uk Kim {
449a159c266SJung-uk Kim ACPI_ERROR ((AE_INFO,
450a159c266SJung-uk Kim "Control Method %p has no attached object",
451a159c266SJung-uk Kim Node));
452a159c266SJung-uk Kim return_ACPI_STATUS (AE_AML_INTERNAL);
453a159c266SJung-uk Kim }
454a159c266SJung-uk Kim
455a159c266SJung-uk Kim ACPI_DEBUG_PRINT ((ACPI_DB_PARSE,
456a159c266SJung-uk Kim "Control Method - %p Args %X\n",
457a159c266SJung-uk Kim Node, MethodDesc->Method.ParamCount));
458a159c266SJung-uk Kim
459a159c266SJung-uk Kim /* Get the number of arguments to expect */
460a159c266SJung-uk Kim
461a159c266SJung-uk Kim WalkState->ArgCount = MethodDesc->Method.ParamCount;
462a159c266SJung-uk Kim return_ACPI_STATUS (AE_OK);
463a159c266SJung-uk Kim }
464a159c266SJung-uk Kim
465a159c266SJung-uk Kim /*
466a159c266SJung-uk Kim * Special handling if the name was not found during the lookup -
467a159c266SJung-uk Kim * some NotFound cases are allowed
468a159c266SJung-uk Kim */
469a159c266SJung-uk Kim if (Status == AE_NOT_FOUND)
470a159c266SJung-uk Kim {
471a159c266SJung-uk Kim /* 1) NotFound is ok during load pass 1/2 (allow forward references) */
472a159c266SJung-uk Kim
473a159c266SJung-uk Kim if ((WalkState->ParseFlags & ACPI_PARSE_MODE_MASK) !=
474a159c266SJung-uk Kim ACPI_PARSE_EXECUTE)
475a159c266SJung-uk Kim {
476a159c266SJung-uk Kim Status = AE_OK;
477a159c266SJung-uk Kim }
478a159c266SJung-uk Kim
479a159c266SJung-uk Kim /* 2) NotFound during a CondRefOf(x) is ok by definition */
480a159c266SJung-uk Kim
4810d84335fSJung-uk Kim else if (WalkState->Op->Common.AmlOpcode == AML_CONDITIONAL_REF_OF_OP)
482a159c266SJung-uk Kim {
483a159c266SJung-uk Kim Status = AE_OK;
484a159c266SJung-uk Kim }
485a159c266SJung-uk Kim
486a159c266SJung-uk Kim /*
487a159c266SJung-uk Kim * 3) NotFound while building a Package is ok at this point, we
488a159c266SJung-uk Kim * may flag as an error later if slack mode is not enabled.
489a159c266SJung-uk Kim * (Some ASL code depends on allowing this behavior)
490a159c266SJung-uk Kim */
491a159c266SJung-uk Kim else if ((Arg->Common.Parent) &&
492a159c266SJung-uk Kim ((Arg->Common.Parent->Common.AmlOpcode == AML_PACKAGE_OP) ||
4930d84335fSJung-uk Kim (Arg->Common.Parent->Common.AmlOpcode == AML_VARIABLE_PACKAGE_OP)))
494a159c266SJung-uk Kim {
495a159c266SJung-uk Kim Status = AE_OK;
496a159c266SJung-uk Kim }
497a159c266SJung-uk Kim }
498a159c266SJung-uk Kim
499a159c266SJung-uk Kim /* Final exception check (may have been changed from code above) */
500a159c266SJung-uk Kim
501a159c266SJung-uk Kim if (ACPI_FAILURE (Status))
502a159c266SJung-uk Kim {
503b7b7e711SJung-uk Kim ACPI_ERROR_NAMESPACE (WalkState->ScopeInfo, Path, Status);
504a159c266SJung-uk Kim
505a159c266SJung-uk Kim if ((WalkState->ParseFlags & ACPI_PARSE_MODE_MASK) ==
506a159c266SJung-uk Kim ACPI_PARSE_EXECUTE)
507a159c266SJung-uk Kim {
508a159c266SJung-uk Kim /* Report a control method execution error */
509a159c266SJung-uk Kim
510a159c266SJung-uk Kim Status = AcpiDsMethodError (Status, WalkState);
511a159c266SJung-uk Kim }
512a159c266SJung-uk Kim }
513a159c266SJung-uk Kim
514a159c266SJung-uk Kim /* Save the namepath */
515a159c266SJung-uk Kim
516a159c266SJung-uk Kim Arg->Common.Value.Name = Path;
517a159c266SJung-uk Kim return_ACPI_STATUS (Status);
518a159c266SJung-uk Kim }
519a159c266SJung-uk Kim
520a159c266SJung-uk Kim
521a159c266SJung-uk Kim /*******************************************************************************
522a159c266SJung-uk Kim *
523a159c266SJung-uk Kim * FUNCTION: AcpiPsGetNextSimpleArg
524a159c266SJung-uk Kim *
525a159c266SJung-uk Kim * PARAMETERS: ParserState - Current parser state object
526a159c266SJung-uk Kim * ArgType - The argument type (AML_*_ARG)
527a159c266SJung-uk Kim * Arg - Where the argument is returned
528a159c266SJung-uk Kim *
529a159c266SJung-uk Kim * RETURN: None
530a159c266SJung-uk Kim *
531a159c266SJung-uk Kim * DESCRIPTION: Get the next simple argument (constant, string, or namestring)
532a159c266SJung-uk Kim *
533a159c266SJung-uk Kim ******************************************************************************/
534a159c266SJung-uk Kim
535a159c266SJung-uk Kim void
AcpiPsGetNextSimpleArg(ACPI_PARSE_STATE * ParserState,UINT32 ArgType,ACPI_PARSE_OBJECT * Arg)536a159c266SJung-uk Kim AcpiPsGetNextSimpleArg (
537a159c266SJung-uk Kim ACPI_PARSE_STATE *ParserState,
538a159c266SJung-uk Kim UINT32 ArgType,
539a159c266SJung-uk Kim ACPI_PARSE_OBJECT *Arg)
540a159c266SJung-uk Kim {
541a159c266SJung-uk Kim UINT32 Length;
542a159c266SJung-uk Kim UINT16 Opcode;
543a159c266SJung-uk Kim UINT8 *Aml = ParserState->Aml;
544a159c266SJung-uk Kim
545a159c266SJung-uk Kim
546a159c266SJung-uk Kim ACPI_FUNCTION_TRACE_U32 (PsGetNextSimpleArg, ArgType);
547a159c266SJung-uk Kim
548a159c266SJung-uk Kim
549a159c266SJung-uk Kim switch (ArgType)
550a159c266SJung-uk Kim {
551a159c266SJung-uk Kim case ARGP_BYTEDATA:
552a159c266SJung-uk Kim
553a159c266SJung-uk Kim /* Get 1 byte from the AML stream */
554a159c266SJung-uk Kim
555a159c266SJung-uk Kim Opcode = AML_BYTE_OP;
556a159c266SJung-uk Kim Arg->Common.Value.Integer = (UINT64) *Aml;
557a159c266SJung-uk Kim Length = 1;
558a159c266SJung-uk Kim break;
559a159c266SJung-uk Kim
560a159c266SJung-uk Kim case ARGP_WORDDATA:
561a159c266SJung-uk Kim
562a159c266SJung-uk Kim /* Get 2 bytes from the AML stream */
563a159c266SJung-uk Kim
564a159c266SJung-uk Kim Opcode = AML_WORD_OP;
565a159c266SJung-uk Kim ACPI_MOVE_16_TO_64 (&Arg->Common.Value.Integer, Aml);
566a159c266SJung-uk Kim Length = 2;
567a159c266SJung-uk Kim break;
568a159c266SJung-uk Kim
569a159c266SJung-uk Kim case ARGP_DWORDDATA:
570a159c266SJung-uk Kim
571a159c266SJung-uk Kim /* Get 4 bytes from the AML stream */
572a159c266SJung-uk Kim
573a159c266SJung-uk Kim Opcode = AML_DWORD_OP;
574a159c266SJung-uk Kim ACPI_MOVE_32_TO_64 (&Arg->Common.Value.Integer, Aml);
575a159c266SJung-uk Kim Length = 4;
576a159c266SJung-uk Kim break;
577a159c266SJung-uk Kim
578a159c266SJung-uk Kim case ARGP_QWORDDATA:
579a159c266SJung-uk Kim
580a159c266SJung-uk Kim /* Get 8 bytes from the AML stream */
581a159c266SJung-uk Kim
582a159c266SJung-uk Kim Opcode = AML_QWORD_OP;
583a159c266SJung-uk Kim ACPI_MOVE_64_TO_64 (&Arg->Common.Value.Integer, Aml);
584a159c266SJung-uk Kim Length = 8;
585a159c266SJung-uk Kim break;
586a159c266SJung-uk Kim
587a159c266SJung-uk Kim case ARGP_CHARLIST:
588a159c266SJung-uk Kim
589a159c266SJung-uk Kim /* Get a pointer to the string, point past the string */
590a159c266SJung-uk Kim
591a159c266SJung-uk Kim Opcode = AML_STRING_OP;
592a159c266SJung-uk Kim Arg->Common.Value.String = ACPI_CAST_PTR (char, Aml);
593a159c266SJung-uk Kim
594a159c266SJung-uk Kim /* Find the null terminator */
595a159c266SJung-uk Kim
596a159c266SJung-uk Kim Length = 0;
597a159c266SJung-uk Kim while (Aml[Length])
598a159c266SJung-uk Kim {
599a159c266SJung-uk Kim Length++;
600a159c266SJung-uk Kim }
601a159c266SJung-uk Kim Length++;
602a159c266SJung-uk Kim break;
603a159c266SJung-uk Kim
604a159c266SJung-uk Kim case ARGP_NAME:
605a159c266SJung-uk Kim case ARGP_NAMESTRING:
606a159c266SJung-uk Kim
607a159c266SJung-uk Kim AcpiPsInitOp (Arg, AML_INT_NAMEPATH_OP);
608a159c266SJung-uk Kim Arg->Common.Value.Name = AcpiPsGetNextNamestring (ParserState);
609a159c266SJung-uk Kim return_VOID;
610a159c266SJung-uk Kim
611a159c266SJung-uk Kim default:
612a159c266SJung-uk Kim
613a159c266SJung-uk Kim ACPI_ERROR ((AE_INFO, "Invalid ArgType 0x%X", ArgType));
614a159c266SJung-uk Kim return_VOID;
615a159c266SJung-uk Kim }
616a159c266SJung-uk Kim
617a159c266SJung-uk Kim AcpiPsInitOp (Arg, Opcode);
618a159c266SJung-uk Kim ParserState->Aml += Length;
619a159c266SJung-uk Kim return_VOID;
620a159c266SJung-uk Kim }
621a159c266SJung-uk Kim
622a159c266SJung-uk Kim
623a159c266SJung-uk Kim /*******************************************************************************
624a159c266SJung-uk Kim *
625a159c266SJung-uk Kim * FUNCTION: AcpiPsGetNextField
626a159c266SJung-uk Kim *
627a159c266SJung-uk Kim * PARAMETERS: ParserState - Current parser state object
628a159c266SJung-uk Kim *
629a159c266SJung-uk Kim * RETURN: A newly allocated FIELD op
630a159c266SJung-uk Kim *
631a159c266SJung-uk Kim * DESCRIPTION: Get next field (NamedField, ReservedField, or AccessField)
632a159c266SJung-uk Kim *
633a159c266SJung-uk Kim ******************************************************************************/
634a159c266SJung-uk Kim
635a159c266SJung-uk Kim static ACPI_PARSE_OBJECT *
AcpiPsGetNextField(ACPI_PARSE_STATE * ParserState)636a159c266SJung-uk Kim AcpiPsGetNextField (
637a159c266SJung-uk Kim ACPI_PARSE_STATE *ParserState)
638a159c266SJung-uk Kim {
639fe0f0bbbSJung-uk Kim UINT8 *Aml;
640a159c266SJung-uk Kim ACPI_PARSE_OBJECT *Field;
641a159c266SJung-uk Kim ACPI_PARSE_OBJECT *Arg = NULL;
642a159c266SJung-uk Kim UINT16 Opcode;
643a159c266SJung-uk Kim UINT32 Name;
644a159c266SJung-uk Kim UINT8 AccessType;
645a159c266SJung-uk Kim UINT8 AccessAttribute;
646a159c266SJung-uk Kim UINT8 AccessLength;
647a159c266SJung-uk Kim UINT32 PkgLength;
648a159c266SJung-uk Kim UINT8 *PkgEnd;
649a159c266SJung-uk Kim UINT32 BufferLength;
650a159c266SJung-uk Kim
651a159c266SJung-uk Kim
652a159c266SJung-uk Kim ACPI_FUNCTION_TRACE (PsGetNextField);
653a159c266SJung-uk Kim
654a159c266SJung-uk Kim
6550d84335fSJung-uk Kim ASL_CV_CAPTURE_COMMENTS_ONLY (ParserState);
656fe0f0bbbSJung-uk Kim Aml = ParserState->Aml;
657a159c266SJung-uk Kim
658a159c266SJung-uk Kim /* Determine field type */
659a159c266SJung-uk Kim
660a159c266SJung-uk Kim switch (ACPI_GET8 (ParserState->Aml))
661a159c266SJung-uk Kim {
662a159c266SJung-uk Kim case AML_FIELD_OFFSET_OP:
663a159c266SJung-uk Kim
664a159c266SJung-uk Kim Opcode = AML_INT_RESERVEDFIELD_OP;
665a159c266SJung-uk Kim ParserState->Aml++;
666a159c266SJung-uk Kim break;
667a159c266SJung-uk Kim
668a159c266SJung-uk Kim case AML_FIELD_ACCESS_OP:
669a159c266SJung-uk Kim
670a159c266SJung-uk Kim Opcode = AML_INT_ACCESSFIELD_OP;
671a159c266SJung-uk Kim ParserState->Aml++;
672a159c266SJung-uk Kim break;
673a159c266SJung-uk Kim
674a159c266SJung-uk Kim case AML_FIELD_CONNECTION_OP:
675a159c266SJung-uk Kim
676a159c266SJung-uk Kim Opcode = AML_INT_CONNECTION_OP;
677a159c266SJung-uk Kim ParserState->Aml++;
678a159c266SJung-uk Kim break;
679a159c266SJung-uk Kim
680a159c266SJung-uk Kim case AML_FIELD_EXT_ACCESS_OP:
681a159c266SJung-uk Kim
682a159c266SJung-uk Kim Opcode = AML_INT_EXTACCESSFIELD_OP;
683a159c266SJung-uk Kim ParserState->Aml++;
684a159c266SJung-uk Kim break;
685a159c266SJung-uk Kim
686a159c266SJung-uk Kim default:
687a159c266SJung-uk Kim
688a159c266SJung-uk Kim Opcode = AML_INT_NAMEDFIELD_OP;
689a159c266SJung-uk Kim break;
690a159c266SJung-uk Kim }
691a159c266SJung-uk Kim
692a159c266SJung-uk Kim /* Allocate a new field op */
693a159c266SJung-uk Kim
694fe0f0bbbSJung-uk Kim Field = AcpiPsAllocOp (Opcode, Aml);
695a159c266SJung-uk Kim if (!Field)
696a159c266SJung-uk Kim {
697a159c266SJung-uk Kim return_PTR (NULL);
698a159c266SJung-uk Kim }
699a159c266SJung-uk Kim
700a159c266SJung-uk Kim /* Decode the field type */
701a159c266SJung-uk Kim
7020d84335fSJung-uk Kim ASL_CV_CAPTURE_COMMENTS_ONLY (ParserState);
703a159c266SJung-uk Kim switch (Opcode)
704a159c266SJung-uk Kim {
705a159c266SJung-uk Kim case AML_INT_NAMEDFIELD_OP:
706a159c266SJung-uk Kim
707a159c266SJung-uk Kim /* Get the 4-character name */
708a159c266SJung-uk Kim
709a159c266SJung-uk Kim ACPI_MOVE_32_TO_32 (&Name, ParserState->Aml);
710a159c266SJung-uk Kim AcpiPsSetName (Field, Name);
711278f0de6SJung-uk Kim ParserState->Aml += ACPI_NAMESEG_SIZE;
712a159c266SJung-uk Kim
7130d84335fSJung-uk Kim
7140d84335fSJung-uk Kim ASL_CV_CAPTURE_COMMENTS_ONLY (ParserState);
7150d84335fSJung-uk Kim
7160d84335fSJung-uk Kim #ifdef ACPI_ASL_COMPILER
7170d84335fSJung-uk Kim /*
7180d84335fSJung-uk Kim * Because the package length isn't represented as a parse tree object,
7190d84335fSJung-uk Kim * take comments surrounding this and add to the previously created
7200d84335fSJung-uk Kim * parse node.
7210d84335fSJung-uk Kim */
7220d84335fSJung-uk Kim if (Field->Common.InlineComment)
7230d84335fSJung-uk Kim {
7240d84335fSJung-uk Kim Field->Common.NameComment = Field->Common.InlineComment;
7250d84335fSJung-uk Kim }
7260d84335fSJung-uk Kim Field->Common.InlineComment = AcpiGbl_CurrentInlineComment;
7270d84335fSJung-uk Kim AcpiGbl_CurrentInlineComment = NULL;
7280d84335fSJung-uk Kim #endif
7290d84335fSJung-uk Kim
730a159c266SJung-uk Kim /* Get the length which is encoded as a package length */
731a159c266SJung-uk Kim
732a159c266SJung-uk Kim Field->Common.Value.Size = AcpiPsGetNextPackageLength (ParserState);
733a159c266SJung-uk Kim break;
734a159c266SJung-uk Kim
735a159c266SJung-uk Kim
736a159c266SJung-uk Kim case AML_INT_RESERVEDFIELD_OP:
737a159c266SJung-uk Kim
738a159c266SJung-uk Kim /* Get the length which is encoded as a package length */
739a159c266SJung-uk Kim
740a159c266SJung-uk Kim Field->Common.Value.Size = AcpiPsGetNextPackageLength (ParserState);
741a159c266SJung-uk Kim break;
742a159c266SJung-uk Kim
743a159c266SJung-uk Kim
744a159c266SJung-uk Kim case AML_INT_ACCESSFIELD_OP:
745a159c266SJung-uk Kim case AML_INT_EXTACCESSFIELD_OP:
746a159c266SJung-uk Kim
747a159c266SJung-uk Kim /*
748a159c266SJung-uk Kim * Get AccessType and AccessAttrib and merge into the field Op
749a159c266SJung-uk Kim * AccessType is first operand, AccessAttribute is second. stuff
750a159c266SJung-uk Kim * these bytes into the node integer value for convenience.
751a159c266SJung-uk Kim */
752a159c266SJung-uk Kim
753a159c266SJung-uk Kim /* Get the two bytes (Type/Attribute) */
754a159c266SJung-uk Kim
755a159c266SJung-uk Kim AccessType = ACPI_GET8 (ParserState->Aml);
756a159c266SJung-uk Kim ParserState->Aml++;
757a159c266SJung-uk Kim AccessAttribute = ACPI_GET8 (ParserState->Aml);
758a159c266SJung-uk Kim ParserState->Aml++;
759a159c266SJung-uk Kim
760a159c266SJung-uk Kim Field->Common.Value.Integer = (UINT8) AccessType;
761a159c266SJung-uk Kim Field->Common.Value.Integer |= (UINT16) (AccessAttribute << 8);
762a159c266SJung-uk Kim
763a159c266SJung-uk Kim /* This opcode has a third byte, AccessLength */
764a159c266SJung-uk Kim
765a159c266SJung-uk Kim if (Opcode == AML_INT_EXTACCESSFIELD_OP)
766a159c266SJung-uk Kim {
767a159c266SJung-uk Kim AccessLength = ACPI_GET8 (ParserState->Aml);
768a159c266SJung-uk Kim ParserState->Aml++;
769a159c266SJung-uk Kim
770a159c266SJung-uk Kim Field->Common.Value.Integer |= (UINT32) (AccessLength << 16);
771a159c266SJung-uk Kim }
772a159c266SJung-uk Kim break;
773a159c266SJung-uk Kim
774a159c266SJung-uk Kim
775a159c266SJung-uk Kim case AML_INT_CONNECTION_OP:
776a159c266SJung-uk Kim
777a159c266SJung-uk Kim /*
778a159c266SJung-uk Kim * Argument for Connection operator can be either a Buffer
779a159c266SJung-uk Kim * (resource descriptor), or a NameString.
780a159c266SJung-uk Kim */
781fe0f0bbbSJung-uk Kim Aml = ParserState->Aml;
782a159c266SJung-uk Kim if (ACPI_GET8 (ParserState->Aml) == AML_BUFFER_OP)
783a159c266SJung-uk Kim {
784a159c266SJung-uk Kim ParserState->Aml++;
785a159c266SJung-uk Kim
7860d84335fSJung-uk Kim ASL_CV_CAPTURE_COMMENTS_ONLY (ParserState);
787a159c266SJung-uk Kim PkgEnd = ParserState->Aml;
788a159c266SJung-uk Kim PkgLength = AcpiPsGetNextPackageLength (ParserState);
789a159c266SJung-uk Kim PkgEnd += PkgLength;
790a159c266SJung-uk Kim
7910d84335fSJung-uk Kim ASL_CV_CAPTURE_COMMENTS_ONLY (ParserState);
792a159c266SJung-uk Kim if (ParserState->Aml < PkgEnd)
793a159c266SJung-uk Kim {
794a159c266SJung-uk Kim /* Non-empty list */
795a159c266SJung-uk Kim
796fe0f0bbbSJung-uk Kim Arg = AcpiPsAllocOp (AML_INT_BYTELIST_OP, Aml);
797a159c266SJung-uk Kim if (!Arg)
798a159c266SJung-uk Kim {
799c708f80eSJung-uk Kim AcpiPsFreeOp (Field);
800a159c266SJung-uk Kim return_PTR (NULL);
801a159c266SJung-uk Kim }
802a159c266SJung-uk Kim
803a159c266SJung-uk Kim /* Get the actual buffer length argument */
804a159c266SJung-uk Kim
805a159c266SJung-uk Kim Opcode = ACPI_GET8 (ParserState->Aml);
806a159c266SJung-uk Kim ParserState->Aml++;
807a159c266SJung-uk Kim
8080d84335fSJung-uk Kim ASL_CV_CAPTURE_COMMENTS_ONLY (ParserState);
809a159c266SJung-uk Kim switch (Opcode)
810a159c266SJung-uk Kim {
811a159c266SJung-uk Kim case AML_BYTE_OP: /* AML_BYTEDATA_ARG */
812a9d8d09cSJung-uk Kim
813a159c266SJung-uk Kim BufferLength = ACPI_GET8 (ParserState->Aml);
814a159c266SJung-uk Kim ParserState->Aml += 1;
815a159c266SJung-uk Kim break;
816a159c266SJung-uk Kim
817a159c266SJung-uk Kim case AML_WORD_OP: /* AML_WORDDATA_ARG */
818a9d8d09cSJung-uk Kim
819a159c266SJung-uk Kim BufferLength = ACPI_GET16 (ParserState->Aml);
820a159c266SJung-uk Kim ParserState->Aml += 2;
821a159c266SJung-uk Kim break;
822a159c266SJung-uk Kim
823a159c266SJung-uk Kim case AML_DWORD_OP: /* AML_DWORDATA_ARG */
824a9d8d09cSJung-uk Kim
825a159c266SJung-uk Kim BufferLength = ACPI_GET32 (ParserState->Aml);
826a159c266SJung-uk Kim ParserState->Aml += 4;
827a159c266SJung-uk Kim break;
828a159c266SJung-uk Kim
829a159c266SJung-uk Kim default:
830a9d8d09cSJung-uk Kim
831a159c266SJung-uk Kim BufferLength = 0;
832a159c266SJung-uk Kim break;
833a159c266SJung-uk Kim }
834a159c266SJung-uk Kim
835a159c266SJung-uk Kim /* Fill in bytelist data */
836a159c266SJung-uk Kim
8370d84335fSJung-uk Kim ASL_CV_CAPTURE_COMMENTS_ONLY (ParserState);
838a159c266SJung-uk Kim Arg->Named.Value.Size = BufferLength;
839a159c266SJung-uk Kim Arg->Named.Data = ParserState->Aml;
840a159c266SJung-uk Kim }
841a159c266SJung-uk Kim
842a159c266SJung-uk Kim /* Skip to End of byte data */
843a159c266SJung-uk Kim
844a159c266SJung-uk Kim ParserState->Aml = PkgEnd;
845a159c266SJung-uk Kim }
846a159c266SJung-uk Kim else
847a159c266SJung-uk Kim {
848fe0f0bbbSJung-uk Kim Arg = AcpiPsAllocOp (AML_INT_NAMEPATH_OP, Aml);
849a159c266SJung-uk Kim if (!Arg)
850a159c266SJung-uk Kim {
851c708f80eSJung-uk Kim AcpiPsFreeOp (Field);
852a159c266SJung-uk Kim return_PTR (NULL);
853a159c266SJung-uk Kim }
854a159c266SJung-uk Kim
855a159c266SJung-uk Kim /* Get the Namestring argument */
856a159c266SJung-uk Kim
857a159c266SJung-uk Kim Arg->Common.Value.Name = AcpiPsGetNextNamestring (ParserState);
858a159c266SJung-uk Kim }
859a159c266SJung-uk Kim
860a159c266SJung-uk Kim /* Link the buffer/namestring to parent (CONNECTION_OP) */
861a159c266SJung-uk Kim
862a159c266SJung-uk Kim AcpiPsAppendArg (Field, Arg);
863a159c266SJung-uk Kim break;
864a159c266SJung-uk Kim
865a159c266SJung-uk Kim
866a159c266SJung-uk Kim default:
867a159c266SJung-uk Kim
868a159c266SJung-uk Kim /* Opcode was set in previous switch */
869a159c266SJung-uk Kim break;
870a159c266SJung-uk Kim }
871a159c266SJung-uk Kim
872a159c266SJung-uk Kim return_PTR (Field);
873a159c266SJung-uk Kim }
874a159c266SJung-uk Kim
875a159c266SJung-uk Kim
876a159c266SJung-uk Kim /*******************************************************************************
877a159c266SJung-uk Kim *
878a159c266SJung-uk Kim * FUNCTION: AcpiPsGetNextArg
879a159c266SJung-uk Kim *
880a159c266SJung-uk Kim * PARAMETERS: WalkState - Current state
881a159c266SJung-uk Kim * ParserState - Current parser state object
882a159c266SJung-uk Kim * ArgType - The argument type (AML_*_ARG)
883a159c266SJung-uk Kim * ReturnArg - Where the next arg is returned
884a159c266SJung-uk Kim *
885a159c266SJung-uk Kim * RETURN: Status, and an op object containing the next argument.
886a159c266SJung-uk Kim *
887a159c266SJung-uk Kim * DESCRIPTION: Get next argument (including complex list arguments that require
888a159c266SJung-uk Kim * pushing the parser stack)
889a159c266SJung-uk Kim *
890a159c266SJung-uk Kim ******************************************************************************/
891a159c266SJung-uk Kim
892a159c266SJung-uk Kim ACPI_STATUS
AcpiPsGetNextArg(ACPI_WALK_STATE * WalkState,ACPI_PARSE_STATE * ParserState,UINT32 ArgType,ACPI_PARSE_OBJECT ** ReturnArg)893a159c266SJung-uk Kim AcpiPsGetNextArg (
894a159c266SJung-uk Kim ACPI_WALK_STATE *WalkState,
895a159c266SJung-uk Kim ACPI_PARSE_STATE *ParserState,
896a159c266SJung-uk Kim UINT32 ArgType,
897a159c266SJung-uk Kim ACPI_PARSE_OBJECT **ReturnArg)
898a159c266SJung-uk Kim {
899a159c266SJung-uk Kim ACPI_PARSE_OBJECT *Arg = NULL;
900a159c266SJung-uk Kim ACPI_PARSE_OBJECT *Prev = NULL;
901a159c266SJung-uk Kim ACPI_PARSE_OBJECT *Field;
902a159c266SJung-uk Kim UINT32 Subop;
903a159c266SJung-uk Kim ACPI_STATUS Status = AE_OK;
904a159c266SJung-uk Kim
905a159c266SJung-uk Kim
906a159c266SJung-uk Kim ACPI_FUNCTION_TRACE_PTR (PsGetNextArg, ParserState);
907a159c266SJung-uk Kim
908a159c266SJung-uk Kim
9091cc50d6bSJung-uk Kim ACPI_DEBUG_PRINT ((ACPI_DB_PARSE,
9101cc50d6bSJung-uk Kim "Expected argument type ARGP: %s (%2.2X)\n",
9111cc50d6bSJung-uk Kim AcpiUtGetArgumentTypeName (ArgType), ArgType));
9121cc50d6bSJung-uk Kim
913a159c266SJung-uk Kim switch (ArgType)
914a159c266SJung-uk Kim {
915a159c266SJung-uk Kim case ARGP_BYTEDATA:
916a159c266SJung-uk Kim case ARGP_WORDDATA:
917a159c266SJung-uk Kim case ARGP_DWORDDATA:
918a159c266SJung-uk Kim case ARGP_CHARLIST:
919a159c266SJung-uk Kim case ARGP_NAME:
920a159c266SJung-uk Kim case ARGP_NAMESTRING:
921a159c266SJung-uk Kim
922a159c266SJung-uk Kim /* Constants, strings, and namestrings are all the same size */
923a159c266SJung-uk Kim
924fe0f0bbbSJung-uk Kim Arg = AcpiPsAllocOp (AML_BYTE_OP, ParserState->Aml);
925a159c266SJung-uk Kim if (!Arg)
926a159c266SJung-uk Kim {
927a159c266SJung-uk Kim return_ACPI_STATUS (AE_NO_MEMORY);
928a159c266SJung-uk Kim }
929f8146b88SJung-uk Kim
930a159c266SJung-uk Kim AcpiPsGetNextSimpleArg (ParserState, ArgType, Arg);
931a159c266SJung-uk Kim break;
932a159c266SJung-uk Kim
933a159c266SJung-uk Kim case ARGP_PKGLENGTH:
934a159c266SJung-uk Kim
935a159c266SJung-uk Kim /* Package length, nothing returned */
936a159c266SJung-uk Kim
937a159c266SJung-uk Kim ParserState->PkgEnd = AcpiPsGetNextPackageEnd (ParserState);
938a159c266SJung-uk Kim break;
939a159c266SJung-uk Kim
940a159c266SJung-uk Kim case ARGP_FIELDLIST:
941a159c266SJung-uk Kim
942a159c266SJung-uk Kim if (ParserState->Aml < ParserState->PkgEnd)
943a159c266SJung-uk Kim {
944a159c266SJung-uk Kim /* Non-empty list */
945a159c266SJung-uk Kim
946a159c266SJung-uk Kim while (ParserState->Aml < ParserState->PkgEnd)
947a159c266SJung-uk Kim {
948a159c266SJung-uk Kim Field = AcpiPsGetNextField (ParserState);
949a159c266SJung-uk Kim if (!Field)
950a159c266SJung-uk Kim {
951a159c266SJung-uk Kim return_ACPI_STATUS (AE_NO_MEMORY);
952a159c266SJung-uk Kim }
953a159c266SJung-uk Kim
954a159c266SJung-uk Kim if (Prev)
955a159c266SJung-uk Kim {
956a159c266SJung-uk Kim Prev->Common.Next = Field;
957a159c266SJung-uk Kim }
958a159c266SJung-uk Kim else
959a159c266SJung-uk Kim {
960a159c266SJung-uk Kim Arg = Field;
961a159c266SJung-uk Kim }
962a159c266SJung-uk Kim Prev = Field;
963a159c266SJung-uk Kim }
964a159c266SJung-uk Kim
965a159c266SJung-uk Kim /* Skip to End of byte data */
966a159c266SJung-uk Kim
967a159c266SJung-uk Kim ParserState->Aml = ParserState->PkgEnd;
968a159c266SJung-uk Kim }
969a159c266SJung-uk Kim break;
970a159c266SJung-uk Kim
971a159c266SJung-uk Kim case ARGP_BYTELIST:
972a159c266SJung-uk Kim
973a159c266SJung-uk Kim if (ParserState->Aml < ParserState->PkgEnd)
974a159c266SJung-uk Kim {
975a159c266SJung-uk Kim /* Non-empty list */
976a159c266SJung-uk Kim
977fe0f0bbbSJung-uk Kim Arg = AcpiPsAllocOp (AML_INT_BYTELIST_OP,
978fe0f0bbbSJung-uk Kim ParserState->Aml);
979a159c266SJung-uk Kim if (!Arg)
980a159c266SJung-uk Kim {
981a159c266SJung-uk Kim return_ACPI_STATUS (AE_NO_MEMORY);
982a159c266SJung-uk Kim }
983a159c266SJung-uk Kim
984a159c266SJung-uk Kim /* Fill in bytelist data */
985a159c266SJung-uk Kim
986a159c266SJung-uk Kim Arg->Common.Value.Size = (UINT32)
987a159c266SJung-uk Kim ACPI_PTR_DIFF (ParserState->PkgEnd, ParserState->Aml);
988a159c266SJung-uk Kim Arg->Named.Data = ParserState->Aml;
989a159c266SJung-uk Kim
990a159c266SJung-uk Kim /* Skip to End of byte data */
991a159c266SJung-uk Kim
992a159c266SJung-uk Kim ParserState->Aml = ParserState->PkgEnd;
993a159c266SJung-uk Kim }
994a159c266SJung-uk Kim break;
995a159c266SJung-uk Kim
996a159c266SJung-uk Kim case ARGP_SIMPLENAME:
997f8146b88SJung-uk Kim case ARGP_NAME_OR_REF:
998a159c266SJung-uk Kim
9991cc50d6bSJung-uk Kim ACPI_DEBUG_PRINT ((ACPI_DB_PARSE,
10001cc50d6bSJung-uk Kim "**** SimpleName/NameOrRef: %s (%2.2X)\n",
10011cc50d6bSJung-uk Kim AcpiUtGetArgumentTypeName (ArgType), ArgType));
10021cc50d6bSJung-uk Kim
1003a159c266SJung-uk Kim Subop = AcpiPsPeekOpcode (ParserState);
1004a159c266SJung-uk Kim if (Subop == 0 ||
1005a159c266SJung-uk Kim AcpiPsIsLeadingChar (Subop) ||
1006efcc2a30SJung-uk Kim ACPI_IS_ROOT_PREFIX (Subop) ||
1007efcc2a30SJung-uk Kim ACPI_IS_PARENT_PREFIX (Subop))
1008a159c266SJung-uk Kim {
1009a159c266SJung-uk Kim /* NullName or NameString */
1010a159c266SJung-uk Kim
1011fe0f0bbbSJung-uk Kim Arg = AcpiPsAllocOp (AML_INT_NAMEPATH_OP, ParserState->Aml);
1012a159c266SJung-uk Kim if (!Arg)
1013a159c266SJung-uk Kim {
1014a159c266SJung-uk Kim return_ACPI_STATUS (AE_NO_MEMORY);
1015a159c266SJung-uk Kim }
1016a159c266SJung-uk Kim
1017f8146b88SJung-uk Kim Status = AcpiPsGetNextNamepath (WalkState, ParserState,
1018f8146b88SJung-uk Kim Arg, ACPI_NOT_METHOD_CALL);
1019a159c266SJung-uk Kim }
10201cc50d6bSJung-uk Kim else
10211cc50d6bSJung-uk Kim {
10221cc50d6bSJung-uk Kim /* Single complex argument, nothing returned */
10231cc50d6bSJung-uk Kim
10241cc50d6bSJung-uk Kim WalkState->ArgCount = 1;
10251cc50d6bSJung-uk Kim }
10261cc50d6bSJung-uk Kim break;
10271cc50d6bSJung-uk Kim
10281cc50d6bSJung-uk Kim case ARGP_TARGET:
10291cc50d6bSJung-uk Kim case ARGP_SUPERNAME:
10301cc50d6bSJung-uk Kim
10311cc50d6bSJung-uk Kim ACPI_DEBUG_PRINT ((ACPI_DB_PARSE,
10321cc50d6bSJung-uk Kim "**** Target/Supername: %s (%2.2X)\n",
10331cc50d6bSJung-uk Kim AcpiUtGetArgumentTypeName (ArgType), ArgType));
10341cc50d6bSJung-uk Kim
10351cc50d6bSJung-uk Kim Subop = AcpiPsPeekOpcode (ParserState);
103628482948SJung-uk Kim if (Subop == 0 ||
103728482948SJung-uk Kim AcpiPsIsLeadingChar (Subop) ||
103828482948SJung-uk Kim ACPI_IS_ROOT_PREFIX (Subop) ||
103928482948SJung-uk Kim ACPI_IS_PARENT_PREFIX (Subop))
10401cc50d6bSJung-uk Kim {
10411cc50d6bSJung-uk Kim /* NULL target (zero). Convert to a NULL namepath */
10421cc50d6bSJung-uk Kim
10431cc50d6bSJung-uk Kim Arg = AcpiPsAllocOp (AML_INT_NAMEPATH_OP, ParserState->Aml);
10441cc50d6bSJung-uk Kim if (!Arg)
10451cc50d6bSJung-uk Kim {
10461cc50d6bSJung-uk Kim return_ACPI_STATUS (AE_NO_MEMORY);
10471cc50d6bSJung-uk Kim }
10481cc50d6bSJung-uk Kim
10491cc50d6bSJung-uk Kim Status = AcpiPsGetNextNamepath (WalkState, ParserState,
10501cc50d6bSJung-uk Kim Arg, ACPI_POSSIBLE_METHOD_CALL);
105128482948SJung-uk Kim
105228482948SJung-uk Kim if (Arg->Common.AmlOpcode == AML_INT_METHODCALL_OP)
105328482948SJung-uk Kim {
10548438a7a8SJung-uk Kim /* Free method call op and corresponding namestring sub-ob */
10558438a7a8SJung-uk Kim
10568438a7a8SJung-uk Kim AcpiPsFreeOp (Arg->Common.Value.Arg);
105728482948SJung-uk Kim AcpiPsFreeOp (Arg);
105828482948SJung-uk Kim Arg = NULL;
105928482948SJung-uk Kim WalkState->ArgCount = 1;
106028482948SJung-uk Kim }
1061a159c266SJung-uk Kim }
1062a159c266SJung-uk Kim else
1063a159c266SJung-uk Kim {
1064a159c266SJung-uk Kim /* Single complex argument, nothing returned */
1065a159c266SJung-uk Kim
1066a159c266SJung-uk Kim WalkState->ArgCount = 1;
1067a159c266SJung-uk Kim }
1068a159c266SJung-uk Kim break;
1069a159c266SJung-uk Kim
1070a159c266SJung-uk Kim case ARGP_DATAOBJ:
1071a159c266SJung-uk Kim case ARGP_TERMARG:
1072a159c266SJung-uk Kim
10731cc50d6bSJung-uk Kim ACPI_DEBUG_PRINT ((ACPI_DB_PARSE,
10741cc50d6bSJung-uk Kim "**** TermArg/DataObj: %s (%2.2X)\n",
10751cc50d6bSJung-uk Kim AcpiUtGetArgumentTypeName (ArgType), ArgType));
10761cc50d6bSJung-uk Kim
1077a159c266SJung-uk Kim /* Single complex argument, nothing returned */
1078a159c266SJung-uk Kim
1079a159c266SJung-uk Kim WalkState->ArgCount = 1;
1080a159c266SJung-uk Kim break;
1081a159c266SJung-uk Kim
1082a159c266SJung-uk Kim case ARGP_DATAOBJLIST:
1083a159c266SJung-uk Kim case ARGP_TERMLIST:
1084a159c266SJung-uk Kim case ARGP_OBJLIST:
1085a159c266SJung-uk Kim
1086a159c266SJung-uk Kim if (ParserState->Aml < ParserState->PkgEnd)
1087a159c266SJung-uk Kim {
1088a159c266SJung-uk Kim /* Non-empty list of variable arguments, nothing returned */
1089a159c266SJung-uk Kim
1090a159c266SJung-uk Kim WalkState->ArgCount = ACPI_VAR_ARGS;
1091a159c266SJung-uk Kim }
1092a159c266SJung-uk Kim break;
1093a159c266SJung-uk Kim
1094a159c266SJung-uk Kim default:
1095a159c266SJung-uk Kim
1096a159c266SJung-uk Kim ACPI_ERROR ((AE_INFO, "Invalid ArgType: 0x%X", ArgType));
1097a159c266SJung-uk Kim Status = AE_AML_OPERAND_TYPE;
1098a159c266SJung-uk Kim break;
1099a159c266SJung-uk Kim }
1100a159c266SJung-uk Kim
1101a159c266SJung-uk Kim *ReturnArg = Arg;
1102a159c266SJung-uk Kim return_ACPI_STATUS (Status);
1103a159c266SJung-uk Kim }
1104