1/******************************************************************************
2 *
3 * Module Name: dtcompile.c - Front-end for data table compiler
4 *
5 *****************************************************************************/
6
7/*
8 * Copyright (C) 2000 - 2011, Intel Corp.
9 * All rights reserved.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * 1. Redistributions of source code must retain the above copyright
15 *    notice, this list of conditions, and the following disclaimer,
16 *    without modification.
17 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
18 *    substantially similar to the "NO WARRANTY" disclaimer below
19 *    ("Disclaimer") and any redistribution must be conditioned upon
20 *    including a substantially similar Disclaimer requirement for further
21 *    binary redistribution.
22 * 3. Neither the names of the above-listed copyright holders nor the names
23 *    of any contributors may be used to endorse or promote products derived
24 *    from this software without specific prior written permission.
25 *
26 * Alternatively, this software may be distributed under the terms of the
27 * GNU General Public License ("GPL") version 2 as published by the Free
28 * Software Foundation.
29 *
30 * NO WARRANTY
31 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
32 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
33 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
34 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
35 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
36 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
37 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
38 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
39 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
40 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
41 * POSSIBILITY OF SUCH DAMAGES.
42 */
43
44#define __DTCOMPILE_C__
45#define _DECLARE_DT_GLOBALS
46
47#include <contrib/dev/acpica/compiler/aslcompiler.h>
48#include <contrib/dev/acpica/compiler/dtcompiler.h>
49
50#define _COMPONENT          DT_COMPILER
51        ACPI_MODULE_NAME    ("dtcompile")
52
53static char                 VersionString[9];
54
55
56/* Local prototypes */
57
58static ACPI_STATUS
59DtInitialize (
60    void);
61
62static ACPI_STATUS
63DtCompileDataTable (
64    DT_FIELD                **Field);
65
66static void
67DtInsertCompilerIds (
68    DT_FIELD                *FieldList);
69
70
71/******************************************************************************
72 *
73 * FUNCTION:    DtDoCompile
74 *
75 * PARAMETERS:  None
76 *
77 * RETURN:      Status
78 *
79 * DESCRIPTION: Main entry point for the data table compiler.
80 *
81 * Note: Assumes Gbl_Files[ASL_FILE_INPUT] is initialized and the file is
82 *          open at seek offset zero.
83 *
84 *****************************************************************************/
85
86ACPI_STATUS
87DtDoCompile (
88    void)
89{
90    ACPI_STATUS             Status;
91    UINT8                   Event;
92    DT_FIELD                *FieldList;
93
94
95    /* Initialize globals */
96
97    Status = DtInitialize ();
98    if (ACPI_FAILURE (Status))
99    {
100        printf ("Error during compiler initialization, 0x%X\n", Status);
101        return (Status);
102    }
103
104    /*
105     * Scan the input file (file is already open) and
106     * build the parse tree
107     */
108    Event = UtBeginEvent ("Scan and parse input file");
109    FieldList = DtScanFile (Gbl_Files[ASL_FILE_INPUT].Handle);
110    UtEndEvent (Event);
111
112    /* Did the parse tree get successfully constructed? */
113
114    if (!FieldList)
115    {
116        /* TBD: temporary error message. Msgs should come from function above */
117
118        DtError (ASL_ERROR, ASL_MSG_SYNTAX, NULL,
119            "Input file does not appear to be an ASL or data table source file");
120
121        Status = AE_ERROR;
122        goto CleanupAndExit;
123    }
124
125    Event = UtBeginEvent ("Compile parse tree");
126
127    /*
128     * Compile the parse tree
129     */
130    Status = DtCompileDataTable (&FieldList);
131    UtEndEvent (Event);
132
133    DtFreeFieldList ();
134
135    if (ACPI_FAILURE (Status))
136    {
137        /* TBD: temporary error message. Msgs should come from function above */
138
139        DtError (ASL_ERROR, ASL_MSG_SYNTAX, NULL,
140            "Could not compile input file");
141
142        goto CleanupAndExit;
143    }
144
145    /* Create/open the binary output file */
146
147    Gbl_Files[ASL_FILE_AML_OUTPUT].Filename = NULL;
148    Status = FlOpenAmlOutputFile (Gbl_OutputFilenamePrefix);
149    if (ACPI_FAILURE (Status))
150    {
151        goto CleanupAndExit;
152    }
153
154    /* Write the binary, then the optional hex file */
155
156    DtOutputBinary (Gbl_RootTable);
157    LsDoHexOutput ();
158    DtWriteTableToListing ();
159
160CleanupAndExit:
161
162    CmCleanupAndExit ();
163    return (Status);
164}
165
166
167/******************************************************************************
168 *
169 * FUNCTION:    DtInitialize
170 *
171 * PARAMETERS:  None
172 *
173 * RETURN:      Status
174 *
175 * DESCRIPTION: Initialize data table compiler globals. Enables multiple
176 *              compiles per invocation.
177 *
178 *****************************************************************************/
179
180static ACPI_STATUS
181DtInitialize (
182    void)
183{
184    ACPI_STATUS             Status;
185
186
187    Status = AcpiOsInitialize ();
188    if (ACPI_FAILURE (Status))
189    {
190        return (Status);
191    }
192
193    Status = AcpiUtInitGlobals ();
194    if (ACPI_FAILURE (Status))
195    {
196        return (Status);
197    }
198
199    Gbl_FieldList = NULL;
200    Gbl_RootTable = NULL;
201    Gbl_SubtableStack = NULL;
202
203    sprintf (VersionString, "%X", (UINT32) ACPI_CA_VERSION);
204    return (AE_OK);
205}
206
207
208/******************************************************************************
209 *
210 * FUNCTION:    DtInsertCompilerIds
211 *
212 * PARAMETERS:  FieldList           - Current field list pointer
213 *
214 * RETURN:      None
215 *
216 * DESCRIPTION: Insert the IDs (Name, Version) of the current compiler into
217 *              the original ACPI table header.
218 *
219 *****************************************************************************/
220
221static void
222DtInsertCompilerIds (
223    DT_FIELD                *FieldList)
224{
225    DT_FIELD                *Next;
226    UINT32                  i;
227
228
229    /*
230     * Don't insert current compiler ID if requested. Used for compiler
231     * debug/validation only.
232     */
233    if (Gbl_UseOriginalCompilerId)
234    {
235        return;
236    }
237
238    /* Walk to the Compiler fields at the end of the header */
239
240    Next = FieldList;
241    for (i = 0; i < 7; i++)
242    {
243        Next = Next->Next;
244    }
245
246    Next->Value = ASL_CREATOR_ID;
247    Next->Flags = DT_FIELD_NOT_ALLOCATED;
248
249    Next = Next->Next;
250    Next->Value = VersionString;
251    Next->Flags = DT_FIELD_NOT_ALLOCATED;
252}
253
254
255/******************************************************************************
256 *
257 * FUNCTION:    DtCompileDataTable
258 *
259 * PARAMETERS:  FieldList           - Current field list pointer
260 *
261 * RETURN:      Status
262 *
263 * DESCRIPTION: Entry point to compile one data table
264 *
265 *****************************************************************************/
266
267static ACPI_STATUS
268DtCompileDataTable (
269    DT_FIELD                **FieldList)
270{
271    ACPI_DMTABLE_DATA       *TableData;
272    DT_SUBTABLE             *Subtable;
273    char                    *Signature;
274    ACPI_TABLE_HEADER       *AcpiTableHeader;
275    ACPI_STATUS             Status;
276
277
278    /* Verify that we at least have a table signature and save it */
279
280    Signature = DtGetFieldValue (*FieldList);
281    if (!Signature)
282    {
283        sprintf (MsgBuffer, "Expected \"%s\"", "Signature");
284        DtNameError (ASL_ERROR, ASL_MSG_INVALID_FIELD_NAME,
285            *FieldList, MsgBuffer);
286        return (AE_ERROR);
287    }
288
289    Gbl_Signature = UtLocalCalloc (ACPI_STRLEN (Signature) + 1);
290    strcpy (Gbl_Signature, Signature);
291
292    /*
293     * Handle tables that don't use the common ACPI table header structure.
294     * Currently, these are the FACS and RSDP. Also check for an OEMx table,
295     * these tables have user-defined contents.
296     */
297    if (ACPI_COMPARE_NAME (Signature, ACPI_SIG_FACS))
298    {
299        Status = DtCompileFacs (FieldList);
300        if (ACPI_FAILURE (Status))
301        {
302            return (Status);
303        }
304
305        DtSetTableLength ();
306        return (Status);
307    }
308    else if (ACPI_COMPARE_NAME (Signature, ACPI_SIG_RSDP))
309    {
310        Status = DtCompileRsdp (FieldList);
311        return (Status);
312    }
313
314    /*
315     * All other tables must use the common ACPI table header. Insert the
316     * current iASL IDs (name, version), and compile the header now.
317     */
318    DtInsertCompilerIds (*FieldList);
319
320    Status = DtCompileTable (FieldList, AcpiDmTableInfoHeader,
321                &Gbl_RootTable, TRUE);
322    if (ACPI_FAILURE (Status))
323    {
324        return (Status);
325    }
326
327    DtPushSubtable (Gbl_RootTable);
328
329    /* Validate the signature via the ACPI table list */
330
331    TableData = AcpiDmGetTableData (Signature);
332    if (!TableData)
333    {
334        DtCompileGeneric ((void **) FieldList);
335        goto Out;
336    }
337
338    /* Dispatch to per-table compile */
339
340    if (TableData->CmTableHandler)
341    {
342        /* Complex table, has a handler */
343
344        Status = TableData->CmTableHandler ((void **) FieldList);
345        if (ACPI_FAILURE (Status))
346        {
347            return (Status);
348        }
349    }
350    else if (TableData->TableInfo)
351    {
352        /* Simple table, just walk the info table */
353
354        Subtable = NULL;
355        Status = DtCompileTable (FieldList, TableData->TableInfo,
356                    &Subtable, TRUE);
357        if (ACPI_FAILURE (Status))
358        {
359            return (Status);
360        }
361
362        DtInsertSubtable (Gbl_RootTable, Subtable);
363        DtPopSubtable ();
364    }
365    else
366    {
367        DtFatal (ASL_MSG_COMPILER_INTERNAL, *FieldList,
368            "Missing table dispatch info");
369        return (AE_ERROR);
370    }
371
372Out:
373    /* Set the final table length and then the checksum */
374
375    DtSetTableLength ();
376    AcpiTableHeader = ACPI_CAST_PTR (
377        ACPI_TABLE_HEADER, Gbl_RootTable->Buffer);
378    DtSetTableChecksum (&AcpiTableHeader->Checksum);
379
380    return (AE_OK);
381}
382
383
384/******************************************************************************
385 *
386 * FUNCTION:    DtCompileTable
387 *
388 * PARAMETERS:  Field               - Current field list pointer
389 *              Info                - Info table for this ACPI table
390 *              RetSubtable         - Compile result of table
391 *              Required            - If this subtable must exist
392 *
393 * RETURN:      Status
394 *
395 * DESCRIPTION: Compile a subtable
396 *
397 *****************************************************************************/
398
399ACPI_STATUS
400DtCompileTable (
401    DT_FIELD                **Field,
402    ACPI_DMTABLE_INFO       *Info,
403    DT_SUBTABLE             **RetSubtable,
404    BOOLEAN                 Required)
405{
406    DT_FIELD                *LocalField;
407    UINT32                  Length;
408    DT_SUBTABLE             *Subtable;
409    DT_SUBTABLE             *InlineSubtable;
410    UINT32                  FieldLength = 0;
411    UINT8                   FieldType;
412    UINT8                   *Buffer;
413    UINT8                   *FlagBuffer = NULL;
414    ACPI_STATUS             Status;
415
416
417    if (!Field || !*Field)
418    {
419        return (AE_BAD_PARAMETER);
420    }
421
422    Length = DtGetSubtableLength (*Field, Info);
423    if (Length == ASL_EOF)
424    {
425        return (AE_ERROR);
426    }
427
428    Subtable = UtLocalCalloc (sizeof (DT_SUBTABLE));
429
430    if (Length > 0)
431    {
432        Subtable->Buffer = UtLocalCalloc (Length);
433    }
434    Subtable->Length = Length;
435    Subtable->TotalLength = Length;
436    Buffer = Subtable->Buffer;
437
438    LocalField = *Field;
439
440    /*
441     * Main loop walks the info table for this ACPI table or subtable
442     */
443    for (; Info->Name; Info++)
444    {
445        if (!LocalField)
446        {
447            sprintf (MsgBuffer, "Found NULL field - Field name \"%s\" needed",
448                Info->Name);
449            DtFatal (ASL_MSG_COMPILER_INTERNAL, NULL, MsgBuffer);
450            Status = AE_BAD_DATA;
451            goto Error;
452        }
453
454        /* Maintain table offsets */
455
456        LocalField->TableOffset = Gbl_CurrentTableOffset;
457        FieldLength = DtGetFieldLength (LocalField, Info);
458        Gbl_CurrentTableOffset += FieldLength;
459
460        FieldType = DtGetFieldType (Info);
461        Gbl_InputFieldCount++;
462
463        switch (FieldType)
464        {
465        case DT_FIELD_TYPE_FLAGS_INTEGER:
466            /*
467             * Start of the definition of a flags field.
468             * This master flags integer starts at value zero, in preparation
469             * to compile and insert the flag fields from the individual bits
470             */
471            LocalField = LocalField->Next;
472            *Field = LocalField;
473
474            FlagBuffer = Buffer;
475            break;
476
477        case DT_FIELD_TYPE_FLAG:
478
479            /* Individual Flag field, can be multiple bits */
480
481            if (FlagBuffer)
482            {
483                DtCompileFlag (FlagBuffer, LocalField, Info);
484            }
485            else
486            {
487                /* TBD - this is an internal error */
488            }
489
490            LocalField = LocalField->Next;
491            *Field = LocalField;
492            break;
493
494        case DT_FIELD_TYPE_INLINE_SUBTABLE:
495            /*
496             * Recursion (one level max): compile GAS (Generic Address)
497             * or Notify in-line subtable
498             */
499            *Field = LocalField;
500
501            if (Info->Opcode == ACPI_DMT_GAS)
502            {
503                Status = DtCompileTable (Field, AcpiDmTableInfoGas,
504                    &InlineSubtable, TRUE);
505            }
506            else
507            {
508                Status = DtCompileTable (Field, AcpiDmTableInfoHestNotify,
509                    &InlineSubtable, TRUE);
510            }
511
512            if (ACPI_FAILURE (Status))
513            {
514                goto Error;
515            }
516
517            DtSetSubtableLength (InlineSubtable);
518
519            ACPI_MEMCPY (Buffer, InlineSubtable->Buffer, FieldLength);
520            ACPI_FREE (InlineSubtable->Buffer);
521            ACPI_FREE (InlineSubtable);
522            LocalField = *Field;
523            break;
524
525        case DT_FIELD_TYPE_LABEL:
526
527            DtWriteFieldToListing (Buffer, LocalField, 0);
528            LocalField = LocalField->Next;
529            break;
530
531        default:
532
533            /* Normal case for most field types (Integer, String, etc.) */
534
535            DtCompileOneField (Buffer, LocalField,
536                FieldLength, FieldType, Info->Flags);
537
538            DtWriteFieldToListing (Buffer, LocalField, FieldLength);
539            LocalField = LocalField->Next;
540
541            if (Info->Flags & DT_LENGTH)
542            {
543                /* Field is an Integer that will contain a subtable length */
544
545                Subtable->LengthField = Buffer;
546                Subtable->SizeOfLengthField = FieldLength;
547            }
548
549            break;
550        }
551
552        Buffer += FieldLength;
553    }
554
555    *Field = LocalField;
556    *RetSubtable = Subtable;
557    return (AE_OK);
558
559Error:
560    ACPI_FREE (Subtable->Buffer);
561    ACPI_FREE (Subtable);
562    return (Status);
563}
564