xref: /titanic_44/usr/src/uts/intel/io/acpica/parser/psloop.c (revision 48a4016cae8aa2b8b3d8b258eb22e0c781912bed)
1 /******************************************************************************
2  *
3  * Module Name: psloop - Main AML parse loop
4  *
5  *****************************************************************************/
6 
7 /*
8  * Copyright (C) 2000 - 2016, 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 MERCHANTIBILITY 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 /*
45  * Parse the AML and build an operation tree as most interpreters, (such as
46  * Perl) do. Parsing is done by hand rather than with a YACC generated parser
47  * to tightly constrain stack and dynamic memory usage. Parsing is kept
48  * flexible and the code fairly compact by parsing based on a list of AML
49  * opcode templates in AmlOpInfo[].
50  */
51 
52 #include "acpi.h"
53 #include "accommon.h"
54 #include "acinterp.h"
55 #include "acparser.h"
56 #include "acdispat.h"
57 #include "amlcode.h"
58 
59 #define _COMPONENT          ACPI_PARSER
60         ACPI_MODULE_NAME    ("psloop")
61 
62 
63 /* Local prototypes */
64 
65 static ACPI_STATUS
66 AcpiPsGetArguments (
67     ACPI_WALK_STATE         *WalkState,
68     UINT8                   *AmlOpStart,
69     ACPI_PARSE_OBJECT       *Op);
70 
71 static void
72 AcpiPsLinkModuleCode (
73     ACPI_PARSE_OBJECT       *ParentOp,
74     UINT8                   *AmlStart,
75     UINT32                  AmlLength,
76     ACPI_OWNER_ID           OwnerId);
77 
78 
79 /*******************************************************************************
80  *
81  * FUNCTION:    AcpiPsGetArguments
82  *
83  * PARAMETERS:  WalkState           - Current state
84  *              AmlOpStart          - Op start in AML
85  *              Op                  - Current Op
86  *
87  * RETURN:      Status
88  *
89  * DESCRIPTION: Get arguments for passed Op.
90  *
91  ******************************************************************************/
92 
93 static ACPI_STATUS
94 AcpiPsGetArguments (
95     ACPI_WALK_STATE         *WalkState,
96     UINT8                   *AmlOpStart,
97     ACPI_PARSE_OBJECT       *Op)
98 {
99     ACPI_STATUS             Status = AE_OK;
100     ACPI_PARSE_OBJECT       *Arg = NULL;
101     const ACPI_OPCODE_INFO  *OpInfo;
102 
103 
104     ACPI_FUNCTION_TRACE_PTR (PsGetArguments, WalkState);
105 
106 
107     switch (Op->Common.AmlOpcode)
108     {
109     case AML_BYTE_OP:       /* AML_BYTEDATA_ARG */
110     case AML_WORD_OP:       /* AML_WORDDATA_ARG */
111     case AML_DWORD_OP:      /* AML_DWORDATA_ARG */
112     case AML_QWORD_OP:      /* AML_QWORDATA_ARG */
113     case AML_STRING_OP:     /* AML_ASCIICHARLIST_ARG */
114 
115         /* Fill in constant or string argument directly */
116 
117         AcpiPsGetNextSimpleArg (&(WalkState->ParserState),
118             GET_CURRENT_ARG_TYPE (WalkState->ArgTypes), Op);
119         break;
120 
121     case AML_INT_NAMEPATH_OP:   /* AML_NAMESTRING_ARG */
122 
123         Status = AcpiPsGetNextNamepath (WalkState,
124             &(WalkState->ParserState), Op, ACPI_POSSIBLE_METHOD_CALL);
125         if (ACPI_FAILURE (Status))
126         {
127             return_ACPI_STATUS (Status);
128         }
129 
130         WalkState->ArgTypes = 0;
131         break;
132 
133     default:
134         /*
135          * Op is not a constant or string, append each argument to the Op
136          */
137         while (GET_CURRENT_ARG_TYPE (WalkState->ArgTypes) &&
138             !WalkState->ArgCount)
139         {
140             WalkState->Aml = WalkState->ParserState.Aml;
141 
142             Status = AcpiPsGetNextArg (WalkState, &(WalkState->ParserState),
143                 GET_CURRENT_ARG_TYPE (WalkState->ArgTypes), &Arg);
144             if (ACPI_FAILURE (Status))
145             {
146                 return_ACPI_STATUS (Status);
147             }
148 
149             if (Arg)
150             {
151                 AcpiPsAppendArg (Op, Arg);
152             }
153 
154             INCREMENT_ARG_LIST (WalkState->ArgTypes);
155         }
156 
157 
158         /*
159          * Handle executable code at "module-level". This refers to
160          * executable opcodes that appear outside of any control method.
161          */
162         if ((WalkState->PassNumber <= ACPI_IMODE_LOAD_PASS2) &&
163             ((WalkState->ParseFlags & ACPI_PARSE_DISASSEMBLE) == 0))
164         {
165             /*
166              * We want to skip If/Else/While constructs during Pass1 because we
167              * want to actually conditionally execute the code during Pass2.
168              *
169              * Except for disassembly, where we always want to walk the
170              * If/Else/While packages
171              */
172             switch (Op->Common.AmlOpcode)
173             {
174             case AML_IF_OP:
175             case AML_ELSE_OP:
176             case AML_WHILE_OP:
177                 /*
178                  * Currently supported module-level opcodes are:
179                  * IF/ELSE/WHILE. These appear to be the most common,
180                  * and easiest to support since they open an AML
181                  * package.
182                  */
183                 if (WalkState->PassNumber == ACPI_IMODE_LOAD_PASS1)
184                 {
185                     AcpiPsLinkModuleCode (Op->Common.Parent, AmlOpStart,
186                         (UINT32) (WalkState->ParserState.PkgEnd - AmlOpStart),
187                         WalkState->OwnerId);
188                 }
189 
190                 ACPI_DEBUG_PRINT ((ACPI_DB_PARSE,
191                     "Pass1: Skipping an If/Else/While body\n"));
192 
193                 /* Skip body of if/else/while in pass 1 */
194 
195                 WalkState->ParserState.Aml = WalkState->ParserState.PkgEnd;
196                 WalkState->ArgCount = 0;
197                 break;
198 
199             default:
200                 /*
201                  * Check for an unsupported executable opcode at module
202                  * level. We must be in PASS1, the parent must be a SCOPE,
203                  * The opcode class must be EXECUTE, and the opcode must
204                  * not be an argument to another opcode.
205                  */
206                 if ((WalkState->PassNumber == ACPI_IMODE_LOAD_PASS1) &&
207                     (Op->Common.Parent->Common.AmlOpcode == AML_SCOPE_OP))
208                 {
209                     OpInfo = AcpiPsGetOpcodeInfo (Op->Common.AmlOpcode);
210                     if ((OpInfo->Class == AML_CLASS_EXECUTE) &&
211                         (!Arg))
212                     {
213                         ACPI_WARNING ((AE_INFO,
214                             "Unsupported module-level executable opcode "
215                             "0x%.2X at table offset 0x%.4X",
216                             Op->Common.AmlOpcode,
217                             (UINT32) (ACPI_PTR_DIFF (AmlOpStart,
218                                 WalkState->ParserState.AmlStart) +
219                                 sizeof (ACPI_TABLE_HEADER))));
220                     }
221                 }
222                 break;
223             }
224         }
225 
226         /* Special processing for certain opcodes */
227 
228         switch (Op->Common.AmlOpcode)
229         {
230         case AML_METHOD_OP:
231             /*
232              * Skip parsing of control method because we don't have enough
233              * info in the first pass to parse it correctly.
234              *
235              * Save the length and address of the body
236              */
237             Op->Named.Data = WalkState->ParserState.Aml;
238             Op->Named.Length = (UINT32)
239                 (WalkState->ParserState.PkgEnd - WalkState->ParserState.Aml);
240 
241             /* Skip body of method */
242 
243             WalkState->ParserState.Aml = WalkState->ParserState.PkgEnd;
244             WalkState->ArgCount = 0;
245             break;
246 
247         case AML_BUFFER_OP:
248         case AML_PACKAGE_OP:
249         case AML_VAR_PACKAGE_OP:
250 
251             if ((Op->Common.Parent) &&
252                 (Op->Common.Parent->Common.AmlOpcode == AML_NAME_OP) &&
253                 (WalkState->PassNumber <= ACPI_IMODE_LOAD_PASS2))
254             {
255                 /*
256                  * Skip parsing of Buffers and Packages because we don't have
257                  * enough info in the first pass to parse them correctly.
258                  */
259                 Op->Named.Data = AmlOpStart;
260                 Op->Named.Length = (UINT32)
261                     (WalkState->ParserState.PkgEnd - AmlOpStart);
262 
263                 /* Skip body */
264 
265                 WalkState->ParserState.Aml = WalkState->ParserState.PkgEnd;
266                 WalkState->ArgCount = 0;
267             }
268             break;
269 
270         case AML_WHILE_OP:
271 
272             if (WalkState->ControlState)
273             {
274                 WalkState->ControlState->Control.PackageEnd =
275                     WalkState->ParserState.PkgEnd;
276             }
277             break;
278 
279         default:
280 
281             /* No action for all other opcodes */
282 
283             break;
284         }
285 
286         break;
287     }
288 
289     return_ACPI_STATUS (AE_OK);
290 }
291 
292 
293 /*******************************************************************************
294  *
295  * FUNCTION:    AcpiPsLinkModuleCode
296  *
297  * PARAMETERS:  ParentOp            - Parent parser op
298  *              AmlStart            - Pointer to the AML
299  *              AmlLength           - Length of executable AML
300  *              OwnerId             - OwnerId of module level code
301  *
302  * RETURN:      None.
303  *
304  * DESCRIPTION: Wrap the module-level code with a method object and link the
305  *              object to the global list. Note, the mutex field of the method
306  *              object is used to link multiple module-level code objects.
307  *
308  ******************************************************************************/
309 
310 static void
311 AcpiPsLinkModuleCode (
312     ACPI_PARSE_OBJECT       *ParentOp,
313     UINT8                   *AmlStart,
314     UINT32                  AmlLength,
315     ACPI_OWNER_ID           OwnerId)
316 {
317     ACPI_OPERAND_OBJECT     *Prev;
318     ACPI_OPERAND_OBJECT     *Next;
319     ACPI_OPERAND_OBJECT     *MethodObj;
320     ACPI_NAMESPACE_NODE     *ParentNode;
321 
322 
323     ACPI_FUNCTION_TRACE (PsLinkModuleCode);
324 
325 
326     /* Get the tail of the list */
327 
328     Prev = Next = AcpiGbl_ModuleCodeList;
329     while (Next)
330     {
331         Prev = Next;
332         Next = Next->Method.Mutex;
333     }
334 
335     /*
336      * Insert the module level code into the list. Merge it if it is
337      * adjacent to the previous element.
338      */
339     if (!Prev ||
340        ((Prev->Method.AmlStart + Prev->Method.AmlLength) != AmlStart))
341     {
342         /* Create, initialize, and link a new temporary method object */
343 
344         MethodObj = AcpiUtCreateInternalObject (ACPI_TYPE_METHOD);
345         if (!MethodObj)
346         {
347             return_VOID;
348         }
349 
350         ACPI_DEBUG_PRINT ((ACPI_DB_PARSE,
351             "Create/Link new code block: %p\n", MethodObj));
352 
353         if (ParentOp->Common.Node)
354         {
355             ParentNode = ParentOp->Common.Node;
356         }
357         else
358         {
359             ParentNode = AcpiGbl_RootNode;
360         }
361 
362         MethodObj->Method.AmlStart = AmlStart;
363         MethodObj->Method.AmlLength = AmlLength;
364         MethodObj->Method.OwnerId = OwnerId;
365         MethodObj->Method.InfoFlags |= ACPI_METHOD_MODULE_LEVEL;
366 
367         /*
368          * Save the parent node in NextObject. This is cheating, but we
369          * don't want to expand the method object.
370          */
371         MethodObj->Method.NextObject =
372             ACPI_CAST_PTR (ACPI_OPERAND_OBJECT, ParentNode);
373 
374         if (!Prev)
375         {
376             AcpiGbl_ModuleCodeList = MethodObj;
377         }
378         else
379         {
380             Prev->Method.Mutex = MethodObj;
381         }
382     }
383     else
384     {
385         ACPI_DEBUG_PRINT ((ACPI_DB_PARSE,
386             "Appending to existing code block: %p\n", Prev));
387 
388         Prev->Method.AmlLength += AmlLength;
389     }
390 
391     return_VOID;
392 }
393 
394 /*******************************************************************************
395  *
396  * FUNCTION:    AcpiPsParseLoop
397  *
398  * PARAMETERS:  WalkState           - Current state
399  *
400  * RETURN:      Status
401  *
402  * DESCRIPTION: Parse AML (pointed to by the current parser state) and return
403  *              a tree of ops.
404  *
405  ******************************************************************************/
406 
407 ACPI_STATUS
408 AcpiPsParseLoop (
409     ACPI_WALK_STATE         *WalkState)
410 {
411     ACPI_STATUS             Status = AE_OK;
412     ACPI_PARSE_OBJECT       *Op = NULL;     /* current op */
413     ACPI_PARSE_STATE        *ParserState;
414     UINT8                   *AmlOpStart = NULL;
415 
416 
417     ACPI_FUNCTION_TRACE_PTR (PsParseLoop, WalkState);
418 
419 
420     if (WalkState->DescendingCallback == NULL)
421     {
422         return_ACPI_STATUS (AE_BAD_PARAMETER);
423     }
424 
425     ParserState = &WalkState->ParserState;
426     WalkState->ArgTypes = 0;
427 
428 #if (!defined (ACPI_NO_METHOD_EXECUTION) && !defined (ACPI_CONSTANT_EVAL_ONLY))
429 
430     if (WalkState->WalkType & ACPI_WALK_METHOD_RESTART)
431     {
432         /* We are restarting a preempted control method */
433 
434         if (AcpiPsHasCompletedScope (ParserState))
435         {
436             /*
437              * We must check if a predicate to an IF or WHILE statement
438              * was just completed
439              */
440             if ((ParserState->Scope->ParseScope.Op) &&
441                ((ParserState->Scope->ParseScope.Op->Common.AmlOpcode == AML_IF_OP) ||
442                 (ParserState->Scope->ParseScope.Op->Common.AmlOpcode == AML_WHILE_OP)) &&
443                 (WalkState->ControlState) &&
444                 (WalkState->ControlState->Common.State ==
445                     ACPI_CONTROL_PREDICATE_EXECUTING))
446             {
447                 /*
448                  * A predicate was just completed, get the value of the
449                  * predicate and branch based on that value
450                  */
451                 WalkState->Op = NULL;
452                 Status = AcpiDsGetPredicateValue (WalkState, ACPI_TO_POINTER (TRUE));
453                 if (ACPI_FAILURE (Status) &&
454                     ((Status & AE_CODE_MASK) != AE_CODE_CONTROL))
455                 {
456                     if (Status == AE_AML_NO_RETURN_VALUE)
457                     {
458                         ACPI_EXCEPTION ((AE_INFO, Status,
459                             "Invoked method did not return a value"));
460                     }
461 
462                     ACPI_EXCEPTION ((AE_INFO, Status, "GetPredicate Failed"));
463                     return_ACPI_STATUS (Status);
464                 }
465 
466                 Status = AcpiPsNextParseState (WalkState, Op, Status);
467             }
468 
469             AcpiPsPopScope (ParserState, &Op,
470                 &WalkState->ArgTypes, &WalkState->ArgCount);
471             ACPI_DEBUG_PRINT ((ACPI_DB_PARSE, "Popped scope, Op=%p\n", Op));
472         }
473         else if (WalkState->PrevOp)
474         {
475             /* We were in the middle of an op */
476 
477             Op = WalkState->PrevOp;
478             WalkState->ArgTypes = WalkState->PrevArgTypes;
479         }
480     }
481 #endif
482 
483     /* Iterative parsing loop, while there is more AML to process: */
484 
485     while ((ParserState->Aml < ParserState->AmlEnd) || (Op))
486     {
487         AmlOpStart = ParserState->Aml;
488         if (!Op)
489         {
490             Status = AcpiPsCreateOp (WalkState, AmlOpStart, &Op);
491             if (ACPI_FAILURE (Status))
492             {
493                 if (Status == AE_CTRL_PARSE_CONTINUE)
494                 {
495                     continue;
496                 }
497 
498                 if (Status == AE_CTRL_PARSE_PENDING)
499                 {
500                     Status = AE_OK;
501                 }
502 
503                 if (Status == AE_CTRL_TERMINATE)
504                 {
505                     return_ACPI_STATUS (Status);
506                 }
507 
508                 Status = AcpiPsCompleteOp (WalkState, &Op, Status);
509                 if (ACPI_FAILURE (Status))
510                 {
511                     return_ACPI_STATUS (Status);
512                 }
513 
514                 continue;
515             }
516 
517             AcpiExStartTraceOpcode (Op, WalkState);
518         }
519 
520 
521         /*
522          * Start ArgCount at zero because we don't know if there are
523          * any args yet
524          */
525         WalkState->ArgCount  = 0;
526 
527         /* Are there any arguments that must be processed? */
528 
529         if (WalkState->ArgTypes)
530         {
531             /* Get arguments */
532 
533             Status = AcpiPsGetArguments (WalkState, AmlOpStart, Op);
534             if (ACPI_FAILURE (Status))
535             {
536                 Status = AcpiPsCompleteOp (WalkState, &Op, Status);
537                 if (ACPI_FAILURE (Status))
538                 {
539                     return_ACPI_STATUS (Status);
540                 }
541 
542                 continue;
543             }
544         }
545 
546         /* Check for arguments that need to be processed */
547 
548         if (WalkState->ArgCount)
549         {
550             /*
551              * There are arguments (complex ones), push Op and
552              * prepare for argument
553              */
554             Status = AcpiPsPushScope (ParserState, Op,
555                 WalkState->ArgTypes, WalkState->ArgCount);
556             if (ACPI_FAILURE (Status))
557             {
558                 Status = AcpiPsCompleteOp (WalkState, &Op, Status);
559                 if (ACPI_FAILURE (Status))
560                 {
561                     return_ACPI_STATUS (Status);
562                 }
563 
564                 continue;
565             }
566 
567             Op = NULL;
568             continue;
569         }
570 
571         /*
572          * All arguments have been processed -- Op is complete,
573          * prepare for next
574          */
575         WalkState->OpInfo = AcpiPsGetOpcodeInfo (Op->Common.AmlOpcode);
576         if (WalkState->OpInfo->Flags & AML_NAMED)
577         {
578             if (Op->Common.AmlOpcode == AML_REGION_OP ||
579                 Op->Common.AmlOpcode == AML_DATA_REGION_OP)
580             {
581                 /*
582                  * Skip parsing of control method or opregion body,
583                  * because we don't have enough info in the first pass
584                  * to parse them correctly.
585                  *
586                  * Completed parsing an OpRegion declaration, we now
587                  * know the length.
588                  */
589                 Op->Named.Length = (UINT32) (ParserState->Aml - Op->Named.Data);
590             }
591         }
592 
593         if (WalkState->OpInfo->Flags & AML_CREATE)
594         {
595             /*
596              * Backup to beginning of CreateXXXfield declaration (1 for
597              * Opcode)
598              *
599              * BodyLength is unknown until we parse the body
600              */
601             Op->Named.Length = (UINT32) (ParserState->Aml - Op->Named.Data);
602         }
603 
604         if (Op->Common.AmlOpcode == AML_BANK_FIELD_OP)
605         {
606             /*
607              * Backup to beginning of BankField declaration
608              *
609              * BodyLength is unknown until we parse the body
610              */
611             Op->Named.Length = (UINT32) (ParserState->Aml - Op->Named.Data);
612         }
613 
614         /* This op complete, notify the dispatcher */
615 
616         if (WalkState->AscendingCallback != NULL)
617         {
618             WalkState->Op = Op;
619             WalkState->Opcode = Op->Common.AmlOpcode;
620 
621             Status = WalkState->AscendingCallback (WalkState);
622             Status = AcpiPsNextParseState (WalkState, Op, Status);
623             if (Status == AE_CTRL_PENDING)
624             {
625                 Status = AE_OK;
626             }
627         }
628 
629         Status = AcpiPsCompleteOp (WalkState, &Op, Status);
630         if (ACPI_FAILURE (Status))
631         {
632             return_ACPI_STATUS (Status);
633         }
634 
635     } /* while ParserState->Aml */
636 
637     Status = AcpiPsCompleteFinalOp (WalkState, Op, Status);
638     return_ACPI_STATUS (Status);
639 }
640