1 /******************************************************************************
2 *
3 * Module Name: dtcompile.c - Front-end for data table compiler
4 *
5 *****************************************************************************/
6
7 /*
8 * Copyright (C) 2000 - 2013, 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 "aslcompiler.h"
48 #include "dtcompiler.h"
49
50 #define _COMPONENT DT_COMPILER
51 ACPI_MODULE_NAME ("dtcompile")
52
53 static char VersionString[9];
54
55
56 /* Local prototypes */
57
58 static ACPI_STATUS
59 DtInitialize (
60 void);
61
62 static ACPI_STATUS
63 DtCompileDataTable (
64 DT_FIELD **Field);
65
66 static void
67 DtInsertCompilerIds (
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
86 ACPI_STATUS
87 DtDoCompile (
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 /* Preprocessor */
105
106 Event = UtBeginEvent ("Preprocess input file");
107 PrDoPreprocess ();
108 UtEndEvent (Event);
109
110 if (Gbl_PreprocessOnly)
111 {
112 return (AE_OK);
113 }
114
115 /*
116 * Scan the input file (file is already open) and
117 * build the parse tree
118 */
119 Event = UtBeginEvent ("Scan and parse input file");
120 FieldList = DtScanFile (Gbl_Files[ASL_FILE_INPUT].Handle);
121 UtEndEvent (Event);
122
123 /* Did the parse tree get successfully constructed? */
124
125 if (!FieldList)
126 {
127 /* TBD: temporary error message. Msgs should come from function above */
128
129 DtError (ASL_ERROR, ASL_MSG_SYNTAX, NULL,
130 "Input file does not appear to be an ASL or data table source file");
131
132 Status = AE_ERROR;
133 goto CleanupAndExit;
134 }
135
136 Event = UtBeginEvent ("Compile parse tree");
137
138 /*
139 * Compile the parse tree
140 */
141 Status = DtCompileDataTable (&FieldList);
142 UtEndEvent (Event);
143
144 DtFreeFieldList ();
145
146 if (ACPI_FAILURE (Status))
147 {
148 /* TBD: temporary error message. Msgs should come from function above */
149
150 DtError (ASL_ERROR, ASL_MSG_SYNTAX, NULL,
151 "Could not compile input file");
152
153 goto CleanupAndExit;
154 }
155
156 /* Create/open the binary output file */
157
158 Gbl_Files[ASL_FILE_AML_OUTPUT].Filename = NULL;
159 Status = FlOpenAmlOutputFile (Gbl_OutputFilenamePrefix);
160 if (ACPI_FAILURE (Status))
161 {
162 goto CleanupAndExit;
163 }
164
165 /* Write the binary, then the optional hex file */
166
167 DtOutputBinary (Gbl_RootTable);
168 HxDoHexOutput ();
169 DtWriteTableToListing ();
170
171 CleanupAndExit:
172
173 CmCleanupAndExit ();
174 return (Status);
175 }
176
177
178 /******************************************************************************
179 *
180 * FUNCTION: DtInitialize
181 *
182 * PARAMETERS: None
183 *
184 * RETURN: Status
185 *
186 * DESCRIPTION: Initialize data table compiler globals. Enables multiple
187 * compiles per invocation.
188 *
189 *****************************************************************************/
190
191 static ACPI_STATUS
192 DtInitialize (
193 void)
194 {
195 ACPI_STATUS Status;
196
197
198 Status = AcpiOsInitialize ();
199 if (ACPI_FAILURE (Status))
200 {
201 return (Status);
202 }
203
204 Status = AcpiUtInitGlobals ();
205 if (ACPI_FAILURE (Status))
206 {
207 return (Status);
208 }
209
210 Gbl_FieldList = NULL;
211 Gbl_RootTable = NULL;
212 Gbl_SubtableStack = NULL;
213
214 sprintf (VersionString, "%X", (UINT32) ACPI_CA_VERSION);
215 return (AE_OK);
216 }
217
218
219 /******************************************************************************
220 *
221 * FUNCTION: DtInsertCompilerIds
222 *
223 * PARAMETERS: FieldList - Current field list pointer
224 *
225 * RETURN: None
226 *
227 * DESCRIPTION: Insert the IDs (Name, Version) of the current compiler into
228 * the original ACPI table header.
229 *
230 *****************************************************************************/
231
232 static void
233 DtInsertCompilerIds (
234 DT_FIELD *FieldList)
235 {
236 DT_FIELD *Next;
237 UINT32 i;
238
239
240 /*
241 * Don't insert current compiler ID if requested. Used for compiler
242 * debug/validation only.
243 */
244 if (Gbl_UseOriginalCompilerId)
245 {
246 return;
247 }
248
249 /* Walk to the Compiler fields at the end of the header */
250
251 Next = FieldList;
252 for (i = 0; i < 7; i++)
253 {
254 Next = Next->Next;
255 }
256
257 Next->Value = ASL_CREATOR_ID;
258 Next->Flags = DT_FIELD_NOT_ALLOCATED;
259
260 Next = Next->Next;
261 Next->Value = VersionString;
262 Next->Flags = DT_FIELD_NOT_ALLOCATED;
263 }
264
265
266 /******************************************************************************
267 *
268 * FUNCTION: DtCompileDataTable
269 *
270 * PARAMETERS: FieldList - Current field list pointer
271 *
272 * RETURN: Status
273 *
274 * DESCRIPTION: Entry point to compile one data table
275 *
276 *****************************************************************************/
277
278 static ACPI_STATUS
279 DtCompileDataTable (
280 DT_FIELD **FieldList)
281 {
282 ACPI_DMTABLE_DATA *TableData;
283 DT_SUBTABLE *Subtable;
284 char *Signature;
285 ACPI_TABLE_HEADER *AcpiTableHeader;
286 ACPI_STATUS Status;
287 DT_FIELD *RootField = *FieldList;
288
289
290 /* Verify that we at least have a table signature and save it */
291
292 Signature = DtGetFieldValue (*FieldList);
293 if (!Signature)
294 {
295 sprintf (MsgBuffer, "Expected \"%s\"", "Signature");
296 DtNameError (ASL_ERROR, ASL_MSG_INVALID_FIELD_NAME,
297 *FieldList, MsgBuffer);
298 return (AE_ERROR);
299 }
300
301 Gbl_Signature = UtLocalCalloc (ACPI_STRLEN (Signature) + 1);
302 strcpy (Gbl_Signature, Signature);
303
304 /*
305 * Handle tables that don't use the common ACPI table header structure.
306 * Currently, these are the FACS and RSDP. Also check for an OEMx table,
307 * these tables have user-defined contents.
308 */
309 if (ACPI_COMPARE_NAME (Signature, ACPI_SIG_FACS))
310 {
311 Status = DtCompileFacs (FieldList);
312 if (ACPI_FAILURE (Status))
313 {
314 return (Status);
315 }
316
317 DtSetTableLength ();
318 return (Status);
319 }
320 else if (ACPI_VALIDATE_RSDP_SIG (Signature))
321 {
322 Status = DtCompileRsdp (FieldList);
323 return (Status);
324 }
325 else if (ACPI_COMPARE_NAME (Signature, ACPI_SIG_S3PT))
326 {
327 Status = DtCompileS3pt (FieldList);
328 if (ACPI_FAILURE (Status))
329 {
330 return (Status);
331 }
332
333 DtSetTableLength ();
334 return (Status);
335 }
336
337 /*
338 * All other tables must use the common ACPI table header. Insert the
339 * current iASL IDs (name, version), and compile the header now.
340 */
341 DtInsertCompilerIds (*FieldList);
342
343 Status = DtCompileTable (FieldList, AcpiDmTableInfoHeader,
344 &Gbl_RootTable, TRUE);
345 if (ACPI_FAILURE (Status))
346 {
347 return (Status);
348 }
349
350 DtPushSubtable (Gbl_RootTable);
351
352 /* Validate the signature via the ACPI table list */
353
354 TableData = AcpiDmGetTableData (Signature);
355 if (!TableData || Gbl_CompileGeneric)
356 {
357 DtCompileGeneric ((void **) FieldList);
358 goto FinishHeader;
359 }
360
361 /* Dispatch to per-table compile */
362
363 if (TableData->CmTableHandler)
364 {
365 /* Complex table, has a handler */
366
367 Status = TableData->CmTableHandler ((void **) FieldList);
368 if (ACPI_FAILURE (Status))
369 {
370 return (Status);
371 }
372 }
373 else if (TableData->TableInfo)
374 {
375 /* Simple table, just walk the info table */
376
377 Subtable = NULL;
378 Status = DtCompileTable (FieldList, TableData->TableInfo,
379 &Subtable, TRUE);
380 if (ACPI_FAILURE (Status))
381 {
382 return (Status);
383 }
384
385 DtInsertSubtable (Gbl_RootTable, Subtable);
386 DtPopSubtable ();
387 }
388 else
389 {
390 DtFatal (ASL_MSG_COMPILER_INTERNAL, *FieldList,
391 "Missing table dispatch info");
392 return (AE_ERROR);
393 }
394
395 FinishHeader:
396
397 /* Set the final table length and then the checksum */
398
399 DtSetTableLength ();
400 AcpiTableHeader = ACPI_CAST_PTR (
401 ACPI_TABLE_HEADER, Gbl_RootTable->Buffer);
402 DtSetTableChecksum (&AcpiTableHeader->Checksum);
403
404 DtDumpFieldList (RootField);
405 DtDumpSubtableList ();
406 return (AE_OK);
407 }
408
409
410 /******************************************************************************
411 *
412 * FUNCTION: DtCompileTable
413 *
414 * PARAMETERS: Field - Current field list pointer
415 * Info - Info table for this ACPI table
416 * RetSubtable - Compile result of table
417 * Required - If this subtable must exist
418 *
419 * RETURN: Status
420 *
421 * DESCRIPTION: Compile a subtable
422 *
423 *****************************************************************************/
424
425 ACPI_STATUS
426 DtCompileTable (
427 DT_FIELD **Field,
428 ACPI_DMTABLE_INFO *Info,
429 DT_SUBTABLE **RetSubtable,
430 BOOLEAN Required)
431 {
432 DT_FIELD *LocalField;
433 UINT32 Length;
434 DT_SUBTABLE *Subtable;
435 DT_SUBTABLE *InlineSubtable;
436 UINT32 FieldLength = 0;
437 UINT8 FieldType;
438 UINT8 *Buffer;
439 UINT8 *FlagBuffer = NULL;
440 UINT32 CurrentFlagByteOffset = 0;
441 ACPI_STATUS Status;
442
443
444 if (!Field || !*Field)
445 {
446 return (AE_BAD_PARAMETER);
447 }
448
449 /* Ignore optional subtable if name does not match */
450
451 if ((Info->Flags & DT_OPTIONAL) &&
452 ACPI_STRCMP ((*Field)->Name, Info->Name))
453 {
454 *RetSubtable = NULL;
455 return (AE_OK);
456 }
457
458 Length = DtGetSubtableLength (*Field, Info);
459 if (Length == ASL_EOF)
460 {
461 return (AE_ERROR);
462 }
463
464 Subtable = UtLocalCalloc (sizeof (DT_SUBTABLE));
465
466 if (Length > 0)
467 {
468 Subtable->Buffer = UtLocalCalloc (Length);
469 }
470 Subtable->Length = Length;
471 Subtable->TotalLength = Length;
472 Buffer = Subtable->Buffer;
473
474 LocalField = *Field;
475
476 /*
477 * Main loop walks the info table for this ACPI table or subtable
478 */
479 for (; Info->Name; Info++)
480 {
481 if (Info->Opcode == ACPI_DMT_EXTRA_TEXT)
482 {
483 continue;
484 }
485
486 if (!LocalField)
487 {
488 sprintf (MsgBuffer, "Found NULL field - Field name \"%s\" needed",
489 Info->Name);
490 DtFatal (ASL_MSG_COMPILER_INTERNAL, NULL, MsgBuffer);
491 Status = AE_BAD_DATA;
492 goto Error;
493 }
494
495 /* Maintain table offsets */
496
497 LocalField->TableOffset = Gbl_CurrentTableOffset;
498 FieldLength = DtGetFieldLength (LocalField, Info);
499 Gbl_CurrentTableOffset += FieldLength;
500
501 FieldType = DtGetFieldType (Info);
502 Gbl_InputFieldCount++;
503
504 switch (FieldType)
505 {
506 case DT_FIELD_TYPE_FLAGS_INTEGER:
507 /*
508 * Start of the definition of a flags field.
509 * This master flags integer starts at value zero, in preparation
510 * to compile and insert the flag fields from the individual bits
511 */
512 LocalField = LocalField->Next;
513 *Field = LocalField;
514
515 FlagBuffer = Buffer;
516 CurrentFlagByteOffset = Info->Offset;
517 break;
518
519 case DT_FIELD_TYPE_FLAG:
520
521 /* Individual Flag field, can be multiple bits */
522
523 if (FlagBuffer)
524 {
525 /*
526 * We must increment the FlagBuffer when we have crossed
527 * into the next flags byte within the flags field
528 * of type DT_FIELD_TYPE_FLAGS_INTEGER.
529 */
530 FlagBuffer += (Info->Offset - CurrentFlagByteOffset);
531 CurrentFlagByteOffset = Info->Offset;
532
533 DtCompileFlag (FlagBuffer, LocalField, Info);
534 }
535 else
536 {
537 /* TBD - this is an internal error */
538 }
539
540 LocalField = LocalField->Next;
541 *Field = LocalField;
542 break;
543
544 case DT_FIELD_TYPE_INLINE_SUBTABLE:
545 /*
546 * Recursion (one level max): compile GAS (Generic Address)
547 * or Notify in-line subtable
548 */
549 *Field = LocalField;
550
551 if (Info->Opcode == ACPI_DMT_GAS)
552 {
553 Status = DtCompileTable (Field, AcpiDmTableInfoGas,
554 &InlineSubtable, TRUE);
555 }
556 else
557 {
558 Status = DtCompileTable (Field, AcpiDmTableInfoHestNotify,
559 &InlineSubtable, TRUE);
560 }
561
562 if (ACPI_FAILURE (Status))
563 {
564 goto Error;
565 }
566
567 DtSetSubtableLength (InlineSubtable);
568
569 ACPI_MEMCPY (Buffer, InlineSubtable->Buffer, FieldLength);
570 ACPI_FREE (InlineSubtable->Buffer);
571 ACPI_FREE (InlineSubtable);
572 LocalField = *Field;
573 break;
574
575 case DT_FIELD_TYPE_LABEL:
576
577 DtWriteFieldToListing (Buffer, LocalField, 0);
578 LocalField = LocalField->Next;
579 break;
580
581 default:
582
583 /* Normal case for most field types (Integer, String, etc.) */
584
585 DtCompileOneField (Buffer, LocalField,
586 FieldLength, FieldType, Info->Flags);
587
588 DtWriteFieldToListing (Buffer, LocalField, FieldLength);
589 LocalField = LocalField->Next;
590
591 if (Info->Flags & DT_LENGTH)
592 {
593 /* Field is an Integer that will contain a subtable length */
594
595 Subtable->LengthField = Buffer;
596 Subtable->SizeOfLengthField = FieldLength;
597 }
598
599 break;
600 }
601
602 Buffer += FieldLength;
603 }
604
605 *Field = LocalField;
606 *RetSubtable = Subtable;
607 return (AE_OK);
608
609 Error:
610 ACPI_FREE (Subtable->Buffer);
611 ACPI_FREE (Subtable);
612 return (Status);
613 }