1 /******************************************************************************
2 *
3 * Module Name: asloperands - AML operand processing
4 *
5 *****************************************************************************/
6
7 /******************************************************************************
8 *
9 * 1. Copyright Notice
10 *
11 * Some or all of this work - Copyright (c) 1999 - 2023, Intel Corp.
12 * All rights reserved.
13 *
14 * 2. License
15 *
16 * 2.1. This is your license from Intel Corp. under its intellectual property
17 * rights. You may have additional license terms from the party that provided
18 * you this software, covering your right to use that party's intellectual
19 * property rights.
20 *
21 * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
22 * copy of the source code appearing in this file ("Covered Code") an
23 * irrevocable, perpetual, worldwide license under Intel's copyrights in the
24 * base code distributed originally by Intel ("Original Intel Code") to copy,
25 * make derivatives, distribute, use and display any portion of the Covered
26 * Code in any form, with the right to sublicense such rights; and
27 *
28 * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
29 * license (with the right to sublicense), under only those claims of Intel
30 * patents that are infringed by the Original Intel Code, to make, use, sell,
31 * offer to sell, and import the Covered Code and derivative works thereof
32 * solely to the minimum extent necessary to exercise the above copyright
33 * license, and in no event shall the patent license extend to any additions
34 * to or modifications of the Original Intel Code. No other license or right
35 * is granted directly or by implication, estoppel or otherwise;
36 *
37 * The above copyright and patent license is granted only if the following
38 * conditions are met:
39 *
40 * 3. Conditions
41 *
42 * 3.1. Redistribution of Source with Rights to Further Distribute Source.
43 * Redistribution of source code of any substantial portion of the Covered
44 * Code or modification with rights to further distribute source must include
45 * the above Copyright Notice, the above License, this list of Conditions,
46 * and the following Disclaimer and Export Compliance provision. In addition,
47 * Licensee must cause all Covered Code to which Licensee contributes to
48 * contain a file documenting the changes Licensee made to create that Covered
49 * Code and the date of any change. Licensee must include in that file the
50 * documentation of any changes made by any predecessor Licensee. Licensee
51 * must include a prominent statement that the modification is derived,
52 * directly or indirectly, from Original Intel Code.
53 *
54 * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
55 * Redistribution of source code of any substantial portion of the Covered
56 * Code or modification without rights to further distribute source must
57 * include the following Disclaimer and Export Compliance provision in the
58 * documentation and/or other materials provided with distribution. In
59 * addition, Licensee may not authorize further sublicense of source of any
60 * portion of the Covered Code, and must include terms to the effect that the
61 * license from Licensee to its licensee is limited to the intellectual
62 * property embodied in the software Licensee provides to its licensee, and
63 * not to intellectual property embodied in modifications its licensee may
64 * make.
65 *
66 * 3.3. Redistribution of Executable. Redistribution in executable form of any
67 * substantial portion of the Covered Code or modification must reproduce the
68 * above Copyright Notice, and the following Disclaimer and Export Compliance
69 * provision in the documentation and/or other materials provided with the
70 * distribution.
71 *
72 * 3.4. Intel retains all right, title, and interest in and to the Original
73 * Intel Code.
74 *
75 * 3.5. Neither the name Intel nor any other trademark owned or controlled by
76 * Intel shall be used in advertising or otherwise to promote the sale, use or
77 * other dealings in products derived from or relating to the Covered Code
78 * without prior written authorization from Intel.
79 *
80 * 4. Disclaimer and Export Compliance
81 *
82 * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
83 * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
84 * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE,
85 * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY
86 * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY
87 * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
88 * PARTICULAR PURPOSE.
89 *
90 * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
91 * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
92 * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
93 * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
94 * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
95 * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS
96 * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
97 * LIMITED REMEDY.
98 *
99 * 4.3. Licensee shall not export, either directly or indirectly, any of this
100 * software or system incorporating such software without first obtaining any
101 * required license or other approval from the U. S. Department of Commerce or
102 * any other agency or department of the United States Government. In the
103 * event Licensee exports any such software from the United States or
104 * re-exports any such software from a foreign destination, Licensee shall
105 * ensure that the distribution and export/re-export of the software is in
106 * compliance with all laws, regulations, orders, or other restrictions of the
107 * U.S. Export Administration Regulations. Licensee agrees that neither it nor
108 * any of its subsidiaries will export/re-export any technical data, process,
109 * software, or service, directly or indirectly, to any country for which the
110 * United States government or any agency thereof requires an export license,
111 * other governmental approval, or letter of assurance, without first obtaining
112 * such license, approval or letter.
113 *
114 *****************************************************************************
115 *
116 * Alternatively, you may choose to be licensed under the terms of the
117 * following license:
118 *
119 * Redistribution and use in source and binary forms, with or without
120 * modification, are permitted provided that the following conditions
121 * are met:
122 * 1. Redistributions of source code must retain the above copyright
123 * notice, this list of conditions, and the following disclaimer,
124 * without modification.
125 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
126 * substantially similar to the "NO WARRANTY" disclaimer below
127 * ("Disclaimer") and any redistribution must be conditioned upon
128 * including a substantially similar Disclaimer requirement for further
129 * binary redistribution.
130 * 3. Neither the names of the above-listed copyright holders nor the names
131 * of any contributors may be used to endorse or promote products derived
132 * from this software without specific prior written permission.
133 *
134 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
135 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
136 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
137 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
138 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
139 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
140 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
141 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
142 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
143 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
144 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
145 *
146 * Alternatively, you may choose to be licensed under the terms of the
147 * GNU General Public License ("GPL") version 2 as published by the Free
148 * Software Foundation.
149 *
150 *****************************************************************************/
151
152 #include <contrib/dev/acpica/compiler/aslcompiler.h>
153 #include "aslcompiler.y.h"
154 #include <contrib/dev/acpica/include/amlcode.h>
155
156 #define _COMPONENT ACPI_COMPILER
157 ACPI_MODULE_NAME ("asloperands")
158
159 /* Local prototypes */
160
161 static void
162 OpnDoField (
163 ACPI_PARSE_OBJECT *Op);
164
165 static void
166 OpnDoBankField (
167 ACPI_PARSE_OBJECT *Op);
168
169 static void
170 OpnDoBuffer (
171 ACPI_PARSE_OBJECT *Op);
172
173 static void
174 OpnDoDefinitionBlock (
175 ACPI_PARSE_OBJECT *Op);
176
177 static void
178 OpnDoFieldCommon (
179 ACPI_PARSE_OBJECT *FieldOp,
180 ACPI_PARSE_OBJECT *Op);
181
182 static void
183 OpnDoIndexField (
184 ACPI_PARSE_OBJECT *Op);
185
186 static void
187 OpnDoLoadTable (
188 ACPI_PARSE_OBJECT *Op);
189
190 static void
191 OpnDoMethod (
192 ACPI_PARSE_OBJECT *Op);
193
194 static void
195 OpnDoMutex (
196 ACPI_PARSE_OBJECT *Op);
197
198 static void
199 OpnDoRegion (
200 ACPI_PARSE_OBJECT *Op);
201
202 static void
203 OpnAttachNameToNode (
204 ACPI_PARSE_OBJECT *Op);
205
206
207 /*******************************************************************************
208 *
209 * FUNCTION: OpnDoMutex
210 *
211 * PARAMETERS: Op - The parent parse node
212 *
213 * RETURN: None
214 *
215 * DESCRIPTION: Construct the operands for the MUTEX ASL keyword.
216 *
217 ******************************************************************************/
218
219 static void
OpnDoMutex(ACPI_PARSE_OBJECT * Op)220 OpnDoMutex (
221 ACPI_PARSE_OBJECT *Op)
222 {
223 ACPI_PARSE_OBJECT *Next;
224
225
226 Next = Op->Asl.Child;
227 Next = Next->Asl.Next;
228
229 if (Next->Asl.Value.Integer > 15)
230 {
231 AslError (ASL_ERROR, ASL_MSG_SYNC_LEVEL, Next, NULL);
232 }
233 return;
234 }
235
236
237 /*******************************************************************************
238 *
239 * FUNCTION: OpnDoMethod
240 *
241 * PARAMETERS: Op - The parent parse node
242 *
243 * RETURN: None
244 *
245 * DESCRIPTION: Construct the operands for the METHOD ASL keyword.
246 *
247 ******************************************************************************/
248
249 static void
OpnDoMethod(ACPI_PARSE_OBJECT * Op)250 OpnDoMethod (
251 ACPI_PARSE_OBJECT *Op)
252 {
253 ACPI_PARSE_OBJECT *Next;
254
255 /* Optional arguments for this opcode with defaults */
256
257 UINT8 NumArgs = 0;
258 UINT8 Serialized = 0;
259 UINT8 Concurrency = 0;
260 UINT8 MethodFlags;
261
262
263 /* Opcode and package length first */
264 /* Method name */
265
266 Next = Op->Asl.Child;
267
268 /* Num args */
269
270 Next = Next->Asl.Next;
271 if (Next->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
272 {
273 NumArgs = (UINT8) Next->Asl.Value.Integer;
274 Next->Asl.ParseOpcode = PARSEOP_DEFAULT_ARG;
275 }
276
277 /* Serialized Flag */
278
279 Next = Next->Asl.Next;
280 if (Next->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
281 {
282 Serialized = (UINT8) Next->Asl.Value.Integer;
283 Next->Asl.ParseOpcode = PARSEOP_DEFAULT_ARG;
284 }
285
286 /* Concurrency value (valid values are 0-15) */
287
288 Next = Next->Asl.Next;
289 if (Next->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
290 {
291 /* This is a ByteConstExpr, so eval the constant now */
292
293 OpcAmlConstantWalk (Next, 0, NULL);
294
295 if (Next->Asl.Value.Integer > 15)
296 {
297 AslError (ASL_ERROR, ASL_MSG_SYNC_LEVEL, Next, NULL);
298 }
299
300 Concurrency = (UINT8) Next->Asl.Value.Integer;
301 }
302
303 /* Put the bits in their proper places */
304
305 MethodFlags = (UINT8)
306 ((NumArgs & 0x7) |
307 ((Serialized & 0x1) << 3) |
308 ((Concurrency & 0xF) << 4));
309
310 /* Use the last node for the combined flags byte */
311
312 Next->Asl.Value.Integer = MethodFlags;
313 Next->Asl.AmlOpcode = AML_RAW_DATA_BYTE;
314 Next->Asl.AmlLength = 1;
315 Next->Asl.ParseOpcode = PARSEOP_RAW_DATA;
316
317 /* Save the arg count in the first node */
318
319 Op->Asl.Extra = NumArgs;
320 }
321
322
323 /*******************************************************************************
324 *
325 * FUNCTION: OpnDoFieldCommon
326 *
327 * PARAMETERS: FieldOp - Node for an ASL field
328 * Op - The parent parse node
329 *
330 * RETURN: None
331 *
332 * DESCRIPTION: Construct the AML operands for the various field keywords,
333 * FIELD, BANKFIELD, INDEXFIELD
334 *
335 ******************************************************************************/
336
337 static void
OpnDoFieldCommon(ACPI_PARSE_OBJECT * FieldOp,ACPI_PARSE_OBJECT * Op)338 OpnDoFieldCommon (
339 ACPI_PARSE_OBJECT *FieldOp,
340 ACPI_PARSE_OBJECT *Op)
341 {
342 ACPI_PARSE_OBJECT *Next;
343 ACPI_PARSE_OBJECT *PkgLengthNode;
344 UINT32 CurrentBitOffset;
345 UINT32 NewBitOffset;
346 UINT8 AccessType;
347 UINT8 LockRule;
348 UINT8 UpdateRule;
349 UINT8 FieldFlags;
350 UINT32 MinimumLength;
351
352
353 /* AccessType -- not optional, so no need to check for DEFAULT_ARG */
354
355 AccessType = (UINT8) Op->Asl.Value.Integer;
356 Op->Asl.ParseOpcode = PARSEOP_DEFAULT_ARG;
357
358 /* Set the access type in the parent (field) node for use later */
359
360 FieldOp->Asl.Value.Integer = AccessType;
361
362 /* LockRule -- not optional, so no need to check for DEFAULT_ARG */
363
364 Next = Op->Asl.Next;
365 LockRule = (UINT8) Next->Asl.Value.Integer;
366 Next->Asl.ParseOpcode = PARSEOP_DEFAULT_ARG;
367
368 /* UpdateRule -- not optional, so no need to check for DEFAULT_ARG */
369
370 Next = Next->Asl.Next;
371 UpdateRule = (UINT8) Next->Asl.Value.Integer;
372
373 /*
374 * Generate the flags byte. The various fields are already
375 * in the right bit position via translation from the
376 * keywords by the parser.
377 */
378 FieldFlags = (UINT8) (AccessType | LockRule | UpdateRule);
379
380 /* Use the previous node to be the FieldFlags node */
381
382 /* Set the node to RAW_DATA */
383
384 Next->Asl.Value.Integer = FieldFlags;
385 Next->Asl.AmlOpcode = AML_RAW_DATA_BYTE;
386 Next->Asl.AmlLength = 1;
387 Next->Asl.ParseOpcode = PARSEOP_RAW_DATA;
388
389 /* Process the FieldUnitList */
390
391 Next = Next->Asl.Next;
392 CurrentBitOffset = 0;
393
394 while (Next)
395 {
396 /* Save the offset of this field unit */
397
398 Next->Asl.ExtraValue = CurrentBitOffset;
399
400 switch (Next->Asl.ParseOpcode)
401 {
402 case PARSEOP_ACCESSAS:
403
404 PkgLengthNode = Next->Asl.Child;
405 AccessType = (UINT8) PkgLengthNode->Asl.Value.Integer;
406
407 /* Nothing additional to do */
408 break;
409
410 case PARSEOP_OFFSET:
411
412 /* New offset into the field */
413
414 PkgLengthNode = Next->Asl.Child;
415 NewBitOffset = ((UINT32) PkgLengthNode->Asl.Value.Integer) * 8;
416
417 /*
418 * Examine the specified offset in relation to the
419 * current offset counter.
420 */
421 if (NewBitOffset < CurrentBitOffset)
422 {
423 /*
424 * Not allowed to specify a backwards offset!
425 * Issue error and ignore this node.
426 */
427 AslError (ASL_ERROR, ASL_MSG_BACKWARDS_OFFSET, PkgLengthNode,
428 NULL);
429 Next->Asl.ParseOpcode = PARSEOP_DEFAULT_ARG;
430 PkgLengthNode->Asl.ParseOpcode = PARSEOP_DEFAULT_ARG;
431 }
432 #ifdef _OBSOLETE_CODE
433 /*
434 * January 2022: removed this check due to complaints by users
435 * for too many (invalid) remarks.
436 */
437 else if (NewBitOffset == CurrentBitOffset)
438 {
439 /*
440 * This Offset() operator is redundant and not needed,
441 * because the offset value is the same as the current
442 * offset.
443 */
444 AslError (ASL_REMARK, ASL_MSG_OFFSET, PkgLengthNode, NULL);
445
446 if (AslGbl_OptimizeTrivialParseNodes)
447 {
448 /*
449 * Optimize this Offset() operator by removing/ignoring
450 * it. Set the related nodes to default.
451 */
452 Next->Asl.ParseOpcode = PARSEOP_DEFAULT_ARG;
453 PkgLengthNode->Asl.ParseOpcode = PARSEOP_DEFAULT_ARG;
454
455 AslError (ASL_OPTIMIZATION, ASL_MSG_OFFSET, PkgLengthNode,
456 "Optimizer has removed statement");
457 }
458 else
459 {
460 /* Optimization is disabled, treat as a valid Offset */
461
462 PkgLengthNode->Asl.Value.Integer =
463 NewBitOffset - CurrentBitOffset;
464 CurrentBitOffset = NewBitOffset;
465 }
466 }
467 #endif
468 else
469 {
470 /*
471 * Valid new offset - set the value to be inserted into the AML
472 * and update the offset counter.
473 */
474 PkgLengthNode->Asl.Value.Integer =
475 NewBitOffset - CurrentBitOffset;
476 CurrentBitOffset = NewBitOffset;
477 }
478 break;
479
480 case PARSEOP_NAMESEG:
481 case PARSEOP_RESERVED_BYTES:
482
483 /* Named or reserved field entry */
484
485 PkgLengthNode = Next->Asl.Child;
486 NewBitOffset = (UINT32) PkgLengthNode->Asl.Value.Integer;
487 CurrentBitOffset += NewBitOffset;
488
489 if ((NewBitOffset == 0) &&
490 (Next->Asl.ParseOpcode == PARSEOP_RESERVED_BYTES) &&
491 AslGbl_OptimizeTrivialParseNodes)
492 {
493 /*
494 * Unnamed field with a bit length of zero. We can
495 * safely just ignore this. However, we will not ignore
496 * a named field of zero length, we don't want to just
497 * toss out a name.
498 */
499 Next->Asl.ParseOpcode = PARSEOP_DEFAULT_ARG;
500 PkgLengthNode->Asl.ParseOpcode = PARSEOP_DEFAULT_ARG;
501 break;
502 }
503
504 /* Save the current AccessAs value for error checking later */
505
506 switch (AccessType)
507 {
508 case AML_FIELD_ACCESS_ANY:
509 case AML_FIELD_ACCESS_BYTE:
510 case AML_FIELD_ACCESS_BUFFER:
511 default:
512
513 MinimumLength = 8;
514 break;
515
516 case AML_FIELD_ACCESS_WORD:
517 MinimumLength = 16;
518 break;
519
520 case AML_FIELD_ACCESS_DWORD:
521 MinimumLength = 32;
522 break;
523
524 case AML_FIELD_ACCESS_QWORD:
525 MinimumLength = 64;
526 break;
527 }
528
529 PkgLengthNode->Asl.ExtraValue = MinimumLength;
530 break;
531
532 default:
533
534 /* All supported field opcodes must appear above */
535
536 break;
537 }
538
539 /* Move on to next entry in the field list */
540
541 Next = Next->Asl.Next;
542 }
543 }
544
545
546 /*******************************************************************************
547 *
548 * FUNCTION: OpnDoField
549 *
550 * PARAMETERS: Op - The parent parse node
551 *
552 * RETURN: None
553 *
554 * DESCRIPTION: Construct the AML operands for the FIELD ASL keyword
555 *
556 ******************************************************************************/
557
558 static void
OpnDoField(ACPI_PARSE_OBJECT * Op)559 OpnDoField (
560 ACPI_PARSE_OBJECT *Op)
561 {
562 ACPI_PARSE_OBJECT *Next;
563
564
565 /* Opcode is parent node */
566 /* First child is field name */
567
568 Next = Op->Asl.Child;
569
570 /* Second child is the AccessType */
571
572 OpnDoFieldCommon (Op, Next->Asl.Next);
573 }
574
575
576 /*******************************************************************************
577 *
578 * FUNCTION: OpnDoIndexField
579 *
580 * PARAMETERS: Op - The parent parse node
581 *
582 * RETURN: None
583 *
584 * DESCRIPTION: Construct the AML operands for the INDEXFIELD ASL keyword
585 *
586 ******************************************************************************/
587
588 static void
OpnDoIndexField(ACPI_PARSE_OBJECT * Op)589 OpnDoIndexField (
590 ACPI_PARSE_OBJECT *Op)
591 {
592 ACPI_PARSE_OBJECT *Next;
593
594
595 /* Opcode is parent node */
596 /* First child is the index name */
597
598 Next = Op->Asl.Child;
599
600 /* Second child is the data name */
601
602 Next = Next->Asl.Next;
603
604 /* Third child is the AccessType */
605
606 OpnDoFieldCommon (Op, Next->Asl.Next);
607 }
608
609
610 /*******************************************************************************
611 *
612 * FUNCTION: OpnDoBankField
613 *
614 * PARAMETERS: Op - The parent parse node
615 *
616 * RETURN: None
617 *
618 * DESCRIPTION: Construct the AML operands for the BANKFIELD ASL keyword
619 *
620 ******************************************************************************/
621
622 static void
OpnDoBankField(ACPI_PARSE_OBJECT * Op)623 OpnDoBankField (
624 ACPI_PARSE_OBJECT *Op)
625 {
626 ACPI_PARSE_OBJECT *Next;
627
628
629 /* Opcode is parent node */
630 /* First child is the region name */
631
632 Next = Op->Asl.Child;
633
634 /* Second child is the bank name */
635
636 Next = Next->Asl.Next;
637
638 /* Third child is the bank value */
639
640 Next = Next->Asl.Next;
641
642 /* Fourth child is the AccessType */
643
644 OpnDoFieldCommon (Op, Next->Asl.Next);
645 }
646
647
648 /*******************************************************************************
649 *
650 * FUNCTION: OpnDoRegion
651 *
652 * PARAMETERS: Op - The parent parse node
653 *
654 * RETURN: None
655 *
656 * DESCRIPTION: Tries to get the length of the region. Can only do this at
657 * compile time if the length is a constant.
658 *
659 ******************************************************************************/
660
661 static void
OpnDoRegion(ACPI_PARSE_OBJECT * Op)662 OpnDoRegion (
663 ACPI_PARSE_OBJECT *Op)
664 {
665 ACPI_PARSE_OBJECT *Next;
666 ACPI_ADR_SPACE_TYPE SpaceId;
667
668
669 /* Opcode is parent node */
670 /* First child is the region name */
671
672 Next = Op->Asl.Child;
673
674 /* Second child is the space ID */
675
676 Next = Next->Asl.Next;
677 SpaceId = (ACPI_ADR_SPACE_TYPE) Next->Common.Value.Integer;
678
679 /* Third child is the region offset */
680
681 Next = Next->Asl.Next;
682
683 /* Fourth child is the region length */
684
685 Next = Next->Asl.Next;
686 if (Next->Asl.ParseOpcode == PARSEOP_INTEGER)
687 {
688 /* Check for zero length */
689
690 Op->Asl.Value.Integer = Next->Asl.Value.Integer;
691 if (!Op->Asl.Value.Integer && (SpaceId < ACPI_NUM_PREDEFINED_REGIONS))
692 {
693 AslError (ASL_ERROR, ASL_MSG_REGION_LENGTH, Op, NULL);
694 }
695 }
696 else
697 {
698 Op->Asl.Value.Integer = ACPI_UINT64_MAX;
699 }
700 }
701
702
703 /*******************************************************************************
704 *
705 * FUNCTION: OpnDoBuffer
706 *
707 * PARAMETERS: Op - The parent parse node
708 *
709 * RETURN: None
710 *
711 * DESCRIPTION: Construct the AML operands for the BUFFER ASL keyword. We
712 * build a single raw byte buffer from the initialization nodes,
713 * each parse node contains a buffer byte.
714 *
715 ******************************************************************************/
716
717 static void
OpnDoBuffer(ACPI_PARSE_OBJECT * Op)718 OpnDoBuffer (
719 ACPI_PARSE_OBJECT *Op)
720 {
721 ACPI_PARSE_OBJECT *InitializerOp;
722 ACPI_PARSE_OBJECT *BufferLengthOp;
723
724 /* Optional arguments for this opcode with defaults */
725
726 UINT32 BufferLength = 0;
727
728
729 /* Opcode and package length first */
730 /* Buffer Length is next, followed by the initializer list */
731
732 BufferLengthOp = Op->Asl.Child;
733 InitializerOp = BufferLengthOp->Asl.Next;
734
735 /*
736 * If the BufferLength is not an INTEGER or was not specified in the ASL
737 * (DEFAULT_ARG), it is a TermArg that is
738 * evaluated at run-time, and we are therefore finished.
739 */
740 if ((BufferLengthOp->Asl.ParseOpcode != PARSEOP_INTEGER) &&
741 (BufferLengthOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG))
742 {
743 return;
744 }
745
746 /*
747 * We want to count the number of items in the initializer list, because if
748 * it is larger than the buffer length, we will define the buffer size
749 * to be the size of the initializer list (as per the ACPI Specification)
750 */
751 switch (InitializerOp->Asl.ParseOpcode)
752 {
753 case PARSEOP_INTEGER:
754 case PARSEOP_BYTECONST:
755 case PARSEOP_WORDCONST:
756 case PARSEOP_DWORDCONST:
757
758 /* The peer list contains the byte list (if any...) */
759
760 while (InitializerOp)
761 {
762 /* For buffers, this is a list of raw bytes */
763
764 InitializerOp->Asl.AmlOpcode = AML_RAW_DATA_BYTE;
765 InitializerOp->Asl.AmlLength = 1;
766 InitializerOp->Asl.ParseOpcode = PARSEOP_RAW_DATA;
767
768 BufferLength++;
769 InitializerOp = ASL_GET_PEER_NODE (InitializerOp);
770 }
771 break;
772
773 case PARSEOP_STRING_LITERAL:
774
775 /*
776 * Only one initializer, the string. Buffer must be big enough to hold
777 * the string plus the null termination byte
778 */
779 BufferLength = strlen (InitializerOp->Asl.Value.String) + 1;
780
781 InitializerOp->Asl.AmlOpcode = AML_RAW_DATA_BUFFER;
782 InitializerOp->Asl.AmlLength = BufferLength;
783 InitializerOp->Asl.ParseOpcode = PARSEOP_RAW_DATA;
784 break;
785
786 case PARSEOP_RAW_DATA:
787
788 /* Buffer nodes are already initialized (e.g. Unicode operator) */
789 return;
790
791 case PARSEOP_DEFAULT_ARG:
792 break;
793
794 default:
795
796 AslError (ASL_ERROR, ASL_MSG_INVALID_OPERAND, InitializerOp,
797 "Unknown buffer initializer opcode");
798 printf ("Unknown buffer initializer opcode [%s]\n",
799 UtGetOpName (InitializerOp->Asl.ParseOpcode));
800 return;
801 }
802
803 /* Check if initializer list is longer than the buffer length */
804
805 if (BufferLengthOp->Asl.Value.Integer > BufferLength)
806 {
807 BufferLength = (UINT32) BufferLengthOp->Asl.Value.Integer;
808 }
809
810 if (!BufferLength)
811 {
812 /* No length AND no items -- issue notice */
813
814 AslError (ASL_REMARK, ASL_MSG_BUFFER_LENGTH, BufferLengthOp, NULL);
815
816 /* But go ahead and put the buffer length of zero into the AML */
817 }
818
819 /*
820 * Just set the buffer size node to be the buffer length, regardless
821 * of whether it was previously an integer or a default_arg placeholder
822 */
823 BufferLengthOp->Asl.ParseOpcode = PARSEOP_INTEGER;
824 BufferLengthOp->Asl.AmlOpcode = AML_DWORD_OP;
825 BufferLengthOp->Asl.Value.Integer = BufferLength;
826
827 (void) OpcSetOptimalIntegerSize (BufferLengthOp);
828 UtSetParseOpName (BufferLengthOp);
829
830 /* Remaining nodes are handled via the tree walk */
831 }
832
833
834 /*******************************************************************************
835 *
836 * FUNCTION: OpnDoPackage
837 *
838 * PARAMETERS: Op - The parent parse node
839 *
840 * RETURN: None
841 *
842 * DESCRIPTION: Construct the AML operands for the PACKAGE ASL keyword. NOTE:
843 * can only be called after constants have been folded, to ensure
844 * that the PackageLength operand has been fully reduced.
845 *
846 ******************************************************************************/
847
848 void
OpnDoPackage(ACPI_PARSE_OBJECT * Op)849 OpnDoPackage (
850 ACPI_PARSE_OBJECT *Op)
851 {
852 ACPI_PARSE_OBJECT *InitializerOp;
853 ACPI_PARSE_OBJECT *PackageLengthOp;
854 UINT32 PackageLength = 0;
855
856
857 /* Opcode and package length first, followed by the initializer list */
858
859 PackageLengthOp = Op->Asl.Child;
860 InitializerOp = PackageLengthOp->Asl.Next;
861
862 /* Count the number of items in the initializer list */
863
864 if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
865 {
866 /* The peer list contains the byte list (if any...) */
867
868 while (InitializerOp)
869 {
870 PackageLength++;
871 InitializerOp = InitializerOp->Asl.Next;
872 }
873 }
874
875 /* If package length is a constant, compare to the initializer list */
876
877 if ((PackageLengthOp->Asl.ParseOpcode == PARSEOP_INTEGER) ||
878 (PackageLengthOp->Asl.ParseOpcode == PARSEOP_QWORDCONST))
879 {
880 if (PackageLengthOp->Asl.Value.Integer > PackageLength)
881 {
882 /*
883 * Allow package length to be longer than the initializer
884 * list -- but if the length of initializer list is nonzero,
885 * issue a message since this is probably a coding error,
886 * even though technically legal.
887 */
888 if (PackageLength > 0)
889 {
890 AslError (ASL_REMARK, ASL_MSG_LIST_LENGTH_SHORT,
891 PackageLengthOp, NULL);
892 }
893
894 PackageLength = (UINT32) PackageLengthOp->Asl.Value.Integer;
895 }
896 else if (PackageLengthOp->Asl.Value.Integer < PackageLength)
897 {
898 /*
899 * The package length is smaller than the length of the
900 * initializer list. This is an error as per the ACPI spec.
901 */
902 AslError (ASL_ERROR, ASL_MSG_LIST_LENGTH_LONG,
903 PackageLengthOp, NULL);
904 }
905 }
906
907 if (PackageLengthOp->Asl.ParseOpcode == PARSEOP_DEFAULT_ARG)
908 {
909 /*
910 * This is the case if the PackageLength was left empty - Package()
911 * The package length becomes the length of the initializer list
912 */
913 Op->Asl.Child->Asl.ParseOpcode = PARSEOP_INTEGER;
914 Op->Asl.Child->Asl.Value.Integer = PackageLength;
915 UtSetParseOpName (Op);
916
917 /* Set the AML opcode */
918
919 (void) OpcSetOptimalIntegerSize (Op->Asl.Child);
920 }
921
922 /* If not a variable-length package, check for a zero package length */
923
924 if ((PackageLengthOp->Asl.ParseOpcode == PARSEOP_INTEGER) ||
925 (PackageLengthOp->Asl.ParseOpcode == PARSEOP_QWORDCONST) ||
926 (PackageLengthOp->Asl.ParseOpcode == PARSEOP_ZERO) ||
927 (PackageLengthOp->Asl.ParseOpcode == PARSEOP_DEFAULT_ARG))
928 {
929 if (!PackageLength)
930 {
931 /* No length AND no initializer list -- issue a remark */
932
933 AslError (ASL_REMARK, ASL_MSG_PACKAGE_LENGTH,
934 PackageLengthOp, NULL);
935
936 /* But go ahead and put the buffer length of zero into the AML */
937 }
938 }
939
940 /*
941 * If the PackageLength is a constant <= 255, we can change the
942 * AML opcode from VarPackage to a simple (ACPI 1.0) Package opcode.
943 */
944 if (((Op->Asl.Child->Asl.ParseOpcode == PARSEOP_INTEGER) &&
945 (Op->Asl.Child->Asl.Value.Integer <= 255)) ||
946 (Op->Asl.Child->Asl.ParseOpcode == PARSEOP_ONE) ||
947 (Op->Asl.Child->Asl.ParseOpcode == PARSEOP_ONES)||
948 (Op->Asl.Child->Asl.ParseOpcode == PARSEOP_ZERO))
949 {
950 Op->Asl.AmlOpcode = AML_PACKAGE_OP;
951 Op->Asl.ParseOpcode = PARSEOP_PACKAGE;
952
953 /*
954 * Just set the package size node to be the package length, regardless
955 * of whether it was previously an integer or a default_arg placeholder
956 */
957 PackageLengthOp->Asl.AmlOpcode = AML_RAW_DATA_BYTE;
958 PackageLengthOp->Asl.AmlLength = 1;
959 PackageLengthOp->Asl.ParseOpcode = PARSEOP_RAW_DATA;
960 PackageLengthOp->Asl.Value.Integer = PackageLength;
961 }
962
963 /* Remaining nodes are handled via the tree walk */
964 }
965
966
967 /*******************************************************************************
968 *
969 * FUNCTION: OpnDoLoadTable
970 *
971 * PARAMETERS: Op - The parent parse node
972 *
973 * RETURN: None
974 *
975 * DESCRIPTION: Construct the AML operands for the LOADTABLE ASL keyword.
976 *
977 ******************************************************************************/
978
979 static void
OpnDoLoadTable(ACPI_PARSE_OBJECT * Op)980 OpnDoLoadTable (
981 ACPI_PARSE_OBJECT *Op)
982 {
983 ACPI_PARSE_OBJECT *Next;
984
985
986 /* Opcode is parent node */
987 /* First child is the table signature */
988
989 Next = Op->Asl.Child;
990
991 /* Second child is the OEM ID*/
992
993 Next = Next->Asl.Next;
994
995 /* Third child is the OEM table ID */
996
997 Next = Next->Asl.Next;
998
999 /* Fourth child is the RootPath string */
1000
1001 Next = Next->Asl.Next;
1002 if (Next->Asl.ParseOpcode == PARSEOP_ZERO)
1003 {
1004 Next->Asl.ParseOpcode = PARSEOP_STRING_LITERAL;
1005 Next->Asl.Value.String = "\\";
1006 Next->Asl.AmlLength = 2;
1007 OpcGenerateAmlOpcode (Next);
1008 }
1009
1010 #ifdef ASL_FUTURE_IMPLEMENTATION
1011
1012 /* TBD: NOT IMPLEMENTED */
1013 /* Fifth child is the [optional] ParameterPathString */
1014 /* Sixth child is the [optional] ParameterData */
1015
1016 Next = Next->Asl.Next;
1017 if (Next->Asl.ParseOpcode == DEFAULT_ARG)
1018 {
1019 Next->Asl.AmlLength = 1;
1020 Next->Asl.ParseOpcode = ZERO;
1021 OpcGenerateAmlOpcode (Next);
1022 }
1023
1024
1025 Next = Next->Asl.Next;
1026 if (Next->Asl.ParseOpcode == DEFAULT_ARG)
1027 {
1028 Next->Asl.AmlLength = 1;
1029 Next->Asl.ParseOpcode = ZERO;
1030 OpcGenerateAmlOpcode (Next);
1031 }
1032 #endif
1033 }
1034
1035
1036 /*******************************************************************************
1037 *
1038 * FUNCTION: OpnDoDefinitionBlock
1039 *
1040 * PARAMETERS: Op - The parent parse node
1041 *
1042 * RETURN: None
1043 *
1044 * DESCRIPTION: Construct the AML operands for the DEFINITIONBLOCK ASL keyword
1045 *
1046 ******************************************************************************/
1047
1048 static void
OpnDoDefinitionBlock(ACPI_PARSE_OBJECT * Op)1049 OpnDoDefinitionBlock (
1050 ACPI_PARSE_OBJECT *Op)
1051 {
1052 ACPI_PARSE_OBJECT *Child;
1053 ACPI_SIZE Length;
1054 UINT32 i;
1055 char *Filename;
1056 ACPI_STATUS Status;
1057
1058
1059 /*
1060 * These nodes get stuffed into the table header. They are special
1061 * cased when the table is written to the output file.
1062 *
1063 * Mark all of these nodes as non-usable so they won't get output
1064 * as AML opcodes!
1065 */
1066
1067 /* Get AML filename. Use it if non-null */
1068
1069 Child = Op->Asl.Child;
1070 if (Child->Asl.Value.Buffer &&
1071 *Child->Asl.Value.Buffer &&
1072 (AslGbl_UseDefaultAmlFilename))
1073 {
1074 /*
1075 * The walk may traverse multiple definition blocks. Switch files
1076 * to ensure that the correct files are manipulated.
1077 */
1078 FlSwitchFileSet (Op->Asl.Filename);
1079
1080 /*
1081 * We will use the AML filename that is embedded in the source file
1082 * for the output filename.
1083 */
1084 Filename = UtLocalCacheCalloc (strlen (AslGbl_DirectoryPath) +
1085 strlen ((char *) Child->Asl.Value.Buffer) + 1);
1086
1087 /* Prepend the current directory path */
1088
1089 strcpy (Filename, AslGbl_DirectoryPath);
1090 strcat (Filename, (char *) Child->Asl.Value.Buffer);
1091
1092 AslGbl_OutputFilenamePrefix = Filename;
1093 UtConvertBackslashes (AslGbl_OutputFilenamePrefix);
1094
1095 /*
1096 * Use the definition block file parameter instead of the input
1097 * filename. Since all files were opened previously, remove the
1098 * existing file and open a new file with the name of this
1099 * definition block parameter. Since AML code generation has yet
1100 * to happen, the previous file can be removed without any impacts.
1101 */
1102 FlCloseFile (ASL_FILE_AML_OUTPUT);
1103 FlDeleteFile (ASL_FILE_AML_OUTPUT);
1104 Status = FlOpenAmlOutputFile (AslGbl_OutputFilenamePrefix);
1105 if (ACPI_FAILURE (Status))
1106 {
1107 AslError (ASL_ERROR, ASL_MSG_OUTPUT_FILE_OPEN, NULL, NULL);
1108 return;
1109 }
1110 }
1111
1112 Child->Asl.ParseOpcode = PARSEOP_DEFAULT_ARG;
1113
1114 /* Signature */
1115
1116 Child = Child->Asl.Next;
1117 Child->Asl.ParseOpcode = PARSEOP_DEFAULT_ARG;
1118 if (Child->Asl.Value.String)
1119 {
1120 AslGbl_FilesList->TableSignature = Child->Asl.Value.String;
1121 AslGbl_TableSignature = Child->Asl.Value.String;
1122 if (strlen (AslGbl_TableSignature) != ACPI_NAMESEG_SIZE)
1123 {
1124 AslError (ASL_ERROR, ASL_MSG_TABLE_SIGNATURE, Child,
1125 "Length must be exactly 4 characters");
1126 }
1127
1128 for (i = 0; i < ACPI_NAMESEG_SIZE; i++)
1129 {
1130 if (!isalnum ((int) AslGbl_TableSignature[i]))
1131 {
1132 AslError (ASL_ERROR, ASL_MSG_TABLE_SIGNATURE, Child,
1133 "Contains non-alphanumeric characters");
1134 }
1135 }
1136 }
1137
1138 /* Revision */
1139
1140 Child = Child->Asl.Next;
1141 Child->Asl.ParseOpcode = PARSEOP_DEFAULT_ARG;
1142
1143 /*
1144 * We used the revision to set the integer width earlier
1145 */
1146
1147 /* OEMID */
1148
1149 Child = Child->Asl.Next;
1150 Child->Asl.ParseOpcode = PARSEOP_DEFAULT_ARG;
1151 if (Child->Asl.Value.String &&
1152 strlen (Child->Asl.Value.String) > ACPI_OEM_ID_SIZE)
1153 {
1154 AslError (ASL_ERROR, ASL_MSG_OEM_ID, Child,
1155 "Length cannot exceed 6 characters");
1156 }
1157
1158 /* OEM TableID */
1159
1160 Child = Child->Asl.Next;
1161 Child->Asl.ParseOpcode = PARSEOP_DEFAULT_ARG;
1162 if (Child->Asl.Value.String)
1163 {
1164 Length = strlen (Child->Asl.Value.String);
1165 if (Length > ACPI_OEM_TABLE_ID_SIZE)
1166 {
1167 AslError (ASL_ERROR, ASL_MSG_OEM_TABLE_ID, Child,
1168 "Length cannot exceed 8 characters");
1169 }
1170
1171 AslGbl_TableId = UtLocalCacheCalloc (Length + 1);
1172 strcpy (AslGbl_TableId, Child->Asl.Value.String);
1173 AslGbl_FilesList->TableId = AslGbl_TableId;
1174
1175 /*
1176 * Convert anything non-alphanumeric to an underscore. This
1177 * allows us to use the TableID to generate unique C symbols.
1178 */
1179 for (i = 0; i < Length; i++)
1180 {
1181 if (!isalnum ((int) AslGbl_TableId[i]))
1182 {
1183 AslGbl_TableId[i] = '_';
1184 }
1185 }
1186 }
1187
1188 /* OEM Revision */
1189
1190 Child = Child->Asl.Next;
1191 Child->Asl.ParseOpcode = PARSEOP_DEFAULT_ARG;
1192 }
1193
1194
1195 /*******************************************************************************
1196 *
1197 * FUNCTION: UtGetArg
1198 *
1199 * PARAMETERS: Op - Get an argument for this op
1200 * Argn - Nth argument to get
1201 *
1202 * RETURN: The argument (as an Op object). NULL if argument does not exist
1203 *
1204 * DESCRIPTION: Get the specified op's argument (peer)
1205 *
1206 ******************************************************************************/
1207
1208 ACPI_PARSE_OBJECT *
UtGetArg(ACPI_PARSE_OBJECT * Op,UINT32 Argn)1209 UtGetArg (
1210 ACPI_PARSE_OBJECT *Op,
1211 UINT32 Argn)
1212 {
1213 ACPI_PARSE_OBJECT *Arg = NULL;
1214
1215
1216 /* Get the requested argument object */
1217
1218 Arg = Op->Asl.Child;
1219 while (Arg && Argn)
1220 {
1221 Argn--;
1222 Arg = Arg->Asl.Next;
1223 }
1224
1225 return (Arg);
1226 }
1227
1228
1229 /*******************************************************************************
1230 *
1231 * FUNCTION: OpnAttachNameToNode
1232 *
1233 * PARAMETERS: Op - The parent parse node
1234 *
1235 * RETURN: None
1236 *
1237 * DESCRIPTION: For the named ASL/AML operators, get the actual name from the
1238 * argument list and attach it to the parent node so that we
1239 * can get to it quickly later.
1240 *
1241 ******************************************************************************/
1242
1243 static void
OpnAttachNameToNode(ACPI_PARSE_OBJECT * Op)1244 OpnAttachNameToNode (
1245 ACPI_PARSE_OBJECT *Op)
1246 {
1247 ACPI_PARSE_OBJECT *Child = NULL;
1248
1249
1250 switch (Op->Asl.AmlOpcode)
1251 {
1252 case AML_DATA_REGION_OP:
1253 case AML_DEVICE_OP:
1254 case AML_EVENT_OP:
1255 case AML_EXTERNAL_OP:
1256 case AML_METHOD_OP:
1257 case AML_MUTEX_OP:
1258 case AML_REGION_OP:
1259 case AML_POWER_RESOURCE_OP:
1260 case AML_PROCESSOR_OP:
1261 case AML_THERMAL_ZONE_OP:
1262 case AML_NAME_OP:
1263 case AML_SCOPE_OP:
1264
1265 Child = UtGetArg (Op, 0);
1266 break;
1267
1268 case AML_ALIAS_OP:
1269
1270 Child = UtGetArg (Op, 1);
1271 break;
1272
1273 case AML_CREATE_BIT_FIELD_OP:
1274 case AML_CREATE_BYTE_FIELD_OP:
1275 case AML_CREATE_WORD_FIELD_OP:
1276 case AML_CREATE_DWORD_FIELD_OP:
1277 case AML_CREATE_QWORD_FIELD_OP:
1278
1279 Child = UtGetArg (Op, 2);
1280 break;
1281
1282 case AML_CREATE_FIELD_OP:
1283
1284 Child = UtGetArg (Op, 3);
1285 break;
1286
1287 case AML_BANK_FIELD_OP:
1288 case AML_INDEX_FIELD_OP:
1289 case AML_FIELD_OP:
1290
1291 return;
1292
1293 default:
1294
1295 return;
1296 }
1297
1298 if (Child)
1299 {
1300 UtAttachNamepathToOwner (Op, Child);
1301 }
1302 }
1303
1304
1305 /*******************************************************************************
1306 *
1307 * FUNCTION: OpnGenerateAmlOperands
1308 *
1309 * PARAMETERS: Op - The parent parse node
1310 *
1311 * RETURN: None
1312 *
1313 * DESCRIPTION: Prepare nodes to be output as AML data and operands. The more
1314 * complex AML opcodes require processing of the child nodes
1315 * (arguments/operands).
1316 *
1317 ******************************************************************************/
1318
1319 void
OpnGenerateAmlOperands(ACPI_PARSE_OBJECT * Op)1320 OpnGenerateAmlOperands (
1321 ACPI_PARSE_OBJECT *Op)
1322 {
1323
1324
1325 if (Op->Asl.AmlOpcode == AML_RAW_DATA_BYTE)
1326 {
1327 return;
1328 }
1329
1330 switch (Op->Asl.ParseOpcode)
1331 {
1332 case PARSEOP_DEFINITION_BLOCK:
1333
1334 OpnDoDefinitionBlock (Op);
1335 break;
1336
1337 case PARSEOP_METHOD:
1338
1339 OpnDoMethod (Op);
1340 break;
1341
1342 case PARSEOP_MUTEX:
1343
1344 OpnDoMutex (Op);
1345 break;
1346
1347 case PARSEOP_FIELD:
1348
1349 OpnDoField (Op);
1350 break;
1351
1352 case PARSEOP_INDEXFIELD:
1353
1354 OpnDoIndexField (Op);
1355 break;
1356
1357 case PARSEOP_BANKFIELD:
1358
1359 OpnDoBankField (Op);
1360 break;
1361
1362 case PARSEOP_BUFFER:
1363
1364 OpnDoBuffer (Op);
1365 break;
1366
1367 case PARSEOP_LOADTABLE:
1368
1369 OpnDoLoadTable (Op);
1370 break;
1371
1372 case PARSEOP_OPERATIONREGION:
1373
1374 OpnDoRegion (Op);
1375 break;
1376
1377 case PARSEOP_RESOURCETEMPLATE:
1378
1379 RsDoResourceTemplate (Op);
1380 break;
1381
1382 case PARSEOP_NAMESEG:
1383 case PARSEOP_NAMESTRING:
1384 case PARSEOP_METHODCALL:
1385 case PARSEOP_STRING_LITERAL:
1386 default:
1387
1388 break;
1389 }
1390
1391 /* TBD: move */
1392
1393 OpnAttachNameToNode (Op);
1394 }
1395