AcpiParser.c

Go to the documentation of this file.

 
#include <Uefi.h>
#include <Library/UefiLib.h>
#include <Library/UefiBootServicesTableLib.h>
#include <Library/BaseMemoryLib.h>
#include "AcpiParser.h"
#include "AcpiView.h"
#include "AcpiViewConfig.h"
 
STATIC UINT32  gIndent;
STATIC UINT32  mTableErrorCount;
STATIC UINT32  mTableWarningCount;
 
STATIC ACPI_DESCRIPTION_HEADER_INFO  AcpiHdrInfo;
 
STATIC CONST ACPI_PARSER  AcpiHeaderParser[] = {
  PARSE_ACPI_HEADER (&AcpiHdrInfo)
};
 
VOID
ResetErrorCount (
  VOID
  )
{
  mTableErrorCount = 0;
}
 
UINT32
GetErrorCount (
  VOID
  )
{
  return mTableErrorCount;
}
 
VOID
ResetWarningCount (
  VOID
  )
{
  mTableWarningCount = 0;
}
 
UINT32
GetWarningCount (
  VOID
  )
{
  return mTableWarningCount;
}
 
VOID
EFIAPI
IncrementErrorCount (
  VOID
  )
{
  mTableErrorCount++;
}
 
VOID
EFIAPI
IncrementWarningCount (
  VOID
  )
{
  mTableWarningCount++;
}
 
BOOLEAN
EFIAPI
VerifyChecksum (
  IN BOOLEAN  Log,
  IN UINT8    *Ptr,
  IN UINT32   Length
  )
{
  UINTN  ByteCount;
  UINT8  Checksum;
  UINTN  OriginalAttribute;
 
  //
  // set local variables to suppress incorrect compiler/analyzer warnings
  //
  OriginalAttribute = 0;
  ByteCount         = 0;
  Checksum          = 0;
 
  while (ByteCount < Length) {
    Checksum += *(Ptr++);
    ByteCount++;
  }
 
  if (Log) {
    OriginalAttribute = gST->ConOut->Mode->Attribute;
    if (Checksum == 0) {
      if (GetColourHighlighting ()) {
        gST->ConOut->SetAttribute (
                       gST->ConOut,
                       EFI_TEXT_ATTR (
                         EFI_GREEN,
                         ((OriginalAttribute&(BIT4|BIT5|BIT6))>>4)
                         )
                       );
      }
 
      Print (L"Table Checksum : OK\n\n");
    } else {
      IncrementErrorCount ();
      if (GetColourHighlighting ()) {
        gST->ConOut->SetAttribute (
                       gST->ConOut,
                       EFI_TEXT_ATTR (
                         EFI_RED,
                         ((OriginalAttribute&(BIT4|BIT5|BIT6))>>4)
                         )
                       );
      }
 
      Print (L"Table Checksum : FAILED (0x%X)\n\n", Checksum);
    }
 
    if (GetColourHighlighting ()) {
      gST->ConOut->SetAttribute (gST->ConOut, OriginalAttribute);
    }
  }
 
  return (Checksum == 0);
}
 
VOID
EFIAPI
DumpRaw (
  IN UINT8   *Ptr,
  IN UINT32  Length
  )
{
  UINTN  ByteCount;
  UINTN  PartLineChars;
  UINTN  AsciiBufferIndex;
  CHAR8  AsciiBuffer[17];
 
  ByteCount        = 0;
  AsciiBufferIndex = 0;
 
  Print (L"Address  : 0x%p\n", Ptr);
  Print (L"Length   : %d\n", Length);
 
  while (ByteCount < Length) {
    if ((ByteCount & 0x0F) == 0) {
      AsciiBuffer[AsciiBufferIndex] = '\0';
      Print (L"  %a\n%08X : ", AsciiBuffer, ByteCount);
      AsciiBufferIndex = 0;
    } else if ((ByteCount & 0x07) == 0) {
      Print (L"- ");
    }
 
    if ((*Ptr >= ' ') && (*Ptr < 0x7F)) {
      AsciiBuffer[AsciiBufferIndex++] = *Ptr;
    } else {
      AsciiBuffer[AsciiBufferIndex++] = '.';
    }
 
    Print (L"%02X ", *Ptr++);
 
    ByteCount++;
  }
 
  // Justify the final line using spaces before printing
  // the ASCII data.
  PartLineChars = (Length & 0x0F);
  if (PartLineChars != 0) {
    PartLineChars = 48 - (PartLineChars * 3);
    if ((Length & 0x0F) <= 8) {
      PartLineChars += 2;
    }
 
    while (PartLineChars > 0) {
      Print (L" ");
      PartLineChars--;
    }
  }
 
  // Print ASCII data for the final line.
  AsciiBuffer[AsciiBufferIndex] = '\0';
  Print (L"  %a\n\n", AsciiBuffer);
}
 
