arch/all-pc/acpica/source/tools/acpidump/apdump.c

   1 /******************************************************************************
   2  *
   3  * Module Name: apdump - Dump routines for ACPI tables (acpidump)
   4  *
   5  *****************************************************************************/
   6
   7 /*
   8  * Copyright (C) 2000 - 2013, 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 "acpidump.h"
  45
  46
  47 /* Local prototypes */
  48
  49 static int
  50 ApDumpTableBuffer (
  51     ACPI_TABLE_HEADER       *Table,
  52     UINT32                  Instance,
  53     ACPI_PHYSICAL_ADDRESS   Address);
  54
  55
  56 /******************************************************************************
  57  *
  58  * FUNCTION:    ApIsValidHeader
  59  *
  60  * PARAMETERS:  Table               - Pointer to table to be validated
  61  *
  62  * RETURN:      TRUE if the header appears to be valid. FALSE otherwise
  63  *
  64  * DESCRIPTION: Check for a valid ACPI table header
  65  *
  66  ******************************************************************************/
  67
  68 BOOLEAN
  69 ApIsValidHeader (
  70     ACPI_TABLE_HEADER       *Table)
  71 {
  72     if (!ACPI_VALIDATE_RSDP_SIG (Table->Signature))
  73     {
  74         /* Make sure signature is all ASCII and a valid ACPI name */
  75
  76         if (!AcpiUtValidAcpiName (Table->Signature))
  77         {
  78             fprintf (stderr, "Table signature (0x%8.8X) is invalid\n",
  79                 *(UINT32 *) Table->Signature);
  80             return (FALSE);
  81         }
  82
  83         /* Check for minimum table length */
  84
  85         if (Table->Length < sizeof (ACPI_TABLE_HEADER))
  86         {
  87             fprintf (stderr, "Table length (0x%8.8X) is invalid\n",
  88                 Table->Length);
  89             return (FALSE);
  90         }
  91     }
  92
  93     return (TRUE);
  94 }
  95
  96
  97 /******************************************************************************
  98  *
  99  * FUNCTION:    ApIsValidChecksum
 100  *
 101  * PARAMETERS:  Table               - Pointer to table to be validated
 102  *
 103  * RETURN:      TRUE if the checksum appears to be valid. FALSE otherwise
 104  *
 105  * DESCRIPTION: Check for a valid ACPI table checksum
 106  *
 107  ******************************************************************************/
 108
 109 BOOLEAN
 110 ApIsValidChecksum (
 111     ACPI_TABLE_HEADER       *Table)
 112 {
 113     ACPI_STATUS             Status;
 114     ACPI_TABLE_RSDP         *Rsdp;
 115
 116
 117     if (ACPI_VALIDATE_RSDP_SIG (Table->Signature))
 118     {
 119         /*
 120          * Checksum for RSDP.
 121          * Note: Other checksums are computed during the table dump.
 122          */
 123
 124         Rsdp = ACPI_CAST_PTR (ACPI_TABLE_RSDP, Table);
 125         Status = AcpiTbValidateRsdp (Rsdp);
 126     }
 127     else
 128     {
 129         Status = AcpiTbVerifyChecksum (Table, Table->Length);
 130     }
 131
 132     if (ACPI_FAILURE (Status))
 133     {
 134         fprintf (stderr, "%4.4s: Warning: wrong checksum\n",
 135             Table->Signature);
 136     }
 137
 138     return (AE_OK);
 139 }
 140
 141
 142 /******************************************************************************
 143  *
 144  * FUNCTION:    ApGetTableLength
 145  *
 146  * PARAMETERS:  Table               - Pointer to the table
 147  *
 148  * RETURN:      Table length
 149  *
 150  * DESCRIPTION: Obtain table length according to table signature
 151  *
 152  ******************************************************************************/
 153
 154 UINT32
 155 ApGetTableLength (
 156     ACPI_TABLE_HEADER       *Table)
 157 {
 158     ACPI_TABLE_RSDP         *Rsdp;
 159
 160
 161     /* Check if table is valid */
 162
 163     if (!ApIsValidHeader (Table))
 164     {
 165         return (0);
 166     }
 167
 168     if (ACPI_VALIDATE_RSDP_SIG (Table->Signature))
 169     {
 170         Rsdp = ACPI_CAST_PTR (ACPI_TABLE_RSDP, Table);
 171         return (Rsdp->Length);
 172     }
 173     else
 174     {
 175         return (Table->Length);
 176     }
 177 }
 178
 179
 180 /******************************************************************************
 181  *
 182  * FUNCTION:    ApDumpTableBuffer
 183  *
 184  * PARAMETERS:  Table               - ACPI table to be dumped
 185  *              Instance            - ACPI table instance no. to be dumped
 186  *              Address             - Physical address of the table
 187  *
 188  * RETURN:      None
 189  *
 190  * DESCRIPTION: Dump an ACPI table in standard ASCII hex format, with a
 191  *              header that is compatible with the AcpiXtract utility.
 192  *
 193  ******************************************************************************/
 194
 195 static int
 196 ApDumpTableBuffer (
 197     ACPI_TABLE_HEADER       *Table,
 198     UINT32                  Instance,
 199     ACPI_PHYSICAL_ADDRESS   Address)
 200 {
 201     UINT32                  TableLength;
 202
 203
 204     TableLength = ApGetTableLength (Table);
 205
 206     /* Print only the header if requested */
 207
 208     if (Gbl_SummaryMode)
 209     {
 210         AcpiTbPrintTableHeader (Address, Table);
 211         return (0);
 212     }
 213
 214     /* Dump to binary file if requested */
 215
 216     if (Gbl_BinaryMode)
 217     {
 218         return (ApWriteToBinaryFile (Table, Instance));
 219     }
 220
 221     /*
 222      * Dump the table with header for use with acpixtract utility
 223      * Note: simplest to just always emit a 64-bit address. AcpiXtract
 224      * utility can handle this.
 225      */
 226     printf ("%4.4s @ 0x%8.8X%8.8X\n", Table->Signature,
 227         ACPI_FORMAT_UINT64 (Address));
 228
 229     AcpiUtDumpBuffer (ACPI_CAST_PTR (UINT8, Table), TableLength,
 230         DB_BYTE_DISPLAY, 0);
 231     printf ("\n");
 232     return (0);
 233 }
 234
 235
 236 /******************************************************************************
 237  *
 238  * FUNCTION:    ApDumpAllTables
 239  *
 240  * PARAMETERS:  None
 241  *
 242  * RETURN:      Status
 243  *
 244  * DESCRIPTION: Get all tables from the RSDT/XSDT (or at least all of the
 245  *              tables that we can possibly get).
 246  *
 247  ******************************************************************************/
 248
 249 int
 250 ApDumpAllTables (
 251     void)
 252 {
 253     ACPI_TABLE_HEADER       *Table;
 254     UINT32                  Instance = 0;
 255     ACPI_PHYSICAL_ADDRESS   Address;
 256     ACPI_STATUS             Status;
 257     UINT32                  i;
 258
 259
 260     /* Get and dump all available ACPI tables */
 261
 262     for (i = 0; i < AP_MAX_ACPI_FILES; i++)
 263     {
 264         Status = AcpiOsGetTableByIndex (i, &Table, &Instance, &Address);
 265         if (ACPI_FAILURE (Status))
 266         {
 267             /* AE_LIMIT means that no more tables are available */
 268
 269             if (Status == AE_LIMIT)
 270             {
 271                 return (0);
 272             }
 273             else if (i == 0)
 274             {
 275                 fprintf (stderr, "Could not get ACPI tables, %s\n",
 276                     AcpiFormatException (Status));
 277                 return (-1);
 278             }
 279             else
 280             {
 281                 fprintf (stderr, "Could not get ACPI table at index %u, %s\n",
 282                     i, AcpiFormatException (Status));
 283                 continue;
 284             }
 285         }
 286
 287         if (ApDumpTableBuffer (Table, Instance, Address))
 288         {
 289             return (-1);
 290         }
 291         free (Table);
 292     }
 293
 294     /* Something seriously bad happened if the loop terminates here */
 295
 296     return (-1);
 297 }
 298
 299
 300 /******************************************************************************
 301  *
 302  * FUNCTION:    ApDumpTableByAddress
 303  *
 304  * PARAMETERS:  AsciiAddress        - Address for requested ACPI table
 305  *
 306  * RETURN:      Status
 307  *
 308  * DESCRIPTION: Get an ACPI table via a physical address and dump it.
 309  *
 310  ******************************************************************************/
 311
 312 int
 313 ApDumpTableByAddress (
 314     char                    *AsciiAddress)
 315 {
 316     ACPI_PHYSICAL_ADDRESS   Address;
 317     ACPI_TABLE_HEADER       *Table;
 318     ACPI_STATUS             Status;
 319     int                     TableStatus;
 320     UINT64                  LongAddress;
 321
 322
 323     /* Convert argument to an integer physical address */
 324
 325     Status = AcpiUtStrtoul64 (AsciiAddress, 0, &LongAddress);
 326     if (ACPI_FAILURE (Status))
 327     {
 328         fprintf (stderr, "%s: Could not convert to a physical address\n",
 329             AsciiAddress);
 330         return (-1);
 331     }
 332
 333     Address = (ACPI_PHYSICAL_ADDRESS) LongAddress;
 334     Status = AcpiOsGetTableByAddress (Address, &Table);
 335     if (ACPI_FAILURE (Status))
 336     {
 337         fprintf (stderr, "Could not get table at 0x%8.8X%8.8X, %s\n",
 338             ACPI_FORMAT_UINT64 (Address),
 339             AcpiFormatException (Status));
 340         return (-1);
 341     }
 342
 343     TableStatus = ApDumpTableBuffer (Table, 0, Address);
 344     free (Table);
 345     return (TableStatus);
 346 }
 347
 348
 349 /******************************************************************************
 350  *
 351  * FUNCTION:    ApDumpTableByName
 352  *
 353  * PARAMETERS:  Signature           - Requested ACPI table signature
 354  *
 355  * RETURN:      Status
 356  *
 357  * DESCRIPTION: Get an ACPI table via a signature and dump it. Handles
 358  *              multiple tables with the same signature (SSDTs).
 359  *
 360  ******************************************************************************/
 361
 362 int
 363 ApDumpTableByName (
 364     char                    *Signature)
 365 {
 366     char                    LocalSignature [ACPI_NAME_SIZE + 1];
 367     UINT32                  Instance;
 368     ACPI_TABLE_HEADER       *Table;
 369     ACPI_PHYSICAL_ADDRESS   Address;
 370     ACPI_STATUS             Status;
 371
 372
 373     if (strlen (Signature) != ACPI_NAME_SIZE)
 374     {
 375         fprintf (stderr,
 376             "Invalid table signature [%s]: must be exactly 4 characters\n",
 377             Signature);
 378         return (-1);
 379     }
 380
 381     /* Table signatures are expected to be uppercase */
 382
 383     strcpy (LocalSignature, Signature);
 384     AcpiUtStrupr (LocalSignature);
 385
 386     /* To be friendly, handle tables whose signatures do not match the name */
 387
 388     if (ACPI_COMPARE_NAME (LocalSignature, AP_DUMP_SIG_RSDP))
 389     {
 390         strcpy (LocalSignature, AP_DUMP_SIG_RSDP);
 391     }
 392     else if (ACPI_COMPARE_NAME (LocalSignature, "FADT"))
 393     {
 394         strcpy (LocalSignature, ACPI_SIG_FADT);
 395     }
 396     else if (ACPI_COMPARE_NAME (LocalSignature, "MADT"))
 397     {
 398         strcpy (LocalSignature, ACPI_SIG_MADT);
 399     }
 400
 401     /* Dump all instances of this signature (to handle multiple SSDTs) */
 402
 403     for (Instance = 0; Instance < AP_MAX_ACPI_FILES; Instance++)
 404     {
 405         Status = AcpiOsGetTableByName (LocalSignature, Instance,
 406             &Table, &Address);
 407         if (ACPI_FAILURE (Status))
 408         {
 409             /* AE_LIMIT means that no more tables are available */
 410
 411             if (Status == AE_LIMIT)
 412             {
 413                 return (0);
 414             }
 415
 416             fprintf (stderr,
 417                 "Could not get ACPI table with signature [%s], %s\n",
 418                 LocalSignature, AcpiFormatException (Status));
 419             return (-1);
 420         }
 421
 422         if (ApDumpTableBuffer (Table, Instance, Address))
 423         {
 424             return (-1);
 425         }
 426         free (Table);
 427     }
 428
 429     /* Something seriously bad happened if the loop terminates here */
 430
 431     return (-1);
 432 }
 433
 434
 435 /******************************************************************************
 436  *
 437  * FUNCTION:    ApDumpTableFromFile
 438  *
 439  * PARAMETERS:  Pathname            - File containing the binary ACPI table
 440  *
 441  * RETURN:      Status
 442  *
 443  * DESCRIPTION: Dump an ACPI table from a binary file
 444  *
 445  ******************************************************************************/
 446
 447 int
 448 ApDumpTableFromFile (
 449     char                    *Pathname)
 450 {
 451     ACPI_TABLE_HEADER       *Table;
 452     UINT32                  FileSize = 0;
 453     int                     TableStatus;
 454
 455
 456     /* Get the entire ACPI table from the file */
 457
 458     Table = ApGetTableFromFile (Pathname, &FileSize);
 459     if (!Table)
 460     {
 461         return (-1);
 462     }
 463
 464     /* File must be at least as long as the table length */
 465
 466     if (Table->Length > FileSize)
 467     {
 468         fprintf (stderr,
 469             "Table length (0x%X) is too large for input file (0x%X) %s\n",
 470             Table->Length, FileSize, Pathname);
 471         return (-1);
 472     }
 473
 474     if (Gbl_VerboseMode)
 475     {
 476         fprintf (stderr,
 477             "Input file:  %s contains table [%4.4s], 0x%X (%u) bytes\n",
 478             Pathname, Table->Signature, FileSize, FileSize);
 479     }
 480
 481     TableStatus = ApDumpTableBuffer (Table, 0, 0);
 482     free (Table);
 483     return (TableStatus);
 484 }
 485
 486
 487 /******************************************************************************
 488  *
 489  * FUNCTION:    AcpiOs* print functions
 490  *
 491  * DESCRIPTION: Used for linkage with ACPICA modules
 492  *
 493  ******************************************************************************/
 494
 495 void ACPI_INTERNAL_VAR_XFACE
 496 AcpiOsPrintf (
 497     const char              *Fmt,
 498     ...)
 499 {
 500     va_list                 Args;
 501
 502     va_start (Args, Fmt);
 503     vfprintf (stdout, Fmt, Args);
 504     va_end (Args);
 505 }
 506
 507 void
 508 AcpiOsVprintf (
 509     const char              *Fmt,
 510     va_list                 Args)
 511 {
 512     vfprintf (stdout, Fmt, Args);
 513 }