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

   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
  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     /*
 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
 160 CleanupAndExit:
 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
 180 static ACPI_STATUS
 181 DtInitialize (
 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
 221 static void
 222 DtInsertCompilerIds (
 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
 267 static ACPI_STATUS
 268 DtCompileDataTable (
 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
 383 Out:
 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
 410 ACPI_STATUS
 411 DtCompileTable (
 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
 585 Error:
 586     ACPI_FREE (Subtable->Buffer);
 587     ACPI_FREE (Subtable);
 588     return (Status);
 589 }