VOID
EFIAPI
DumpUint8 (
  IN CONST CHAR16  *Format,
  IN UINT8         *Ptr
  )
{
  Print (Format, *Ptr);
}
 
VOID
EFIAPI
DumpUint16 (
  IN CONST CHAR16  *Format,
  IN UINT8         *Ptr
  )
{
  Print (Format, *(UINT16 *)Ptr);
}
 
VOID
EFIAPI
DumpUint32 (
  IN CONST CHAR16  *Format,
  IN UINT8         *Ptr
  )
{
  Print (Format, *(UINT32 *)Ptr);
}
 
VOID
EFIAPI
DumpUint64 (
  IN CONST CHAR16  *Format,
  IN UINT8         *Ptr
  )
{
  // Some fields are not aligned and this causes alignment faults
  // on ARM platforms if the compiler generates LDRD instructions.
  // Perform word access so that LDRD instructions are not generated.
  UINT64  Val;
 
  Val = *(UINT32 *)(Ptr + sizeof (UINT32));
 
  Val  = LShiftU64 (Val, 32);
  Val |= (UINT64)*(UINT32 *)Ptr;
 
  Print (Format, Val);
}
 
VOID
EFIAPI
Dump3Chars (
  IN CONST CHAR16  *Format OPTIONAL,
  IN UINT8         *Ptr,
  IN UINT32        Length
  )
{
  Print (
    (Format != NULL) ? Format : L"%c%c%c",
    Ptr[0],
    Ptr[1],
    Ptr[2]
    );
}
 
VOID
EFIAPI
Dump4Chars (
  IN CONST CHAR16  *Format OPTIONAL,
  IN UINT8         *Ptr,
  IN UINT32        Length
  )
{
  Print (
    (Format != NULL) ? Format : L"%c%c%c%c",
    Ptr[0],
    Ptr[1],
    Ptr[2],
    Ptr[3]
    );
}
 
VOID
EFIAPI
Dump6Chars (
  IN CONST CHAR16  *Format OPTIONAL,
  IN UINT8         *Ptr,
  IN UINT32        Length
  )
{
  Print (
    (Format != NULL) ? Format : L"%c%c%c%c%c%c",
    Ptr[0],
    Ptr[1],
    Ptr[2],
    Ptr[3],
    Ptr[4],
    Ptr[5]
    );
}
 
VOID
EFIAPI
Dump8Chars (
  IN CONST CHAR16  *Format OPTIONAL,
  IN UINT8         *Ptr,
  IN UINT32        Length
  )
{
  Print (
    (Format != NULL) ? Format : L"%c%c%c%c%c%c%c%c",
    Ptr[0],
    Ptr[1],
    Ptr[2],
    Ptr[3],
    Ptr[4],
    Ptr[5],
    Ptr[6],
    Ptr[7]
    );
}
 
VOID
EFIAPI
Dump12Chars (
  IN CONST CHAR16  *Format OPTIONAL,
  IN       UINT8   *Ptr,
  IN UINT32        Length
  )
{
  Print (
    (Format != NULL) ? Format : L"%c%c%c%c%c%c%c%c%c%c%c%c",
    Ptr[0],
    Ptr[1],
    Ptr[2],
    Ptr[3],
    Ptr[4],
    Ptr[5],
    Ptr[6],
    Ptr[7],
    Ptr[8],
    Ptr[9],
    Ptr[10],
    Ptr[11]
    );
}
 
VOID
EFIAPI
Dump16Chars (
  IN CONST CHAR16  *Format OPTIONAL,
  IN UINT8         *Ptr,
  IN UINT32        Length
  )
{
  Print (
    (Format != NULL) ? Format : L"%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c",
    Ptr[0],
    Ptr[1],
    Ptr[2],
    Ptr[3],
    Ptr[4],
    Ptr[5],
    Ptr[6],
    Ptr[7],
    Ptr[8],
    Ptr[9],
    Ptr[10],
    Ptr[11],
    Ptr[12],
    Ptr[13],
    Ptr[14],
    Ptr[15]
    );
}
 
