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