1/******************************************************************************
2 *
3 * Module Name: aslcodegen - AML code generation
4 *
5 *****************************************************************************/
6
7/******************************************************************************
8 *
9 * 1. Copyright Notice
10 *
11 * Some or all of this work - Copyright (c) 1999 - 2017, 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#include <contrib/dev/acpica/include/acconvert.h>
156
157#define _COMPONENT          ACPI_COMPILER
158        ACPI_MODULE_NAME    ("aslcodegen")
159
160/* Local prototypes */
161
162static ACPI_STATUS
163CgAmlWriteWalk (
164    ACPI_PARSE_OBJECT       *Op,
165    UINT32                  Level,
166    void                    *Context);
167
168static void
169CgWriteAmlOpcode (
170    ACPI_PARSE_OBJECT       *Op);
171
172static void
173CgWriteTableHeader (
174    ACPI_PARSE_OBJECT       *Op);
175
176static void
177CgCloseTable (
178    void);
179
180static void
181CgWriteNode (
182    ACPI_PARSE_OBJECT       *Op);
183
184
185/*******************************************************************************
186 *
187 * FUNCTION:    CgGenerateAmlOutput
188 *
189 * PARAMETERS:  None.
190 *
191 * RETURN:      None
192 *
193 * DESCRIPTION: Generate AML code. Currently generates the listing file
194 *              simultaneously.
195 *
196 ******************************************************************************/
197
198void
199CgGenerateAmlOutput (
200    void)
201{
202
203    /* Generate the AML output file */
204
205    FlSeekFile (ASL_FILE_SOURCE_OUTPUT, 0);
206    Gbl_SourceLine = 0;
207    Gbl_NextError = Gbl_ErrorLog;
208
209    TrWalkParseTree (Gbl_ParseTreeRoot, ASL_WALK_VISIT_DOWNWARD,
210        CgAmlWriteWalk, NULL, NULL);
211
212    DbgPrint (ASL_TREE_OUTPUT, ASL_PARSE_TREE_HEADER2);
213    CgCloseTable ();
214}
215
216
217/*******************************************************************************
218 *
219 * FUNCTION:    CgAmlWriteWalk
220 *
221 * PARAMETERS:  ASL_WALK_CALLBACK
222 *
223 * RETURN:      Status
224 *
225 * DESCRIPTION: Parse tree walk to generate the AML code.
226 *
227 ******************************************************************************/
228
229static ACPI_STATUS
230CgAmlWriteWalk (
231    ACPI_PARSE_OBJECT       *Op,
232    UINT32                  Level,
233    void                    *Context)
234{
235
236    /* Generate the AML for this node */
237
238    CgWriteNode (Op);
239
240    if (!Gbl_DebugFlag)
241    {
242        return (AE_OK);
243    }
244
245    /* Print header at level 0. Alignment assumes 32-bit pointers */
246
247    if (!Level)
248    {
249        DbgPrint (ASL_TREE_OUTPUT,
250            "\nFinal parse tree used for AML output:\n");
251        DbgPrint (ASL_TREE_OUTPUT, ASL_PARSE_TREE_HEADER2);
252    }
253
254    /* Dump ParseOp name and possible value */
255
256    switch (Op->Asl.ParseOpcode)
257    {
258    case PARSEOP_NAMESEG:
259    case PARSEOP_NAMESTRING:
260    case PARSEOP_METHODCALL:
261    case PARSEOP_STRING_LITERAL:
262
263        UtDumpStringOp (Op, Level);
264        break;
265
266    default:
267
268        UtDumpBasicOp (Op, Level);
269        break;
270    }
271
272    DbgPrint (ASL_TREE_OUTPUT, ASL_PARSE_TREE_DEBUG2,
273        /* 1  */ (UINT32) Op->Asl.Value.Integer,
274        /* 2  */ Op->Asl.ParseOpcode,
275        /* 3  */ Op->Asl.AmlOpcode,
276        /* 4  */ Op->Asl.AmlOpcodeLength,
277        /* 5  */ Op->Asl.AmlPkgLenBytes,
278        /* 6  */ Op->Asl.AmlLength,
279        /* 7  */ Op->Asl.AmlSubtreeLength,
280        /* 8  */ Op->Asl.Parent ? Op->Asl.Parent->Asl.AmlSubtreeLength : 0,
281        /* 9  */ Op,
282        /* 10 */ Op->Asl.Parent,
283        /* 11 */ Op->Asl.Child,
284        /* 12 */ Op->Asl.Next,
285        /* 13 */ Op->Asl.CompileFlags,
286        /* 14 */ Op->Asl.AcpiBtype,
287        /* 15 */ Op->Asl.FinalAmlLength,
288        /* 16 */ Op->Asl.Column,
289        /* 17 */ Op->Asl.LineNumber,
290        /* 18 */ Op->Asl.EndLine,
291        /* 19 */ Op->Asl.LogicalLineNumber,
292        /* 20 */ Op->Asl.EndLogicalLine);
293
294    TrPrintOpFlags (Op->Asl.CompileFlags, ASL_TREE_OUTPUT);
295    DbgPrint (ASL_TREE_OUTPUT, "\n");
296    return (AE_OK);
297}
298
299
300/*******************************************************************************
301 *
302 * FUNCTION:    CgLocalWriteAmlData
303 *
304 * PARAMETERS:  Op              - Current parse op
305 *              Buffer          - Buffer to write
306 *              Length          - Size of data in buffer
307 *
308 * RETURN:      None
309 *
310 * DESCRIPTION: Write a buffer of AML data to the AML output file.
311 *
312 ******************************************************************************/
313
314void
315CgLocalWriteAmlData (
316    ACPI_PARSE_OBJECT       *Op,
317    void                    *Buffer,
318    UINT32                  Length)
319{
320
321    /* Write the raw data to the AML file */
322
323    FlWriteFile (ASL_FILE_AML_OUTPUT, Buffer, Length);
324
325    /* Update the final AML length for this node (used for listings) */
326
327    if (Op)
328    {
329        Op->Asl.FinalAmlLength += Length;
330    }
331}
332
333
334/*******************************************************************************
335 *
336 * FUNCTION:    CgWriteAmlOpcode
337 *
338 * PARAMETERS:  Op            - Parse node with an AML opcode
339 *
340 * RETURN:      None.
341 *
342 * DESCRIPTION: Write the AML opcode corresponding to a parse node.
343 *
344 ******************************************************************************/
345
346static void
347CgWriteAmlOpcode (
348    ACPI_PARSE_OBJECT       *Op)
349{
350    UINT8                   PkgLenFirstByte;
351    UINT32                  i;
352    union {
353        UINT16                  Opcode;
354        UINT8                   OpcodeBytes[2];
355    } Aml;
356    union {
357        UINT32                  Len;
358        UINT8                   LenBytes[4];
359    } PkgLen;
360
361
362    /* We expect some DEFAULT_ARGs, just ignore them */
363
364    if (Op->Asl.ParseOpcode == PARSEOP_DEFAULT_ARG)
365    {
366        return;
367    }
368
369    /*
370     * Before printing the bytecode, generate comment byte codes
371     * associated with this node.
372     */
373    if (AcpiGbl_CaptureComments)
374    {
375        CgWriteAmlComment(Op);
376    }
377
378    switch (Op->Asl.AmlOpcode)
379    {
380    case AML_UNASSIGNED_OPCODE:
381
382        /* These opcodes should not get here */
383
384        printf ("Found a node with an unassigned AML opcode\n");
385        FlPrintFile (ASL_FILE_STDERR,
386            "Found a node with an unassigned AML opcode\n");
387        return;
388
389    case AML_INT_RESERVEDFIELD_OP:
390
391        /* Special opcodes for within a field definition */
392
393        Aml.Opcode = AML_FIELD_OFFSET_OP;
394        break;
395
396    case AML_INT_ACCESSFIELD_OP:
397
398        Aml.Opcode = AML_FIELD_ACCESS_OP;
399        break;
400
401    case AML_INT_CONNECTION_OP:
402
403        Aml.Opcode = AML_FIELD_CONNECTION_OP;
404        break;
405
406    default:
407
408        Aml.Opcode = Op->Asl.AmlOpcode;
409        break;
410    }
411
412
413    switch (Aml.Opcode)
414    {
415    case AML_PACKAGE_LENGTH:
416
417        /* Value is the length to be encoded (Used in field definitions) */
418
419        PkgLen.Len = (UINT32) Op->Asl.Value.Integer;
420        break;
421
422    default:
423
424        /* Check for two-byte opcode */
425
426        if (Aml.Opcode > 0x00FF)
427        {
428            /* Write the high byte first */
429
430            CgLocalWriteAmlData (Op, &Aml.OpcodeBytes[1], 1);
431        }
432
433        CgLocalWriteAmlData (Op, &Aml.OpcodeBytes[0], 1);
434
435        /* Subtreelength doesn't include length of package length bytes */
436
437        PkgLen.Len = Op->Asl.AmlSubtreeLength + Op->Asl.AmlPkgLenBytes;
438        break;
439    }
440
441    /* Does this opcode have an associated "PackageLength" field? */
442
443    if (Op->Asl.CompileFlags & OP_AML_PACKAGE)
444    {
445        if (Op->Asl.AmlPkgLenBytes == 1)
446        {
447            /* Simplest case -- no bytes to follow, just write the count */
448
449            CgLocalWriteAmlData (Op, &PkgLen.LenBytes[0], 1);
450        }
451        else if (Op->Asl.AmlPkgLenBytes != 0)
452        {
453            /*
454             * Encode the "bytes to follow" in the first byte, top two bits.
455             * The low-order nybble of the length is in the bottom 4 bits
456             */
457            PkgLenFirstByte = (UINT8)
458                (((UINT32) (Op->Asl.AmlPkgLenBytes - 1) << 6) |
459                (PkgLen.LenBytes[0] & 0x0F));
460
461            CgLocalWriteAmlData (Op, &PkgLenFirstByte, 1);
462
463            /*
464             * Shift the length over by the 4 bits we just stuffed
465             * in the first byte
466             */
467            PkgLen.Len >>= 4;
468
469            /*
470             * Now we can write the remaining bytes -
471             * either 1, 2, or 3 bytes
472             */
473            for (i = 0; i < (UINT32) (Op->Asl.AmlPkgLenBytes - 1); i++)
474            {
475                CgLocalWriteAmlData (Op, &PkgLen.LenBytes[i], 1);
476            }
477        }
478    }
479
480    switch (Aml.Opcode)
481    {
482    case AML_BYTE_OP:
483
484        CgLocalWriteAmlData (Op, &Op->Asl.Value.Integer, 1);
485        break;
486
487    case AML_WORD_OP:
488
489        CgLocalWriteAmlData (Op, &Op->Asl.Value.Integer, 2);
490       break;
491
492    case AML_DWORD_OP:
493
494        CgLocalWriteAmlData (Op, &Op->Asl.Value.Integer, 4);
495        break;
496
497    case AML_QWORD_OP:
498
499        CgLocalWriteAmlData (Op, &Op->Asl.Value.Integer, 8);
500        break;
501
502    case AML_STRING_OP:
503
504        CgLocalWriteAmlData (Op, Op->Asl.Value.String, Op->Asl.AmlLength);
505        break;
506
507    default:
508
509        /* All data opcodes must appear above */
510
511        break;
512    }
513}
514
515
516/*******************************************************************************
517 *
518 * FUNCTION:    CgWriteTableHeader
519 *
520 * PARAMETERS:  Op        - The DEFINITIONBLOCK node
521 *
522 * RETURN:      None
523 *
524 * DESCRIPTION: Write a table header corresponding to the DEFINITIONBLOCK
525 *
526 ******************************************************************************/
527
528static void
529CgWriteTableHeader (
530    ACPI_PARSE_OBJECT       *Op)
531{
532    ACPI_PARSE_OBJECT       *Child;
533    UINT32                  CommentLength;
534    ACPI_COMMENT_NODE       *Current;
535
536
537    /* AML filename */
538
539    Child = Op->Asl.Child;
540
541    /* Signature */
542
543    Child = Child->Asl.Next;
544
545    /*
546     * For ASL-/ASL+ converter: replace the table signature with
547     * "XXXX" and save the original table signature. This results in an AML
548     * file with the signature "XXXX". The converter should remove this AML
549     * file. In the event where this AML file does not get deleted, the
550     * "XXXX" table signature prevents this AML file from running on the AML
551     * interpreter.
552     */
553    if (AcpiGbl_CaptureComments)
554    {
555        strncpy(AcpiGbl_TableSig, Child->Asl.Value.String, ACPI_NAME_SIZE);
556        Child->Asl.Value.String = ACPI_SIG_XXXX;
557    }
558
559    strncpy (TableHeader.Signature, Child->Asl.Value.String, ACPI_NAME_SIZE);
560
561    /* Revision */
562
563    Child = Child->Asl.Next;
564    TableHeader.Revision = (UINT8) Child->Asl.Value.Integer;
565
566    /* Command-line Revision override */
567
568    if (Gbl_RevisionOverride)
569    {
570        TableHeader.Revision = Gbl_RevisionOverride;
571    }
572
573    /* OEMID */
574
575    Child = Child->Asl.Next;
576    strncpy (TableHeader.OemId, Child->Asl.Value.String, ACPI_OEM_ID_SIZE);
577
578    /* OEM TableID */
579
580    Child = Child->Asl.Next;
581    strncpy (TableHeader.OemTableId, Child->Asl.Value.String, ACPI_OEM_TABLE_ID_SIZE);
582
583    /* OEM Revision */
584
585    Child = Child->Asl.Next;
586    TableHeader.OemRevision = (UINT32) Child->Asl.Value.Integer;
587
588    /* Compiler ID */
589
590    ACPI_MOVE_NAME (TableHeader.AslCompilerId, ASL_CREATOR_ID);
591
592    /* Compiler version */
593
594    TableHeader.AslCompilerRevision = ACPI_CA_VERSION;
595
596    /* Table length. Checksum zero for now, will rewrite later */
597
598    TableHeader.Length = sizeof (ACPI_TABLE_HEADER) +
599        Op->Asl.AmlSubtreeLength;
600
601    /* Calculate the comment lengths for this definition block parseOp */
602
603    if (AcpiGbl_CaptureComments)
604    {
605        CvDbgPrint ("Calculating comment lengths for %s in write header\n",
606            Op->Asl.ParseOpName);
607
608        /*
609         * Take the filename without extensions, add 3 for the new extension
610         * and another 3 for the a908 bytecode and null terminator.
611         */
612        TableHeader.Length += strrchr (Gbl_ParseTreeRoot->Asl.Filename, '.')
613            - Gbl_ParseTreeRoot->Asl.Filename + 1 + 3 + 3;
614        Op->Asl.AmlSubtreeLength +=
615            strlen (Gbl_ParseTreeRoot->Asl.Filename) + 3;
616    CvDbgPrint ("     Length: %lu\n",
617            strlen (Gbl_ParseTreeRoot->Asl.Filename) + 3);
618
619        if (Op->Asl.CommentList)
620        {
621            Current = Op->Asl.CommentList;
622            while (Current)
623            {
624                CommentLength = strlen (Current->Comment)+3;
625                CvDbgPrint ("Length of standard comment): %d\n", CommentLength);
626                CvDbgPrint ("    Comment string: %s\n\n", Current->Comment);
627                TableHeader.Length += CommentLength;
628                Op->Asl.AmlSubtreeLength += CommentLength;
629                Current = Current->Next;
630            CvDbgPrint ("    Length: %u\n", CommentLength);
631            }
632        }
633        if (Op->Asl.CloseBraceComment)
634        {
635            CommentLength = strlen (Op->Asl.CloseBraceComment)+3;
636            CvDbgPrint ("Length of inline comment +3: %d\n", CommentLength);
637            CvDbgPrint ("    Comment string: %s\n\n", Op->Asl.CloseBraceComment);
638            TableHeader.Length += CommentLength;
639            Op->Asl.AmlSubtreeLength += CommentLength;
640        CvDbgPrint ("    Length: %u\n", CommentLength);
641        }
642    }
643
644    TableHeader.Checksum = 0;
645
646    Op->Asl.FinalAmlOffset = ftell (Gbl_Files[ASL_FILE_AML_OUTPUT].Handle);
647
648    /* Write entire header and clear the table header global */
649
650    CgLocalWriteAmlData (Op, &TableHeader, sizeof (ACPI_TABLE_HEADER));
651    memset (&TableHeader, 0, sizeof (ACPI_TABLE_HEADER));
652}
653
654
655/*******************************************************************************
656 *
657 * FUNCTION:    CgUpdateHeader
658 *
659 * PARAMETERS:  Op                  - Op for the Definition Block
660 *
661 * RETURN:      None.
662 *
663 * DESCRIPTION: Complete the ACPI table by calculating the checksum and
664 *              re-writing the header for the input definition block
665 *
666 ******************************************************************************/
667
668static void
669CgUpdateHeader (
670    ACPI_PARSE_OBJECT       *Op)
671{
672    signed char             Sum;
673    UINT32                  i;
674    UINT32                  Length;
675    UINT8                   FileByte;
676    UINT8                   Checksum;
677
678
679    /* Calculate the checksum over the entire definition block */
680
681    Sum = 0;
682    Length = sizeof (ACPI_TABLE_HEADER) + Op->Asl.AmlSubtreeLength;
683    FlSeekFile (ASL_FILE_AML_OUTPUT, Op->Asl.FinalAmlOffset);
684
685    for (i = 0; i < Length; i++)
686    {
687        if (FlReadFile (ASL_FILE_AML_OUTPUT, &FileByte, 1) != AE_OK)
688        {
689            printf ("EOF while reading checksum bytes\n");
690            return;
691        }
692
693        Sum = (signed char) (Sum + FileByte);
694    }
695
696    Checksum = (UINT8) (0 - Sum);
697
698    /* Re-write the the checksum byte */
699
700    FlSeekFile (ASL_FILE_AML_OUTPUT, Op->Asl.FinalAmlOffset +
701        ACPI_OFFSET (ACPI_TABLE_HEADER, Checksum));
702
703    FlWriteFile (ASL_FILE_AML_OUTPUT, &Checksum, 1);
704}
705
706
707/*******************************************************************************
708 *
709 * FUNCTION:    CgCloseTable
710 *
711 * PARAMETERS:  None.
712 *
713 * RETURN:      None.
714 *
715 * DESCRIPTION: Complete the ACPI table by calculating the checksum and
716 *              re-writing each table header. This allows support for
717 *              multiple definition blocks in a single source file.
718 *
719 ******************************************************************************/
720
721static void
722CgCloseTable (
723    void)
724{
725    ACPI_PARSE_OBJECT   *Op;
726
727
728    /* Process all definition blocks */
729
730    Op = Gbl_ParseTreeRoot->Asl.Child;
731    while (Op)
732    {
733        CgUpdateHeader (Op);
734        Op = Op->Asl.Next;
735    }
736}
737
738
739/*******************************************************************************
740 *
741 * FUNCTION:    CgWriteNode
742 *
743 * PARAMETERS:  Op            - Parse node to write.
744 *
745 * RETURN:      None.
746 *
747 * DESCRIPTION: Write the AML that corresponds to a parse node.
748 *
749 ******************************************************************************/
750
751static void
752CgWriteNode (
753    ACPI_PARSE_OBJECT       *Op)
754{
755    ASL_RESOURCE_NODE       *Rnode;
756
757
758    /* Write all comments here. */
759
760    if (AcpiGbl_CaptureComments)
761    {
762        CgWriteAmlComment(Op);
763    }
764
765    /* Always check for DEFAULT_ARG and other "Noop" nodes */
766    /* TBD: this may not be the best place for this check */
767
768    if ((Op->Asl.ParseOpcode == PARSEOP_DEFAULT_ARG)  ||
769        (Op->Asl.ParseOpcode == PARSEOP_INCLUDE)      ||
770        (Op->Asl.ParseOpcode == PARSEOP_INCLUDE_END))
771    {
772        return;
773    }
774
775    if ((Op->Asl.ParseOpcode == PARSEOP_EXTERNAL) &&
776        Gbl_DoExternals == FALSE)
777    {
778        return;
779    }
780
781    Op->Asl.FinalAmlLength = 0;
782
783    switch (Op->Asl.AmlOpcode)
784    {
785    case AML_RAW_DATA_BYTE:
786    case AML_RAW_DATA_WORD:
787    case AML_RAW_DATA_DWORD:
788    case AML_RAW_DATA_QWORD:
789
790        CgLocalWriteAmlData (Op, &Op->Asl.Value.Integer, Op->Asl.AmlLength);
791        return;
792
793
794    case AML_RAW_DATA_BUFFER:
795
796        CgLocalWriteAmlData (Op, Op->Asl.Value.Buffer, Op->Asl.AmlLength);
797        return;
798
799
800    case AML_RAW_DATA_CHAIN:
801
802        Rnode = ACPI_CAST_PTR (ASL_RESOURCE_NODE, Op->Asl.Value.Buffer);
803        while (Rnode)
804        {
805            CgLocalWriteAmlData (Op, Rnode->Buffer, Rnode->BufferLength);
806            Rnode = Rnode->Next;
807        }
808        return;
809
810    default:
811
812        /* Internal data opcodes must all appear above */
813
814        break;
815    }
816
817    switch (Op->Asl.ParseOpcode)
818    {
819    case PARSEOP_DEFAULT_ARG:
820
821        break;
822
823    case PARSEOP_DEFINITION_BLOCK:
824
825        CgWriteTableHeader (Op);
826        if (AcpiGbl_CaptureComments)
827        {
828            CgWriteAmlDefBlockComment (Op);
829        }
830        break;
831
832    case PARSEOP_NAMESEG:
833    case PARSEOP_NAMESTRING:
834    case PARSEOP_METHODCALL:
835
836        CgLocalWriteAmlData (Op, Op->Asl.Value.String, Op->Asl.AmlLength);
837        break;
838
839    default:
840
841        CgWriteAmlOpcode (Op);
842        break;
843    }
844}
845