VOID
EFIAPI
DumpReserved (
  IN CONST CHAR16  *Format OPTIONAL,
  IN UINT8         *Ptr,
  IN UINT32        Length
  )
{
  switch (Length) {
    case 8:
      Print (
        L"%u %u %u %u %u %u %u %u",
        Ptr[0],
        Ptr[1],
        Ptr[2],
        Ptr[3],
        Ptr[4],
        Ptr[5],
        Ptr[6],
        Ptr[7]
        );
      break;
    case 7:
      Print (
        L"%u %u %u %u %u %u %u",
        Ptr[0],
        Ptr[1],
        Ptr[2],
        Ptr[3],
        Ptr[4],
        Ptr[5],
        Ptr[6]
        );
      break;
    case 6:
      Print (
        L"%u %u %u %u %u %u",
        Ptr[0],
        Ptr[1],
        Ptr[2],
        Ptr[3],
        Ptr[4],
        Ptr[5]
        );
      break;
    case 5:
      Print (
        L"%u %u %u %u %u",
        Ptr[0],
        Ptr[1],
        Ptr[2],
        Ptr[3],
        Ptr[4]
        );
      break;
    case 4:
      Print (
        L"%u %u %u %u",
        Ptr[0],
        Ptr[1],
        Ptr[2],
        Ptr[3]
        );
      break;
    case 3:
      Print (
        L"%u %u %u",
        Ptr[0],
        Ptr[1],
        Ptr[2]
        );
      break;
    case 2:
      Print (
        L"%u %u",
        Ptr[0],
        Ptr[1]
        );
      break;
    case 1:
      Print (
        L"%u",
        Ptr[0]
        );
      break;
    default:
      return;
  }
}
 
VOID
EFIAPI
DumpReservedBits (
  IN CONST CHAR16  *Format OPTIONAL,
  IN UINT8         *Ptr,
  IN UINT32        Length
  )
{
  UINT32  ByteLength;
 
  ByteLength = (Length + 7) >> 3;
  DumpReserved (Format, Ptr, ByteLength);
}
 
VOID
EFIAPI
PrintFieldName (
  IN UINT32        Indent,
  IN CONST CHAR16  *FieldName
  )
{
  Print (
    L"%*a%-*s : ",
    gIndent + Indent,
    "",
    (OUTPUT_FIELD_COLUMN_WIDTH - gIndent - Indent),
    FieldName
    );
}
 
UINT32
EFIAPI
ParseAcpi (
  IN BOOLEAN            Trace,
  IN UINT32             Indent,
  IN CONST CHAR8        *AsciiName OPTIONAL,
  IN UINT8              *Ptr,
  IN UINT32             Length,
  IN CONST ACPI_PARSER  *Parser,
  IN UINT32             ParserItems
  )
{
  UINT32   Index;
  UINT32   Offset;
  BOOLEAN  HighLight;
  UINTN    OriginalAttribute;
 
  //
  // set local variables to suppress incorrect compiler/analyzer warnings
  //
  OriginalAttribute = 0;
  Offset            = 0;
 
  // Increment the Indent
  gIndent += Indent;
 
  if (Trace && (AsciiName != NULL)) {
    HighLight = GetColourHighlighting ();
 
    if (HighLight) {
      OriginalAttribute = gST->ConOut->Mode->Attribute;
      gST->ConOut->SetAttribute (
                     gST->ConOut,
                     EFI_TEXT_ATTR (
                       EFI_YELLOW,
                       ((OriginalAttribute&(BIT4|BIT5|BIT6))>>4)
                       )
                     );
    }
 
    Print (
      L"%*a%-*a :\n",
      gIndent,
      "",
      (OUTPUT_FIELD_COLUMN_WIDTH - gIndent),
      AsciiName
      );
    if (HighLight) {
      gST->ConOut->SetAttribute (gST->ConOut, OriginalAttribute);
    }
  }
 
  for (Index = 0; Index < ParserItems; Index++) {
    if ((Offset + Parser[Index].Length) > Length) {
      // For fields outside the buffer length provided, reset any pointers
      // which were supposed to be updated by this function call
      if (Parser[Index].ItemPtr != NULL) {
        *Parser[Index].ItemPtr = NULL;
      }
 
      // We don't parse past the end of the max length specified
      continue;
    }
 
    if (GetConsistencyChecking () &&
        (Offset != Parser[Index].Offset))
    {
      IncrementErrorCount ();
      Print (
        L"\nERROR: %a: Offset Mismatch for %s\n"
        L"CurrentOffset = %d FieldOffset = %d\n",
        AsciiName,
        Parser[Index].NameStr,
        Offset,
        Parser[Index].Offset
        );
    }
 
    if (Trace) {
      // if there is a Formatter function let the function handle
      // the printing else if a Format is specified in the table use
      // the Format for printing
      PrintFieldName (2, Parser[Index].NameStr);
      if (Parser[Index].PrintFormatter != NULL) {
        Parser[Index].PrintFormatter (Parser[Index].Format, Ptr, Parser[Index].Length);
      } else if (Parser[Index].Format != NULL) {
        switch (Parser[Index].Length) {
          case 1:
            DumpUint8 (Parser[Index].Format, Ptr);
            break;
          case 2:
            DumpUint16 (Parser[Index].Format, Ptr);
            break;
          case 4:
            DumpUint32 (Parser[Index].Format, Ptr);
            break;
          case 8:
            DumpUint64 (Parser[Index].Format, Ptr);
            break;
          default:
            Print (
              L"\nERROR: %a: CANNOT PARSE THIS FIELD, Field Length = %d\n",
              AsciiName,
              Parser[Index].Length
              );
        } // switch
      }
 
      // Validating only makes sense if we are tracing
      // the parsed table entries, to report by table name.
      if (GetConsistencyChecking () &&
          (Parser[Index].FieldValidator != NULL))
      {
        Parser[Index].FieldValidator (
                        Ptr,
                        Parser[Index].Length,
                        Parser[Index].Context
                        );
      }
 
      Print (L"\n");
    } // if (Trace)
 
    if (Parser[Index].ItemPtr != NULL) {
      *Parser[Index].ItemPtr = (VOID *)Ptr;
    }
 
    Ptr    += Parser[Index].Length;
    Offset += Parser[Index].Length;
  } // for
 
  // Decrement the Indent
  gIndent -= Indent;
  return Offset;
}
 
