psargs.c revision 1.1.1.15 
1/******************************************************************************
2 *
3 * Module Name: psargs - Parse AML opcode arguments
4 *
5 *****************************************************************************/
6
7/*
8 * Copyright (C) 2000 - 2021, Intel Corp.
9 * All rights reserved.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * 1. Redistributions of source code must retain the above copyright
15 *    notice, this list of conditions, and the following disclaimer,
16 *    without modification.
17 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
18 *    substantially similar to the "NO WARRANTY" disclaimer below
19 *    ("Disclaimer") and any redistribution must be conditioned upon
20 *    including a substantially similar Disclaimer requirement for further
21 *    binary redistribution.
22 * 3. Neither the names of the above-listed copyright holders nor the names
23 *    of any contributors may be used to endorse or promote products derived
24 *    from this software without specific prior written permission.
25 *
26 * Alternatively, this software may be distributed under the terms of the
27 * GNU General Public License ("GPL") version 2 as published by the Free
28 * Software Foundation.
29 *
30 * NO WARRANTY
31 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
32 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
33 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
34 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
35 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
36 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
37 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
38 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
39 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
40 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
41 * POSSIBILITY OF SUCH DAMAGES.
42 */
43
44#include "acpi.h"
45#include "accommon.h"
46#include "acparser.h"
47#include "amlcode.h"
48#include "acnamesp.h"
49#include "acdispat.h"
50#include "acconvert.h"
51
52#define _COMPONENT          ACPI_PARSER
53        ACPI_MODULE_NAME    ("psargs")
54
55/* Local prototypes */
56
57static UINT32
58AcpiPsGetNextPackageLength (
59    ACPI_PARSE_STATE        *ParserState);
60
61static ACPI_PARSE_OBJECT *
62AcpiPsGetNextField (
63    ACPI_PARSE_STATE        *ParserState);
64
65
66/*******************************************************************************
67 *
68 * FUNCTION:    AcpiPsGetNextPackageLength
69 *
70 * PARAMETERS:  ParserState         - Current parser state object
71 *
72 * RETURN:      Decoded package length. On completion, the AML pointer points
73 *              past the length byte or bytes.
74 *
75 * DESCRIPTION: Decode and return a package length field.
76 *              Note: Largest package length is 28 bits, from ACPI specification
77 *
78 ******************************************************************************/
79
80static UINT32
81AcpiPsGetNextPackageLength (
82    ACPI_PARSE_STATE        *ParserState)
83{
84    UINT8                   *Aml = ParserState->Aml;
85    UINT32                  PackageLength = 0;
86    UINT32                  ByteCount;
87    UINT8                   ByteZeroMask = 0x3F; /* Default [0:5] */
88
89
90    ACPI_FUNCTION_TRACE (PsGetNextPackageLength);
91
92
93    /*
94     * Byte 0 bits [6:7] contain the number of additional bytes
95     * used to encode the package length, either 0,1,2, or 3
96     */
97    ByteCount = (Aml[0] >> 6);
98    ParserState->Aml += ((ACPI_SIZE) ByteCount + 1);
99
100    /* Get bytes 3, 2, 1 as needed */
101
102    while (ByteCount)
103    {
104        /*
105         * Final bit positions for the package length bytes:
106         *      Byte3->[20:27]
107         *      Byte2->[12:19]
108         *      Byte1->[04:11]
109         *      Byte0->[00:03]
110         */
111        PackageLength |= (Aml[ByteCount] << ((ByteCount << 3) - 4));
112
113        ByteZeroMask = 0x0F; /* Use bits [0:3] of byte 0 */
114        ByteCount--;
115    }
116
117    /* Byte 0 is a special case, either bits [0:3] or [0:5] are used */
118
119    PackageLength |= (Aml[0] & ByteZeroMask);
120    return_UINT32 (PackageLength);
121}
122
123
124/*******************************************************************************
125 *
126 * FUNCTION:    AcpiPsGetNextPackageEnd
127 *
128 * PARAMETERS:  ParserState         - Current parser state object
129 *
130 * RETURN:      Pointer to end-of-package +1
131 *
132 * DESCRIPTION: Get next package length and return a pointer past the end of
133 *              the package. Consumes the package length field
134 *
135 ******************************************************************************/
136
137UINT8 *
138AcpiPsGetNextPackageEnd (
139    ACPI_PARSE_STATE        *ParserState)
140{
141    UINT8                   *Start = ParserState->Aml;
142    UINT32                  PackageLength;
143
144
145    ACPI_FUNCTION_TRACE (PsGetNextPackageEnd);
146
147
148    /* Function below updates ParserState->Aml */
149
150    PackageLength = AcpiPsGetNextPackageLength (ParserState);
151
152    return_PTR (Start + PackageLength); /* end of package */
153}
154
155
156/*******************************************************************************
157 *
158 * FUNCTION:    AcpiPsGetNextNamestring
159 *
160 * PARAMETERS:  ParserState         - Current parser state object
161 *
162 * RETURN:      Pointer to the start of the name string (pointer points into
163 *              the AML.
164 *
165 * DESCRIPTION: Get next raw namestring within the AML stream. Handles all name
166 *              prefix characters. Set parser state to point past the string.
167 *              (Name is consumed from the AML.)
168 *
169 ******************************************************************************/
170
171char *
172AcpiPsGetNextNamestring (
173    ACPI_PARSE_STATE        *ParserState)
174{
175    UINT8                   *Start = ParserState->Aml;
176    UINT8                   *End = ParserState->Aml;
177
178
179    ACPI_FUNCTION_TRACE (PsGetNextNamestring);
180
181
182    /* Point past any namestring prefix characters (backslash or carat) */
183
184    while (ACPI_IS_ROOT_PREFIX (*End) ||
185           ACPI_IS_PARENT_PREFIX (*End))
186    {
187        End++;
188    }
189
190    /* Decode the path prefix character */
191
192    switch (*End)
193    {
194    case 0:
195
196        /* NullName */
197
198        if (End == Start)
199        {
200            Start = NULL;
201        }
202        End++;
203        break;
204
205    case AML_DUAL_NAME_PREFIX:
206
207        /* Two name segments */
208
209        End += 1 + (2 * ACPI_NAMESEG_SIZE);
210        break;
211
212    case AML_MULTI_NAME_PREFIX:
213
214        /* Multiple name segments, 4 chars each, count in next byte */
215
216        End += 2 + (*(End + 1) * ACPI_NAMESEG_SIZE);
217        break;
218
219    default:
220
221        /* Single name segment */
222
223        End += ACPI_NAMESEG_SIZE;
224        break;
225    }
226
227    ParserState->Aml = End;
228    return_PTR ((char *) Start);
229}
230
231
232/*******************************************************************************
233 *
234 * FUNCTION:    AcpiPsGetNextNamepath
235 *
236 * PARAMETERS:  ParserState         - Current parser state object
237 *              Arg                 - Where the namepath will be stored
238 *              ArgCount            - If the namepath points to a control method
239 *                                    the method's argument is returned here.
240 *              PossibleMethodCall  - Whether the namepath can possibly be the
241 *                                    start of a method call
242 *
243 * RETURN:      Status
244 *
245 * DESCRIPTION: Get next name (if method call, return # of required args).
246 *              Names are looked up in the internal namespace to determine
247 *              if the name represents a control method. If a method
248 *              is found, the number of arguments to the method is returned.
249 *              This information is critical for parsing to continue correctly.
250 *
251 ******************************************************************************/
252
253ACPI_STATUS
254AcpiPsGetNextNamepath (
255    ACPI_WALK_STATE         *WalkState,
256    ACPI_PARSE_STATE        *ParserState,
257    ACPI_PARSE_OBJECT       *Arg,
258    BOOLEAN                 PossibleMethodCall)
259{
260    ACPI_STATUS             Status;
261    char                    *Path;
262    ACPI_PARSE_OBJECT       *NameOp;
263    ACPI_OPERAND_OBJECT     *MethodDesc;
264    ACPI_NAMESPACE_NODE     *Node;
265    UINT8                   *Start = ParserState->Aml;
266
267
268    ACPI_FUNCTION_TRACE (PsGetNextNamepath);
269
270
271    Path = AcpiPsGetNextNamestring (ParserState);
272    AcpiPsInitOp (Arg, AML_INT_NAMEPATH_OP);
273
274    /* Null path case is allowed, just exit */
275
276    if (!Path)
277    {
278        Arg->Common.Value.Name = Path;
279        return_ACPI_STATUS (AE_OK);
280    }
281
282    /*
283     * Lookup the name in the internal namespace, starting with the current
284     * scope. We don't want to add anything new to the namespace here,
285     * however, so we use MODE_EXECUTE.
286     * Allow searching of the parent tree, but don't open a new scope -
287     * we just want to lookup the object (must be mode EXECUTE to perform
288     * the upsearch)
289     */
290    Status = AcpiNsLookup (WalkState->ScopeInfo, Path,
291        ACPI_TYPE_ANY, ACPI_IMODE_EXECUTE,
292        ACPI_NS_SEARCH_PARENT | ACPI_NS_DONT_OPEN_SCOPE, NULL, &Node);
293
294    /*
295     * If this name is a control method invocation, we must
296     * setup the method call
297     */
298    if (ACPI_SUCCESS (Status) &&
299        PossibleMethodCall &&
300        (Node->Type == ACPI_TYPE_METHOD))
301    {
302        if ((GET_CURRENT_ARG_TYPE (WalkState->ArgTypes) == ARGP_SUPERNAME) ||
303            (GET_CURRENT_ARG_TYPE (WalkState->ArgTypes) == ARGP_TARGET))
304        {
305            /*
306             * AcpiPsGetNextNamestring has increased the AML pointer past
307             * the method invocation namestring, so we need to restore the
308             * saved AML pointer back to the original method invocation
309             * namestring.
310             */
311            WalkState->ParserState.Aml = Start;
312            WalkState->ArgCount = 1;
313            AcpiPsInitOp (Arg, AML_INT_METHODCALL_OP);
314        }
315
316        /* This name is actually a control method invocation */
317
318        MethodDesc = AcpiNsGetAttachedObject (Node);
319        ACPI_DEBUG_PRINT ((ACPI_DB_PARSE,
320            "Control Method invocation %4.4s - %p Desc %p Path=%p\n",
321            Node->Name.Ascii, Node, MethodDesc, Path));
322
323        NameOp = AcpiPsAllocOp (AML_INT_NAMEPATH_OP, Start);
324        if (!NameOp)
325        {
326            return_ACPI_STATUS (AE_NO_MEMORY);
327        }
328
329        /* Change Arg into a METHOD CALL and attach name to it */
330
331        AcpiPsInitOp (Arg, AML_INT_METHODCALL_OP);
332        NameOp->Common.Value.Name = Path;
333
334        /* Point METHODCALL/NAME to the METHOD Node */
335
336        NameOp->Common.Node = Node;
337        AcpiPsAppendArg (Arg, NameOp);
338
339        if (!MethodDesc)
340        {
341            ACPI_ERROR ((AE_INFO,
342                "Control Method %p has no attached object",
343                Node));
344            return_ACPI_STATUS (AE_AML_INTERNAL);
345        }
346
347        ACPI_DEBUG_PRINT ((ACPI_DB_PARSE,
348            "Control Method - %p Args %X\n",
349            Node, MethodDesc->Method.ParamCount));
350
351        /* Get the number of arguments to expect */
352
353        WalkState->ArgCount = MethodDesc->Method.ParamCount;
354        return_ACPI_STATUS (AE_OK);
355    }
356
357    /*
358     * Special handling if the name was not found during the lookup -
359     * some NotFound cases are allowed
360     */
361    if (Status == AE_NOT_FOUND)
362    {
363        /* 1) NotFound is ok during load pass 1/2 (allow forward references) */
364
365        if ((WalkState->ParseFlags & ACPI_PARSE_MODE_MASK) !=
366            ACPI_PARSE_EXECUTE)
367        {
368            Status = AE_OK;
369        }
370
371        /* 2) NotFound during a CondRefOf(x) is ok by definition */
372
373        else if (WalkState->Op->Common.AmlOpcode == AML_CONDITIONAL_REF_OF_OP)
374        {
375            Status = AE_OK;
376        }
377
378        /*
379         * 3) NotFound while building a Package is ok at this point, we
380         * may flag as an error later if slack mode is not enabled.
381         * (Some ASL code depends on allowing this behavior)
382         */
383        else if ((Arg->Common.Parent) &&
384            ((Arg->Common.Parent->Common.AmlOpcode == AML_PACKAGE_OP) ||
385             (Arg->Common.Parent->Common.AmlOpcode == AML_VARIABLE_PACKAGE_OP)))
386        {
387            Status = AE_OK;
388        }
389    }
390
391    /* Final exception check (may have been changed from code above) */
392
393    if (ACPI_FAILURE (Status))
394    {
395        ACPI_ERROR_NAMESPACE (WalkState->ScopeInfo, Path, Status);
396
397        if ((WalkState->ParseFlags & ACPI_PARSE_MODE_MASK) ==
398            ACPI_PARSE_EXECUTE)
399        {
400            /* Report a control method execution error */
401
402            Status = AcpiDsMethodError (Status, WalkState);
403        }
404    }
405
406    /* Save the namepath */
407
408    Arg->Common.Value.Name = Path;
409    return_ACPI_STATUS (Status);
410}
411
412
413/*******************************************************************************
414 *
415 * FUNCTION:    AcpiPsGetNextSimpleArg
416 *
417 * PARAMETERS:  ParserState         - Current parser state object
418 *              ArgType             - The argument type (AML_*_ARG)
419 *              Arg                 - Where the argument is returned
420 *
421 * RETURN:      None
422 *
423 * DESCRIPTION: Get the next simple argument (constant, string, or namestring)
424 *
425 ******************************************************************************/
426
427void
428AcpiPsGetNextSimpleArg (
429    ACPI_PARSE_STATE        *ParserState,
430    UINT32                  ArgType,
431    ACPI_PARSE_OBJECT       *Arg)
432{
433    UINT32                  Length;
434    UINT16                  Opcode;
435    UINT8                   *Aml = ParserState->Aml;
436
437
438    ACPI_FUNCTION_TRACE_U32 (PsGetNextSimpleArg, ArgType);
439
440
441    switch (ArgType)
442    {
443    case ARGP_BYTEDATA:
444
445        /* Get 1 byte from the AML stream */
446
447        Opcode = AML_BYTE_OP;
448        Arg->Common.Value.Integer = (UINT64) *Aml;
449        Length = 1;
450        break;
451
452    case ARGP_WORDDATA:
453
454        /* Get 2 bytes from the AML stream */
455
456        Opcode = AML_WORD_OP;
457        ACPI_MOVE_16_TO_64 (&Arg->Common.Value.Integer, Aml);
458        Length = 2;
459        break;
460
461    case ARGP_DWORDDATA:
462
463        /* Get 4 bytes from the AML stream */
464
465        Opcode = AML_DWORD_OP;
466        ACPI_MOVE_32_TO_64 (&Arg->Common.Value.Integer, Aml);
467        Length = 4;
468        break;
469
470    case ARGP_QWORDDATA:
471
472        /* Get 8 bytes from the AML stream */
473
474        Opcode = AML_QWORD_OP;
475        ACPI_MOVE_64_TO_64 (&Arg->Common.Value.Integer, Aml);
476        Length = 8;
477        break;
478
479    case ARGP_CHARLIST:
480
481        /* Get a pointer to the string, point past the string */
482
483        Opcode = AML_STRING_OP;
484        Arg->Common.Value.String = ACPI_CAST_PTR (char, Aml);
485
486        /* Find the null terminator */
487
488        Length = 0;
489        while (Aml[Length])
490        {
491            Length++;
492        }
493        Length++;
494        break;
495
496    case ARGP_NAME:
497    case ARGP_NAMESTRING:
498
499        AcpiPsInitOp (Arg, AML_INT_NAMEPATH_OP);
500        Arg->Common.Value.Name = AcpiPsGetNextNamestring (ParserState);
501        return_VOID;
502
503    default:
504
505        ACPI_ERROR ((AE_INFO, "Invalid ArgType 0x%X", ArgType));
506        return_VOID;
507    }
508
509    AcpiPsInitOp (Arg, Opcode);
510    ParserState->Aml += Length;
511    return_VOID;
512}
513
514
515/*******************************************************************************
516 *
517 * FUNCTION:    AcpiPsGetNextField
518 *
519 * PARAMETERS:  ParserState         - Current parser state object
520 *
521 * RETURN:      A newly allocated FIELD op
522 *
523 * DESCRIPTION: Get next field (NamedField, ReservedField, or AccessField)
524 *
525 ******************************************************************************/
526
527static ACPI_PARSE_OBJECT *
528AcpiPsGetNextField (
529    ACPI_PARSE_STATE        *ParserState)
530{
531    UINT8                   *Aml;
532    ACPI_PARSE_OBJECT       *Field;
533    ACPI_PARSE_OBJECT       *Arg = NULL;
534    UINT16                  Opcode;
535    UINT32                  Name;
536    UINT8                   AccessType;
537    UINT8                   AccessAttribute;
538    UINT8                   AccessLength;
539    UINT32                  PkgLength;
540    UINT8                   *PkgEnd;
541    UINT32                  BufferLength;
542
543
544    ACPI_FUNCTION_TRACE (PsGetNextField);
545
546
547    ASL_CV_CAPTURE_COMMENTS_ONLY (ParserState);
548    Aml = ParserState->Aml;
549
550    /* Determine field type */
551
552    switch (ACPI_GET8 (ParserState->Aml))
553    {
554    case AML_FIELD_OFFSET_OP:
555
556        Opcode = AML_INT_RESERVEDFIELD_OP;
557        ParserState->Aml++;
558        break;
559
560    case AML_FIELD_ACCESS_OP:
561
562        Opcode = AML_INT_ACCESSFIELD_OP;
563        ParserState->Aml++;
564        break;
565
566    case AML_FIELD_CONNECTION_OP:
567
568        Opcode = AML_INT_CONNECTION_OP;
569        ParserState->Aml++;
570        break;
571
572    case AML_FIELD_EXT_ACCESS_OP:
573
574        Opcode = AML_INT_EXTACCESSFIELD_OP;
575        ParserState->Aml++;
576        break;
577
578    default:
579
580        Opcode = AML_INT_NAMEDFIELD_OP;
581        break;
582    }
583
584    /* Allocate a new field op */
585
586    Field = AcpiPsAllocOp (Opcode, Aml);
587    if (!Field)
588    {
589        return_PTR (NULL);
590    }
591
592    /* Decode the field type */
593
594    ASL_CV_CAPTURE_COMMENTS_ONLY (ParserState);
595    switch (Opcode)
596    {
597    case AML_INT_NAMEDFIELD_OP:
598
599        /* Get the 4-character name */
600
601        ACPI_MOVE_32_TO_32 (&Name, ParserState->Aml);
602        AcpiPsSetName (Field, Name);
603        ParserState->Aml += ACPI_NAMESEG_SIZE;
604
605
606        ASL_CV_CAPTURE_COMMENTS_ONLY (ParserState);
607
608#ifdef ACPI_ASL_COMPILER
609        /*
610         * Because the package length isn't represented as a parse tree object,
611         * take comments surrounding this and add to the previously created
612         * parse node.
613         */
614        if (Field->Common.InlineComment)
615        {
616            Field->Common.NameComment = Field->Common.InlineComment;
617        }
618        Field->Common.InlineComment  = AcpiGbl_CurrentInlineComment;
619        AcpiGbl_CurrentInlineComment = NULL;
620#endif
621
622        /* Get the length which is encoded as a package length */
623
624        Field->Common.Value.Size = AcpiPsGetNextPackageLength (ParserState);
625        break;
626
627
628    case AML_INT_RESERVEDFIELD_OP:
629
630        /* Get the length which is encoded as a package length */
631
632        Field->Common.Value.Size = AcpiPsGetNextPackageLength (ParserState);
633        break;
634
635
636    case AML_INT_ACCESSFIELD_OP:
637    case AML_INT_EXTACCESSFIELD_OP:
638
639        /*
640         * Get AccessType and AccessAttrib and merge into the field Op
641         * AccessType is first operand, AccessAttribute is second. stuff
642         * these bytes into the node integer value for convenience.
643         */
644
645        /* Get the two bytes (Type/Attribute) */
646
647        AccessType = ACPI_GET8 (ParserState->Aml);
648        ParserState->Aml++;
649        AccessAttribute = ACPI_GET8 (ParserState->Aml);
650        ParserState->Aml++;
651
652        Field->Common.Value.Integer = (UINT8) AccessType;
653        Field->Common.Value.Integer |= (UINT16) (AccessAttribute << 8);
654
655        /* This opcode has a third byte, AccessLength */
656
657        if (Opcode == AML_INT_EXTACCESSFIELD_OP)
658        {
659            AccessLength = ACPI_GET8 (ParserState->Aml);
660            ParserState->Aml++;
661
662            Field->Common.Value.Integer |= (UINT32) (AccessLength << 16);
663        }
664        break;
665
666
667    case AML_INT_CONNECTION_OP:
668
669        /*
670         * Argument for Connection operator can be either a Buffer
671         * (resource descriptor), or a NameString.
672         */
673        Aml = ParserState->Aml;
674        if (ACPI_GET8 (ParserState->Aml) == AML_BUFFER_OP)
675        {
676            ParserState->Aml++;
677
678            ASL_CV_CAPTURE_COMMENTS_ONLY (ParserState);
679            PkgEnd = ParserState->Aml;
680            PkgLength = AcpiPsGetNextPackageLength (ParserState);
681            PkgEnd += PkgLength;
682
683            ASL_CV_CAPTURE_COMMENTS_ONLY (ParserState);
684            if (ParserState->Aml < PkgEnd)
685            {
686                /* Non-empty list */
687
688                Arg = AcpiPsAllocOp (AML_INT_BYTELIST_OP, Aml);
689                if (!Arg)
690                {
691                    AcpiPsFreeOp (Field);
692                    return_PTR (NULL);
693                }
694
695                /* Get the actual buffer length argument */
696
697                Opcode = ACPI_GET8 (ParserState->Aml);
698                ParserState->Aml++;
699
700                ASL_CV_CAPTURE_COMMENTS_ONLY (ParserState);
701                switch (Opcode)
702                {
703                case AML_BYTE_OP:       /* AML_BYTEDATA_ARG */
704
705                    BufferLength = ACPI_GET8 (ParserState->Aml);
706                    ParserState->Aml += 1;
707                    break;
708
709                case AML_WORD_OP:       /* AML_WORDDATA_ARG */
710
711                    BufferLength = ACPI_GET16 (ParserState->Aml);
712                    ParserState->Aml += 2;
713                    break;
714
715                case AML_DWORD_OP:      /* AML_DWORDATA_ARG */
716
717                    BufferLength = ACPI_GET32 (ParserState->Aml);
718                    ParserState->Aml += 4;
719                    break;
720
721                default:
722
723                    BufferLength = 0;
724                    break;
725                }
726
727                /* Fill in bytelist data */
728
729                ASL_CV_CAPTURE_COMMENTS_ONLY (ParserState);
730                Arg->Named.Value.Size = BufferLength;
731                Arg->Named.Data = ParserState->Aml;
732            }
733
734            /* Skip to End of byte data */
735
736            ParserState->Aml = PkgEnd;
737        }
738        else
739        {
740            Arg = AcpiPsAllocOp (AML_INT_NAMEPATH_OP, Aml);
741            if (!Arg)
742            {
743                AcpiPsFreeOp (Field);
744                return_PTR (NULL);
745            }
746
747            /* Get the Namestring argument */
748
749            Arg->Common.Value.Name = AcpiPsGetNextNamestring (ParserState);
750        }
751
752        /* Link the buffer/namestring to parent (CONNECTION_OP) */
753
754        AcpiPsAppendArg (Field, Arg);
755        break;
756
757
758    default:
759
760        /* Opcode was set in previous switch */
761        break;
762    }
763
764    return_PTR (Field);
765}
766
767
768/*******************************************************************************
769 *
770 * FUNCTION:    AcpiPsGetNextArg
771 *
772 * PARAMETERS:  WalkState           - Current state
773 *              ParserState         - Current parser state object
774 *              ArgType             - The argument type (AML_*_ARG)
775 *              ReturnArg           - Where the next arg is returned
776 *
777 * RETURN:      Status, and an op object containing the next argument.
778 *
779 * DESCRIPTION: Get next argument (including complex list arguments that require
780 *              pushing the parser stack)
781 *
782 ******************************************************************************/
783
784ACPI_STATUS
785AcpiPsGetNextArg (
786    ACPI_WALK_STATE         *WalkState,
787    ACPI_PARSE_STATE        *ParserState,
788    UINT32                  ArgType,
789    ACPI_PARSE_OBJECT       **ReturnArg)
790{
791    ACPI_PARSE_OBJECT       *Arg = NULL;
792    ACPI_PARSE_OBJECT       *Prev = NULL;
793    ACPI_PARSE_OBJECT       *Field;
794    UINT32                  Subop;
795    ACPI_STATUS             Status = AE_OK;
796
797
798    ACPI_FUNCTION_TRACE_PTR (PsGetNextArg, ParserState);
799
800
801    ACPI_DEBUG_PRINT ((ACPI_DB_PARSE,
802        "Expected argument type ARGP: %s (%2.2X)\n",
803        AcpiUtGetArgumentTypeName (ArgType), ArgType));
804
805    switch (ArgType)
806    {
807    case ARGP_BYTEDATA:
808    case ARGP_WORDDATA:
809    case ARGP_DWORDDATA:
810    case ARGP_CHARLIST:
811    case ARGP_NAME:
812    case ARGP_NAMESTRING:
813
814        /* Constants, strings, and namestrings are all the same size */
815
816        Arg = AcpiPsAllocOp (AML_BYTE_OP, ParserState->Aml);
817        if (!Arg)
818        {
819            return_ACPI_STATUS (AE_NO_MEMORY);
820        }
821
822        AcpiPsGetNextSimpleArg (ParserState, ArgType, Arg);
823        break;
824
825    case ARGP_PKGLENGTH:
826
827        /* Package length, nothing returned */
828
829        ParserState->PkgEnd = AcpiPsGetNextPackageEnd (ParserState);
830        break;
831
832    case ARGP_FIELDLIST:
833
834        if (ParserState->Aml < ParserState->PkgEnd)
835        {
836            /* Non-empty list */
837
838            while (ParserState->Aml < ParserState->PkgEnd)
839            {
840                Field = AcpiPsGetNextField (ParserState);
841                if (!Field)
842                {
843                    return_ACPI_STATUS (AE_NO_MEMORY);
844                }
845
846                if (Prev)
847                {
848                    Prev->Common.Next = Field;
849                }
850                else
851                {
852                    Arg = Field;
853                }
854                Prev = Field;
855            }
856
857            /* Skip to End of byte data */
858
859            ParserState->Aml = ParserState->PkgEnd;
860        }
861        break;
862
863    case ARGP_BYTELIST:
864
865        if (ParserState->Aml < ParserState->PkgEnd)
866        {
867            /* Non-empty list */
868
869            Arg = AcpiPsAllocOp (AML_INT_BYTELIST_OP,
870                ParserState->Aml);
871            if (!Arg)
872            {
873                return_ACPI_STATUS (AE_NO_MEMORY);
874            }
875
876            /* Fill in bytelist data */
877
878            Arg->Common.Value.Size = (UINT32)
879                ACPI_PTR_DIFF (ParserState->PkgEnd, ParserState->Aml);
880            Arg->Named.Data = ParserState->Aml;
881
882            /* Skip to End of byte data */
883
884            ParserState->Aml = ParserState->PkgEnd;
885        }
886        break;
887
888    case ARGP_SIMPLENAME:
889    case ARGP_NAME_OR_REF:
890
891        ACPI_DEBUG_PRINT ((ACPI_DB_PARSE,
892            "**** SimpleName/NameOrRef: %s (%2.2X)\n",
893            AcpiUtGetArgumentTypeName (ArgType), ArgType));
894
895        Subop = AcpiPsPeekOpcode (ParserState);
896        if (Subop == 0                  ||
897            AcpiPsIsLeadingChar (Subop) ||
898            ACPI_IS_ROOT_PREFIX (Subop) ||
899            ACPI_IS_PARENT_PREFIX (Subop))
900        {
901            /* NullName or NameString */
902
903            Arg = AcpiPsAllocOp (AML_INT_NAMEPATH_OP, ParserState->Aml);
904            if (!Arg)
905            {
906                return_ACPI_STATUS (AE_NO_MEMORY);
907            }
908
909            Status = AcpiPsGetNextNamepath (WalkState, ParserState,
910                Arg, ACPI_NOT_METHOD_CALL);
911        }
912        else
913        {
914            /* Single complex argument, nothing returned */
915
916            WalkState->ArgCount = 1;
917        }
918        break;
919
920    case ARGP_TARGET:
921    case ARGP_SUPERNAME:
922
923        ACPI_DEBUG_PRINT ((ACPI_DB_PARSE,
924            "**** Target/Supername: %s (%2.2X)\n",
925            AcpiUtGetArgumentTypeName (ArgType), ArgType));
926
927        Subop = AcpiPsPeekOpcode (ParserState);
928        if (Subop == 0                  ||
929            AcpiPsIsLeadingChar (Subop) ||
930            ACPI_IS_ROOT_PREFIX (Subop) ||
931            ACPI_IS_PARENT_PREFIX (Subop))
932        {
933            /* NULL target (zero). Convert to a NULL namepath */
934
935            Arg = AcpiPsAllocOp (AML_INT_NAMEPATH_OP, ParserState->Aml);
936            if (!Arg)
937            {
938                return_ACPI_STATUS (AE_NO_MEMORY);
939            }
940
941            Status = AcpiPsGetNextNamepath (WalkState, ParserState,
942                Arg, ACPI_POSSIBLE_METHOD_CALL);
943
944            if (Arg->Common.AmlOpcode == AML_INT_METHODCALL_OP)
945            {
946                /* Free method call op and corresponding namestring sub-ob */
947
948                AcpiPsFreeOp (Arg->Common.Value.Arg);
949                AcpiPsFreeOp (Arg);
950                Arg = NULL;
951                WalkState->ArgCount = 1;
952            }
953        }
954        else
955        {
956            /* Single complex argument, nothing returned */
957
958            WalkState->ArgCount = 1;
959        }
960        break;
961
962    case ARGP_DATAOBJ:
963    case ARGP_TERMARG:
964
965        ACPI_DEBUG_PRINT ((ACPI_DB_PARSE,
966            "**** TermArg/DataObj: %s (%2.2X)\n",
967            AcpiUtGetArgumentTypeName (ArgType), ArgType));
968
969        /* Single complex argument, nothing returned */
970
971        WalkState->ArgCount = 1;
972        break;
973
974    case ARGP_DATAOBJLIST:
975    case ARGP_TERMLIST:
976    case ARGP_OBJLIST:
977
978        if (ParserState->Aml < ParserState->PkgEnd)
979        {
980            /* Non-empty list of variable arguments, nothing returned */
981
982            WalkState->ArgCount = ACPI_VAR_ARGS;
983        }
984        break;
985
986    default:
987
988        ACPI_ERROR ((AE_INFO, "Invalid ArgType: 0x%X", ArgType));
989        Status = AE_AML_OPERAND_TYPE;
990        break;
991    }
992
993    *ReturnArg = Arg;
994    return_ACPI_STATUS (Status);
995}
996