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