STATIC CONST ACPI_PARSER  GasParser[] = {
  { L"Address Space ID",    1, 0, L"0x%x",  NULL, NULL, NULL, NULL },
  { L"Register Bit Width",  1, 1, L"0x%x",  NULL, NULL, NULL, NULL },
  { L"Register Bit Offset", 1, 2, L"0x%x",  NULL, NULL, NULL, NULL },
  { L"Access Size",         1, 3, L"0x%x",  NULL, NULL, NULL, NULL },
  { L"Address",             8, 4, L"0x%lx", NULL, NULL, NULL, NULL }
};
 
UINT32
EFIAPI
DumpGasStruct (
  IN UINT8   *Ptr,
  IN UINT32  Indent,
  IN UINT32  Length
  )
{
  Print (L"\n");
  return ParseAcpi (
           TRUE,
           Indent,
           NULL,
           Ptr,
           Length,
           PARSER_PARAMS (GasParser)
           );
}
 
VOID
EFIAPI
DumpGas (
  IN CONST CHAR16  *Format OPTIONAL,
  IN UINT8         *Ptr,
  IN UINT32        Length
  )
{
  DumpGasStruct (Ptr, 2, sizeof (EFI_ACPI_6_3_GENERIC_ADDRESS_STRUCTURE));
}
 
UINT32
EFIAPI
DumpAcpiHeader (
  IN UINT8  *Ptr
  )
{
  return ParseAcpi (
           TRUE,
           0,
           "ACPI Table Header",
           Ptr,
           sizeof (EFI_ACPI_DESCRIPTION_HEADER),
           PARSER_PARAMS (AcpiHeaderParser)
           );
}
 
UINT32
EFIAPI
ParseAcpiHeader (
  IN  UINT8         *Ptr,
  OUT CONST UINT32  **Signature,
  OUT CONST UINT32  **Length,
  OUT CONST UINT8   **Revision
  )
{
  UINT32  BytesParsed;
 
  BytesParsed = ParseAcpi (
                  FALSE,
                  0,
                  NULL,
                  Ptr,
                  sizeof (EFI_ACPI_DESCRIPTION_HEADER),
                  PARSER_PARAMS (AcpiHeaderParser)
                  );
 
  *Signature = AcpiHdrInfo.Signature;
  *Length    = AcpiHdrInfo.Length;
  *Revision  = AcpiHdrInfo.Revision;
 
  return BytesParsed;
}
 
