dtcompile.c revision 228110 
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    else if (ACPI_COMPARE_NAME (Signature, ACPI_SIG_S3PT))
314    {
315        Status = DtCompileS3pt (FieldList);
316        if (ACPI_FAILURE (Status))
317        {
318            return (Status);
319        }
320
321        DtSetTableLength ();
322        return (Status);
323    }
324
325    /*
326     * All other tables must use the common ACPI table header. Insert the
327     * current iASL IDs (name, version), and compile the header now.
328     */
329    DtInsertCompilerIds (*FieldList);
330
331    Status = DtCompileTable (FieldList, AcpiDmTableInfoHeader,
332                &Gbl_RootTable, TRUE);
333    if (ACPI_FAILURE (Status))
334    {
335        return (Status);
336    }
337
338    DtPushSubtable (Gbl_RootTable);
339
340    /* Validate the signature via the ACPI table list */
341
342    TableData = AcpiDmGetTableData (Signature);
343    if (!TableData || Gbl_CompileGeneric)
344    {
345        DtCompileGeneric ((void **) FieldList);
346        goto Out;
347    }
348
349    /* Dispatch to per-table compile */
350
351    if (TableData->CmTableHandler)
352    {
353        /* Complex table, has a handler */
354
355        Status = TableData->CmTableHandler ((void **) FieldList);
356        if (ACPI_FAILURE (Status))
357        {
358            return (Status);
359        }
360    }
361    else if (TableData->TableInfo)
362    {
363        /* Simple table, just walk the info table */
364
365        Subtable = NULL;
366        Status = DtCompileTable (FieldList, TableData->TableInfo,
367                    &Subtable, TRUE);
368        if (ACPI_FAILURE (Status))
369        {
370            return (Status);
371        }
372
373        DtInsertSubtable (Gbl_RootTable, Subtable);
374        DtPopSubtable ();
375    }
376    else
377    {
378        DtFatal (ASL_MSG_COMPILER_INTERNAL, *FieldList,
379            "Missing table dispatch info");
380        return (AE_ERROR);
381    }
382
383Out:
384    /* Set the final table length and then the checksum */
385
386    DtSetTableLength ();
387    AcpiTableHeader = ACPI_CAST_PTR (
388        ACPI_TABLE_HEADER, Gbl_RootTable->Buffer);
389    DtSetTableChecksum (&AcpiTableHeader->Checksum);
390
391    return (AE_OK);
392}
393
394
395/******************************************************************************
396 *
397 * FUNCTION:    DtCompileTable
398 *
399 * PARAMETERS:  Field               - Current field list pointer
400 *              Info                - Info table for this ACPI table
401 *              RetSubtable         - Compile result of table
402 *              Required            - If this subtable must exist
403 *
404 * RETURN:      Status
405 *
406 * DESCRIPTION: Compile a subtable
407 *
408 *****************************************************************************/
409
410ACPI_STATUS
411DtCompileTable (
412    DT_FIELD                **Field,
413    ACPI_DMTABLE_INFO       *Info,
414    DT_SUBTABLE             **RetSubtable,
415    BOOLEAN                 Required)
416{
417    DT_FIELD                *LocalField;
418    UINT32                  Length;
419    DT_SUBTABLE             *Subtable;
420    DT_SUBTABLE             *InlineSubtable;
421    UINT32                  FieldLength = 0;
422    UINT8                   FieldType;
423    UINT8                   *Buffer;
424    UINT8                   *FlagBuffer = NULL;
425    UINT32                  CurrentFlagByteOffset = 0;
426    ACPI_STATUS             Status;
427
428
429    if (!Field || !*Field)
430    {
431        return (AE_BAD_PARAMETER);
432    }
433
434    Length = DtGetSubtableLength (*Field, Info);
435    if (Length == ASL_EOF)
436    {
437        return (AE_ERROR);
438    }
439
440    Subtable = UtLocalCalloc (sizeof (DT_SUBTABLE));
441
442    if (Length > 0)
443    {
444        Subtable->Buffer = UtLocalCalloc (Length);
445    }
446    Subtable->Length = Length;
447    Subtable->TotalLength = Length;
448    Buffer = Subtable->Buffer;
449
450    LocalField = *Field;
451
452    /*
453     * Main loop walks the info table for this ACPI table or subtable
454     */
455    for (; Info->Name; Info++)
456    {
457        if (Info->Opcode == ACPI_DMT_EXTRA_TEXT)
458        {
459            continue;
460        }
461
462        if (!LocalField)
463        {
464            sprintf (MsgBuffer, "Found NULL field - Field name \"%s\" needed",
465                Info->Name);
466            DtFatal (ASL_MSG_COMPILER_INTERNAL, NULL, MsgBuffer);
467            Status = AE_BAD_DATA;
468            goto Error;
469        }
470
471        /* Maintain table offsets */
472
473        LocalField->TableOffset = Gbl_CurrentTableOffset;
474        FieldLength = DtGetFieldLength (LocalField, Info);
475        Gbl_CurrentTableOffset += FieldLength;
476
477        FieldType = DtGetFieldType (Info);
478        Gbl_InputFieldCount++;
479
480        switch (FieldType)
481        {
482        case DT_FIELD_TYPE_FLAGS_INTEGER:
483            /*
484             * Start of the definition of a flags field.
485             * This master flags integer starts at value zero, in preparation
486             * to compile and insert the flag fields from the individual bits
487             */
488            LocalField = LocalField->Next;
489            *Field = LocalField;
490
491            FlagBuffer = Buffer;
492            CurrentFlagByteOffset = Info->Offset;
493            break;
494
495        case DT_FIELD_TYPE_FLAG:
496
497            /* Individual Flag field, can be multiple bits */
498
499            if (FlagBuffer)
500            {
501                /*
502                 * We must increment the FlagBuffer when we have crossed
503                 * into the next flags byte within the flags field
504                 * of type DT_FIELD_TYPE_FLAGS_INTEGER.
505                 */
506                FlagBuffer += (Info->Offset - CurrentFlagByteOffset);
507                CurrentFlagByteOffset = Info->Offset;
508
509                DtCompileFlag (FlagBuffer, LocalField, Info);
510            }
511            else
512            {
513                /* TBD - this is an internal error */
514            }
515
516            LocalField = LocalField->Next;
517            *Field = LocalField;
518            break;
519
520        case DT_FIELD_TYPE_INLINE_SUBTABLE:
521            /*
522             * Recursion (one level max): compile GAS (Generic Address)
523             * or Notify in-line subtable
524             */
525            *Field = LocalField;
526
527            if (Info->Opcode == ACPI_DMT_GAS)
528            {
529                Status = DtCompileTable (Field, AcpiDmTableInfoGas,
530                    &InlineSubtable, TRUE);
531            }
532            else
533            {
534                Status = DtCompileTable (Field, AcpiDmTableInfoHestNotify,
535                    &InlineSubtable, TRUE);
536            }
537
538            if (ACPI_FAILURE (Status))
539            {
540                goto Error;
541            }
542
543            DtSetSubtableLength (InlineSubtable);
544
545            ACPI_MEMCPY (Buffer, InlineSubtable->Buffer, FieldLength);
546            ACPI_FREE (InlineSubtable->Buffer);
547            ACPI_FREE (InlineSubtable);
548            LocalField = *Field;
549            break;
550
551        case DT_FIELD_TYPE_LABEL:
552
553            DtWriteFieldToListing (Buffer, LocalField, 0);
554            LocalField = LocalField->Next;
555            break;
556
557        default:
558
559            /* Normal case for most field types (Integer, String, etc.) */
560
561            DtCompileOneField (Buffer, LocalField,
562                FieldLength, FieldType, Info->Flags);
563
564            DtWriteFieldToListing (Buffer, LocalField, FieldLength);
565            LocalField = LocalField->Next;
566
567            if (Info->Flags & DT_LENGTH)
568            {
569                /* Field is an Integer that will contain a subtable length */
570
571                Subtable->LengthField = Buffer;
572                Subtable->SizeOfLengthField = FieldLength;
573            }
574
575            break;
576        }
577
578        Buffer += FieldLength;
579    }
580
581    *Field = LocalField;
582    *RetSubtable = Subtable;
583    return (AE_OK);
584
585Error:
586    ACPI_FREE (Subtable->Buffer);
587    ACPI_FREE (Subtable);
588    return (Status);
589}
590