ShellPkg/Library/UefiShellAcpiViewCommandLib/AcpiParser.h

   1 /** @file
   2   Header file for ACPI parser
   3
   4   Copyright (c) 2016 - 2020, 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 traces 12 characters which can be optionally
 189   formated using the format string if specified.
 190
 191   If no format string is specified the Format must be NULL.
 192
 193   @param [in] Format  Optional format string for tracing the data.
 194   @param [in] Ptr     Pointer to the start of the buffer.
 195 **/
 196 VOID
 197 EFIAPI
 198 Dump12Chars (
 199   IN CONST CHAR16* Format OPTIONAL,
 200   IN       UINT8*  Ptr
 201   );
 202
 203 /**
 204   This function indents and prints the ACPI table Field Name.
 205
 206   @param [in] Indent      Number of spaces to add to the global table
 207                           indent. The global table indent is 0 by default;
 208                           however this value is updated on entry to the
 209                           ParseAcpi() by adding the indent value provided to
 210                           ParseAcpi() and restored back on exit. Therefore
 211                           the total indent in the output is dependent on from
 212                           where this function is called.
 213   @param [in] FieldName   Pointer to the Field Name.
 214 **/
 215 VOID
 216 EFIAPI
 217 PrintFieldName (
 218   IN UINT32         Indent,
 219   IN CONST CHAR16*  FieldName
 220   );
 221
 222 /**
 223   This function pointer is the template for customizing the trace output
 224
 225   @param [in] Format  Format string for tracing the data as specified by
 226                       the 'Format' member of ACPI_PARSER.
 227   @param [in] Ptr     Pointer to the start of the buffer.
 228 **/
 229 typedef VOID (EFIAPI *FNPTR_PRINT_FORMATTER)(CONST CHAR16* Format, UINT8* Ptr);
 230
 231 /**
 232   This function pointer is the template for validating an ACPI table field.
 233
 234   @param [in] Ptr     Pointer to the start of the field data.
 235   @param [in] Context Pointer to context specific information as specified by
 236                       the 'Context' member of the ACPI_PARSER.
 237                       e.g. this could be a pointer to the ACPI table header.
 238 **/
 239 typedef VOID (EFIAPI *FNPTR_FIELD_VALIDATOR)(UINT8* Ptr, VOID* Context);
 240
 241 /**
 242   The ACPI_PARSER structure describes the fields of an ACPI table and
 243   provides means for the parser to interpret and trace appropriately.
 244
 245   The first three members are populated based on information present in
 246   in the ACPI table specifications. The remaining members describe how
 247   the parser should report the field information, validate the field data
 248   and/or update an external pointer to the field (ItemPtr).
 249
 250   ParseAcpi() uses the format string specified by 'Format' for tracing
 251   the field data. If the field is more complex and requires additional
 252   processing for formatting and representation a print formatter function
 253   can be specified in 'PrintFormatter'.
 254   The PrintFormatter function may choose to use the format string
 255   specified by 'Format' or use its own internal format string.
 256
 257   The 'Format' and 'PrintFormatter' members allow flexibility for
 258   representing the field data.
 259 **/
 260 typedef struct AcpiParser {
 261
 262   /// String describing the ACPI table field
 263   /// (Field column from ACPI table spec)
 264   CONST CHAR16*         NameStr;
 265
 266   /// The length of the field.
 267   /// (Byte Length column from ACPI table spec)
 268   UINT32                Length;
 269
 270   /// The offset of the field from the start of the table.
 271   /// (Byte Offset column from ACPI table spec)
 272   UINT32                Offset;
 273
 274   /// Optional Print() style format string for tracing the data. If not
 275   /// used this must be set to NULL.
 276   CONST CHAR16*         Format;
 277
 278   /// Optional pointer to a print formatter function which
 279   /// is typically used to trace complex field information.
 280   /// If not used this must be set to NULL.
 281   /// The Format string is passed to the PrintFormatter function
 282   /// but may be ignored by the implementation code.
 283   FNPTR_PRINT_FORMATTER PrintFormatter;
 284
 285   /// Optional pointer which may be set to request the parser to update
 286   /// a pointer to the field data. If unused this must be set to NULL.
 287   VOID**                ItemPtr;
 288
 289   /// Optional pointer to a field validator function.
 290   /// The function should directly report any appropriate error or warning
 291   /// and invoke the appropriate counter update function.
 292   /// If not used this parameter must be set to NULL.
 293   FNPTR_FIELD_VALIDATOR FieldValidator;
 294
 295   /// Optional pointer to context specific information,
 296   /// which the Field Validator function can use to determine
 297   /// additional information about the ACPI table and make
 298   /// decisions about the field being validated.
 299   /// e.g. this could be a pointer to the ACPI table header
 300   VOID*                 Context;
 301 } ACPI_PARSER;
 302
 303 /**
 304   A structure used to store the pointers to the members of the
 305   ACPI description header structure that was parsed.
 306 **/
 307 typedef struct AcpiDescriptionHeaderInfo {
 308   /// ACPI table signature
 309   UINT32* Signature;
 310   /// Length of the ACPI table
 311   UINT32* Length;
 312   /// Revision
 313   UINT8*  Revision;
 314   /// Checksum
 315   UINT8*  Checksum;
 316   /// OEM Id - length is 6 bytes
 317   UINT8*  OemId;
 318   /// OEM table Id
 319   UINT64* OemTableId;
 320   /// OEM revision Id
 321   UINT32* OemRevision;
 322   /// Creator Id
 323   UINT32* CreatorId;
 324   /// Creator revision
 325   UINT32* CreatorRevision;
 326 } ACPI_DESCRIPTION_HEADER_INFO;
 327
 328 /**
 329   This function is used to parse an ACPI table buffer.
 330
 331   The ACPI table buffer is parsed using the ACPI table parser information
 332   specified by a pointer to an array of ACPI_PARSER elements. This parser
 333   function iterates through each item on the ACPI_PARSER array and logs the
 334   ACPI table fields.
 335
 336   This function can optionally be used to parse ACPI tables and fetch specific
 337   field values. The ItemPtr member of the ACPI_PARSER structure (where used)
 338   is updated by this parser function to point to the selected field data
 339   (e.g. useful for variable length nested fields).
 340
 341   @param [in] Trace        Trace the ACPI fields TRUE else only parse the
 342                            table.
 343   @param [in] Indent       Number of spaces to indent the output.
 344   @param [in] AsciiName    Optional pointer to an ASCII string that describes
 345                            the table being parsed.
 346   @param [in] Ptr          Pointer to the start of the buffer.
 347   @param [in] Length       Length of the buffer pointed by Ptr.
 348   @param [in] Parser       Pointer to an array of ACPI_PARSER structure that
 349                            describes the table being parsed.
 350   @param [in] ParserItems  Number of items in the ACPI_PARSER array.
 351
 352   @retval Number of bytes parsed.
 353 **/
 354 UINT32
 355 EFIAPI
 356 ParseAcpi (
 357   IN BOOLEAN            Trace,
 358   IN UINT32             Indent,
 359   IN CONST CHAR8*       AsciiName OPTIONAL,
 360   IN UINT8*             Ptr,
 361   IN UINT32             Length,
 362   IN CONST ACPI_PARSER* Parser,
 363   IN UINT32             ParserItems
 364   );
 365
 366 /**
 367    This is a helper macro to pass parameters to the Parser functions.
 368
 369   @param [in] Parser The name of the ACPI_PARSER array describing the
 370               ACPI table fields.
 371 **/
 372 #define PARSER_PARAMS(Parser) Parser, sizeof (Parser) / sizeof (Parser[0])
 373
 374 /**
 375   This is a helper macro for describing the ACPI header fields.
 376
 377   @param [out] Info  Pointer to retrieve the ACPI table header information.
 378 **/
 379 #define PARSE_ACPI_HEADER(Info)                   \
 380   { L"Signature", 4, 0, NULL, Dump4Chars,         \
 381     (VOID**)&(Info)->Signature , NULL, NULL },    \
 382   { L"Length", 4, 4, L"%d", NULL,                 \
 383     (VOID**)&(Info)->Length, NULL, NULL },        \
 384   { L"Revision", 1, 8, L"%d", NULL,               \
 385     (VOID**)&(Info)->Revision, NULL, NULL },      \
 386   { L"Checksum", 1, 9, L"0x%X", NULL,             \
 387     (VOID**)&(Info)->Checksum, NULL, NULL },      \
 388   { L"Oem ID", 6, 10, NULL, Dump6Chars,           \
 389     (VOID**)&(Info)->OemId, NULL, NULL },         \
 390   { L"Oem Table ID", 8, 16, NULL, Dump8Chars,     \
 391     (VOID**)&(Info)->OemTableId, NULL, NULL },    \
 392   { L"Oem Revision", 4, 24, L"0x%X", NULL,        \
 393     (VOID**)&(Info)->OemRevision, NULL, NULL },   \
 394   { L"Creator ID", 4, 28, NULL, Dump4Chars,       \
 395     (VOID**)&(Info)->CreatorId, NULL, NULL },     \
 396   { L"Creator Revision", 4, 32, L"0x%X", NULL,    \
 397     (VOID**)&(Info)->CreatorRevision, NULL, NULL }
 398
 399 /**
 400   This function indents and traces the GAS structure as described by the GasParser.
 401
 402   @param [in] Ptr     Pointer to the start of the buffer.
 403   @param [in] Indent  Number of spaces to indent the output.
 404   @param [in] Length  Length of the GAS structure buffer.
 405
 406   @retval Number of bytes parsed.
 407 **/
 408 UINT32
 409 EFIAPI
 410 DumpGasStruct (
 411   IN UINT8*        Ptr,
 412   IN UINT32        Indent,
 413   IN UINT32        Length
 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 FACS table.
 529   When trace is enabled this function parses the FACS table and
 530   traces the ACPI 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 ParseAcpiFacs (
 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 FADT table.
 550   This function parses the FADT table and optionally traces the ACPI
 551   table fields.
 552
 553   This function also performs validation of the ACPI table fields.
 554
 555   @param [in] Trace              If TRUE, trace the ACPI fields.
 556   @param [in] Ptr                Pointer to the start of the buffer.
 557   @param [in] AcpiTableLength    Length of the ACPI table.
 558   @param [in] AcpiTableRevision  Revision of the ACPI table.
 559 **/
 560 VOID
 561 EFIAPI
 562 ParseAcpiFadt (
 563   IN BOOLEAN Trace,
 564   IN UINT8*  Ptr,
 565   IN UINT32  AcpiTableLength,
 566   IN UINT8   AcpiTableRevision
 567   );
 568
 569 /**
 570   This function parses the ACPI GTDT table.
 571   When trace is enabled this function parses the GTDT table and
 572   traces the ACPI table fields.
 573
 574   This function also parses the following platform timer structures:
 575     - GT Block timer
 576     - Watchdog timer
 577
 578   This function also performs validation of the ACPI table fields.
 579
 580   @param [in] Trace              If TRUE, trace the ACPI fields.
 581   @param [in] Ptr                Pointer to the start of the buffer.
 582   @param [in] AcpiTableLength    Length of the ACPI table.
 583   @param [in] AcpiTableRevision  Revision of the ACPI table.
 584 **/
 585 VOID
 586 EFIAPI
 587 ParseAcpiGtdt (
 588   IN BOOLEAN Trace,
 589   IN UINT8*  Ptr,
 590   IN UINT32  AcpiTableLength,
 591   IN UINT8   AcpiTableRevision
 592   );
 593
 594 /**
 595   This function parses the ACPI IORT table.
 596   When trace is enabled this function parses the IORT table and
 597   traces the ACPI fields.
 598
 599   This function also parses the following nodes:
 600     - ITS Group
 601     - Named Component
 602     - Root Complex
 603     - SMMUv1/2
 604     - SMMUv3
 605     - PMCG
 606
 607   This function also performs validation of the ACPI table fields.
 608
 609   @param [in] Trace              If TRUE, trace the ACPI fields.
 610   @param [in] Ptr                Pointer to the start of the buffer.
 611   @param [in] AcpiTableLength    Length of the ACPI table.
 612   @param [in] AcpiTableRevision  Revision of the ACPI table.
 613 **/
 614 VOID
 615 EFIAPI
 616 ParseAcpiIort (
 617   IN BOOLEAN Trace,
 618   IN UINT8*  Ptr,
 619   IN UINT32  AcpiTableLength,
 620   IN UINT8   AcpiTableRevision
 621   );
 622
 623 /**
 624   This function parses the ACPI MADT table.
 625   When trace is enabled this function parses the MADT table and
 626   traces the ACPI table fields.
 627
 628   This function currently parses the following Interrupt Controller
 629   Structures:
 630     - GICC
 631     - GICD
 632     - GIC MSI Frame
 633     - GICR
 634     - GIC ITS
 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 ParseAcpiMadt (
 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 MCFG table.
 654   When trace is enabled this function parses the MCFG 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 ParseAcpiMcfg (
 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 PPTT table.
 675   When trace is enabled this function parses the PPTT table and
 676   traces the ACPI table fields.
 677
 678   This function also performs validation of the ACPI table fields.
 679
 680   @param [in] Trace              If TRUE, trace the ACPI fields.
 681   @param [in] Ptr                Pointer to the start of the buffer.
 682   @param [in] AcpiTableLength    Length of the ACPI table.
 683   @param [in] AcpiTableRevision  Revision of the ACPI table.
 684 **/
 685 VOID
 686 EFIAPI
 687 ParseAcpiPptt (
 688   IN BOOLEAN Trace,
 689   IN UINT8*  Ptr,
 690   IN UINT32  AcpiTableLength,
 691   IN UINT8   AcpiTableRevision
 692   );
 693
 694 /**
 695   This function parses the ACPI RSDP table.
 696
 697   This function invokes the parser for the XSDT table.
 698   * Note - This function does not support parsing of RSDT table.
 699
 700   This function also performs a RAW dump of the ACPI table and
 701   validates the checksum.
 702
 703   @param [in] Trace              If TRUE, trace the ACPI fields.
 704   @param [in] Ptr                Pointer to the start of the buffer.
 705   @param [in] AcpiTableLength    Length of the ACPI table.
 706   @param [in] AcpiTableRevision  Revision of the ACPI table.
 707 **/
 708 VOID
 709 EFIAPI
 710 ParseAcpiRsdp (
 711   IN BOOLEAN Trace,
 712   IN UINT8*  Ptr,
 713   IN UINT32  AcpiTableLength,
 714   IN UINT8   AcpiTableRevision
 715   );
 716
 717 /**
 718   This function parses the ACPI SLIT table.
 719   When trace is enabled this function parses the SLIT table and
 720   traces the ACPI table fields.
 721
 722   This function also validates System Localities for the following:
 723     - Diagonal elements have a normalized value of 10
 724     - Relative distance from System Locality at i*N+j is same as
 725       j*N+i
 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 ParseAcpiSlit (
 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 SPCR table.
 743   When trace is enabled this function parses the SPCR table and
 744   traces the ACPI table fields.
 745
 746   This function also performs validations of the ACPI table fields.
 747
 748   @param [in] Trace              If TRUE, trace the ACPI fields.
 749   @param [in] Ptr                Pointer to the start of the buffer.
 750   @param [in] AcpiTableLength    Length of the ACPI table.
 751   @param [in] AcpiTableRevision  Revision of the ACPI table.
 752 **/
 753 VOID
 754 EFIAPI
 755 ParseAcpiSpcr (
 756   IN BOOLEAN Trace,
 757   IN UINT8*  Ptr,
 758   IN UINT32  AcpiTableLength,
 759   IN UINT8   AcpiTableRevision
 760   );
 761
 762 /**
 763   This function parses the ACPI SRAT table.
 764   When trace is enabled this function parses the SRAT table and
 765   traces the ACPI table fields.
 766
 767   This function parses the following Resource Allocation Structures:
 768     - Processor Local APIC/SAPIC Affinity Structure
 769     - Memory Affinity Structure
 770     - Processor Local x2APIC Affinity Structure
 771     - GICC Affinity Structure
 772
 773   This function also performs validation of the ACPI table fields.
 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 ParseAcpiSrat (
 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 SSDT table.
 791   When trace is enabled this function parses the SSDT table and
 792   traces the ACPI table fields.
 793   For the SSDT table only the ACPI header fields are
 794   parsed and traced.
 795
 796   @param [in] Trace              If TRUE, trace the ACPI fields.
 797   @param [in] Ptr                Pointer to the start of the buffer.
 798   @param [in] AcpiTableLength    Length of the ACPI table.
 799   @param [in] AcpiTableRevision  Revision of the ACPI table.
 800 **/
 801 VOID
 802 EFIAPI
 803 ParseAcpiSsdt (
 804   IN BOOLEAN Trace,
 805   IN UINT8*  Ptr,
 806   IN UINT32  AcpiTableLength,
 807   IN UINT8   AcpiTableRevision
 808   );
 809
 810 /**
 811   This function parses the ACPI XSDT table
 812   and optionally traces the ACPI table fields.
 813
 814   This function also performs validation of the XSDT table.
 815
 816   @param [in] Trace              If TRUE, trace the ACPI fields.
 817   @param [in] Ptr                Pointer to the start of the buffer.
 818   @param [in] AcpiTableLength    Length of the ACPI table.
 819   @param [in] AcpiTableRevision  Revision of the ACPI table.
 820 **/
 821 VOID
 822 EFIAPI
 823 ParseAcpiXsdt (
 824   IN BOOLEAN Trace,
 825   IN UINT8*  Ptr,
 826   IN UINT32  AcpiTableLength,
 827   IN UINT8   AcpiTableRevision
 828   );
 829
 830 #endif // ACPIPARSER_H_