sys/contrib/dev/acpica/source/common/adisasm.c

   1 /******************************************************************************
   2  *
   3  * Module Name: adisasm - Application-level disassembler routines
   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 #include "aslcompiler.h"
  45 #include "acparser.h"
  46 #include "amlcode.h"
  47 #include "acdisasm.h"
  48 #include "acdispat.h"
  49 #include "acnamesp.h"
  50 #include "actables.h"
  51 #include "acapps.h"
  52
  53 #include <stdio.h>
  54 #include <time.h>
  55
  56
  57 #define _COMPONENT          ACPI_TOOLS
  58         ACPI_MODULE_NAME    ("adisasm")
  59
  60 /* Local prototypes */
  61
  62 static void
  63 AdCreateTableHeader (
  64     char                    *Filename,
  65     ACPI_TABLE_HEADER       *Table);
  66
  67 static ACPI_STATUS
  68 AdStoreTable (
  69     ACPI_TABLE_HEADER       *Table,
  70     UINT32                  *TableIndex);
  71
  72 /* Stubs for ASL compiler */
  73
  74 #ifndef ACPI_ASL_COMPILER
  75 BOOLEAN
  76 AcpiDsIsResultUsed (
  77     ACPI_PARSE_OBJECT       *Op,
  78     ACPI_WALK_STATE         *WalkState)
  79 {
  80     return TRUE;
  81 }
  82
  83 ACPI_STATUS
  84 AcpiDsMethodError (
  85     ACPI_STATUS             Status,
  86     ACPI_WALK_STATE         *WalkState)
  87 {
  88     return (Status);
  89 }
  90 #endif
  91
  92 ACPI_STATUS
  93 AcpiNsLoadTable (
  94     UINT32                  TableIndex,
  95     ACPI_NAMESPACE_NODE     *Node)
  96 {
  97     return (AE_NOT_IMPLEMENTED);
  98 }
  99
 100 ACPI_STATUS
 101 AcpiDsRestartControlMethod (
 102     ACPI_WALK_STATE         *WalkState,
 103     ACPI_OPERAND_OBJECT     *ReturnDesc)
 104 {
 105     return (AE_OK);
 106 }
 107
 108 void
 109 AcpiDsTerminateControlMethod (
 110     ACPI_OPERAND_OBJECT     *MethodDesc,
 111     ACPI_WALK_STATE         *WalkState)
 112 {
 113     return;
 114 }
 115
 116 ACPI_STATUS
 117 AcpiDsCallControlMethod (
 118     ACPI_THREAD_STATE       *Thread,
 119     ACPI_WALK_STATE         *WalkState,
 120     ACPI_PARSE_OBJECT       *Op)
 121 {
 122     return (AE_OK);
 123 }
 124
 125 ACPI_STATUS
 126 AcpiDsMethodDataInitArgs (
 127     ACPI_OPERAND_OBJECT     **Params,
 128     UINT32                  MaxParamCount,
 129     ACPI_WALK_STATE         *WalkState)
 130 {
 131     return (AE_OK);
 132 }
 133
 134
 135 static ACPI_TABLE_DESC      LocalTables[1];
 136 ACPI_PARSE_OBJECT    *AcpiGbl_ParseOpRoot;
 137
 138
 139 /*******************************************************************************
 140  *
 141  * FUNCTION:    AdInitialize
 142  *
 143  * PARAMETERS:  None
 144  *
 145  * RETURN:      Status
 146  *
 147  * DESCRIPTION: ACPICA and local initialization
 148  *
 149  ******************************************************************************/
 150
 151 ACPI_STATUS
 152 AdInitialize (
 153     void)
 154 {
 155     ACPI_STATUS             Status;
 156
 157
 158     /* ACPICA subsystem initialization */
 159
 160     Status = AcpiOsInitialize ();
 161     if (ACPI_FAILURE (Status))
 162     {
 163         return (Status);
 164     }
 165
 166     Status = AcpiUtInitGlobals ();
 167     if (ACPI_FAILURE (Status))
 168     {
 169         return (Status);
 170     }
 171
 172     Status = AcpiUtMutexInitialize ();
 173     if (ACPI_FAILURE (Status))
 174     {
 175         return (Status);
 176     }
 177
 178     Status = AcpiNsRootInitialize ();
 179     if (ACPI_FAILURE (Status))
 180     {
 181         return (Status);
 182     }
 183
 184     /* Setup the Table Manager (cheat - there is no RSDT) */
 185
 186     AcpiGbl_RootTableList.MaxTableCount = 1;
 187     AcpiGbl_RootTableList.CurrentTableCount = 0;
 188     AcpiGbl_RootTableList.Tables = LocalTables;
 189
 190     return (Status);
 191 }
 192
 193
 194 /******************************************************************************
 195  *
 196  * FUNCTION:    AdAmlDisassemble
 197  *
 198  * PARAMETERS:  Filename            - AML input filename
 199  *              OutToFile           - TRUE if output should go to a file
 200  *              Prefix              - Path prefix for output
 201  *              OutFilename         - where the filename is returned
 202  *
 203  * RETURN:      Status
 204  *
 205  * DESCRIPTION: Disassemble an entire ACPI table
 206  *
 207  *****************************************************************************/
 208
 209 ACPI_STATUS
 210 AdAmlDisassemble (
 211     BOOLEAN                 OutToFile,
 212     char                    *Filename,
 213     char                    *Prefix,
 214     char                    **OutFilename)
 215 {
 216     ACPI_STATUS             Status;
 217     ACPI_STATUS             GlobalStatus = AE_OK;
 218     char                    *DisasmFilename = NULL;
 219     char                    *ExternalFilename;
 220     ACPI_EXTERNAL_FILE      *ExternalFileList = AcpiGbl_ExternalFileList;
 221     FILE                    *File = NULL;
 222     ACPI_TABLE_HEADER       *Table = NULL;
 223     ACPI_TABLE_HEADER       *ExternalTable;
 224     ACPI_OWNER_ID           OwnerId;
 225
 226
 227     /*
 228      * Input: AML code from either a file or via GetTables (memory or
 229      * registry)
 230      */
 231     if (Filename)
 232     {
 233         Status = AcpiDbGetTableFromFile (Filename, &Table, FALSE);
 234         if (ACPI_FAILURE (Status))
 235         {
 236             return (Status);
 237         }
 238
 239         /*
 240          * External filenames separated by commas
 241          * Example: iasl -e file1,file2,file3 -d xxx.aml
 242          */
 243         while (ExternalFileList)
 244         {
 245             ExternalFilename = ExternalFileList->Path;
 246             if (!strcmp (ExternalFilename, Filename))
 247             {
 248                 /* Next external file */
 249
 250                 ExternalFileList = ExternalFileList->Next;
 251                 continue;
 252             }
 253
 254             Status = AcpiDbGetTableFromFile (ExternalFilename, &ExternalTable, TRUE);
 255             if (ACPI_FAILURE (Status))
 256             {
 257                 if (Status == AE_TYPE)
 258                 {
 259                     ExternalFileList = ExternalFileList->Next;
 260                     GlobalStatus = AE_TYPE;
 261                     Status = AE_OK;
 262                     continue;
 263                 }
 264                 return (Status);
 265             }
 266
 267             /* Load external table for symbol resolution */
 268
 269             if (ExternalTable)
 270             {
 271                 Status = AdParseTable (ExternalTable, &OwnerId, TRUE, TRUE);
 272                 if (ACPI_FAILURE (Status))
 273                 {
 274                     AcpiOsPrintf ("Could not parse external ACPI tables, %s\n",
 275                         AcpiFormatException (Status));
 276                     return (Status);
 277                 }
 278
 279                 /*
 280                  * Load namespace from names created within control methods
 281                  * Set owner id of nodes in external table
 282                  */
 283                 AcpiDmFinishNamespaceLoad (AcpiGbl_ParseOpRoot,
 284                     AcpiGbl_RootNode, OwnerId);
 285                 AcpiPsDeleteParseTree (AcpiGbl_ParseOpRoot);
 286             }
 287
 288             /* Next external file */
 289
 290             ExternalFileList = ExternalFileList->Next;
 291         }
 292
 293         if (ACPI_FAILURE (GlobalStatus))
 294         {
 295             return (GlobalStatus);
 296         }
 297
 298         /* Clear external list generated by Scope in external tables */
 299
 300         if (AcpiGbl_ExternalFileList)
 301         {
 302             AcpiDmClearExternalList ();
 303         }
 304
 305         /* Load any externals defined in the optional external ref file */
 306
 307         AcpiDmGetExternalsFromFile ();
 308     }
 309     else
 310     {
 311         Status = AdGetLocalTables ();
 312         if (ACPI_FAILURE (Status))
 313         {
 314             AcpiOsPrintf ("Could not get ACPI tables, %s\n",
 315                 AcpiFormatException (Status));
 316             return (Status);
 317         }
 318
 319         if (!AcpiGbl_DbOpt_Disasm)
 320         {
 321             return (AE_OK);
 322         }
 323
 324         /* Obtained the local tables, just disassemble the DSDT */
 325
 326         Status = AcpiGetTable (ACPI_SIG_DSDT, 0, &Table);
 327         if (ACPI_FAILURE (Status))
 328         {
 329             AcpiOsPrintf ("Could not get DSDT, %s\n",
 330                 AcpiFormatException (Status));
 331             return (Status);
 332         }
 333
 334         AcpiOsPrintf ("\nDisassembly of DSDT\n");
 335         Prefix = AdGenerateFilename ("dsdt", Table->OemTableId);
 336     }
 337
 338     /*
 339      * Output: ASL code. Redirect to a file if requested
 340      */
 341     if (OutToFile)
 342     {
 343         /* Create/Open a disassembly output file */
 344
 345         DisasmFilename = FlGenerateFilename (Prefix, FILE_SUFFIX_DISASSEMBLY);
 346         if (!DisasmFilename)
 347         {
 348             fprintf (stderr, "Could not generate output filename\n");
 349             Status = AE_ERROR;
 350             goto Cleanup;
 351         }
 352
 353         File = fopen (DisasmFilename, "w+");
 354         if (!File)
 355         {
 356             fprintf (stderr, "Could not open output file %s\n", DisasmFilename);
 357             Status = AE_ERROR;
 358             goto Cleanup;
 359         }
 360
 361         AcpiOsRedirectOutput (File);
 362     }
 363
 364     *OutFilename = DisasmFilename;
 365
 366     /* ForceAmlDisassembly means to assume the table contains valid AML */
 367
 368     if (!AcpiGbl_ForceAmlDisassembly && !AcpiUtIsAmlTable (Table))
 369     {
 370         AdDisassemblerHeader (Filename, ACPI_IS_DATA_TABLE);
 371         AcpiOsPrintf (" * ACPI Data Table [%4.4s]\n *\n",
 372             Table->Signature);
 373         AcpiOsPrintf (" * Format: [HexOffset DecimalOffset ByteLength]  "
 374             "FieldName : FieldValue\n */\n\n");
 375
 376         AcpiDmDumpDataTable (Table);
 377         fprintf (stderr, "Acpi Data Table [%4.4s] decoded\n",
 378             Table->Signature);
 379
 380         if (File)
 381         {
 382             fprintf (stderr, "Formatted output:  %s - %u bytes\n",
 383                 DisasmFilename, CmGetFileSize (File));
 384         }
 385     }
 386     else
 387     {
 388         /* Always parse the tables, only option is what to display */
 389
 390         Status = AdParseTable (Table, &OwnerId, TRUE, FALSE);
 391         if (ACPI_FAILURE (Status))
 392         {
 393             AcpiOsPrintf ("Could not parse ACPI tables, %s\n",
 394                 AcpiFormatException (Status));
 395             goto Cleanup;
 396         }
 397
 398         if (AslCompilerdebug)
 399         {
 400             AcpiOsPrintf ("/**** Before second load\n");
 401
 402             if (File)
 403             {
 404                 NsSetupNamespaceListing (File);
 405                 NsDisplayNamespace ();
 406             }
 407             AcpiOsPrintf ("*****/\n");
 408         }
 409
 410         /* Load namespace from names created within control methods */
 411
 412         AcpiDmFinishNamespaceLoad (AcpiGbl_ParseOpRoot,
 413             AcpiGbl_RootNode, OwnerId);
 414
 415         /*
 416          * Cross reference the namespace here, in order to
 417          * generate External() statements
 418          */
 419         AcpiDmCrossReferenceNamespace (AcpiGbl_ParseOpRoot,
 420             AcpiGbl_RootNode, OwnerId);
 421
 422         if (AslCompilerdebug)
 423         {
 424             AcpiDmDumpTree (AcpiGbl_ParseOpRoot);
 425         }
 426
 427         /* Find possible calls to external control methods */
 428
 429         AcpiDmFindOrphanMethods (AcpiGbl_ParseOpRoot);
 430
 431         /*
 432          * If we found any external control methods, we must reparse
 433          * the entire tree with the new information (namely, the
 434          * number of arguments per method)
 435          */
 436         if (AcpiDmGetExternalMethodCount ())
 437         {
 438             fprintf (stderr,
 439                 "\nFound %u external control methods, "
 440                 "reparsing with new information\n",
 441                 AcpiDmGetExternalMethodCount ());
 442
 443             /* Reparse, rebuild namespace */
 444
 445             AcpiPsDeleteParseTree (AcpiGbl_ParseOpRoot);
 446             AcpiGbl_ParseOpRoot = NULL;
 447             AcpiNsDeleteNamespaceSubtree (AcpiGbl_RootNode);
 448
 449             AcpiGbl_RootNode                    = NULL;
 450             AcpiGbl_RootNodeStruct.Name.Integer = ACPI_ROOT_NAME;
 451             AcpiGbl_RootNodeStruct.DescriptorType = ACPI_DESC_TYPE_NAMED;
 452             AcpiGbl_RootNodeStruct.Type         = ACPI_TYPE_DEVICE;
 453             AcpiGbl_RootNodeStruct.Parent       = NULL;
 454             AcpiGbl_RootNodeStruct.Child        = NULL;
 455             AcpiGbl_RootNodeStruct.Peer         = NULL;
 456             AcpiGbl_RootNodeStruct.Object       = NULL;
 457             AcpiGbl_RootNodeStruct.Flags        = 0;
 458
 459             Status = AcpiNsRootInitialize ();
 460
 461             /* New namespace, add the external definitions first */
 462
 463             AcpiDmAddExternalsToNamespace ();
 464
 465             /* Parse the table again. No need to reload it, however */
 466
 467             Status = AdParseTable (Table, NULL, FALSE, FALSE);
 468             if (ACPI_FAILURE (Status))
 469             {
 470                 AcpiOsPrintf ("Could not parse ACPI tables, %s\n",
 471                     AcpiFormatException (Status));
 472                 goto Cleanup;
 473             }
 474
 475             /* Cross reference the namespace again */
 476
 477             AcpiDmFinishNamespaceLoad (AcpiGbl_ParseOpRoot,
 478                 AcpiGbl_RootNode, OwnerId);
 479
 480             AcpiDmCrossReferenceNamespace (AcpiGbl_ParseOpRoot,
 481                 AcpiGbl_RootNode, OwnerId);
 482
 483             if (AslCompilerdebug)
 484             {
 485                 AcpiOsPrintf ("/**** After second load and resource conversion\n");
 486                 if (File)
 487                 {
 488                     NsSetupNamespaceListing (File);
 489                     NsDisplayNamespace ();
 490                 }
 491                 AcpiOsPrintf ("*****/\n");
 492
 493                 AcpiDmDumpTree (AcpiGbl_ParseOpRoot);
 494             }
 495         }
 496
 497         /*
 498          * Now that the namespace is finalized, we can perform namespace
 499          * transforms.
 500          *
 501          * 1) Convert fixed-offset references to resource descriptors
 502          *    to symbolic references (Note: modifies namespace)
 503          */
 504         AcpiDmConvertResourceIndexes (AcpiGbl_ParseOpRoot, AcpiGbl_RootNode);
 505
 506         /* Optional displays */
 507
 508         if (AcpiGbl_DbOpt_Disasm)
 509         {
 510             /* This is the real disassembly */
 511
 512             AdDisplayTables (Filename, Table);
 513
 514             /* Dump hex table if requested (-vt) */
 515
 516             AcpiDmDumpDataTable (Table);
 517
 518             fprintf (stderr, "Disassembly completed\n");
 519             if (File)
 520             {
 521                 fprintf (stderr, "ASL Output:    %s - %u bytes\n",
 522                     DisasmFilename, CmGetFileSize (File));
 523             }
 524
 525             if (Gbl_MapfileFlag)
 526             {
 527                 fprintf (stderr, "%14s %s - %u bytes\n",
 528                     Gbl_Files[ASL_FILE_MAP_OUTPUT].ShortDescription,
 529                     Gbl_Files[ASL_FILE_MAP_OUTPUT].Filename,
 530                     FlGetFileSize (ASL_FILE_MAP_OUTPUT));
 531             }
 532         }
 533     }
 534
 535 Cleanup:
 536
 537     if (Table && !AcpiGbl_ForceAmlDisassembly &&!AcpiUtIsAmlTable (Table))
 538     {
 539         ACPI_FREE (Table);
 540     }
 541
 542     if (File)
 543     {
 544         if (AslCompilerdebug) /* Display final namespace, with transforms */
 545         {
 546             NsSetupNamespaceListing (File);
 547             NsDisplayNamespace ();
 548         }
 549
 550         fclose (File);
 551         AcpiOsRedirectOutput (stdout);
 552     }
 553
 554     AcpiPsDeleteParseTree (AcpiGbl_ParseOpRoot);
 555     AcpiGbl_ParseOpRoot = NULL;
 556     return (Status);
 557 }
 558
 559
 560 /******************************************************************************
 561  *
 562  * FUNCTION:    AdDisassemblerHeader
 563  *
 564  * PARAMETERS:  Filename            - Input file for the table
 565  *              TableType           - Either AML or DataTable
 566  *
 567  * RETURN:      None
 568  *
 569  * DESCRIPTION: Create the disassembler header, including ACPICA signon with
 570  *              current time and date.
 571  *
 572  *****************************************************************************/
 573
 574 void
 575 AdDisassemblerHeader (
 576     char                    *Filename,
 577     UINT8                   TableType)
 578 {
 579     time_t                  Timer;
 580
 581
 582     time (&Timer);
 583
 584     /* Header and input table info */
 585
 586     AcpiOsPrintf ("/*\n");
 587     AcpiOsPrintf (ACPI_COMMON_HEADER (AML_DISASSEMBLER_NAME, " * "));
 588
 589     if (TableType == ACPI_IS_AML_TABLE)
 590     {
 591         if (AcpiGbl_CstyleDisassembly)
 592         {
 593             AcpiOsPrintf (
 594                 " * Disassembling to symbolic ASL+ operators\n"
 595                 " *\n");
 596         }
 597         else
 598         {
 599             AcpiOsPrintf (
 600                 " * Disassembling to non-symbolic legacy ASL operators\n"
 601                 " *\n");
 602         }
 603     }
 604
 605     AcpiOsPrintf (" * Disassembly of %s, %s", Filename, ctime (&Timer));
 606     AcpiOsPrintf (" *\n");
 607 }
 608
 609
 610 /******************************************************************************
 611  *
 612  * FUNCTION:    AdCreateTableHeader
 613  *
 614  * PARAMETERS:  Filename            - Input file for the table
 615  *              Table               - Pointer to the raw table
 616  *
 617  * RETURN:      None
 618  *
 619  * DESCRIPTION: Create the ASL table header, including ACPICA signon with
 620  *              current time and date.
 621  *
 622  *****************************************************************************/
 623
 624 static void
 625 AdCreateTableHeader (
 626     char                    *Filename,
 627     ACPI_TABLE_HEADER       *Table)
 628 {
 629     char                    *NewFilename;
 630     UINT8                   Checksum;
 631
 632
 633     /*
 634      * Print file header and dump original table header
 635      */
 636     AdDisassemblerHeader (Filename, ACPI_IS_AML_TABLE);
 637
 638     AcpiOsPrintf (" * Original Table Header:\n");
 639     AcpiOsPrintf (" *     Signature        \"%4.4s\"\n",    Table->Signature);
 640     AcpiOsPrintf (" *     Length           0x%8.8X (%u)\n", Table->Length, Table->Length);
 641
 642     /* Print and validate the revision */
 643
 644     AcpiOsPrintf (" *     Revision         0x%2.2X",      Table->Revision);
 645
 646     switch (Table->Revision)
 647     {
 648     case 0:
 649
 650         AcpiOsPrintf (" **** Invalid Revision");
 651         break;
 652
 653     case 1:
 654
 655         /* Revision of DSDT controls the ACPI integer width */
 656
 657         if (ACPI_COMPARE_NAME (Table->Signature, ACPI_SIG_DSDT))
 658         {
 659             AcpiOsPrintf (" **** 32-bit table (V1), no 64-bit math support");
 660         }
 661         break;
 662
 663     default:
 664
 665         break;
 666     }
 667     AcpiOsPrintf ("\n");
 668
 669     /* Print and validate the table checksum */
 670
 671     AcpiOsPrintf (" *     Checksum         0x%2.2X",        Table->Checksum);
 672
 673     Checksum = AcpiTbChecksum (ACPI_CAST_PTR (UINT8, Table), Table->Length);
 674     if (Checksum)
 675     {
 676         AcpiOsPrintf (" **** Incorrect checksum, should be 0x%2.2X",
 677             (UINT8) (Table->Checksum - Checksum));
 678     }
 679     AcpiOsPrintf ("\n");
 680
 681     AcpiOsPrintf (" *     OEM ID           \"%.6s\"\n",     Table->OemId);
 682     AcpiOsPrintf (" *     OEM Table ID     \"%.8s\"\n",     Table->OemTableId);
 683     AcpiOsPrintf (" *     OEM Revision     0x%8.8X (%u)\n", Table->OemRevision, Table->OemRevision);
 684     AcpiOsPrintf (" *     Compiler ID      \"%.4s\"\n",     Table->AslCompilerId);
 685     AcpiOsPrintf (" *     Compiler Version 0x%8.8X (%u)\n", Table->AslCompilerRevision, Table->AslCompilerRevision);
 686     AcpiOsPrintf (" */\n");
 687
 688     /* Create AML output filename based on input filename */
 689
 690     if (Filename)
 691     {
 692         NewFilename = FlGenerateFilename (Filename, "aml");
 693     }
 694     else
 695     {
 696         NewFilename = UtStringCacheCalloc (9);
 697         if (NewFilename)
 698         {
 699             strncat (NewFilename, Table->Signature, 4);
 700             strcat (NewFilename, ".aml");
 701         }
 702     }
 703
 704     if (!NewFilename)
 705     {
 706         AcpiOsPrintf (" **** Could not generate AML output filename\n");
 707         return;
 708     }
 709
 710     /* Open the ASL definition block */
 711
 712     AcpiOsPrintf (
 713         "DefinitionBlock (\"%s\", \"%4.4s\", %hu, \"%.6s\", \"%.8s\", 0x%8.8X)\n",
 714         NewFilename, Table->Signature, Table->Revision,
 715         Table->OemId, Table->OemTableId, Table->OemRevision);
 716 }
 717
 718
 719 /******************************************************************************
 720  *
 721  * FUNCTION:    AdDisplayTables
 722  *
 723  * PARAMETERS:  Filename            - Input file for the table
 724  *              Table               - Pointer to the raw table
 725  *
 726  * RETURN:      Status
 727  *
 728  * DESCRIPTION: Display (disassemble) loaded tables and dump raw tables
 729  *
 730  *****************************************************************************/
 731
 732 ACPI_STATUS
 733 AdDisplayTables (
 734     char                    *Filename,
 735     ACPI_TABLE_HEADER       *Table)
 736 {
 737
 738
 739     if (!AcpiGbl_ParseOpRoot)
 740     {
 741         return (AE_NOT_EXIST);
 742     }
 743
 744     if (!AcpiGbl_DbOpt_Verbose)
 745     {
 746         AdCreateTableHeader (Filename, Table);
 747     }
 748
 749     AcpiDmDisassemble (NULL, AcpiGbl_ParseOpRoot, ACPI_UINT32_MAX);
 750     MpEmitMappingInfo ();
 751
 752     if (AcpiGbl_DbOpt_Verbose)
 753     {
 754         AcpiOsPrintf ("\n\nTable Header:\n");
 755         AcpiUtDebugDumpBuffer ((UINT8 *) Table, sizeof (ACPI_TABLE_HEADER),
 756             DB_BYTE_DISPLAY, ACPI_UINT32_MAX);
 757
 758         AcpiOsPrintf ("Table Body (Length 0x%X)\n", Table->Length);
 759         AcpiUtDebugDumpBuffer (((UINT8 *) Table + sizeof (ACPI_TABLE_HEADER)),
 760             Table->Length, DB_BYTE_DISPLAY, ACPI_UINT32_MAX);
 761     }
 762
 763     return (AE_OK);
 764 }
 765
 766
 767 /*******************************************************************************
 768  *
 769  * FUNCTION:    AdStoreTable
 770  *
 771  * PARAMETERS:  Table               - Table header
 772  *              TableIndex          - Where the table index is returned
 773  *
 774  * RETURN:      Status and table index.
 775  *
 776  * DESCRIPTION: Add an ACPI table to the global table list
 777  *
 778  ******************************************************************************/
 779
 780 static ACPI_STATUS
 781 AdStoreTable (
 782     ACPI_TABLE_HEADER       *Table,
 783     UINT32                  *TableIndex)
 784 {
 785     ACPI_STATUS             Status;
 786     ACPI_TABLE_DESC         *TableDesc;
 787
 788
 789     Status = AcpiTbGetNextTableDescriptor (TableIndex, &TableDesc);
 790     if (ACPI_FAILURE (Status))
 791     {
 792         return (Status);
 793     }
 794
 795     /* Initialize added table */
 796
 797     AcpiTbInitTableDescriptor (TableDesc, ACPI_PTR_TO_PHYSADDR (Table),
 798         ACPI_TABLE_ORIGIN_INTERNAL_VIRTUAL, Table);
 799     AcpiTbValidateTable (TableDesc);
 800     return (AE_OK);
 801 }
 802
 803
 804 /******************************************************************************
 805  *
 806  * FUNCTION:    AdGetLocalTables
 807  *
 808  * PARAMETERS:  None
 809  *
 810  * RETURN:      Status
 811  *
 812  * DESCRIPTION: Get the ACPI tables from either memory or a file
 813  *
 814  *****************************************************************************/
 815
 816 ACPI_STATUS
 817 AdGetLocalTables (
 818     void)
 819 {
 820     ACPI_STATUS             Status;
 821     ACPI_TABLE_HEADER       TableHeader;
 822     ACPI_TABLE_HEADER       *NewTable;
 823     UINT32                  TableIndex;
 824
 825
 826     /* Get the DSDT via table override */
 827
 828     ACPI_MOVE_32_TO_32 (TableHeader.Signature, ACPI_SIG_DSDT);
 829     AcpiOsTableOverride (&TableHeader, &NewTable);
 830     if (!NewTable)
 831     {
 832         fprintf (stderr, "Could not obtain DSDT\n");
 833         return (AE_NO_ACPI_TABLES);
 834     }
 835
 836     AdWriteTable (NewTable, NewTable->Length,
 837         ACPI_SIG_DSDT, NewTable->OemTableId);
 838
 839     /* Store DSDT in the Table Manager */
 840
 841     Status = AdStoreTable (NewTable, &TableIndex);
 842     if (ACPI_FAILURE (Status))
 843     {
 844         fprintf (stderr, "Could not store DSDT\n");
 845         return (AE_NO_ACPI_TABLES);
 846     }
 847
 848     return (AE_OK);
 849 }
 850
 851
 852 /******************************************************************************
 853  *
 854  * FUNCTION:    AdParseTable
 855  *
 856  * PARAMETERS:  Table               - Pointer to the raw table
 857  *              OwnerId             - Returned OwnerId of the table
 858  *              LoadTable           - If add table to the global table list
 859  *              External            - If this is an external table
 860  *
 861  * RETURN:      Status
 862  *
 863  * DESCRIPTION: Parse the DSDT.
 864  *
 865  *****************************************************************************/
 866
 867 ACPI_STATUS
 868 AdParseTable (
 869     ACPI_TABLE_HEADER       *Table,
 870     ACPI_OWNER_ID           *OwnerId,
 871     BOOLEAN                 LoadTable,
 872     BOOLEAN                 External)
 873 {
 874     ACPI_STATUS             Status = AE_OK;
 875     ACPI_WALK_STATE         *WalkState;
 876     UINT8                   *AmlStart;
 877     UINT32                  AmlLength;
 878     UINT32                  TableIndex;
 879
 880
 881     if (!Table)
 882     {
 883         return (AE_NOT_EXIST);
 884     }
 885
 886     /* Pass 1:  Parse everything except control method bodies */
 887
 888     fprintf (stderr, "Pass 1 parse of [%4.4s]\n", (char *) Table->Signature);
 889
 890     AmlLength = Table->Length - sizeof (ACPI_TABLE_HEADER);
 891     AmlStart = ((UINT8 *) Table + sizeof (ACPI_TABLE_HEADER));
 892
 893     /* Create the root object */
 894
 895     AcpiGbl_ParseOpRoot = AcpiPsCreateScopeOp ();
 896     if (!AcpiGbl_ParseOpRoot)
 897     {
 898         return (AE_NO_MEMORY);
 899     }
 900
 901     /* Create and initialize a new walk state */
 902
 903     WalkState = AcpiDsCreateWalkState (0,
 904                         AcpiGbl_ParseOpRoot, NULL, NULL);
 905     if (!WalkState)
 906     {
 907         return (AE_NO_MEMORY);
 908     }
 909
 910     Status = AcpiDsInitAmlWalk (WalkState, AcpiGbl_ParseOpRoot,
 911                 NULL, AmlStart, AmlLength, NULL, ACPI_IMODE_LOAD_PASS1);
 912     if (ACPI_FAILURE (Status))
 913     {
 914         return (Status);
 915     }
 916
 917     WalkState->ParseFlags &= ~ACPI_PARSE_DELETE_TREE;
 918     WalkState->ParseFlags |= ACPI_PARSE_DISASSEMBLE;
 919
 920     Status = AcpiPsParseAml (WalkState);
 921     if (ACPI_FAILURE (Status))
 922     {
 923         return (Status);
 924     }
 925
 926     /* If LoadTable is FALSE, we are parsing the last loaded table */
 927
 928     TableIndex = AcpiGbl_RootTableList.CurrentTableCount - 1;
 929
 930     /* Pass 2 */
 931
 932     if (LoadTable)
 933     {
 934         Status = AdStoreTable (Table, &TableIndex);
 935         if (ACPI_FAILURE (Status))
 936         {
 937             return (Status);
 938         }
 939         Status = AcpiTbAllocateOwnerId (TableIndex);
 940         if (ACPI_FAILURE (Status))
 941         {
 942             return (Status);
 943         }
 944         if (OwnerId)
 945         {
 946             Status = AcpiTbGetOwnerId (TableIndex, OwnerId);
 947             if (ACPI_FAILURE (Status))
 948             {
 949                 return (Status);
 950             }
 951         }
 952     }
 953
 954     fprintf (stderr, "Pass 2 parse of [%4.4s]\n", (char *) Table->Signature);
 955
 956     Status = AcpiNsOneCompleteParse (ACPI_IMODE_LOAD_PASS2, TableIndex, NULL);
 957     if (ACPI_FAILURE (Status))
 958     {
 959         return (Status);
 960     }
 961
 962     /* No need to parse control methods of external table */
 963
 964     if (External)
 965     {
 966         return (AE_OK);
 967     }
 968
 969     /*
 970      * Pass 3: Parse control methods and link their parse trees
 971      * into the main parse tree
 972      */
 973     fprintf (stderr,
 974         "Parsing Deferred Opcodes (Methods/Buffers/Packages/Regions)\n");
 975     Status = AcpiDmParseDeferredOps (AcpiGbl_ParseOpRoot);
 976     fprintf (stderr, "\n");
 977
 978     /* Process Resource Templates */
 979
 980     AcpiDmFindResources (AcpiGbl_ParseOpRoot);
 981
 982     fprintf (stderr, "Parsing completed\n");
 983     return (AE_OK);
 984 }