AmlString.c

Go to the documentation of this file.

 
#include <String/AmlString.h>
 
#include <AmlDefines.h>
#include <IndustryStandard/AcpiAml.h>
 
BOOLEAN
EFIAPI
AmlIsNameString (
  IN  UINT32  Root,
  IN  UINT32  ParentPrefix,
  IN  UINT32  SegCount
  )
{
  if (((Root == 0) || (Root == 1))            &&
      (ParentPrefix <= MAX_UINT8)             &&
      (!((ParentPrefix != 0) && (Root != 0))) &&
      (SegCount <= MAX_UINT8)                 &&
      ((SegCount + Root + ParentPrefix) != 0))
  {
    return TRUE;
  }
 
  return FALSE;
}
 
EFI_STATUS
EFIAPI
AmlUpperCaseMemCpyS (
  OUT       CHAR8   *DstBuffer,
  IN        UINT32  MaxDstBufferSize,
  IN  CONST CHAR8   *SrcBuffer,
  IN        UINT32  Count
  )
{
  UINT32  Index;
 
  if ((DstBuffer == NULL) ||
      (SrcBuffer == NULL))
  {
    ASSERT (0);
    return EFI_INVALID_PARAMETER;
  }
 
  if (Count == 0) {
    return EFI_SUCCESS;
  }
 
  if (Count > MaxDstBufferSize) {
    Count = MaxDstBufferSize;
  }
 
  for (Index = 0; Index < Count; Index++) {
    if ((SrcBuffer[Index] >= 'a') && (SrcBuffer[Index] <= 'z')) {
      DstBuffer[Index] = (CHAR8)((UINT8)SrcBuffer[Index] - ('a' - 'A'));
    } else {
      DstBuffer[Index] = SrcBuffer[Index];
    }
  }
 
  return EFI_SUCCESS;
}
 
BOOLEAN
EFIAPI
AmlIsRootPath (
  IN  CONST  CHAR8  *Buffer
  )
{
  if (Buffer == NULL) {
    return FALSE;
  }
 
  if ((Buffer[0] == AML_ROOT_CHAR) && (Buffer[1] == '\0')) {
    return TRUE;
  } else {
    return FALSE;
  }
}
 
BOOLEAN
EFIAPI
AmlIsLeadNameChar (
  IN  CHAR8  Ch
  )
{
  if ((Ch == '_') || ((Ch >= 'A') && (Ch <= 'Z')) || ((Ch >= 'a') && (Ch <= 'z'))) {
    return TRUE;
  } else {
    return FALSE;
  }
}
 
BOOLEAN
EFIAPI
AmlIsNameChar (
  IN  CHAR8  Ch
  )
{
  if (AmlIsLeadNameChar (Ch) || ((Ch >= '0') && (Ch <= '9'))) {
    return TRUE;
  } else {
    return FALSE;
  }
}
 
BOOLEAN
EFIAPI
AslIsNameSeg (
  IN  CONST  CHAR8   *AslBuffer,
  OUT        UINT32  *Size
  )
{
  UINT32  Index;
 
  if ((AslBuffer == NULL) ||
      (Size == NULL))
  {
    return FALSE;
  }
 
  if (!AmlIsLeadNameChar (AslBuffer[0])) {
    return FALSE;
  }
 
  for (Index = 1; Index < AML_NAME_SEG_SIZE; Index++) {
    if ((AslBuffer[Index] == '.')   ||
        (AslBuffer[Index] == '\0'))
    {
      *Size = Index;
      return TRUE;
    } else if (!AmlIsNameChar (AslBuffer[Index])) {
      return FALSE;
    }
  }
 
  *Size = Index;
  return TRUE;
}
 
BOOLEAN
EFIAPI
AmlIsNameSeg (
  IN  CONST  CHAR8  *AmlBuffer
  )
{
  UINT32  Index;
 
  if (AmlBuffer == NULL) {
    return FALSE;
  }
 
  if (!AmlIsLeadNameChar (AmlBuffer[0])) {
    return FALSE;
  }
 
  for (Index = 1; Index < AML_NAME_SEG_SIZE; Index++) {
    if (!AmlIsNameChar (AmlBuffer[Index])) {
      return FALSE;
    }
  }
 
  return TRUE;
}
 
