mirror of
https://github.com/CloverHackyColor/CloverBootloader.git
synced 2024-12-21 15:57:42 +01:00
447 lines
12 KiB
C
447 lines
12 KiB
C
/** @file
|
|
ACPI Sdt Protocol Driver
|
|
|
|
Copyright (c) 2010 - 2018, Intel Corporation. All rights reserved. <BR>
|
|
SPDX-License-Identifier: BSD-2-Clause-Patent
|
|
|
|
**/
|
|
|
|
#include "AcpiTable.h"
|
|
|
|
/**
|
|
Retrieve option term according to AmlByteEncoding and Buffer.
|
|
|
|
@param[in] AmlByteEncoding AML Byte Encoding.
|
|
@param[in] Buffer AML buffer.
|
|
@param[in] MaxBufferSize AML buffer MAX size. The parser can not parse any data exceed this region.
|
|
@param[in] TermIndex Index of the data to retrieve from the object.
|
|
@param[out] DataType Points to the returned data type or EFI_ACPI_DATA_TYPE_NONE if no data exists
|
|
for the specified index.
|
|
@param[out] Data Upon return, points to the pointer to the data.
|
|
@param[out] DataSize Upon return, points to the size of Data.
|
|
|
|
@retval EFI_SUCCESS Success.
|
|
@retval EFI_INVALID_PARAMETER Buffer does not refer to a valid ACPI object.
|
|
**/
|
|
EFI_STATUS
|
|
AmlParseOptionTerm (
|
|
IN AML_BYTE_ENCODING *AmlByteEncoding,
|
|
IN UINT8 *Buffer,
|
|
IN UINTN MaxBufferSize,
|
|
IN AML_OP_PARSE_INDEX TermIndex,
|
|
OUT EFI_ACPI_DATA_TYPE *DataType,
|
|
OUT VOID **Data,
|
|
OUT UINTN *DataSize
|
|
)
|
|
{
|
|
AML_BYTE_ENCODING *ChildAmlByteEncoding;
|
|
EFI_STATUS Status;
|
|
|
|
if (DataType != NULL) {
|
|
*DataType = AmlTypeToAcpiType (AmlByteEncoding->Format[TermIndex - 1]);
|
|
}
|
|
if (Data != NULL) {
|
|
*Data = Buffer;
|
|
}
|
|
//
|
|
// Parse term according to AML type
|
|
//
|
|
switch (AmlByteEncoding->Format[TermIndex - 1]) {
|
|
case AML_UINT8:
|
|
*DataSize = sizeof(UINT8);
|
|
break;
|
|
case AML_UINT16:
|
|
*DataSize = sizeof(UINT16);
|
|
break;
|
|
case AML_UINT32:
|
|
*DataSize = sizeof(UINT32);
|
|
break;
|
|
case AML_UINT64:
|
|
*DataSize = sizeof(UINT64);
|
|
break;
|
|
case AML_STRING:
|
|
*DataSize = AsciiStrSize((CHAR8 *)Buffer);
|
|
break;
|
|
case AML_NAME:
|
|
Status = AmlGetNameStringSize (Buffer, DataSize);
|
|
if (EFI_ERROR (Status)) {
|
|
return EFI_INVALID_PARAMETER;
|
|
}
|
|
break;
|
|
case AML_OBJECT:
|
|
ChildAmlByteEncoding = AmlSearchByOpByte (Buffer);
|
|
if (ChildAmlByteEncoding == NULL) {
|
|
return EFI_INVALID_PARAMETER;
|
|
}
|
|
|
|
//
|
|
// NOTE: We need override DataType here, if there is a case the AML_OBJECT is AML_NAME.
|
|
// We need convert type from EFI_ACPI_DATA_TYPE_CHILD to EFI_ACPI_DATA_TYPE_NAME_STRING.
|
|
// We should not return CHILD because there is NO OpCode for NameString.
|
|
//
|
|
if ((ChildAmlByteEncoding->Attribute & AML_IS_NAME_CHAR) != 0) {
|
|
if (DataType != NULL) {
|
|
*DataType = AmlTypeToAcpiType (AML_NAME);
|
|
}
|
|
Status = AmlGetNameStringSize (Buffer, DataSize);
|
|
if (EFI_ERROR (Status)) {
|
|
return EFI_INVALID_PARAMETER;
|
|
}
|
|
break;
|
|
}
|
|
|
|
//
|
|
// It is real AML_OBJECT
|
|
//
|
|
*DataSize = AmlGetObjectSize (
|
|
ChildAmlByteEncoding,
|
|
Buffer,
|
|
MaxBufferSize
|
|
);
|
|
if (*DataSize == 0) {
|
|
return EFI_INVALID_PARAMETER;
|
|
}
|
|
break;
|
|
case AML_NONE:
|
|
//
|
|
// No term
|
|
//
|
|
case AML_OPCODE:
|
|
default:
|
|
ASSERT (FALSE);
|
|
return EFI_INVALID_PARAMETER;
|
|
}
|
|
if (*DataSize > MaxBufferSize) {
|
|
return EFI_INVALID_PARAMETER;
|
|
}
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
/**
|
|
Retrieve information according to AmlByteEncoding and Buffer.
|
|
|
|
@param[in] AmlByteEncoding AML Byte Encoding.
|
|
@param[in] Buffer AML buffer.
|
|
@param[in] MaxBufferSize AML buffer MAX size. The parser can not parse any data exceed this region.
|
|
@param[in] Index Index of the data to retrieve from the object. In general, indexes read from left-to-right
|
|
in the ACPI encoding, with index 0 always being the ACPI opcode.
|
|
@param[out] DataType Points to the returned data type or EFI_ACPI_DATA_TYPE_NONE if no data exists
|
|
for the specified index.
|
|
@param[out] Data Upon return, points to the pointer to the data.
|
|
@param[out] DataSize Upon return, points to the size of Data.
|
|
|
|
@retval EFI_SUCCESS Success.
|
|
@retval EFI_INVALID_PARAMETER Buffer does not refer to a valid ACPI object.
|
|
**/
|
|
EFI_STATUS
|
|
AmlParseOptionCommon (
|
|
IN AML_BYTE_ENCODING *AmlByteEncoding,
|
|
IN UINT8 *Buffer,
|
|
IN UINTN MaxBufferSize,
|
|
IN AML_OP_PARSE_INDEX Index,
|
|
OUT EFI_ACPI_DATA_TYPE *DataType,
|
|
OUT VOID **Data,
|
|
OUT UINTN *DataSize
|
|
)
|
|
{
|
|
UINT8 *CurrentBuffer;
|
|
UINTN PkgLength;
|
|
UINTN OpLength;
|
|
UINTN PkgOffset;
|
|
AML_OP_PARSE_INDEX TermIndex;
|
|
EFI_STATUS Status;
|
|
|
|
ASSERT ((Index <= AmlByteEncoding->MaxIndex) || (Index == AML_OP_PARSE_INDEX_GET_SIZE));
|
|
|
|
//
|
|
// 0. Check if this is NAME string.
|
|
//
|
|
if ((AmlByteEncoding->Attribute & AML_IS_NAME_CHAR) != 0) {
|
|
//
|
|
// Only allow GET_SIZE
|
|
//
|
|
if (Index != AML_OP_PARSE_INDEX_GET_SIZE) {
|
|
return EFI_INVALID_PARAMETER;
|
|
}
|
|
//
|
|
// return NameString size
|
|
//
|
|
Status = AmlGetNameStringSize (Buffer, DataSize);
|
|
if (EFI_ERROR (Status)) {
|
|
return EFI_INVALID_PARAMETER;
|
|
}
|
|
if (*DataSize > MaxBufferSize) {
|
|
return EFI_INVALID_PARAMETER;
|
|
}
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
//
|
|
// Not NAME string, start parsing
|
|
//
|
|
CurrentBuffer = Buffer;
|
|
|
|
//
|
|
// 1. Get OpCode
|
|
//
|
|
if (Index != AML_OP_PARSE_INDEX_GET_SIZE) {
|
|
*DataType = EFI_ACPI_DATA_TYPE_OPCODE;
|
|
*Data = (VOID *)CurrentBuffer;
|
|
}
|
|
if (*CurrentBuffer == AML_EXT_OP) {
|
|
OpLength = 2;
|
|
} else {
|
|
OpLength = 1;
|
|
}
|
|
*DataSize = OpLength;
|
|
if (Index == AML_OP_PARSE_INDEX_GET_OPCODE) {
|
|
return EFI_SUCCESS;
|
|
}
|
|
if (OpLength > MaxBufferSize) {
|
|
return EFI_INVALID_PARAMETER;
|
|
}
|
|
CurrentBuffer += OpLength;
|
|
|
|
//
|
|
// 2. Skip PkgLength field, if have
|
|
//
|
|
if ((AmlByteEncoding->Attribute & AML_HAS_PKG_LENGTH) != 0) {
|
|
PkgOffset = AmlGetPkgLength(CurrentBuffer, &PkgLength);
|
|
//
|
|
// Override MaxBufferSize if it is valid PkgLength
|
|
//
|
|
if (OpLength + PkgLength > MaxBufferSize) {
|
|
return EFI_INVALID_PARAMETER;
|
|
} else {
|
|
MaxBufferSize = OpLength + PkgLength;
|
|
}
|
|
} else {
|
|
PkgOffset = 0;
|
|
PkgLength = 0;
|
|
}
|
|
CurrentBuffer += PkgOffset;
|
|
|
|
//
|
|
// 3. Get Term one by one.
|
|
//
|
|
TermIndex = AML_OP_PARSE_INDEX_GET_TERM1;
|
|
while ((Index >= TermIndex) && (TermIndex <= AmlByteEncoding->MaxIndex) && ((UINTN)CurrentBuffer < (UINTN)Buffer + MaxBufferSize)) {
|
|
Status = AmlParseOptionTerm (
|
|
AmlByteEncoding,
|
|
CurrentBuffer,
|
|
(UINTN)Buffer + MaxBufferSize - (UINTN)CurrentBuffer,
|
|
TermIndex,
|
|
DataType,
|
|
Data,
|
|
DataSize
|
|
);
|
|
if (EFI_ERROR (Status)) {
|
|
return EFI_INVALID_PARAMETER;
|
|
}
|
|
|
|
if (Index == TermIndex) {
|
|
//
|
|
// Done
|
|
//
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
//
|
|
// Parse next one
|
|
//
|
|
CurrentBuffer += *DataSize;
|
|
TermIndex ++;
|
|
}
|
|
|
|
//
|
|
// Finish all options, but no option found.
|
|
//
|
|
if ((UINTN)CurrentBuffer > (UINTN)Buffer + MaxBufferSize) {
|
|
return EFI_INVALID_PARAMETER;
|
|
}
|
|
if ((UINTN)CurrentBuffer == (UINTN)Buffer + MaxBufferSize) {
|
|
if (Index != AML_OP_PARSE_INDEX_GET_SIZE) {
|
|
return EFI_INVALID_PARAMETER;
|
|
}
|
|
}
|
|
|
|
//
|
|
// 4. Finish parsing all node, return size
|
|
//
|
|
ASSERT (Index == AML_OP_PARSE_INDEX_GET_SIZE);
|
|
if ((AmlByteEncoding->Attribute & AML_HAS_PKG_LENGTH) != 0) {
|
|
*DataSize = OpLength + PkgLength;
|
|
} else {
|
|
*DataSize = (UINTN)CurrentBuffer - (UINTN)Buffer;
|
|
}
|
|
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
/**
|
|
Return object size.
|
|
|
|
@param[in] AmlByteEncoding AML Byte Encoding.
|
|
@param[in] Buffer AML object buffer.
|
|
@param[in] MaxBufferSize AML object buffer MAX size. The parser can not parse any data exceed this region.
|
|
|
|
@return Size of the object.
|
|
**/
|
|
UINTN
|
|
AmlGetObjectSize (
|
|
IN AML_BYTE_ENCODING *AmlByteEncoding,
|
|
IN UINT8 *Buffer,
|
|
IN UINTN MaxBufferSize
|
|
)
|
|
{
|
|
EFI_STATUS Status;
|
|
UINTN DataSize;
|
|
|
|
Status = AmlParseOptionCommon (
|
|
AmlByteEncoding,
|
|
Buffer,
|
|
MaxBufferSize,
|
|
AML_OP_PARSE_INDEX_GET_SIZE,
|
|
NULL,
|
|
NULL,
|
|
&DataSize
|
|
);
|
|
if (EFI_ERROR (Status)) {
|
|
return 0;
|
|
} else {
|
|
return DataSize;
|
|
}
|
|
}
|
|
|
|
/**
|
|
Return object name.
|
|
|
|
@param[in] AmlHandle AML handle.
|
|
|
|
@return Name of the object.
|
|
**/
|
|
CHAR8 *
|
|
AmlGetObjectName (
|
|
IN EFI_AML_HANDLE *AmlHandle
|
|
)
|
|
{
|
|
AML_BYTE_ENCODING *AmlByteEncoding;
|
|
VOID *NameString;
|
|
UINTN NameSize;
|
|
AML_OP_PARSE_INDEX TermIndex;
|
|
EFI_STATUS Status;
|
|
EFI_ACPI_DATA_TYPE DataType;
|
|
|
|
AmlByteEncoding = AmlHandle->AmlByteEncoding;
|
|
|
|
ASSERT ((AmlByteEncoding->Attribute & AML_IN_NAMESPACE) != 0);
|
|
|
|
//
|
|
// Find out Last Name index, according to OpCode table.
|
|
// The last name will be the node name by design.
|
|
//
|
|
TermIndex = AmlByteEncoding->MaxIndex;
|
|
for (TermIndex = AmlByteEncoding->MaxIndex; TermIndex > 0; TermIndex--) {
|
|
if (AmlByteEncoding->Format[TermIndex - 1] == AML_NAME) {
|
|
break;
|
|
}
|
|
}
|
|
ASSERT (TermIndex != 0);
|
|
|
|
//
|
|
// Get Name for this node.
|
|
//
|
|
Status = AmlParseOptionHandleCommon (
|
|
AmlHandle,
|
|
TermIndex,
|
|
&DataType,
|
|
&NameString,
|
|
&NameSize
|
|
);
|
|
if (EFI_ERROR (Status)) {
|
|
return NULL;
|
|
}
|
|
ASSERT (DataType == EFI_ACPI_DATA_TYPE_NAME_STRING);
|
|
|
|
return NameString;
|
|
}
|
|
|
|
/**
|
|
Return offset of last option.
|
|
|
|
@param[in] AmlHandle AML Handle.
|
|
@param[out] Buffer Upon return, points to the offset after last option.
|
|
|
|
@retval EFI_SUCCESS Success.
|
|
@retval EFI_INVALID_PARAMETER AmlHandle does not refer to a valid ACPI object.
|
|
**/
|
|
EFI_STATUS
|
|
AmlGetOffsetAfterLastOption (
|
|
IN EFI_AML_HANDLE *AmlHandle,
|
|
OUT UINT8 **Buffer
|
|
)
|
|
{
|
|
EFI_ACPI_DATA_TYPE DataType;
|
|
VOID *Data;
|
|
UINTN DataSize;
|
|
EFI_STATUS Status;
|
|
|
|
Status = AmlParseOptionHandleCommon (
|
|
AmlHandle,
|
|
AmlHandle->AmlByteEncoding->MaxIndex,
|
|
&DataType,
|
|
&Data,
|
|
&DataSize
|
|
);
|
|
if (EFI_ERROR (Status)) {
|
|
return EFI_INVALID_PARAMETER;
|
|
}
|
|
|
|
//
|
|
// We need to parse the rest buffer after last node.
|
|
//
|
|
*Buffer = (UINT8 *)((UINTN)Data + DataSize);
|
|
|
|
//
|
|
// We need skip PkgLength if no Option
|
|
//
|
|
if (DataType == EFI_ACPI_DATA_TYPE_OPCODE) {
|
|
*Buffer += AmlGetPkgLength (*Buffer, &DataSize);
|
|
}
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
/**
|
|
Retrieve information according to AmlHandle
|
|
|
|
@param[in] AmlHandle AML handle.
|
|
@param[in] Index Index of the data to retrieve from the object. In general, indexes read from left-to-right
|
|
in the ACPI encoding, with index 0 always being the ACPI opcode.
|
|
@param[out] DataType Points to the returned data type or EFI_ACPI_DATA_TYPE_NONE if no data exists
|
|
for the specified index.
|
|
@param[out] Data Upon return, points to the pointer to the data.
|
|
@param[out] DataSize Upon return, points to the size of Data.
|
|
|
|
@retval EFI_SUCCESS Success.
|
|
@retval EFI_INVALID_PARAMETER AmlHandle does not refer to a valid ACPI object.
|
|
**/
|
|
EFI_STATUS
|
|
AmlParseOptionHandleCommon (
|
|
IN EFI_AML_HANDLE *AmlHandle,
|
|
IN AML_OP_PARSE_INDEX Index,
|
|
OUT EFI_ACPI_DATA_TYPE *DataType,
|
|
OUT VOID **Data,
|
|
OUT UINTN *DataSize
|
|
)
|
|
{
|
|
return AmlParseOptionCommon (
|
|
AmlHandle->AmlByteEncoding,
|
|
AmlHandle->Buffer,
|
|
AmlHandle->Size,
|
|
Index,
|
|
DataType,
|
|
Data,
|
|
DataSize
|
|
);
|
|
}
|