sys/contrib/dev/acpica-unix-20061109/tools/acpixtract/acpixtract.c

   1
   2 /******************************************************************************
   3  *
   4  * Module Name: acpixtract - convert ascii ACPI tables to binary
   5  *              $Revision: 1.5 $
   6  *
   7  *****************************************************************************/
   8
   9 /******************************************************************************
  10  *
  11  * 1. Copyright Notice
  12  *
  13  * Some or all of this work - Copyright (c) 1999 - 2006, Intel Corp.
  14  * All rights reserved.
  15  *
  16  * 2. License
  17  *
  18  * 2.1. This is your license from Intel Corp. under its intellectual property
  19  * rights.  You may have additional license terms from the party that provided
  20  * you this software, covering your right to use that party's intellectual
  21  * property rights.
  22  *
  23  * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
  24  * copy of the source code appearing in this file ("Covered Code") an
  25  * irrevocable, perpetual, worldwide license under Intel's copyrights in the
  26  * base code distributed originally by Intel ("Original Intel Code") to copy,
  27  * make derivatives, distribute, use and display any portion of the Covered
  28  * Code in any form, with the right to sublicense such rights; and
  29  *
  30  * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
  31  * license (with the right to sublicense), under only those claims of Intel
  32  * patents that are infringed by the Original Intel Code, to make, use, sell,
  33  * offer to sell, and import the Covered Code and derivative works thereof
  34  * solely to the minimum extent necessary to exercise the above copyright
  35  * license, and in no event shall the patent license extend to any additions
  36  * to or modifications of the Original Intel Code.  No other license or right
  37  * is granted directly or by implication, estoppel or otherwise;
  38  *
  39  * The above copyright and patent license is granted only if the following
  40  * conditions are met:
  41  *
  42  * 3. Conditions
  43  *
  44  * 3.1. Redistribution of Source with Rights to Further Distribute Source.
  45  * Redistribution of source code of any substantial portion of the Covered
  46  * Code or modification with rights to further distribute source must include
  47  * the above Copyright Notice, the above License, this list of Conditions,
  48  * and the following Disclaimer and Export Compliance provision.  In addition,
  49  * Licensee must cause all Covered Code to which Licensee contributes to
  50  * contain a file documenting the changes Licensee made to create that Covered
  51  * Code and the date of any change.  Licensee must include in that file the
  52  * documentation of any changes made by any predecessor Licensee.  Licensee
  53  * must include a prominent statement that the modification is derived,
  54  * directly or indirectly, from Original Intel Code.
  55  *
  56  * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
  57  * Redistribution of source code of any substantial portion of the Covered
  58  * Code or modification without rights to further distribute source must
  59  * include the following Disclaimer and Export Compliance provision in the
  60  * documentation and/or other materials provided with distribution.  In
  61  * addition, Licensee may not authorize further sublicense of source of any
  62  * portion of the Covered Code, and must include terms to the effect that the
  63  * license from Licensee to its licensee is limited to the intellectual
  64  * property embodied in the software Licensee provides to its licensee, and
  65  * not to intellectual property embodied in modifications its licensee may
  66  * make.
  67  *
  68  * 3.3. Redistribution of Executable. Redistribution in executable form of any
  69  * substantial portion of the Covered Code or modification must reproduce the
  70  * above Copyright Notice, and the following Disclaimer and Export Compliance
  71  * provision in the documentation and/or other materials provided with the
  72  * distribution.
  73  *
  74  * 3.4. Intel retains all right, title, and interest in and to the Original
  75  * Intel Code.
  76  *
  77  * 3.5. Neither the name Intel nor any other trademark owned or controlled by
  78  * Intel shall be used in advertising or otherwise to promote the sale, use or
  79  * other dealings in products derived from or relating to the Covered Code
  80  * without prior written authorization from Intel.
  81  *
  82  * 4. Disclaimer and Export Compliance
  83  *
  84  * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
  85  * HERE.  ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
  86  * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT,  ASSISTANCE,
  87  * INSTALLATION, TRAINING OR OTHER SERVICES.  INTEL WILL NOT PROVIDE ANY
  88  * UPDATES, ENHANCEMENTS OR EXTENSIONS.  INTEL SPECIFICALLY DISCLAIMS ANY
  89  * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
  90  * PARTICULAR PURPOSE.
  91  *
  92  * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
  93  * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
  94  * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
  95  * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
  96  * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
  97  * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES.  THESE LIMITATIONS
  98  * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
  99  * LIMITED REMEDY.
 100  *
 101  * 4.3. Licensee shall not export, either directly or indirectly, any of this
 102  * software or system incorporating such software without first obtaining any
 103  * required license or other approval from the U. S. Department of Commerce or
 104  * any other agency or department of the United States Government.  In the
 105  * event Licensee exports any such software from the United States or
 106  * re-exports any such software from a foreign destination, Licensee shall
 107  * ensure that the distribution and export/re-export of the software is in
 108  * compliance with all laws, regulations, orders, or other restrictions of the
 109  * U.S. Export Administration Regulations. Licensee agrees that neither it nor
 110  * any of its subsidiaries will export/re-export any technical data, process,
 111  * software, or service, directly or indirectly, to any country for which the
 112  * United States government or any agency thereof requires an export license,
 113  * other governmental approval, or letter of assurance, without first obtaining
 114  * such license, approval or letter.
 115  *
 116  *****************************************************************************/
 117
 118 #include <stdio.h>
 119 #include <stdlib.h>
 120 #include <string.h>
 121 #include <ctype.h>
 122
 123 #define VERSION             0x20060324
 124
 125 #define FIND_HEADER         0
 126 #define EXTRACT_DATA        1
 127 #define BUFFER_SIZE         256
 128
 129 char                        Filename[16];
 130 unsigned char               Data[16];
 131
 132 /* Local prototypes */
 133
 134 void
 135 CheckAscii (
 136     unsigned char           *Name,
 137     int                     Count);
 138
 139 void
 140 NormalizeSignature (
 141     char                    *Signature);
 142
 143 unsigned int
 144 GetNextInstance (
 145     char                    *InputPathname,
 146     char                    *Signature);
 147
 148 int
 149 ExtractTables (
 150     char                    *InputPathname,
 151     char                    *Signature,
 152     unsigned int            MinimumInstances);
 153
 154 size_t
 155 GetTableHeader (
 156     FILE                    *InputFile,
 157     unsigned char           *OutputData);
 158
 159 unsigned int
 160 CountTableInstances (
 161     char                    *InputPathname,
 162     char                    *Signature);
 163
 164 int
 165 ListTables (
 166     char                    *InputPathname);
 167
 168 size_t
 169 ConvertLine (
 170     char                    *InputLine,
 171     unsigned char           *OutputData);
 172
 173 void
 174 DisplayUsage (
 175     void);
 176
 177
 178 struct TableInfo
 179 {
 180     unsigned int            Signature;
 181     unsigned int            Instances;
 182     unsigned int            NextInstance;
 183     struct TableInfo        *Next;
 184 };
 185
 186 struct TableInfo            *ListHead = NULL;
 187
 188
 189 /******************************************************************************
 190  *
 191  * FUNCTION:    DisplayUsage
 192  *
 193  * DESCRIPTION: Usage message
 194  *
 195  ******************************************************************************/
 196
 197 void
 198 DisplayUsage (
 199     void)
 200 {
 201
 202     printf ("Usage: acpixtract [option] <InputFile>\n");
 203     printf ("\nExtract binary ACPI tables from text acpidump output\n");
 204     printf ("Default invocation extracts all DSDTs and SSDTs\n");
 205     printf ("Version %8.8X\n\n", VERSION);
 206     printf ("Options:\n");
 207     printf (" -a                    Extract all tables, not just DSDT/SSDT\n");
 208     printf (" -l                    List table summaries, do not extract\n");
 209     printf (" -s<Signature>         Extract all tables named <Signature>\n");
 210     printf ("\n");
 211 }
 212
 213
 214 /*******************************************************************************
 215  *
 216  * FUNCTION:    CheckAscii
 217  *
 218  * PARAMETERS:  Name                - Ascii string, at least as long as Count
 219  *              Count               - Number of characters to check
 220  *
 221  * RETURN:      None
 222  *
 223  * DESCRIPTION: Ensure that the requested number of characters are printable
 224  *              Ascii characters. Sets non-printable and null chars to <space>.
 225  *
 226  ******************************************************************************/
 227
 228 void
 229 CheckAscii (
 230     unsigned char           *Name,
 231     int                     Count)
 232 {
 233     int                     i;
 234
 235
 236     for (i = 0; i < Count; i++)
 237     {
 238         if (!Name[i] || !isprint (Name[i]))
 239         {
 240             Name[i] = ' ';
 241         }
 242     }
 243 }
 244
 245
 246 /*******************************************************************************
 247  *
 248  * FUNCTION:    NormalizeSignature
 249  *
 250  * PARAMETERS:  Name                - Ascii string
 251  *
 252  * RETURN:      None
 253  *
 254  * DESCRIPTION: Change "RSD PTR" to "RSDP"
 255  *
 256  ******************************************************************************/
 257
 258 void
 259 NormalizeSignature (
 260     char                    *Signature)
 261 {
 262
 263     if (!strncmp (Signature, "RSD ", 4))
 264     {
 265         Signature[3] = 'P';
 266     }
 267 }
 268
 269
 270 /******************************************************************************
 271  *
 272  * FUNCTION:    ConvertLine
 273  *
 274  * DESCRIPTION: Convert one line of ascii text binary (up to 16 bytes)
 275  *
 276  ******************************************************************************/
 277
 278 size_t
 279 ConvertLine (
 280     char                    *InputLine,
 281     unsigned char           *OutputData)
 282 {
 283     char                    *End;
 284     int                     BytesConverted;
 285     int                     Converted[16];
 286     int                     i;
 287
 288
 289     /* Terminate the input line at the end of the actual data (for sscanf) */
 290
 291     End = strstr (InputLine + 2, "  ");
 292     if (!End)
 293     {
 294         return 0;   /* Don't understand the format */
 295     }
 296     *End = 0;
 297
 298     /*
 299      * Convert one line of table data, of the form:
 300      * <offset>: <up to 16 bytes of hex data> <ASCII representation> <newline>
 301      *
 302      * Example:
 303      * 02C0: 5F 53 42 5F 4C 4E 4B 44 00 12 13 04 0C FF FF 08  _SB_LNKD........
 304      */
 305     BytesConverted = sscanf (InputLine,
 306         "%*s %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x",
 307         &Converted[0],  &Converted[1],  &Converted[2],  &Converted[3],
 308         &Converted[4],  &Converted[5],  &Converted[6],  &Converted[7],
 309         &Converted[8],  &Converted[9],  &Converted[10], &Converted[11],
 310         &Converted[12], &Converted[13], &Converted[14], &Converted[15]);
 311
 312     /* Pack converted data into a byte array */
 313
 314     for (i = 0; i < BytesConverted; i++)
 315     {
 316         OutputData[i] = (unsigned char) Converted[i];
 317     }
 318
 319     return ((size_t) BytesConverted);
 320 }
 321
 322
 323 /******************************************************************************
 324  *
 325  * FUNCTION:    GetTableHeader
 326  *
 327  * DESCRIPTION: Extract and convert a table heaader
 328  *
 329  ******************************************************************************/
 330
 331 size_t
 332 GetTableHeader (
 333     FILE                    *InputFile,
 334     unsigned char           *OutputData)
 335 {
 336     size_t                  BytesConverted;
 337     size_t                  TotalConverted = 0;
 338     char                    Buffer[BUFFER_SIZE];
 339     int                     i;
 340
 341
 342     /* Get the full 36 byte header, requires 3 lines */
 343
 344     for (i = 0; i < 3; i++)
 345     {
 346         if (!fgets (Buffer, BUFFER_SIZE, InputFile))
 347         {
 348             return TotalConverted;
 349         }
 350
 351         BytesConverted = ConvertLine (Buffer, OutputData);
 352         TotalConverted += BytesConverted;
 353         OutputData += 16;
 354
 355         if (BytesConverted != 16)
 356         {
 357             return TotalConverted;
 358         }
 359     }
 360
 361     return TotalConverted;
 362 }
 363
 364
 365 /******************************************************************************
 366  *
 367  * FUNCTION:    CountTableInstances
 368  *
 369  * DESCRIPTION: Count the instances of table <Signature> within the input file
 370  *
 371  ******************************************************************************/
 372
 373 unsigned int
 374 CountTableInstances (
 375     char                    *InputPathname,
 376     char                    *Signature)
 377 {
 378     char                    Buffer[BUFFER_SIZE];
 379     FILE                    *InputFile;
 380     unsigned int            Instances = 0;
 381
 382
 383     InputFile = fopen (InputPathname, "rt");
 384     if (!InputFile)
 385     {
 386         printf ("Could not open %s\n", InputPathname);
 387         return 0;
 388     }
 389
 390     /* Count the number of instances of this signature */
 391
 392     while (fgets (Buffer, BUFFER_SIZE, InputFile))
 393     {
 394         /* Ignore empty lines and lines that start with a space */
 395
 396         if ((Buffer[0] == ' ') ||
 397             (Buffer[0] == '\n'))
 398         {
 399             continue;
 400         }
 401
 402         NormalizeSignature (Buffer);
 403         if (!strncmp (Buffer, Signature, 4))
 404         {
 405             Instances++;
 406         }
 407     }
 408
 409     fclose (InputFile);
 410     return Instances;
 411 }
 412
 413
 414 /******************************************************************************
 415  *
 416  * FUNCTION:    GetNextInstance
 417  *
 418  * DESCRIPTION:
 419  *
 420  ******************************************************************************/
 421
 422 unsigned int
 423 GetNextInstance (
 424     char                    *InputPathname,
 425     char                    *Signature)
 426 {
 427     struct TableInfo        *Info;
 428
 429
 430     Info = ListHead;
 431     while (Info)
 432     {
 433         if (*(unsigned int *) Signature == Info->Signature)
 434         {
 435             break;
 436         }
 437
 438         Info = Info->Next;
 439     }
 440
 441     if (!Info)
 442     {
 443         Info = malloc (sizeof (struct TableInfo));
 444
 445         Info->Signature = *(unsigned int *) Signature;
 446         Info->Instances = CountTableInstances (InputPathname, Signature);
 447         Info->NextInstance = 1;
 448
 449         Info->Next = ListHead;
 450         ListHead = Info;
 451     }
 452
 453     if (Info->Instances > 1)
 454     {
 455         return (Info->NextInstance++);
 456     }
 457
 458     return (0);
 459 }
 460
 461
 462 /******************************************************************************
 463  *
 464  * FUNCTION:    ExtractTables
 465  *
 466  * DESCRIPTION: Convert text ACPI tables to binary
 467  *
 468  ******************************************************************************/
 469
 470 int
 471 ExtractTables (
 472     char                    *InputPathname,
 473     char                    *Signature,
 474     unsigned int            MinimumInstances)
 475 {
 476     char                    Buffer[BUFFER_SIZE];
 477     FILE                    *InputFile;
 478     FILE                    *OutputFile = NULL;
 479     size_t                  BytesWritten;
 480     size_t                  TotalBytesWritten = 0;
 481     size_t                  BytesConverted;
 482     unsigned int            State = FIND_HEADER;
 483     unsigned int            FoundTable = 0;
 484     unsigned int            Instances = 0;
 485     unsigned int            ThisInstance;
 486     char                    ThisSignature[4];
 487
 488
 489     /* Open input in text mode, output is in binary mode */
 490
 491     InputFile = fopen (InputPathname, "rt");
 492     if (!InputFile)
 493     {
 494         printf ("Could not open %s\n", InputPathname);
 495         return -1;
 496     }
 497
 498     if (Signature)
 499     {
 500         /* Are there enough instances of the table to continue? */
 501
 502         NormalizeSignature (Signature);
 503
 504         Instances = CountTableInstances (InputPathname, Signature);
 505         if (Instances < MinimumInstances)
 506         {
 507             printf ("Table %s was not found in %s\n", Signature, InputPathname);
 508             return -1;
 509         }
 510
 511         if (Instances == 0)
 512         {
 513             return 0;
 514         }
 515     }
 516
 517     /* Convert all instances of the table to binary */
 518
 519     while (fgets (Buffer, BUFFER_SIZE, InputFile))
 520     {
 521         switch (State)
 522         {
 523         case FIND_HEADER:
 524
 525             /* Ignore empty lines and lines that start with a space */
 526
 527             if ((Buffer[0] == ' ') ||
 528                 (Buffer[0] == '\n'))
 529             {
 530                 continue;
 531             }
 532
 533             NormalizeSignature (Buffer);
 534             strncpy (ThisSignature, Buffer, 4);
 535
 536             if (Signature)
 537             {
 538                 /* Ignore signatures that don't match */
 539
 540                 if (strncmp (ThisSignature, Signature, 4))
 541                 {
 542                     continue;
 543                 }
 544             }
 545
 546             /* Get the instance # for this signature */
 547
 548             ThisInstance = GetNextInstance (InputPathname, ThisSignature);
 549
 550             /* Build an output filename and create/open the output file */
 551
 552             if (ThisInstance > 0)
 553             {
 554                 sprintf (Filename, "%4.4s%u.dat", ThisSignature, ThisInstance);
 555             }
 556             else
 557             {
 558                 sprintf (Filename, "%4.4s.dat", ThisSignature);
 559             }
 560
 561             OutputFile = fopen (Filename, "w+b");
 562             if (!OutputFile)
 563             {
 564                 printf ("Could not open %s\n", Filename);
 565                 return -1;
 566             }
 567
 568             State = EXTRACT_DATA;
 569             TotalBytesWritten = 0;
 570             FoundTable = 1;
 571             continue;
 572
 573         case EXTRACT_DATA:
 574
 575             /* Empty line or non-data line terminates the data */
 576
 577             if ((Buffer[0] == '\n') ||
 578                 (Buffer[0] != ' '))
 579             {
 580                 fclose (OutputFile);
 581                 OutputFile = NULL;
 582                 State = FIND_HEADER;
 583
 584                 printf ("Acpi table [%4.4s] - % 6d bytes written to %s\n",
 585                     ThisSignature, TotalBytesWritten, Filename);
 586                 continue;
 587             }
 588
 589             /* Convert the ascii data (one line of text) to binary */
 590
 591             BytesConverted = ConvertLine (Buffer, Data);
 592
 593             /* Write the binary data */
 594
 595             BytesWritten = fwrite (Data, 1, BytesConverted, OutputFile);
 596             if (BytesWritten != BytesConverted)
 597             {
 598                 printf ("Write error on %s\n", Filename);
 599                 fclose (OutputFile);
 600                 return -1;
 601             }
 602
 603             TotalBytesWritten += BytesConverted;
 604             continue;
 605
 606         default:
 607             return -1;
 608         }
 609     }
 610
 611     if (!FoundTable)
 612     {
 613         printf ("Table %s was not found in %s\n", Signature, InputPathname);
 614     }
 615
 616     if (OutputFile)
 617     {
 618         fclose (OutputFile);
 619     }
 620
 621     fclose (InputFile);
 622     return 0;
 623 }
 624
 625
 626 /******************************************************************************
 627  *
 628  * FUNCTION:    ListTables
 629  *
 630  * DESCRIPTION: Display info for all ACPI tables found in input
 631  *
 632  ******************************************************************************/
 633
 634 int
 635 ListTables (
 636     char                    *InputPathname)
 637 {
 638     FILE                    *InputFile;
 639     char                    Buffer[BUFFER_SIZE];
 640     size_t                  HeaderSize;
 641     unsigned char           Header[48];
 642     int                     TableCount = 0;
 643
 644
 645     /* Open input in text mode, output is in binary mode */
 646
 647     InputFile = fopen (InputPathname, "rt");
 648     if (!InputFile)
 649     {
 650         printf ("Could not open %s\n", InputPathname);
 651         return -1;
 652     }
 653
 654     printf ("\nSignature Length  OemId     OemTableId   OemRevision CompilerId CompilerRevision\n\n");
 655
 656     while (fgets (Buffer, BUFFER_SIZE, InputFile))
 657     {
 658         /* Ignore empty lines and lines that start with a space */
 659
 660         if ((Buffer[0] == ' ') ||
 661             (Buffer[0] == '\n'))
 662         {
 663             continue;
 664         }
 665
 666         /* Get the 36 byte header and display the fields */
 667
 668         HeaderSize = GetTableHeader (InputFile, Header);
 669         if (HeaderSize < 16)
 670         {
 671             continue;
 672         }
 673
 674         /* RSDP has an oddball signature and header */
 675
 676         if (!strncmp ((char *) Header, "RSD PTR ", 8))
 677         {
 678             CheckAscii (&Header[9], 6);
 679             printf ("%8.4s          \"%6.6s\"\n", "RSDP", &Header[9]);
 680             TableCount++;
 681             continue;
 682         }
 683
 684         /* Minimum size */
 685
 686         if (HeaderSize < 36)
 687         {
 688             continue;
 689         }
 690
 691         /* Signature and Table length */
 692
 693         TableCount++;
 694         printf ("%8.4s % 7d", Header, *(int *) &Header[4]);
 695
 696         /* FACS has only signature and length */
 697
 698         if (!strncmp ((char *) Header, "FACS", 4))
 699         {
 700             printf ("\n");
 701             continue;
 702         }
 703
 704         /* OEM IDs and Compiler IDs */
 705
 706         CheckAscii (&Header[10], 6);
 707         CheckAscii (&Header[16], 8);
 708         CheckAscii (&Header[28], 4);
 709
 710         printf ("  \"%6.6s\"  \"%8.8s\"    %8.8X    \"%4.4s\"     %8.8X\n",
 711             &Header[10], &Header[16], *(int *) &Header[24],
 712             &Header[28], *(int *) &Header[32]);
 713     }
 714
 715     printf ("\nFound %d ACPI tables [%8.8X]\n", TableCount, VERSION);
 716     fclose (InputFile);
 717     return 0;
 718 }
 719
 720
 721 /******************************************************************************
 722  *
 723  * FUNCTION:    main
 724  *
 725  * DESCRIPTION: C main function
 726  *
 727  ******************************************************************************/
 728
 729 int
 730 main (
 731     int                     argc,
 732     char                    *argv[])
 733 {
 734     int                     Status;
 735
 736
 737     if (argc < 2)
 738     {
 739         DisplayUsage ();
 740         return 0;
 741     }
 742
 743     if (argv[1][0] == '-')
 744     {
 745         if (argc < 3)
 746         {
 747             DisplayUsage ();
 748             return 0;
 749         }
 750
 751         switch (argv[1][1])
 752         {
 753         case 'a':
 754             return (ExtractTables (argv[2], NULL, 0));
 755
 756         case 'l':
 757             return (ListTables (argv[2]));
 758
 759         case 's':
 760             return (ExtractTables (argv[2], &argv[1][2], 1));
 761
 762         default:
 763             DisplayUsage ();
 764             return 0;
 765         }
 766     }
 767
 768     /*
 769      * Default output is the DSDT and all SSDTs. One DSDT is required,
 770      * any SSDTs are optional.
 771      */
 772     Status = ExtractTables (argv[1], "DSDT", 1);
 773     if (Status)
 774     {
 775         return Status;
 776     }
 777
 778     Status = ExtractTables (argv[1], "SSDT", 0);
 779     return (Status);
 780 }
 781
 782