EFI_STATUS
EFIAPI
AslParseNameStringInfo (
  IN  CONST CHAR8   *Buffer,
  OUT       UINT32  *Root,
  OUT       UINT32  *ParentPrefix,
  OUT       UINT32  *SegCount
  )
{
  UINT32  NameSegSize;
 
  if ((Buffer == NULL)        ||
      (Root == NULL)          ||
      (ParentPrefix == NULL)  ||
      (SegCount == NULL))
  {
    ASSERT (0);
    return EFI_INVALID_PARAMETER;
  }
 
  *Root         = 0;
  *ParentPrefix = 0;
  *SegCount     = 0;
 
  // Handle Root and ParentPrefix(s).
  if (*Buffer == AML_ROOT_CHAR) {
    *Root = 1;
    Buffer++;
  } else if (*Buffer == AML_PARENT_PREFIX_CHAR) {
    do {
      Buffer++;
      (*ParentPrefix)++;
    } while (*Buffer == AML_PARENT_PREFIX_CHAR);
  }
 
  // Handle SegCount(s).
  while (AslIsNameSeg (Buffer, &NameSegSize)) {
    // Safety checks on NameSegSize.
    if ((NameSegSize == 0) || (NameSegSize > AML_NAME_SEG_SIZE)) {
      ASSERT (0);
      return EFI_INVALID_PARAMETER;
    }
 
    // Increment the NameSeg count.
    (*SegCount)++;
    Buffer += NameSegSize;
 
    // Skip the '.' separator if present.
    if (*Buffer == '.') {
      Buffer++;
    }
  } // while
 
  // An ASL NameString/path must be NULL terminated.
  if (*Buffer != '\0') {
    ASSERT (0);
    return EFI_INVALID_PARAMETER;
  }
 
  if (!AmlIsNameString (*Root, *ParentPrefix, *SegCount)) {
    ASSERT (0);
    return EFI_INVALID_PARAMETER;
  }
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
AmlParseNameStringInfo (
  IN  CONST CHAR8   *Buffer,
  OUT       UINT32  *Root,
  OUT       UINT32  *ParentPrefix,
  OUT       UINT32  *SegCount
  )
{
  if ((Buffer == NULL) ||
      (Root == NULL)   ||
      (ParentPrefix == NULL) ||
      (SegCount == NULL))
  {
    ASSERT (0);
    return EFI_INVALID_PARAMETER;
  }
 
  *Root         = 0;
  *ParentPrefix = 0;
  *SegCount     = 0;
 
  // Handle Root and ParentPrefix(s).
  if (*Buffer == AML_ROOT_CHAR) {
    *Root = 1;
    Buffer++;
  } else if (*Buffer == AML_PARENT_PREFIX_CHAR) {
    do {
      Buffer++;
      (*ParentPrefix)++;
    } while (*Buffer == AML_PARENT_PREFIX_CHAR);
  }
 
  // Handle SegCount(s).
  if (*Buffer == AML_DUAL_NAME_PREFIX) {
    *SegCount = 2;
  } else if (*Buffer == AML_MULTI_NAME_PREFIX) {
    *SegCount = *((UINT8 *)(Buffer + 1));
  } else if (AmlIsNameSeg (Buffer)) {
    *SegCount = 1;
  } else if (*Buffer == AML_ZERO_OP) {
    *SegCount = 0;
  } else {
    ASSERT (0);
    return EFI_INVALID_PARAMETER;
  }
 
  // Safety checks on exit.
  if (!AmlIsNameString (*Root, *ParentPrefix, *SegCount)) {
    ASSERT (0);
    return EFI_INVALID_PARAMETER;
  }
 
  return EFI_SUCCESS;
}
 
UINT32
EFIAPI
AslComputeNameStringSize (
  IN  UINT32  Root,
  IN  UINT32  ParentPrefix,
  IN  UINT32  SegCount
  )
{
  UINT32  TotalSize;
 
  if (!AmlIsNameString (Root, ParentPrefix, SegCount)) {
    ASSERT (0);
    return 0;
  }
 
  // Root and ParentPrefix(s).
  TotalSize = Root + ParentPrefix;
 
  // Add size required for NameSeg(s).
  TotalSize += (SegCount * AML_NAME_SEG_SIZE);
 
  // Add size required for '.' separator(s).
  TotalSize += (SegCount > 1) ? (SegCount - 1) : 0;
 
  // Add 1 byte for NULL termination '\0'.
  TotalSize += 1;
 
  return TotalSize;
}
 
UINT32
EFIAPI
AmlComputeNameStringSize (
  IN  UINT32  Root,
  IN  UINT32  ParentPrefix,
  IN  UINT32  SegCount
  )
{
  UINT32  TotalSize;
 
  if (!AmlIsNameString (Root, ParentPrefix, SegCount)) {
    ASSERT (0);
    return 0;
  }
 
  // Root and ParentPrefix(s).
  TotalSize = Root + ParentPrefix;
 
  // If SegCount == 0, '\0' must end the AML NameString/path.
  TotalSize += (SegCount == 0) ? 1 : (SegCount * AML_NAME_SEG_SIZE);
 
  // AML prefix. SegCount > 2 = MultiNamePrefix, SegCount = 2 DualNamePrefix.
  TotalSize += (SegCount > 2) ? 2 : ((SegCount == 2) ? 1 : 0);
 
  return TotalSize;
}
 
EFI_STATUS
EFIAPI
AslGetNameStringSize (
  IN  CONST CHAR8   *AslPath,
  OUT       UINT32  *AslPathSizePtr
  )
{
  if ((AslPath == NULL) ||
      (AslPathSizePtr == NULL))
  {
    ASSERT (0);
    return EFI_INVALID_PARAMETER;
  }
 
  *AslPathSizePtr = 0;
  do {
    (*AslPathSizePtr)++;
    AslPath++;
  } while (*AslPath != '\0');
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
AmlGetNameStringSize (
  IN   CONST  CHAR8   *AmlPath,
  OUT         UINT32  *AmlPathSizePtr
  )
{
  EFI_STATUS  Status;
 
  UINT32  Root;
  UINT32  ParentPrefix;
  UINT32  SegCount;
 
  if ((AmlPath == NULL) ||
      (AmlPathSizePtr == NULL))
  {
    ASSERT (0);
    return EFI_INVALID_PARAMETER;
  }
 
  Status = AmlParseNameStringInfo (
             AmlPath,
             &Root,
             &ParentPrefix,
             &SegCount
             );
  if (EFI_ERROR (Status)) {
    ASSERT (0);
    return Status;
  }
 
  *AmlPathSizePtr = AmlComputeNameStringSize (Root, ParentPrefix, SegCount);
  if (*AmlPathSizePtr == 0) {
    ASSERT (0);
    return EFI_INVALID_PARAMETER;
  }
 
  return Status;
}
 
EFI_STATUS
EFIAPI
ConvertAslNameToAmlName (
  IN  CONST  CHAR8  *AslPath,
  OUT        CHAR8  **OutAmlPath
  )
{
  EFI_STATUS  Status;
 
  UINT32  Root;
  UINT32  ParentPrefix;
  UINT32  SegCount;
  UINT32  TotalSize;
  UINT32  NameSegSize;
 
  CONST CHAR8  *AslBuffer;
  CHAR8        *AmlBuffer;
  CHAR8        *AmlPath;
 
  if ((AslPath == NULL) ||
      (OutAmlPath == NULL))
  {
    return EFI_INVALID_PARAMETER;
  }
 
  // Analyze AslPath. AslPath is checked in the call.
  Status = AslParseNameStringInfo (AslPath, &Root, &ParentPrefix, &SegCount);
  if (EFI_ERROR (Status)) {
    ASSERT (0);
    return Status;
  }
 
  // Compute TotalSize.
  TotalSize = AmlComputeNameStringSize (Root, ParentPrefix, SegCount);
  if (TotalSize == 0) {
    ASSERT (0);
    return EFI_INVALID_PARAMETER;
  }
 
  // Allocate memory.
  AmlPath = AllocateZeroPool (TotalSize);
  if (AmlPath == NULL) {
    ASSERT (0);
    return EFI_OUT_OF_RESOURCES;
  }
 
  AmlBuffer = AmlPath;
  AslBuffer = AslPath;
 
  // Handle Root and ParentPrefix(s).
  if (Root == 1) {
    *AmlBuffer = AML_ROOT_CHAR;
    AmlBuffer++;
    AslBuffer++;
  } else if (ParentPrefix > 0) {
    SetMem (AmlBuffer, ParentPrefix, AML_PARENT_PREFIX_CHAR);
    AmlBuffer += ParentPrefix;
    AslBuffer += ParentPrefix;
  }
 
  // Handle prefix and SegCount(s).
  if (SegCount > 2) {
    *AmlBuffer = AML_MULTI_NAME_PREFIX;
    AmlBuffer++;
    *AmlBuffer = (UINT8)SegCount;
    AmlBuffer++;
  } else if (SegCount == 2) {
    *AmlBuffer = AML_DUAL_NAME_PREFIX;
    AmlBuffer++;
  }
 
  if (SegCount != 0) {
    // Write NameSeg(s).
    while (1) {
      SegCount--;
 
      // Get the NameSeg size.
      if (!AslIsNameSeg (AslBuffer, &NameSegSize)) {
        ASSERT (0);
        Status = EFI_INVALID_PARAMETER;
        goto error_handler;
      }
 
      // Convert to Upper case and copy.
      Status = AmlUpperCaseMemCpyS (
                 AmlBuffer,
                 TotalSize,
                 AslBuffer,
                 NameSegSize
                 );
      if (EFI_ERROR (Status)) {
        ASSERT (0);
        goto error_handler;
      }
 
      // Complete the NameSeg with an underscore ('_') if shorter than 4 bytes.
      SetMem (
        AmlBuffer + NameSegSize,
        AML_NAME_SEG_SIZE - NameSegSize,
        AML_NAME_CHAR__
        );
 
      // Go to the next NameSeg.
      AmlBuffer += AML_NAME_SEG_SIZE;
      AslBuffer += NameSegSize;
 
      // Skip the '.' separator.
      if (SegCount != 0) {
        if (*AslBuffer == '.') {
          AslBuffer++;
        } else {
          ASSERT (0);
          Status = EFI_INVALID_PARAMETER;
          goto error_handler;
        }
      } else {
        // (SegCount == 0)
        if (*AslBuffer == '\0') {
          break;
        } else {
          ASSERT (0);
          Status = EFI_INVALID_PARAMETER;
          goto error_handler;
        }
      }
    } // while
  } else {
    // (SegCount == 0)
    // '\0' needs to end the AML NameString/path.
    *AmlBuffer = AML_ZERO_OP;
    AmlBuffer++;
  }
 
  // Safety checks on exit.
  // Check that AmlPath has been filled with TotalSize bytes.
  if ((SegCount != 0)               ||
      (*AslBuffer != AML_ZERO_OP)   ||
      (((UINT32)(AmlBuffer - AmlPath)) != TotalSize))
  {
    ASSERT (0);
    Status = EFI_INVALID_PARAMETER;
    goto error_handler;
  }
 
  *OutAmlPath = AmlPath;
  return EFI_SUCCESS;
 
error_handler:
  FreePool (AmlPath);
  return Status;
}
 
EFI_STATUS
EFIAPI
ConvertAmlNameToAslName (
  IN  CONST CHAR8  *AmlPath,
  OUT       CHAR8  **OutAslPath
  )
{
  EFI_STATUS  Status;
 
  UINT32  Root;
  UINT32  ParentPrefix;
  UINT32  SegCount;
  UINT32  TotalSize;
 
  CONST CHAR8  *AmlBuffer;
  CHAR8        *AslBuffer;
  CHAR8        *AslPath;
 
  if ((AmlPath == NULL)   ||
      (OutAslPath == NULL))
  {
    ASSERT (0);
    return EFI_INVALID_PARAMETER;
  }
 
  // Analyze AslPath. AmlPath is checked in the call.
  Status = AmlParseNameStringInfo (AmlPath, &Root, &ParentPrefix, &SegCount);
  if (EFI_ERROR (Status)) {
    ASSERT (0);
    return Status;
  }
 
  // Compute TotalSize.
  TotalSize = AslComputeNameStringSize (Root, ParentPrefix, SegCount);
  if (TotalSize == 0) {
    ASSERT (0);
    return EFI_INVALID_PARAMETER;
  }
 
  // Allocate memory.
  AslPath = AllocateZeroPool (TotalSize);
  if (AslPath == NULL) {
    ASSERT (0);
    return EFI_OUT_OF_RESOURCES;
  }
 
  AmlBuffer = AmlPath;
  AslBuffer = AslPath;
 
  // Handle prefix and SegCount(s).
  if (Root == 1) {
    *AslBuffer = AML_ROOT_CHAR;
    AslBuffer++;
    AmlBuffer++;
  } else if (ParentPrefix > 0) {
    SetMem (AslBuffer, ParentPrefix, AML_PARENT_PREFIX_CHAR);
    AslBuffer += ParentPrefix;
    AmlBuffer += ParentPrefix;
  }
 
  // Handle Root and Parent(s).
  // Skip the MultiName or DualName prefix chars.
  if (SegCount > 2) {
    AmlBuffer += 2;
  } else if (SegCount == 2) {
    AmlBuffer += 1;
  }
 
  // Write NameSeg(s).
  while (SegCount) {
    // NameSeg is already in upper case and always 4 bytes long.
    CopyMem (AslBuffer, AmlBuffer, AML_NAME_SEG_SIZE);
    AslBuffer += AML_NAME_SEG_SIZE;
    AmlBuffer += AML_NAME_SEG_SIZE;
 
    SegCount--;
 
    // Write the '.' separator if there is another NameSeg following.
    if (SegCount != 0) {
      *AslBuffer = '.';
      AslBuffer++;
    }
  } // while
 
  // NULL terminate the ASL NameString.
  *AslBuffer = '\0';
  AslBuffer++;
 
  // Safety checks on exit.
  // Check that AslPath has been filled with TotalSize bytes.
  if (((UINT32)(AslBuffer - AslPath)) != TotalSize) {
    ASSERT (0);
    Status = EFI_INVALID_PARAMETER;
    goto error_handler;
  }
 
  *OutAslPath = AslPath;
  return EFI_SUCCESS;
 
error_handler:
  FreePool (AslPath);
  return Status;
}
 
BOOLEAN
EFIAPI
AslCompareNameString (
  IN  CONST CHAR8  *AslName1,
  IN  CONST CHAR8  *AslName2
  )
{
  EFI_STATUS  Status;
  UINT32      AslName1Len;
  UINT32      AslName2Len;
 
  if ((AslName1 == NULL) ||
      (AslName2 == NULL))
  {
    ASSERT (0);
    return FALSE;
  }
 
  Status = AslGetNameStringSize (AslName1, &AslName1Len);
  if (EFI_ERROR (Status)) {
    ASSERT (0);
    return FALSE;
  }
 
  Status = AslGetNameStringSize (AslName2, &AslName2Len);
  if (EFI_ERROR (Status)) {
    ASSERT (0);
    return FALSE;
  }
 
  // AslName1 and AslName2 don't have the same length
  if (AslName1Len != AslName2Len) {
    return FALSE;
  }
 
  return (CompareMem (AslName1, AslName2, AslName1Len) == 0);
}
 
BOOLEAN
EFIAPI
AmlCompareNameString (
  IN  CONST CHAR8  *AmlName1,
  IN  CONST CHAR8  *AmlName2
  )
{
  EFI_STATUS  Status;
  UINT32      AmlName1Len;
  UINT32      AmlName2Len;
 
  if ((AmlName1 == NULL) ||
      (AmlName2 == NULL))
  {
    ASSERT (0);
    return FALSE;
  }
 
  Status = AmlGetNameStringSize (AmlName1, &AmlName1Len);
  if (EFI_ERROR (Status)) {
    ASSERT (0);
    return FALSE;
  }
 
  Status = AmlGetNameStringSize (AmlName2, &AmlName2Len);
  if (EFI_ERROR (Status)) {
    ASSERT (0);
    return FALSE;
  }
 
  // AmlName1 and AmlName2 don't have the same length
  if (AmlName1Len != AmlName2Len) {
    return FALSE;
  }
 
  return (CompareMem (AmlName1, AmlName2, AmlName1Len) == 0);
}
 
BOOLEAN
EFIAPI
CompareAmlWithAslNameString (
  IN  CONST CHAR8  *AmlName1,
  IN  CONST CHAR8  *AslName2
  )
{
  EFI_STATUS  Status;
 
  CHAR8    *AmlName2;
  BOOLEAN  RetVal;
 
  if ((AmlName1 == NULL) ||
      (AslName2 == NULL))
  {
    ASSERT (0);
    return FALSE;
  }
 
  // Convert the AslName2 to an AmlName2.
  // AmlName2 must be freed.
  Status = ConvertAmlNameToAslName (AslName2, &AmlName2);
  if (EFI_ERROR (Status)) {
    ASSERT (0);
    return FALSE;
  }
 
  RetVal = AmlCompareNameString (AmlName1, AmlName2);
 
  // Free AmlName2.
  FreePool (AmlName2);
 
  return RetVal;
}
 
CONST
CHAR8 *
EFIAPI
AmlGetFirstNameSeg (
  IN  CONST  CHAR8   *AmlPath,
  IN         UINT32  Root,
  IN         UINT32  ParentPrefix
  )
{
  if (AmlPath == NULL) {
    ASSERT (0);
    return NULL;
  }
 
  AmlPath += Root;
  AmlPath += ParentPrefix;
  AmlPath += ((*AmlPath == AML_MULTI_NAME_PREFIX) ? 2
               : (*AmlPath == AML_DUAL_NAME_PREFIX) ? 1 : 0);
  return AmlPath;
}