UINT32
EFIAPI
ParseAcpiBitFields (
  IN BOOLEAN            Trace,
  IN UINT32             Indent,
  IN CONST CHAR8        *AsciiName OPTIONAL,
  IN UINT8              *Ptr,
  IN UINT32             Length,
  IN CONST ACPI_PARSER  *Parser,
  IN UINT32             ParserItems
  )
{
  UINT32   Index;
  UINT32   Offset;
  BOOLEAN  HighLight;
  UINTN    OriginalAttribute;
 
  UINT64  Data;
  UINT64  BitsData;
 
  if ((Length == 0) || (Length > 8)) {
    IncrementErrorCount ();
    Print (
      L"\nERROR: Bitfield Length(%d) is zero or exceeding the 64 bit limit.\n",
      Length
      );
    return 0;
  }
 
  //
  // set local variables to suppress incorrect compiler/analyzer warnings
  //
  OriginalAttribute = 0;
  Offset            = 0;
 
  // Increment the Indent
  gIndent += Indent;
 
  CopyMem ((VOID *)&BitsData, (VOID *)Ptr, Length);
  if (Trace && (AsciiName != NULL)) {
    HighLight = GetColourHighlighting ();
 
    if (HighLight) {
      OriginalAttribute = gST->ConOut->Mode->Attribute;
      gST->ConOut->SetAttribute (
                     gST->ConOut,
                     EFI_TEXT_ATTR (
                       EFI_YELLOW,
                       ((OriginalAttribute&(BIT4|BIT5|BIT6))>>4)
                       )
                     );
    }
 
    Print (
      L"%*a%-*a :\n",
      gIndent,
      "",
      (OUTPUT_FIELD_COLUMN_WIDTH - gIndent),
      AsciiName
      );
    if (HighLight) {
      gST->ConOut->SetAttribute (gST->ConOut, OriginalAttribute);
    }
  }
 
  for (Index = 0; Index < ParserItems; Index++) {
    if ((Offset + Parser[Index].Length) > (Length * 8)) {
      // For fields outside the buffer length provided, reset any pointers
      // which were supposed to be updated by this function call
      if (Parser[Index].ItemPtr != NULL) {
        *Parser[Index].ItemPtr = NULL;
      }
 
      // We don't parse past the end of the max length specified
      continue;
    }
 
    if (Parser[Index].Length == 0) {
      IncrementErrorCount ();
      // don't parse the bitfield whose length is zero
      Print (
        L"\nERROR: %a: Cannot parse this field, Field Length = %d\n",
        Parser[Index].Length
        );
      continue;
    }
 
    if (GetConsistencyChecking () &&
        (Offset != Parser[Index].Offset))
    {
      IncrementErrorCount ();
      Print (
        L"\nERROR: %a: Offset Mismatch for %s\n"
        L"CurrentOffset = %d FieldOffset = %d\n",
        AsciiName,
        Parser[Index].NameStr,
        Offset,
        Parser[Index].Offset
        );
    }
 
    // extract Bitfield data for the current item
    Data = RShiftU64 (BitsData, Parser[Index].Offset) & ~(LShiftU64 (~0ULL, Parser[Index].Length));
 
    if (Trace) {
      // if there is a Formatter function let the function handle
      // the printing else if a Format is specified in the table use
      // the Format for printing
      PrintFieldName (2, Parser[Index].NameStr);
      if (Parser[Index].PrintFormatter != NULL) {
        Parser[Index].PrintFormatter (Parser[Index].Format, (UINT8 *)&Data, Parser[Index].Length);
      } else if (Parser[Index].Format != NULL) {
        // convert bit length to byte length
        switch ((Parser[Index].Length + 7) >> 3) {
          // print the data depends on byte size
          case 1:
            DumpUint8 (Parser[Index].Format, (UINT8 *)&Data);
            break;
          case 2:
            DumpUint16 (Parser[Index].Format, (UINT8 *)&Data);
            break;
          case 3:
          case 4:
            DumpUint32 (Parser[Index].Format, (UINT8 *)&Data);
            break;
          case 5:
          case 6:
          case 7:
          case 8:
            DumpUint64 (Parser[Index].Format, (UINT8 *)&Data);
            break;
          default:
            Print (
              L"\nERROR: %a: CANNOT PARSE THIS FIELD, Field Length = %d\n",
              AsciiName,
              Parser[Index].Length
              );
        } // switch
      }
 
      // Validating only makes sense if we are tracing
      // the parsed table entries, to report by table name.
      if (GetConsistencyChecking () &&
          (Parser[Index].FieldValidator != NULL))
      {
        Parser[Index].FieldValidator (
                        (UINT8 *)&Data,
                        Parser[Index].Length,
                        Parser[Index].Context
                        );
      }
 
      Print (L"\n");
    } // if (Trace)
 
    Offset += Parser[Index].Length;
  } // for
 
  // Decrement the Indent
  gIndent -= Indent;
  return Offset;
}