ShellPkg/Library/UefiShellAcpiViewCommandLib/AcpiParser.h

   1 /** @file
   2   Header file for ACPI parser
   3
   4   Copyright (c) 2016 - 2019, ARM Limited. All rights reserved.
   5   SPDX-License-Identifier: BSD-2-Clause-Patent
   6 **/
   7
   8 #ifndef ACPIPARSER_H_
   9 #define ACPIPARSER_H_
  10
  11 #define OUTPUT_FIELD_COLUMN_WIDTH  36
  12
  13 /// The RSDP table signature is "RSD PTR " (8 bytes)
  14 /// However The signature for ACPI tables is 4 bytes.
  15 /// To work around this oddity define a signature type
  16 /// that allows us to process the log options.
  17 #define RSDP_TABLE_INFO  SIGNATURE_32('R', 'S', 'D', 'P')
  18
  19 /**
  20   This function increments the ACPI table error counter.
  21 **/
  22 VOID
  23 EFIAPI
  24 IncrementErrorCount (
  25   VOID
  26   );
  27
  28 /**
  29   This function increments the ACPI table warning counter.
  30 **/
  31 VOID
  32 EFIAPI
  33 IncrementWarningCount (
  34   VOID
  35   );
  36
  37 /**
  38   This function verifies the ACPI table checksum.
  39
  40   This function verifies the checksum for the ACPI table and optionally
  41   prints the status.
  42
  43   @param [in] Log     If TRUE log the status of the checksum.
  44   @param [in] Ptr     Pointer to the start of the table buffer.
  45   @param [in] Length  The length of the buffer.
  46
  47   @retval TRUE         The checksum is OK.
  48   @retval FALSE        The checksum failed.
  49 **/
  50 BOOLEAN
  51 EFIAPI
  52 VerifyChecksum (
  53   IN BOOLEAN Log,
  54   IN UINT8*  Ptr,
  55   IN UINT32  Length
  56   );
  57
  58 /**
  59   This function performs a raw data dump of the ACPI table.
  60
  61   @param [in] Ptr     Pointer to the start of the table buffer.
  62   @param [in] Length  The length of the buffer.
  63 **/
  64 VOID
  65 EFIAPI
  66 DumpRaw (
  67   IN UINT8* Ptr,
  68   IN UINT32 Length
  69   );
  70
  71 /**
  72   This function traces 1 byte of datum as specified in the format string.
  73
  74   @param [in] Format  The format string for tracing the data.
  75   @param [in] Ptr     Pointer to the start of the buffer.
  76 **/
  77 VOID
  78 EFIAPI
  79 DumpUint8 (
  80   IN CONST CHAR16* Format,
  81   IN UINT8*        Ptr
  82   );
  83
  84 /**
  85   This function traces 2 bytes of data as specified in the format string.
  86
  87   @param [in] Format  The format string for tracing the data.
  88   @param [in] Ptr     Pointer to the start of the buffer.
  89 **/
  90 VOID
  91 EFIAPI
  92 DumpUint16 (
  93   IN CONST CHAR16* Format,
  94   IN UINT8*        Ptr
  95   );
  96
  97 /**
  98   This function traces 4 bytes of data as specified in the format string.
  99
 100   @param [in] Format  The format string for tracing the data.
 101   @param [in] Ptr     Pointer to the start of the buffer.
 102 **/
 103 VOID
 104 EFIAPI
 105 DumpUint32 (
 106   IN CONST CHAR16* Format,
 107   IN UINT8*        Ptr
 108   );
 109
 110 /**
 111   This function traces 8 bytes of data as specified by the format string.
 112
 113   @param [in] Format  The format string for tracing the data.
 114   @param [in] Ptr     Pointer to the start of the buffer.
 115 **/
 116 VOID
 117 EFIAPI
 118 DumpUint64 (
 119   IN CONST CHAR16* Format,
 120   IN UINT8*        Ptr
 121   );
 122
 123 /**
 124   This function traces 3 characters which can be optionally
 125   formated using the format string if specified.
 126
 127   If no format string is specified the Format must be NULL.
 128
 129   @param [in] Format  Optional format string for tracing the data.
 130   @param [in] Ptr     Pointer to the start of the buffer.
 131 **/
 132 VOID
 133 EFIAPI
 134 Dump3Chars (
 135   IN CONST CHAR16* Format OPTIONAL,
 136   IN UINT8*        Ptr
 137   );
 138
 139 /**
 140   This function traces 4 characters which can be optionally
 141   formated using the format string if specified.
 142
 143   If no format string is specified the Format must be NULL.
 144
 145   @param [in] Format  Optional format string for tracing the data.
 146   @param [in] Ptr     Pointer to the start of the buffer.
 147 **/
 148 VOID
 149 EFIAPI
 150 Dump4Chars (
 151   IN CONST CHAR16* Format OPTIONAL,
 152   IN UINT8*        Ptr
 153   );
 154
 155 /**
 156   This function traces 6 characters which can be optionally
 157   formated using the format string if specified.
 158
 159   If no format string is specified the Format must be NULL.
 160
 161   @param [in] Format  Optional format string for tracing the data.
 162   @param [in] Ptr     Pointer to the start of the buffer.
 163 **/
 164 VOID
 165 EFIAPI
 166 Dump6Chars (
 167   IN CONST CHAR16* Format OPTIONAL,
 168   IN UINT8*        Ptr
 169   );
 170
 171 /**
 172   This function traces 8 characters which can be optionally
 173   formated using the format string if specified.
 174
 175   If no format string is specified the Format must be NULL.
 176
 177   @param [in] Format  Optional format string for tracing the data.
 178   @param [in] Ptr     Pointer to the start of the buffer.
 179 **/
 180 VOID
 181 EFIAPI
 182 Dump8Chars (
 183   IN CONST CHAR16* Format OPTIONAL,
 184   IN UINT8*        Ptr
 185   );
 186
 187 /**
 188   This function indents and prints the ACPI table Field Name.
 189
 190   @param [in] Indent      Number of spaces to add to the global table
 191                           indent. The global table indent is 0 by default;
 192                           however this value is updated on entry to the
 193                           ParseAcpi() by adding the indent value provided to
 194                           ParseAcpi() and restored back on exit. Therefore
 195                           the total indent in the output is dependent on from
 196                           where this function is called.
 197   @param [in] FieldName   Pointer to the Field Name.
 198 **/
 199 VOID
 200 EFIAPI
 201 PrintFieldName (
 202   IN UINT32         Indent,
 203   IN CONST CHAR16*  FieldName
 204   );
 205
 206 /**
 207   This function pointer is the template for customizing the trace output
 208
 209   @param [in] Format  Format string for tracing the data as specified by
 210                       the 'Format' member of ACPI_PARSER.
 211   @param [in] Ptr     Pointer to the start of the buffer.
 212 **/
 213 typedef VOID (EFIAPI *FNPTR_PRINT_FORMATTER)(CONST CHAR16* Format, UINT8* Ptr);
 214
 215 /**
 216   This function pointer is the template for validating an ACPI table field.
 217
 218   @param [in] Ptr     Pointer to the start of the field data.
 219   @param [in] Context Pointer to context specific information as specified by
 220                       the 'Context' member of the ACPI_PARSER.
 221                       e.g. this could be a pointer to the ACPI table header.
 222 **/
 223 typedef VOID (EFIAPI *FNPTR_FIELD_VALIDATOR)(UINT8* Ptr, VOID* Context);
 224
 225 /**
 226   The ACPI_PARSER structure describes the fields of an ACPI table and
 227   provides means for the parser to interpret and trace appropriately.
 228
 229   The first three members are populated based on information present in
 230   in the ACPI table specifications. The remaining members describe how
 231   the parser should report the field information, validate the field data
 232   and/or update an external pointer to the field (ItemPtr).
 233
 234   ParseAcpi() uses the format string specified by 'Format' for tracing
 235   the field data. If the field is more complex and requires additional
 236   processing for formatting and representation a print formatter function
 237   can be specified in 'PrintFormatter'.
 238   The PrintFormatter function may choose to use the format string
 239   specified by 'Format' or use its own internal format string.
 240
 241   The 'Format' and 'PrintFormatter' members allow flexibility for
 242   representing the field data.
 243 **/
 244 typedef struct AcpiParser {
 245
 246   /// String describing the ACPI table field
 247   /// (Field column from ACPI table spec)
 248   CONST CHAR16*         NameStr;
 249
 250   /// The length of the field.
 251   /// (Byte Length column from ACPI table spec)
 252   UINT32                Length;
 253
 254   /// The offset of the field from the start of the table.
 255   /// (Byte Offset column from ACPI table spec)
 256   UINT32                Offset;
 257
 258   /// Optional Print() style format string for tracing the data. If not
 259   /// used this must be set to NULL.
 260   CONST CHAR16*         Format;
 261
 262   /// Optional pointer to a print formatter function which
 263   /// is typically used to trace complex field information.
 264   /// If not used this must be set to NULL.
 265   /// The Format string is passed to the PrintFormatter function
 266   /// but may be ignored by the implementation code.
 267   FNPTR_PRINT_FORMATTER PrintFormatter;
 268
 269   /// Optional pointer which may be set to request the parser to update
 270   /// a pointer to the field data. If unused this must be set to NULL.
 271   VOID**                ItemPtr;
 272
 273   /// Optional pointer to a field validator function.
 274   /// The function should directly report any appropriate error or warning
 275   /// and invoke the appropriate counter update function.
 276   /// If not used this parameter must be set to NULL.
 277   FNPTR_FIELD_VALIDATOR FieldValidator;
 278
 279   /// Optional pointer to context specific information,
 280   /// which the Field Validator function can use to determine
 281   /// additional information about the ACPI table and make
 282   /// decisions about the field being validated.
 283   /// e.g. this could be a pointer to the ACPI table header
 284   VOID*                 Context;
 285 } ACPI_PARSER;
 286
 287 /**
 288   A structure used to store the pointers to the members of the
 289   ACPI description header structure that was parsed.
 290 **/
 291 typedef struct AcpiDescriptionHeaderInfo {
 292   /// ACPI table signature
 293   UINT32* Signature;
 294   /// Length of the ACPI table
 295   UINT32* Length;
 296   /// Revision
 297   UINT8*  Revision;
 298   /// Checksum
 299   UINT8*  Checksum;
 300   /// OEM Id - length is 6 bytes
 301   UINT8*  OemId;
 302   /// OEM table Id
 303   UINT64* OemTableId;
 304   /// OEM revision Id
 305   UINT32* OemRevision;
 306   /// Creator Id
 307   UINT32* CreatorId;
 308   /// Creator revision
 309   UINT32* CreatorRevision;
 310 } ACPI_DESCRIPTION_HEADER_INFO;
 311
 312 /**
 313   This function is used to parse an ACPI table buffer.
 314
 315   The ACPI table buffer is parsed using the ACPI table parser information
 316   specified by a pointer to an array of ACPI_PARSER elements. This parser
 317   function iterates through each item on the ACPI_PARSER array and logs the
 318   ACPI table fields.
 319
 320   This function can optionally be used to parse ACPI tables and fetch specific
 321   field values. The ItemPtr member of the ACPI_PARSER structure (where used)
 322   is updated by this parser function to point to the selected field data
 323   (e.g. useful for variable length nested fields).
 324
 325   @param [in] Trace        Trace the ACPI fields TRUE else only parse the
 326                            table.
 327   @param [in] Indent       Number of spaces to indent the output.
 328   @param [in] AsciiName    Optional pointer to an ASCII string that describes
 329                            the table being parsed.
 330   @param [in] Ptr          Pointer to the start of the buffer.
 331   @param [in] Length       Length of the buffer pointed by Ptr.
 332   @param [in] Parser       Pointer to an array of ACPI_PARSER structure that
 333                            describes the table being parsed.
 334   @param [in] ParserItems  Number of items in the ACPI_PARSER array.
 335
 336   @retval Number of bytes parsed.
 337 **/
 338 UINT32
 339 EFIAPI
 340 ParseAcpi (
 341   IN BOOLEAN            Trace,
 342   IN UINT32             Indent,
 343   IN CONST CHAR8*       AsciiName OPTIONAL,
 344   IN UINT8*             Ptr,
 345   IN UINT32             Length,
 346   IN CONST ACPI_PARSER* Parser,
 347   IN UINT32             ParserItems
 348   );
 349
 350 /**
 351    This is a helper macro to pass parameters to the Parser functions.
 352
 353   @param [in] Parser The name of the ACPI_PARSER array describing the
 354               ACPI table fields.
 355 **/
 356 #define PARSER_PARAMS(Parser) Parser, sizeof (Parser) / sizeof (Parser[0])
 357
 358 /**
 359   This is a helper macro for describing the ACPI header fields.
 360
 361   @param [out] Info  Pointer to retrieve the ACPI table header information.
 362 **/
 363 #define PARSE_ACPI_HEADER(Info)                   \
 364   { L"Signature", 4, 0, NULL, Dump4Chars,         \
 365     (VOID**)&(Info)->Signature , NULL, NULL },    \
 366   { L"Length", 4, 4, L"%d", NULL,                 \
 367     (VOID**)&(Info)->Length, NULL, NULL },        \
 368   { L"Revision", 1, 8, L"%d", NULL,               \
 369     (VOID**)&(Info)->Revision, NULL, NULL },      \
 370   { L"Checksum", 1, 9, L"0x%X", NULL,             \
 371     (VOID**)&(Info)->Checksum, NULL, NULL },      \
 372   { L"Oem ID", 6, 10, NULL, Dump6Chars,           \
 373     (VOID**)&(Info)->OemId, NULL, NULL },         \
 374   { L"Oem Table ID", 8, 16, NULL, Dump8Chars,     \
 375     (VOID**)&(Info)->OemTableId, NULL, NULL },    \
 376   { L"Oem Revision", 4, 24, L"0x%X", NULL,        \
 377     (VOID**)&(Info)->OemRevision, NULL, NULL },   \
 378   { L"Creator ID", 4, 28, NULL, Dump4Chars,       \
 379     (VOID**)&(Info)->CreatorId, NULL, NULL },     \
 380   { L"Creator Revision", 4, 32, L"0x%X", NULL,    \
 381     (VOID**)&(Info)->CreatorRevision, NULL, NULL }
 382
 383 /**
 384   Length of the ACPI GAS structure.
 385
 386   NOTE: This might normally be defined as
 387         sizeof (EFI_ACPI_6_2_GENERIC_ADDRESS_STRUCTURE).
 388         However, we deliberately minimise any reference to the EDK2 ACPI
 389         headers in an attempt to provide cross checking.
 390 **/
 391 #define GAS_LENGTH                     12
 392
 393 /**
 394   Length of the ACPI Header structure.
 395
 396   NOTE: This might normally be defined as
 397         sizeof (EFI_ACPI_DESCRIPTION_HEADER).
 398         However, we deliberately minimise any reference to the EDK2 ACPI
 399         headers in an attempt to provide cross checking.
 400 **/
 401 #define ACPI_DESCRIPTION_HEADER_LENGTH  36
 402
 403 /**
 404   This function indents and traces the GAS structure as described by the GasParser.
 405
 406   @param [in] Ptr     Pointer to the start of the buffer.
 407   @param [in] Indent  Number of spaces to indent the output.
 408 **/
 409 VOID
 410 EFIAPI
 411 DumpGasStruct (
 412   IN UINT8*        Ptr,
 413   IN UINT32        Indent
 414   );
 415
 416 /**
 417   This function traces the GAS structure as described by the GasParser.
 418
 419   @param [in] Format  Optional format string for tracing the data.
 420   @param [in] Ptr     Pointer to the start of the buffer.
 421 **/
 422 VOID
 423 EFIAPI
 424 DumpGas (
 425   IN CONST CHAR16* Format OPTIONAL,
 426   IN UINT8*        Ptr
 427   );
 428
 429 /**
 430   This function traces the ACPI header as described by the AcpiHeaderParser.
 431
 432   @param [in] Ptr          Pointer to the start of the buffer.
 433
 434   @retval Number of bytes parsed.
 435 **/
 436 UINT32
 437 EFIAPI
 438 DumpAcpiHeader (
 439   IN UINT8* Ptr
 440   );
 441
 442 /**
 443   This function parses the ACPI header as described by the AcpiHeaderParser.
 444
 445   This function optionally returns the Signature, Length and revision of the
 446   ACPI table.
 447
 448   @param [in]  Ptr        Pointer to the start of the buffer.
 449   @param [out] Signature  Gets location of the ACPI table signature.
 450   @param [out] Length     Gets location of the length of the ACPI table.
 451   @param [out] Revision   Gets location of the revision of the ACPI table.
 452
 453   @retval Number of bytes parsed.
 454 **/
 455 UINT32
 456 EFIAPI
 457 ParseAcpiHeader (
 458   IN  UINT8*         Ptr,
 459   OUT CONST UINT32** Signature,
 460   OUT CONST UINT32** Length,
 461   OUT CONST UINT8**  Revision
 462   );
 463
 464 /**
 465   This function parses the ACPI BGRT table.
 466   When trace is enabled this function parses the BGRT table and
 467   traces the ACPI table fields.
 468
 469   This function also performs validation of the ACPI table fields.
 470
 471   @param [in] Trace              If TRUE, trace the ACPI fields.
 472   @param [in] Ptr                Pointer to the start of the buffer.
 473   @param [in] AcpiTableLength    Length of the ACPI table.
 474   @param [in] AcpiTableRevision  Revision of the ACPI table.
 475 **/
 476 VOID
 477 EFIAPI
 478 ParseAcpiBgrt (
 479   IN BOOLEAN Trace,
 480   IN UINT8*  Ptr,
 481   IN UINT32  AcpiTableLength,
 482   IN UINT8   AcpiTableRevision
 483   );
 484
 485 /**
 486   This function parses the ACPI DBG2 table.
 487   When trace is enabled this function parses the DBG2 table and
 488   traces the ACPI table fields.
 489
 490   This function also performs validation of the ACPI table fields.
 491
 492   @param [in] Trace              If TRUE, trace the ACPI fields.
 493   @param [in] Ptr                Pointer to the start of the buffer.
 494   @param [in] AcpiTableLength    Length of the ACPI table.
 495   @param [in] AcpiTableRevision  Revision of the ACPI table.
 496 **/
 497 VOID
 498 EFIAPI
 499 ParseAcpiDbg2 (
 500   IN BOOLEAN Trace,
 501   IN UINT8*  Ptr,
 502   IN UINT32  AcpiTableLength,
 503   IN UINT8   AcpiTableRevision
 504   );
 505
 506 /**
 507   This function parses the ACPI DSDT table.
 508   When trace is enabled this function parses the DSDT table and
 509   traces the ACPI table fields.
 510   For the DSDT table only the ACPI header fields are parsed and
 511   traced.
 512
 513   @param [in] Trace              If TRUE, trace the ACPI fields.
 514   @param [in] Ptr                Pointer to the start of the buffer.
 515   @param [in] AcpiTableLength    Length of the ACPI table.
 516   @param [in] AcpiTableRevision  Revision of the ACPI table.
 517 **/
 518 VOID
 519 EFIAPI
 520 ParseAcpiDsdt (
 521   IN BOOLEAN Trace,
 522   IN UINT8*  Ptr,
 523   IN UINT32  AcpiTableLength,
 524   IN UINT8   AcpiTableRevision
 525   );
 526
 527 /**
 528   This function parses the ACPI FADT table.
 529   This function parses the FADT table and optionally traces the ACPI
 530   table fields.
 531
 532   This function also performs validation of the ACPI table fields.
 533
 534   @param [in] Trace              If TRUE, trace the ACPI fields.
 535   @param [in] Ptr                Pointer to the start of the buffer.
 536   @param [in] AcpiTableLength    Length of the ACPI table.
 537   @param [in] AcpiTableRevision  Revision of the ACPI table.
 538 **/
 539 VOID
 540 EFIAPI
 541 ParseAcpiFadt (
 542   IN BOOLEAN Trace,
 543   IN UINT8*  Ptr,
 544   IN UINT32  AcpiTableLength,
 545   IN UINT8   AcpiTableRevision
 546   );
 547
 548 /**
 549   This function parses the ACPI GTDT table.
 550   When trace is enabled this function parses the GTDT table and
 551   traces the ACPI table fields.
 552
 553   This function also parses the following platform timer structures:
 554     - GT Block timer
 555     - Watchdog timer
 556
 557   This function also performs validation of the ACPI table fields.
 558
 559   @param [in] Trace              If TRUE, trace the ACPI fields.
 560   @param [in] Ptr                Pointer to the start of the buffer.
 561   @param [in] AcpiTableLength    Length of the ACPI table.
 562   @param [in] AcpiTableRevision  Revision of the ACPI table.
 563 **/
 564 VOID
 565 EFIAPI
 566 ParseAcpiGtdt (
 567   IN BOOLEAN Trace,
 568   IN UINT8*  Ptr,
 569   IN UINT32  AcpiTableLength,
 570   IN UINT8   AcpiTableRevision
 571   );
 572
 573 /**
 574   This function parses the ACPI IORT table.
 575   When trace is enabled this function parses the IORT table and
 576   traces the ACPI fields.
 577
 578   This function also parses the following nodes:
 579     - ITS Group
 580     - Named Component
 581     - Root Complex
 582     - SMMUv1/2
 583     - SMMUv3
 584     - PMCG
 585
 586   This function also performs validation of the ACPI table fields.
 587
 588   @param [in] Trace              If TRUE, trace the ACPI fields.
 589   @param [in] Ptr                Pointer to the start of the buffer.
 590   @param [in] AcpiTableLength    Length of the ACPI table.
 591   @param [in] AcpiTableRevision  Revision of the ACPI table.
 592 **/
 593 VOID
 594 EFIAPI
 595 ParseAcpiIort (
 596   IN BOOLEAN Trace,
 597   IN UINT8*  Ptr,
 598   IN UINT32  AcpiTableLength,
 599   IN UINT8   AcpiTableRevision
 600   );
 601
 602 /**
 603   This function parses the ACPI MADT table.
 604   When trace is enabled this function parses the MADT table and
 605   traces the ACPI table fields.
 606
 607   This function currently parses the following Interrupt Controller
 608   Structures:
 609     - GICC
 610     - GICD
 611     - GIC MSI Frame
 612     - GICR
 613     - GIC ITS
 614
 615   This function also performs validation of the ACPI table fields.
 616
 617   @param [in] Trace              If TRUE, trace the ACPI fields.
 618   @param [in] Ptr                Pointer to the start of the buffer.
 619   @param [in] AcpiTableLength    Length of the ACPI table.
 620   @param [in] AcpiTableRevision  Revision of the ACPI table.
 621 **/
 622 VOID
 623 EFIAPI
 624 ParseAcpiMadt (
 625   IN BOOLEAN Trace,
 626   IN UINT8*  Ptr,
 627   IN UINT32  AcpiTableLength,
 628   IN UINT8   AcpiTableRevision
 629   );
 630
 631 /**
 632   This function parses the ACPI MCFG table.
 633   When trace is enabled this function parses the MCFG table and
 634   traces the ACPI table fields.
 635
 636   This function also performs validation of the ACPI table fields.
 637
 638   @param [in] Trace              If TRUE, trace the ACPI fields.
 639   @param [in] Ptr                Pointer to the start of the buffer.
 640   @param [in] AcpiTableLength    Length of the ACPI table.
 641   @param [in] AcpiTableRevision  Revision of the ACPI table.
 642 **/
 643 VOID
 644 EFIAPI
 645 ParseAcpiMcfg (
 646   IN BOOLEAN Trace,
 647   IN UINT8*  Ptr,
 648   IN UINT32  AcpiTableLength,
 649   IN UINT8   AcpiTableRevision
 650   );
 651
 652 /**
 653   This function parses the ACPI PPTT table.
 654   When trace is enabled this function parses the PPTT table and
 655   traces the ACPI table fields.
 656
 657   This function also performs validation of the ACPI table fields.
 658
 659   @param [in] Trace              If TRUE, trace the ACPI fields.
 660   @param [in] Ptr                Pointer to the start of the buffer.
 661   @param [in] AcpiTableLength    Length of the ACPI table.
 662   @param [in] AcpiTableRevision  Revision of the ACPI table.
 663 **/
 664 VOID
 665 EFIAPI
 666 ParseAcpiPptt (
 667   IN BOOLEAN Trace,
 668   IN UINT8*  Ptr,
 669   IN UINT32  AcpiTableLength,
 670   IN UINT8   AcpiTableRevision
 671   );
 672
 673 /**
 674   This function parses the ACPI RSDP table.
 675
 676   This function invokes the parser for the XSDT table.
 677   * Note - This function does not support parsing of RSDT table.
 678
 679   This function also performs a RAW dump of the ACPI table and
 680   validates the checksum.
 681
 682   @param [in] Trace              If TRUE, trace the ACPI fields.
 683   @param [in] Ptr                Pointer to the start of the buffer.
 684   @param [in] AcpiTableLength    Length of the ACPI table.
 685   @param [in] AcpiTableRevision  Revision of the ACPI table.
 686 **/
 687 VOID
 688 EFIAPI
 689 ParseAcpiRsdp (
 690   IN BOOLEAN Trace,
 691   IN UINT8*  Ptr,
 692   IN UINT32  AcpiTableLength,
 693   IN UINT8   AcpiTableRevision
 694   );
 695
 696 /**
 697   This function parses the ACPI SLIT table.
 698   When trace is enabled this function parses the SLIT table and
 699   traces the ACPI table fields.
 700
 701   This function also validates System Localities for the following:
 702     - Diagonal elements have a normalized value of 10
 703     - Relative distance from System Locality at i*N+j is same as
 704       j*N+i
 705
 706   @param [in] Trace              If TRUE, trace the ACPI fields.
 707   @param [in] Ptr                Pointer to the start of the buffer.
 708   @param [in] AcpiTableLength    Length of the ACPI table.
 709   @param [in] AcpiTableRevision  Revision of the ACPI table.
 710 **/
 711 VOID
 712 EFIAPI
 713 ParseAcpiSlit (
 714   IN BOOLEAN Trace,
 715   IN UINT8*  Ptr,
 716   IN UINT32  AcpiTableLength,
 717   IN UINT8   AcpiTableRevision
 718   );
 719
 720 /**
 721   This function parses the ACPI SPCR table.
 722   When trace is enabled this function parses the SPCR table and
 723   traces the ACPI table fields.
 724
 725   This function also performs validations of the ACPI table fields.
 726
 727   @param [in] Trace              If TRUE, trace the ACPI fields.
 728   @param [in] Ptr                Pointer to the start of the buffer.
 729   @param [in] AcpiTableLength    Length of the ACPI table.
 730   @param [in] AcpiTableRevision  Revision of the ACPI table.
 731 **/
 732 VOID
 733 EFIAPI
 734 ParseAcpiSpcr (
 735   IN BOOLEAN Trace,
 736   IN UINT8*  Ptr,
 737   IN UINT32  AcpiTableLength,
 738   IN UINT8   AcpiTableRevision
 739   );
 740
 741 /**
 742   This function parses the ACPI SRAT table.
 743   When trace is enabled this function parses the SRAT table and
 744   traces the ACPI table fields.
 745
 746   This function parses the following Resource Allocation Structures:
 747     - Processor Local APIC/SAPIC Affinity Structure
 748     - Memory Affinity Structure
 749     - Processor Local x2APIC Affinity Structure
 750     - GICC Affinity Structure
 751
 752   This function also performs validation of the ACPI table fields.
 753
 754   @param [in] Trace              If TRUE, trace the ACPI fields.
 755   @param [in] Ptr                Pointer to the start of the buffer.
 756   @param [in] AcpiTableLength    Length of the ACPI table.
 757   @param [in] AcpiTableRevision  Revision of the ACPI table.
 758 **/
 759 VOID
 760 EFIAPI
 761 ParseAcpiSrat (
 762   IN BOOLEAN Trace,
 763   IN UINT8*  Ptr,
 764   IN UINT32  AcpiTableLength,
 765   IN UINT8   AcpiTableRevision
 766   );
 767
 768 /**
 769   This function parses the ACPI SSDT table.
 770   When trace is enabled this function parses the SSDT table and
 771   traces the ACPI table fields.
 772   For the SSDT table only the ACPI header fields are
 773   parsed and traced.
 774
 775   @param [in] Trace              If TRUE, trace the ACPI fields.
 776   @param [in] Ptr                Pointer to the start of the buffer.
 777   @param [in] AcpiTableLength    Length of the ACPI table.
 778   @param [in] AcpiTableRevision  Revision of the ACPI table.
 779 **/
 780 VOID
 781 EFIAPI
 782 ParseAcpiSsdt (
 783   IN BOOLEAN Trace,
 784   IN UINT8*  Ptr,
 785   IN UINT32  AcpiTableLength,
 786   IN UINT8   AcpiTableRevision
 787   );
 788
 789 /**
 790   This function parses the ACPI XSDT table
 791   and optionally traces the ACPI table fields.
 792
 793   This function also performs validation of the XSDT table.
 794
 795   @param [in] Trace              If TRUE, trace the ACPI fields.
 796   @param [in] Ptr                Pointer to the start of the buffer.
 797   @param [in] AcpiTableLength    Length of the ACPI table.
 798   @param [in] AcpiTableRevision  Revision of the ACPI table.
 799 **/
 800 VOID
 801 EFIAPI
 802 ParseAcpiXsdt (
 803   IN BOOLEAN Trace,
 804   IN UINT8*  Ptr,
 805   IN UINT32  AcpiTableLength,
 806   IN UINT8   AcpiTableRevision
 807   );
 808
 809 #endif // ACPIPARSER_H_