1 /****************************************************************************** 2 * 3 * Module Name: dtcompile.c - Front-end for data table compiler 4 * 5 *****************************************************************************/ 6 7 /****************************************************************************** 8 * 9 * 1. Copyright Notice 10 * 11 * Some or all of this work - Copyright (c) 1999 - 2022, 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 #define _DECLARE_DT_GLOBALS 153 154 #include <contrib/dev/acpica/compiler/aslcompiler.h> 155 156 #define _COMPONENT DT_COMPILER 157 ACPI_MODULE_NAME ("dtcompile") 158 159 static char VersionString[9]; 160 161 162 /* Local prototypes */ 163 164 void 165 DtInitialize ( 166 void); 167 168 static ACPI_STATUS 169 DtCompileDataTable ( 170 DT_FIELD **Field); 171 172 static void 173 DtInsertCompilerIds ( 174 DT_FIELD *FieldList); 175 176 177 /****************************************************************************** 178 * 179 * FUNCTION: DtDoCompile 180 * 181 * PARAMETERS: None 182 * 183 * RETURN: Status 184 * 185 * DESCRIPTION: Main entry point for the data table compiler. 186 * 187 * Note: Assumes AslGbl_Files[ASL_FILE_INPUT] is initialized and the file is 188 * open at seek offset zero. 189 * 190 *****************************************************************************/ 191 192 ACPI_STATUS 193 DtDoCompile ( 194 void) 195 { 196 ACPI_STATUS Status; 197 UINT8 Event; 198 DT_FIELD *FieldList; 199 ASL_GLOBAL_FILE_NODE *FileNode; 200 201 202 /* Initialize globals */ 203 204 DtInitialize (); 205 206 /* Preprocessor */ 207 208 if (AslGbl_PreprocessFlag) 209 { 210 /* Preprocessor */ 211 212 Event = UtBeginEvent ("Preprocess input file"); 213 PrDoPreprocess (); 214 UtEndEvent (Event); 215 216 if (AslGbl_PreprocessOnly) 217 { 218 return (AE_OK); 219 } 220 } 221 222 /* Compile the parse tree */ 223 224 if (AslGbl_DtLexBisonPrototype) 225 { 226 Event = UtBeginEvent ("Parse data table in prototype mode"); 227 228 DtCompilerInitLexer (AslGbl_Files[ASL_FILE_INPUT].Handle); 229 DtCompilerParserparse (); 230 FieldList = AslGbl_FieldList; 231 DtCompilerTerminateLexer (); 232 233 UtEndEvent (Event); 234 } 235 else 236 { 237 /* 238 * Scan the input file (file is already open) and 239 * build the parse tree 240 */ 241 Event = UtBeginEvent ("Scan and parse input file"); 242 FieldList = DtScanFile (AslGbl_Files[ASL_FILE_INPUT].Handle); 243 UtEndEvent (Event); 244 } 245 246 /* Did the parse tree get successfully constructed? */ 247 248 if (!FieldList) 249 { 250 /* TBD: temporary error message. Msgs should come from function above */ 251 252 DtError (ASL_ERROR, ASL_MSG_SYNTAX, NULL, 253 "Input file does not appear to be an ASL or data table source file"); 254 255 return (AE_ERROR); 256 } 257 258 Event = UtBeginEvent ("Compile parse tree"); 259 260 Status = DtCompileDataTable (&FieldList); 261 UtEndEvent (Event); 262 263 FileNode = FlGetCurrentFileNode (); 264 265 FileNode->TotalLineCount = AslGbl_CurrentLineNumber; 266 FileNode->OriginalInputFileSize = AslGbl_InputByteCount; 267 DbgPrint (ASL_PARSE_OUTPUT, "Line count: %u input file size: %u\n", 268 FileNode->TotalLineCount, FileNode->OriginalInputFileSize); 269 270 if (ACPI_FAILURE (Status)) 271 { 272 FileNode->ParserErrorDetected = TRUE; 273 274 /* TBD: temporary error message. Msgs should come from function above */ 275 276 DtError (ASL_ERROR, ASL_MSG_SYNTAX, NULL, 277 "Could not compile input file"); 278 279 return (Status); 280 } 281 282 /* Create/open the binary output file */ 283 284 AslGbl_Files[ASL_FILE_AML_OUTPUT].Filename = NULL; 285 Status = FlOpenAmlOutputFile (AslGbl_OutputFilenamePrefix); 286 if (ACPI_FAILURE (Status)) 287 { 288 return (Status); 289 } 290 291 /* Write the binary, then the optional hex file */ 292 293 DtOutputBinary (AslGbl_RootTable); 294 HxDoHexOutput (); 295 DtWriteTableToListing (); 296 297 /* Save the compile time statistics to the current file node */ 298 299 FileNode->TotalFields = AslGbl_InputFieldCount; 300 FileNode->OutputByteLength = AslGbl_TableLength; 301 302 return (Status); 303 } 304 305 306 /****************************************************************************** 307 * 308 * FUNCTION: DtInitialize 309 * 310 * PARAMETERS: None 311 * 312 * RETURN: Status 313 * 314 * DESCRIPTION: Initialize data table compiler globals. Enables multiple 315 * compiles per invocation. 316 * 317 *****************************************************************************/ 318 319 void 320 DtInitialize ( 321 void) 322 { 323 324 325 AcpiUtSetIntegerWidth (2); /* Set width to 64 bits */ 326 327 AslGbl_FieldList = NULL; 328 AslGbl_RootTable = NULL; 329 AslGbl_SubtableStack = NULL; 330 331 sprintf (VersionString, "%X", (UINT32) ACPI_CA_VERSION); 332 return; 333 } 334 335 336 /****************************************************************************** 337 * 338 * FUNCTION: DtInsertCompilerIds 339 * 340 * PARAMETERS: FieldList - Current field list pointer 341 * 342 * RETURN: None 343 * 344 * DESCRIPTION: Insert the IDs (Name, Version) of the current compiler into 345 * the original ACPI table header. 346 * 347 *****************************************************************************/ 348 349 static void 350 DtInsertCompilerIds ( 351 DT_FIELD *FieldList) 352 { 353 DT_FIELD *Next; 354 UINT32 i; 355 356 357 /* 358 * Don't insert current compiler ID if requested. Used for compiler 359 * debug/validation only. 360 */ 361 if (AslGbl_UseOriginalCompilerId) 362 { 363 return; 364 } 365 366 /* Walk to the Compiler fields at the end of the header */ 367 368 Next = FieldList; 369 for (i = 0; i < 7; i++) 370 { 371 Next = Next->Next; 372 } 373 374 Next->Value = ASL_CREATOR_ID; 375 Next->Flags = DT_FIELD_NOT_ALLOCATED; 376 377 Next = Next->Next; 378 Next->Value = VersionString; 379 Next->Flags = DT_FIELD_NOT_ALLOCATED; 380 } 381 382 383 /****************************************************************************** 384 * 385 * FUNCTION: DtCompileDataTable 386 * 387 * PARAMETERS: FieldList - Current field list pointer 388 * 389 * RETURN: Status 390 * 391 * DESCRIPTION: Entry point to compile one data table 392 * 393 *****************************************************************************/ 394 395 static ACPI_STATUS 396 DtCompileDataTable ( 397 DT_FIELD **FieldList) 398 { 399 const ACPI_DMTABLE_DATA *TableData; 400 DT_SUBTABLE *Subtable; 401 char *Signature; 402 ACPI_TABLE_HEADER *AcpiTableHeader; 403 ACPI_STATUS Status; 404 DT_FIELD *RootField = *FieldList; 405 406 407 /* Verify that we at least have a table signature and save it */ 408 409 Signature = DtGetFieldValue (*FieldList); 410 if (!Signature) 411 { 412 sprintf (AslGbl_MsgBuffer, "Expected \"%s\"", "Signature"); 413 DtNameError (ASL_ERROR, ASL_MSG_INVALID_FIELD_NAME, 414 *FieldList, AslGbl_MsgBuffer); 415 return (AE_ERROR); 416 } 417 418 AslGbl_Signature = UtLocalCacheCalloc (strlen (Signature) + 1); 419 strcpy (AslGbl_Signature, Signature); 420 421 /* 422 * Handle tables that don't use the common ACPI table header structure. 423 * Currently, these are the FACS and RSDP. Also check for an OEMx table, 424 * these tables have user-defined contents. 425 */ 426 if (ACPI_COMPARE_NAMESEG (Signature, ACPI_SIG_FACS)) 427 { 428 Status = DtCompileFacs (FieldList); 429 if (ACPI_FAILURE (Status)) 430 { 431 return (Status); 432 } 433 434 DtSetTableLength (); 435 return (Status); 436 } 437 else if (ACPI_VALIDATE_RSDP_SIG (Signature)) 438 { 439 Status = DtCompileRsdp (FieldList); 440 return (Status); 441 } 442 else if (ACPI_COMPARE_NAMESEG (Signature, ACPI_SIG_S3PT)) 443 { 444 Status = DtCompileS3pt (FieldList); 445 if (ACPI_FAILURE (Status)) 446 { 447 return (Status); 448 } 449 450 DtSetTableLength (); 451 return (Status); 452 } 453 454 /* 455 * If the first field is named "CDAT Table Length" (not "Signature"), 456 * assume that we have a CDAT table (whose table header does not have 457 * a signature). Instead, the TableLength field is where the 458 * signature would (normally) be. 459 */ 460 else if (!strcmp ((*FieldList)->Name, "CDAT Table Length")) 461 { 462 /* No longer true: (However, use this technique in the disassembler) 463 * We are assuming that there 464 * should be at least one non-ASCII byte in the 4-character 465 * Signature field, (At least the high-order byte should be zero). 466 */ 467 Status = DtCompileTable (FieldList, AcpiDmTableInfoCdatTableHdr, 468 &AslGbl_RootTable); 469 if (ACPI_FAILURE (Status)) 470 { 471 return (Status); 472 } 473 474 /* Compile the CDAT */ 475 476 DtPushSubtable (AslGbl_RootTable); 477 Status = DtCompileCdat ((void **) FieldList); 478 if (ACPI_FAILURE (Status)) 479 { 480 return (Status); 481 } 482 483 /* 484 * Set the overall table length and the table checksum. 485 * The entire compiled table (including the CDAT table header with 486 * the table length and checksum) is in AslGbl_RootTable->Buffer. 487 */ 488 DtSetTableLength (); 489 DtSetTableChecksum (&ACPI_CAST_PTR (ACPI_TABLE_CDAT, AslGbl_RootTable->Buffer)->Checksum); 490 491 DtDumpFieldList (RootField); 492 DtDumpSubtableList (); 493 return (AE_OK); 494 } 495 496 /* 497 * All other tables must use the common ACPI table header. Insert the 498 * current iASL IDs (name, version), and compile the header now. 499 */ 500 DtInsertCompilerIds (*FieldList); 501 502 Status = DtCompileTable (FieldList, AcpiDmTableInfoHeader, 503 &AslGbl_RootTable); 504 if (ACPI_FAILURE (Status)) 505 { 506 return (Status); 507 } 508 509 DtPushSubtable (AslGbl_RootTable); 510 511 /* Validate the signature via the ACPI table list */ 512 513 TableData = AcpiDmGetTableData (Signature); 514 if (!TableData || AslGbl_CompileGeneric) 515 { 516 /* Unknown table signature and/or force generic compile */ 517 518 DtCompileGeneric ((void **) FieldList, NULL, NULL); 519 goto FinishHeader; 520 } 521 522 /* Dispatch to per-table compile */ 523 524 if (TableData->CmTableHandler) 525 { 526 /* Complex table, has a handler */ 527 528 Status = TableData->CmTableHandler ((void **) FieldList); 529 if (ACPI_FAILURE (Status)) 530 { 531 return (Status); 532 } 533 } 534 else if (TableData->TableInfo) 535 { 536 /* Simple table, just walk the info table, unless its empty */ 537 538 if (FieldList && *FieldList) 539 { 540 Subtable = NULL; 541 Status = DtCompileTable (FieldList, TableData->TableInfo, 542 &Subtable); 543 if (ACPI_FAILURE (Status)) 544 { 545 return (Status); 546 } 547 548 DtInsertSubtable (AslGbl_RootTable, Subtable); 549 DtPopSubtable (); 550 } 551 } 552 else 553 { 554 DtFatal (ASL_MSG_COMPILER_INTERNAL, *FieldList, 555 "Missing table dispatch info"); 556 return (AE_ERROR); 557 } 558 559 FinishHeader: 560 561 /* Set the final table length and then the checksum */ 562 563 DtSetTableLength (); 564 AcpiTableHeader = ACPI_CAST_PTR ( 565 ACPI_TABLE_HEADER, AslGbl_RootTable->Buffer); 566 DtSetTableChecksum (&AcpiTableHeader->Checksum); 567 568 DtDumpFieldList (RootField); 569 DtDumpSubtableList (); 570 return (AE_OK); 571 } 572 573 574 /****************************************************************************** 575 * 576 * FUNCTION: DtCompileTable 577 * 578 * PARAMETERS: Field - Current field list pointer 579 * Info - Info table for this ACPI table 580 * RetSubtable - Compile result of table 581 * 582 * RETURN: Status 583 * 584 * DESCRIPTION: Compile a subtable 585 * 586 *****************************************************************************/ 587 588 ACPI_STATUS 589 DtCompileTable ( 590 DT_FIELD **Field, 591 ACPI_DMTABLE_INFO *Info, 592 DT_SUBTABLE **RetSubtable) 593 { 594 DT_FIELD *LocalField; 595 UINT32 Length; 596 DT_SUBTABLE *Subtable; 597 DT_SUBTABLE *InlineSubtable = NULL; 598 UINT32 FieldLength = 0; 599 UINT8 FieldType; 600 UINT8 *Buffer; 601 UINT8 *FlagBuffer = NULL; 602 char *String; 603 UINT32 CurrentFlagByteOffset = 0; 604 ACPI_STATUS Status = AE_OK; 605 606 607 if (!Field || !Info) 608 { 609 return (AE_BAD_PARAMETER); 610 } 611 if (!*Field) 612 { 613 /* 614 * The field list is empty, this means that we are out of fields to 615 * parse. In other words, we are at the end of the table. 616 */ 617 return (AE_END_OF_TABLE); 618 } 619 620 /* Ignore optional subtable if name does not match */ 621 622 if ((Info->Flags & DT_OPTIONAL) && 623 strcmp ((*Field)->Name, Info->Name)) 624 { 625 *RetSubtable = NULL; 626 return (AE_OK); 627 } 628 629 Length = DtGetSubtableLength (*Field, Info); 630 if (Length == ASL_EOF) 631 { 632 return (AE_ERROR); 633 } 634 635 Subtable = UtSubtableCacheCalloc (); 636 637 if (Length > 0) 638 { 639 String = UtLocalCacheCalloc (Length); 640 Subtable->Buffer = ACPI_CAST_PTR (UINT8, String); 641 } 642 643 Subtable->Length = Length; 644 Subtable->TotalLength = Length; 645 Buffer = Subtable->Buffer; 646 647 LocalField = *Field; 648 Subtable->Name = LocalField->Name; 649 650 /* 651 * Main loop walks the info table for this ACPI table or subtable 652 */ 653 for (; Info->Name; Info++) 654 { 655 if (Info->Opcode == ACPI_DMT_EXTRA_TEXT) 656 { 657 continue; 658 } 659 660 if (!LocalField) 661 { 662 sprintf (AslGbl_MsgBuffer, "Found NULL field - Field name \"%s\" needed", 663 Info->Name); 664 DtFatal (ASL_MSG_COMPILER_INTERNAL, NULL, AslGbl_MsgBuffer); 665 Status = AE_BAD_DATA; 666 goto Error; 667 } 668 669 /* Maintain table offsets */ 670 671 LocalField->TableOffset = AslGbl_CurrentTableOffset; 672 FieldLength = DtGetFieldLength (LocalField, Info); 673 AslGbl_CurrentTableOffset += FieldLength; 674 675 FieldType = DtGetFieldType (Info); 676 AslGbl_InputFieldCount++; 677 678 if (FieldType != DT_FIELD_TYPE_INLINE_SUBTABLE && 679 strcmp (Info->Name, LocalField->Name)) 680 { 681 sprintf (AslGbl_MsgBuffer, "found \"%s\" expected \"%s\"", 682 LocalField->Name, Info->Name); 683 DtError (ASL_ERROR, ASL_MSG_INVALID_LABEL, LocalField, AslGbl_MsgBuffer); 684 } 685 686 switch (FieldType) 687 { 688 case DT_FIELD_TYPE_FLAGS_INTEGER: 689 /* 690 * Start of the definition of a flags field. 691 * This master flags integer starts at value zero, in preparation 692 * to compile and insert the flag fields from the individual bits 693 */ 694 LocalField = LocalField->Next; 695 *Field = LocalField; 696 697 FlagBuffer = Buffer; 698 CurrentFlagByteOffset = Info->Offset; 699 break; 700 701 case DT_FIELD_TYPE_FLAG: 702 703 /* Individual Flag field, can be multiple bits */ 704 705 if (FlagBuffer) 706 { 707 /* 708 * We must increment the FlagBuffer when we have crossed 709 * into the next flags byte within the flags field 710 * of type DT_FIELD_TYPE_FLAGS_INTEGER. 711 */ 712 FlagBuffer += (Info->Offset - CurrentFlagByteOffset); 713 CurrentFlagByteOffset = Info->Offset; 714 715 DtCompileFlag (FlagBuffer, LocalField, Info); 716 } 717 else 718 { 719 /* TBD - this is an internal error */ 720 } 721 722 LocalField = LocalField->Next; 723 *Field = LocalField; 724 break; 725 726 case DT_FIELD_TYPE_INLINE_SUBTABLE: 727 /* 728 * Recursion (one level max): compile GAS (Generic Address) 729 * or Notify in-line subtable 730 */ 731 *Field = LocalField; 732 733 switch (Info->Opcode) 734 { 735 case ACPI_DMT_GAS: 736 737 Status = DtCompileTable (Field, AcpiDmTableInfoGas, 738 &InlineSubtable); 739 break; 740 741 case ACPI_DMT_HESTNTFY: 742 743 Status = DtCompileTable (Field, AcpiDmTableInfoHestNotify, 744 &InlineSubtable); 745 break; 746 747 case ACPI_DMT_IORTMEM: 748 749 Status = DtCompileTable (Field, AcpiDmTableInfoIortAcc, 750 &InlineSubtable); 751 break; 752 753 default: 754 sprintf (AslGbl_MsgBuffer, "Invalid DMT opcode: 0x%.2X", 755 Info->Opcode); 756 DtFatal (ASL_MSG_COMPILER_INTERNAL, NULL, AslGbl_MsgBuffer); 757 Status = AE_BAD_DATA; 758 break; 759 } 760 761 if (ACPI_FAILURE (Status)) 762 { 763 goto Error; 764 } 765 766 DtSetSubtableLength (InlineSubtable); 767 768 memcpy (Buffer, InlineSubtable->Buffer, FieldLength); 769 LocalField = *Field; 770 break; 771 772 case DT_FIELD_TYPE_LABEL: 773 774 DtWriteFieldToListing (Buffer, LocalField, 0); 775 LocalField = LocalField->Next; 776 break; 777 778 default: 779 780 /* Normal case for most field types (Integer, String, etc.) */ 781 782 DtCompileOneField (Buffer, LocalField, 783 FieldLength, FieldType, Info->Flags); 784 785 DtWriteFieldToListing (Buffer, LocalField, FieldLength); 786 LocalField = LocalField->Next; 787 788 if (Info->Flags & DT_LENGTH) 789 { 790 /* Field is an Integer that will contain a subtable length */ 791 792 Subtable->LengthField = Buffer; 793 Subtable->SizeOfLengthField = FieldLength; 794 } 795 break; 796 } 797 798 Buffer += FieldLength; 799 } 800 801 *Field = LocalField; 802 *RetSubtable = Subtable; 803 return (AE_OK); 804 805 Error: 806 ACPI_FREE (Subtable->Buffer); 807 ACPI_FREE (Subtable); 808 return (Status); 809 } 810 811 812 /****************************************************************************** 813 * 814 * FUNCTION: DtCompileTwoSubtables 815 * 816 * PARAMETERS: List - Current field list pointer 817 * TableInfo1 - Info table 1 818 * TableInfo1 - Info table 2 819 * 820 * RETURN: Status 821 * 822 * DESCRIPTION: Compile tables with a header and one or more same subtables. 823 * Include CPEP, EINJ, ERST, MCFG, MSCT, WDAT 824 * 825 *****************************************************************************/ 826 827 ACPI_STATUS 828 DtCompileTwoSubtables ( 829 void **List, 830 ACPI_DMTABLE_INFO *TableInfo1, 831 ACPI_DMTABLE_INFO *TableInfo2) 832 { 833 ACPI_STATUS Status; 834 DT_SUBTABLE *Subtable; 835 DT_SUBTABLE *ParentTable; 836 DT_FIELD **PFieldList = (DT_FIELD **) List; 837 838 839 Status = DtCompileTable (PFieldList, TableInfo1, &Subtable); 840 if (ACPI_FAILURE (Status)) 841 { 842 return (Status); 843 } 844 845 ParentTable = DtPeekSubtable (); 846 DtInsertSubtable (ParentTable, Subtable); 847 848 while (*PFieldList) 849 { 850 Status = DtCompileTable (PFieldList, TableInfo2, &Subtable); 851 if (ACPI_FAILURE (Status)) 852 { 853 return (Status); 854 } 855 856 DtInsertSubtable (ParentTable, Subtable); 857 } 858 859 return (AE_OK); 860 } 861 862 863 /****************************************************************************** 864 * 865 * FUNCTION: DtCompilePadding 866 * 867 * PARAMETERS: Length - Padding field size 868 * RetSubtable - Compile result of table 869 * 870 * RETURN: Status 871 * 872 * DESCRIPTION: Compile a subtable for padding purpose 873 * 874 *****************************************************************************/ 875 876 ACPI_STATUS 877 DtCompilePadding ( 878 UINT32 Length, 879 DT_SUBTABLE **RetSubtable) 880 { 881 DT_SUBTABLE *Subtable; 882 /* UINT8 *Buffer; */ 883 char *String; 884 885 886 Subtable = UtSubtableCacheCalloc (); 887 888 if (Length > 0) 889 { 890 String = UtLocalCacheCalloc (Length); 891 Subtable->Buffer = ACPI_CAST_PTR (UINT8, String); 892 } 893 894 Subtable->Length = Length; 895 Subtable->TotalLength = Length; 896 /* Buffer = Subtable->Buffer; */ 897 898 *RetSubtable = Subtable; 899 return (AE_OK); 900 } 901