sys/contrib/dev/acpica-unix/compiler/dtcompile.c

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