mirror of
https://github.com/CloverHackyColor/CloverBootloader.git
synced 2024-12-26 16:47:40 +01:00
613 lines
16 KiB
C
613 lines
16 KiB
C
/** @file
|
|
ACPI Sdt Protocol Driver
|
|
|
|
Copyright (c) 2010, Intel Corporation. All rights reserved. <BR>
|
|
This program and the accompanying materials
|
|
are licensed and made available under the terms and conditions of the BSD License
|
|
which accompanies this distribution. The full text of the license may be found at
|
|
http://opensource.org/licenses/bsd-license.php
|
|
|
|
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
|
|
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
|
|
|
**/
|
|
|
|
#include "AcpiTable.h"
|
|
|
|
/**
|
|
Construct node list according to the AML handle.
|
|
|
|
@param[in] AmlHandle AML handle.
|
|
@param[in] AmlRootNodeList AML root node list.
|
|
@param[in] AmlParentNodeList AML parent node list.
|
|
|
|
@retval EFI_SUCCESS Success.
|
|
@retval EFI_INVALID_PARAMETER AML handle does not refer to a valid ACPI object.
|
|
**/
|
|
EFI_STATUS
|
|
AmlConstructNodeList (
|
|
IN EFI_AML_HANDLE *AmlHandle,
|
|
IN EFI_AML_NODE_LIST *AmlRootNodeList,
|
|
IN EFI_AML_NODE_LIST *AmlParentNodeList
|
|
);
|
|
|
|
/**
|
|
Create AML Node.
|
|
|
|
@param[in] NameSeg AML NameSeg.
|
|
@param[in] Parent AML parent node list.
|
|
@param[in] AmlByteEncoding AML Byte Encoding.
|
|
|
|
@return AML Node.
|
|
**/
|
|
EFI_AML_NODE_LIST *
|
|
AmlCreateNode (
|
|
IN UINT8 *NameSeg,
|
|
IN EFI_AML_NODE_LIST *Parent,
|
|
IN AML_BYTE_ENCODING *AmlByteEncoding
|
|
)
|
|
{
|
|
EFI_AML_NODE_LIST *AmlNodeList;
|
|
|
|
AmlNodeList = AllocatePool (sizeof(*AmlNodeList));
|
|
// ASSERT (AmlNodeList != NULL);
|
|
|
|
AmlNodeList->Signature = EFI_AML_NODE_LIST_SIGNATURE;
|
|
CopyMem(AmlNodeList->Name, NameSeg, AML_NAME_SEG_SIZE);
|
|
AmlNodeList->Buffer = NULL;
|
|
AmlNodeList->Size = 0;
|
|
InitializeListHead (&AmlNodeList->Link);
|
|
InitializeListHead (&AmlNodeList->Children);
|
|
AmlNodeList->Parent = Parent;
|
|
AmlNodeList->AmlByteEncoding = AmlByteEncoding;
|
|
|
|
return AmlNodeList;
|
|
}
|
|
|
|
/**
|
|
Find the AML NameSeg in the children of AmlParentNodeList.
|
|
|
|
@param[in] NameSeg AML NameSeg.
|
|
@param[in] AmlParentNodeList AML parent node list.
|
|
@param[in] Create TRUE means to create node if not found.
|
|
|
|
@return AmlChildNode whoes name is same as NameSeg.
|
|
**/
|
|
EFI_AML_NODE_LIST *
|
|
AmlFindNodeInThis (
|
|
IN UINT8 *NameSeg,
|
|
IN EFI_AML_NODE_LIST *AmlParentNodeList,
|
|
IN BOOLEAN Create
|
|
)
|
|
{
|
|
EFI_AML_NODE_LIST *CurrentAmlNodeList;
|
|
LIST_ENTRY *CurrentLink;
|
|
LIST_ENTRY *StartLink;
|
|
EFI_AML_NODE_LIST *AmlNodeList;
|
|
|
|
StartLink = &AmlParentNodeList->Children;
|
|
CurrentLink = StartLink->ForwardLink;
|
|
|
|
while (CurrentLink != StartLink) {
|
|
CurrentAmlNodeList = EFI_AML_NODE_LIST_FROM_LINK (CurrentLink);
|
|
//
|
|
// AML name is same as the one stored
|
|
//
|
|
if (CompareMem (CurrentAmlNodeList->Name, NameSeg, AML_NAME_SEG_SIZE) == 0) {
|
|
//
|
|
// Good! Found it
|
|
//
|
|
return CurrentAmlNodeList;
|
|
}
|
|
CurrentLink = CurrentLink->ForwardLink;
|
|
}
|
|
|
|
//
|
|
// Not found
|
|
//
|
|
if (!Create) {
|
|
return NULL;
|
|
}
|
|
|
|
//
|
|
// Create new node with NULL buffer - it means namespace not be returned.
|
|
//
|
|
AmlNodeList = AmlCreateNode (NameSeg, AmlParentNodeList, NULL);
|
|
InsertTailList (&AmlParentNodeList->Children, &AmlNodeList->Link);
|
|
|
|
return AmlNodeList;
|
|
}
|
|
|
|
/**
|
|
Find the AML NameString in the children of AmlParentNodeList or AmlRootNodeList.
|
|
|
|
@param[in] NameString AML NameString.
|
|
@param[in] AmlRootNodeList AML root node list.
|
|
@param[in] AmlParentNodeList AML parent node list.
|
|
@param[in] Create TRUE means to create node if not found.
|
|
|
|
@return AmlChildNode whoes name is same as NameSeg.
|
|
**/
|
|
EFI_AML_NODE_LIST *
|
|
AmlFindNodeInTheTree (
|
|
IN UINT8 *NameString,
|
|
IN EFI_AML_NODE_LIST *AmlRootNodeList,
|
|
IN EFI_AML_NODE_LIST *AmlParentNodeList,
|
|
IN BOOLEAN Create
|
|
)
|
|
{
|
|
UINT8 *Buffer;
|
|
EFI_AML_NODE_LIST *AmlNodeList;
|
|
EFI_AML_NODE_LIST *AmlCurrentNodeList;
|
|
UINT8 Index;
|
|
UINT8 SegCount;
|
|
|
|
Buffer = NameString;
|
|
|
|
//
|
|
// Handle root or parent prefix
|
|
//
|
|
if (*Buffer == AML_ROOT_CHAR) {
|
|
AmlCurrentNodeList = AmlRootNodeList;
|
|
Buffer += 1;
|
|
} else if (*Buffer == AML_PARENT_PREFIX_CHAR) {
|
|
AmlCurrentNodeList = AmlParentNodeList;
|
|
do {
|
|
if (AmlCurrentNodeList->Parent != NULL) {
|
|
AmlCurrentNodeList = AmlCurrentNodeList->Parent;
|
|
} else {
|
|
//
|
|
// Only root has no parent
|
|
//
|
|
// ASSERT (AmlCurrentNodeList == AmlRootNodeList);
|
|
}
|
|
Buffer += 1;
|
|
} while (*Buffer == AML_PARENT_PREFIX_CHAR);
|
|
} else {
|
|
AmlCurrentNodeList = AmlParentNodeList;
|
|
}
|
|
|
|
//
|
|
// Handle name segment
|
|
//
|
|
if (*Buffer == AML_DUAL_NAME_PREFIX) {
|
|
Buffer += 1;
|
|
SegCount = 2;
|
|
} else if (*Buffer == AML_MULTI_NAME_PREFIX) {
|
|
Buffer += 1;
|
|
SegCount = *Buffer;
|
|
Buffer += 1;
|
|
} else if (*Buffer == 0) {
|
|
//
|
|
// NULL name, only for Root
|
|
//
|
|
// ASSERT (AmlCurrentNodeList == AmlRootNodeList);
|
|
return AmlCurrentNodeList;
|
|
} else {
|
|
SegCount = 1;
|
|
}
|
|
|
|
//
|
|
// Handle NamePath
|
|
//
|
|
Index = 0;
|
|
do {
|
|
AmlNodeList = AmlFindNodeInThis (Buffer, AmlCurrentNodeList, Create);
|
|
if (AmlNodeList == NULL) {
|
|
return NULL;
|
|
}
|
|
AmlCurrentNodeList = AmlNodeList;
|
|
Buffer += AML_NAME_SEG_SIZE;
|
|
Index ++;
|
|
} while (Index < SegCount);
|
|
|
|
return AmlNodeList;
|
|
}
|
|
|
|
/**
|
|
Insert the NameString to the AmlNodeList.
|
|
|
|
@param[in] NameString AML NameString.
|
|
@param[in] Buffer Buffer for the Node.
|
|
@param[in] Size Size for the Node.
|
|
@param[in] AmlRootNodeList AML root node list.
|
|
@param[in] AmlParentNodeList AML parent node list.
|
|
|
|
@return AmlChildNode whoes name is NameString.
|
|
**/
|
|
EFI_AML_NODE_LIST *
|
|
AmlInsertNodeToTree (
|
|
IN UINT8 *NameString,
|
|
IN VOID *Buffer,
|
|
IN UINTN Size,
|
|
IN EFI_AML_NODE_LIST *AmlRootNodeList,
|
|
IN EFI_AML_NODE_LIST *AmlParentNodeList
|
|
)
|
|
{
|
|
EFI_AML_NODE_LIST *AmlNodeList;
|
|
|
|
AmlNodeList = AmlFindNodeInTheTree (
|
|
NameString,
|
|
AmlRootNodeList,
|
|
AmlParentNodeList,
|
|
TRUE // Find and Create
|
|
);
|
|
// ASSERT (AmlNodeList != NULL);
|
|
if (AmlNodeList == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
//
|
|
// Check buffer
|
|
//
|
|
if (AmlNodeList->Buffer == NULL) {
|
|
//
|
|
// NULL means new added one or SCOPE_OP
|
|
//
|
|
if (*(UINT8 *)Buffer != AML_SCOPE_OP) {
|
|
//
|
|
// We need check if new one is SCOPE_OP, because SCOPE_OP just means namespace, not a real device.
|
|
// We should not return SCOPE_OP.
|
|
//
|
|
AmlNodeList->Buffer = Buffer;
|
|
AmlNodeList->Size = Size;
|
|
AmlNodeList->AmlByteEncoding = AmlSearchByOpByte (Buffer);
|
|
}
|
|
return AmlNodeList;
|
|
}
|
|
|
|
//
|
|
// Already added
|
|
//
|
|
if (*(UINT8 *)Buffer == AML_SCOPE_OP) {
|
|
//
|
|
// The new one is SCOPE_OP, OK just return;
|
|
//
|
|
return AmlNodeList;
|
|
}
|
|
|
|
//
|
|
// Oops!!!, There must be something wrong.
|
|
//
|
|
DEBUG ((EFI_D_ERROR, "AML: Override Happen - %a!\n", NameString));
|
|
DEBUG ((EFI_D_ERROR, "AML: Existing Node - %x\n", AmlNodeList->Buffer));
|
|
DEBUG ((EFI_D_ERROR, "AML: New Buffer - %x\n", Buffer));
|
|
|
|
return NULL;
|
|
}
|
|
|
|
/**
|
|
Construct child node list according to the AML handle.
|
|
|
|
@param[in] AmlHandle AML handle.
|
|
@param[in] AmlRootNodeList AML root node list.
|
|
@param[in] AmlParentNodeList AML parent node list.
|
|
|
|
@retval EFI_SUCCESS Success.
|
|
@retval EFI_INVALID_PARAMETER AML handle does not refer to a valid ACPI object.
|
|
**/
|
|
EFI_STATUS
|
|
AmlConstructNodeListForChild (
|
|
IN EFI_AML_HANDLE *AmlHandle,
|
|
IN EFI_AML_NODE_LIST *AmlRootNodeList,
|
|
IN EFI_AML_NODE_LIST *AmlParentNodeList
|
|
)
|
|
{
|
|
AML_BYTE_ENCODING *AmlByteEncoding;
|
|
UINT8 *Buffer;
|
|
UINTN BufferSize;
|
|
UINT8 *CurrentBuffer;
|
|
EFI_AML_HANDLE *AmlChildHandle;
|
|
EFI_STATUS Status;
|
|
|
|
AmlByteEncoding = AmlHandle->AmlByteEncoding;
|
|
Buffer = AmlHandle->Buffer;
|
|
BufferSize = AmlHandle->Size;
|
|
|
|
//
|
|
// Check if we need recursively add node
|
|
//
|
|
if ((AmlByteEncoding->Attribute & AML_HAS_CHILD_OBJ) == 0) {
|
|
//
|
|
// No more node need to be added
|
|
//
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
//
|
|
// Do we need add node within METHOD?
|
|
// Yes, just add Object is OK. But we need filter NameString for METHOD invoke.
|
|
//
|
|
|
|
//
|
|
// Now, we get the last node.
|
|
//
|
|
Status = AmlGetOffsetAfterLastOption (AmlHandle, &CurrentBuffer);
|
|
if (EFI_ERROR(Status)) {
|
|
return EFI_INVALID_PARAMETER;
|
|
}
|
|
|
|
//
|
|
// Go through all the reset buffer.
|
|
//
|
|
while ((UINTN)CurrentBuffer < (UINTN)Buffer + BufferSize) {
|
|
//
|
|
// Find the child node.
|
|
//
|
|
Status = SdtOpenEx (CurrentBuffer, (UINTN)Buffer + BufferSize - (UINTN)CurrentBuffer, (EFI_ACPI_HANDLE *)&AmlChildHandle);
|
|
if (EFI_ERROR(Status)) {
|
|
//
|
|
// No child found, break now.
|
|
//
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Good, find the child. Construct node recursively
|
|
//
|
|
Status = AmlConstructNodeList (
|
|
AmlChildHandle,
|
|
AmlRootNodeList,
|
|
AmlParentNodeList
|
|
);
|
|
if (EFI_ERROR(Status)) {
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Parse next one
|
|
//
|
|
CurrentBuffer += AmlChildHandle->Size;
|
|
|
|
Close ((EFI_ACPI_HANDLE)AmlChildHandle);
|
|
}
|
|
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
/**
|
|
Construct node list according to the AML handle.
|
|
|
|
@param[in] AmlHandle AML handle.
|
|
@param[in] AmlRootNodeList AML root node list.
|
|
@param[in] AmlParentNodeList AML parent node list.
|
|
|
|
@retval EFI_SUCCESS Success.
|
|
@retval EFI_INVALID_PARAMETER AML handle does not refer to a valid ACPI object.
|
|
**/
|
|
EFI_STATUS
|
|
AmlConstructNodeList (
|
|
IN EFI_AML_HANDLE *AmlHandle,
|
|
IN EFI_AML_NODE_LIST *AmlRootNodeList,
|
|
IN EFI_AML_NODE_LIST *AmlParentNodeList
|
|
)
|
|
{
|
|
VOID *NameString;
|
|
EFI_AML_NODE_LIST *AmlNodeList;
|
|
|
|
//
|
|
// 1. Check if there is need to construct node for this OpCode.
|
|
//
|
|
if ((AmlHandle->AmlByteEncoding->Attribute & AML_IN_NAMESPACE) == 0) {
|
|
//
|
|
// No need to construct node, so we just skip this OpCode.
|
|
//
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
//
|
|
// 2. Now, we need construct node for this OpCode.
|
|
//
|
|
NameString = AmlGetObjectName (AmlHandle);
|
|
if (NameString == NULL) {
|
|
return EFI_INVALID_PARAMETER;
|
|
}
|
|
|
|
//
|
|
// Now, we need to insert node to the node list.
|
|
// NOTE: The name here could be AML NameString. So the callee need parse it.
|
|
//
|
|
AmlNodeList = AmlInsertNodeToTree (NameString, AmlHandle->Buffer, AmlHandle->Size, AmlRootNodeList, AmlParentNodeList);
|
|
// ASSERT (AmlNodeList != NULL);
|
|
|
|
//
|
|
// 3. Ok, we need to parse the object list to see if there are more node to be added.
|
|
//
|
|
return AmlConstructNodeListForChild (AmlHandle, AmlRootNodeList, AmlNodeList);
|
|
}
|
|
|
|
/**
|
|
Destruct node list
|
|
|
|
@param[in] AmlParentNodeList AML parent node list.
|
|
**/
|
|
VOID
|
|
AmlDestructNodeList (
|
|
IN EFI_AML_NODE_LIST *AmlParentNodeList
|
|
)
|
|
{
|
|
EFI_AML_NODE_LIST *CurrentAmlNodeList;
|
|
LIST_ENTRY *CurrentLink;
|
|
LIST_ENTRY *StartLink;
|
|
|
|
//
|
|
// Get the children link
|
|
//
|
|
StartLink = &AmlParentNodeList->Children;
|
|
CurrentLink = StartLink->ForwardLink;
|
|
|
|
//
|
|
// Go through all the children
|
|
//
|
|
while (CurrentLink != StartLink) {
|
|
//
|
|
// Destruct the child's list recursively
|
|
//
|
|
CurrentAmlNodeList = EFI_AML_NODE_LIST_FROM_LINK (CurrentLink);
|
|
CurrentLink = CurrentLink->ForwardLink;
|
|
|
|
//
|
|
// Remove this child from list and free the node
|
|
//
|
|
RemoveEntryList (&(CurrentAmlNodeList->Link));
|
|
|
|
AmlDestructNodeList (CurrentAmlNodeList);
|
|
}
|
|
|
|
//
|
|
// Done.
|
|
//
|
|
FreePool(AmlParentNodeList);
|
|
return ;
|
|
}
|
|
|
|
/**
|
|
Dump node list
|
|
|
|
@param[in] AmlParentNodeList AML parent node list.
|
|
@param[in] Level Output debug level.
|
|
**/
|
|
VOID
|
|
AmlDumpNodeInfo (
|
|
IN EFI_AML_NODE_LIST *AmlParentNodeList,
|
|
IN UINTN Level
|
|
)
|
|
{
|
|
EFI_AML_NODE_LIST *CurrentAmlNodeList;
|
|
volatile LIST_ENTRY *CurrentLink;
|
|
UINTN Index;
|
|
|
|
CurrentLink = AmlParentNodeList->Children.ForwardLink;
|
|
|
|
if (Level == 0) {
|
|
DEBUG ((EFI_D_ERROR, "\\"));
|
|
} else {
|
|
for (Index = 0; Index < Level; Index++) {
|
|
DEBUG ((EFI_D_ERROR, " "));
|
|
}
|
|
AmlPrintNameSeg (AmlParentNodeList->Name);
|
|
}
|
|
DEBUG ((EFI_D_ERROR, "\n"));
|
|
|
|
while (CurrentLink != &AmlParentNodeList->Children) {
|
|
CurrentAmlNodeList = EFI_AML_NODE_LIST_FROM_LINK (CurrentLink);
|
|
AmlDumpNodeInfo (CurrentAmlNodeList, Level + 1);
|
|
CurrentLink = CurrentLink->ForwardLink;
|
|
}
|
|
|
|
return ;
|
|
}
|
|
|
|
/**
|
|
Returns the handle of the ACPI object representing the specified ACPI AML path
|
|
|
|
@param[in] AmlHandle Points to the handle of the object representing the starting point for the path search.
|
|
@param[in] AmlPath Points to the ACPI AML path.
|
|
@param[out] Buffer On return, points to the ACPI object which represents AcpiPath, relative to
|
|
HandleIn.
|
|
@param[in] FromRoot TRUE means to find AML path from \ (Root) Node.
|
|
FALSE means to find AML path from this Node (The HandleIn).
|
|
|
|
@retval EFI_SUCCESS Success
|
|
@retval EFI_INVALID_PARAMETER HandleIn does not refer to a valid ACPI object.
|
|
**/
|
|
EFI_STATUS
|
|
AmlFindPath (
|
|
IN EFI_AML_HANDLE *AmlHandle,
|
|
IN UINT8 *AmlPath,
|
|
OUT VOID **Buffer,
|
|
IN BOOLEAN FromRoot
|
|
)
|
|
{
|
|
EFI_AML_NODE_LIST *AmlRootNodeList;
|
|
EFI_STATUS Status;
|
|
EFI_AML_NODE_LIST *AmlNodeList;
|
|
UINT8 RootNameSeg[AML_NAME_SEG_SIZE];
|
|
EFI_AML_NODE_LIST *CurrentAmlNodeList;
|
|
LIST_ENTRY *CurrentLink;
|
|
|
|
//
|
|
// 1. create tree
|
|
//
|
|
|
|
//
|
|
// Create root handle
|
|
//
|
|
RootNameSeg[0] = AML_ROOT_CHAR;
|
|
RootNameSeg[1] = 0;
|
|
AmlRootNodeList = AmlCreateNode (RootNameSeg, NULL, AmlHandle->AmlByteEncoding);
|
|
|
|
Status = AmlConstructNodeList (
|
|
AmlHandle,
|
|
AmlRootNodeList, // Root
|
|
AmlRootNodeList // Parent
|
|
);
|
|
if (EFI_ERROR(Status)) {
|
|
return EFI_INVALID_PARAMETER;
|
|
}
|
|
|
|
DEBUG_CODE_BEGIN ();
|
|
DEBUG ((EFI_D_ERROR, "AcpiSdt: NameSpace:\n"));
|
|
AmlDumpNodeInfo (AmlRootNodeList, 0);
|
|
DEBUG_CODE_END ();
|
|
|
|
//
|
|
// 2. Search the node in the tree
|
|
//
|
|
if (FromRoot) {
|
|
//
|
|
// Search from Root
|
|
//
|
|
CurrentAmlNodeList = AmlRootNodeList;
|
|
} else {
|
|
//
|
|
// Search from this node, NOT ROOT.
|
|
// Since we insert node to ROOT one by one, we just get the first node and search from it.
|
|
//
|
|
CurrentLink = AmlRootNodeList->Children.ForwardLink;
|
|
if (CurrentLink != &AmlRootNodeList->Children) {
|
|
//
|
|
// First node
|
|
//
|
|
CurrentAmlNodeList = EFI_AML_NODE_LIST_FROM_LINK (CurrentLink);
|
|
} else {
|
|
//
|
|
// No child
|
|
//
|
|
CurrentAmlNodeList = NULL;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Search
|
|
//
|
|
if (CurrentAmlNodeList != NULL) {
|
|
DEBUG_CODE_BEGIN ();
|
|
DEBUG ((EFI_D_ERROR, "AcpiSdt: Search from: \\"));
|
|
AmlPrintNameSeg (CurrentAmlNodeList->Name);
|
|
DEBUG ((EFI_D_ERROR, "\n"));
|
|
DEBUG_CODE_END ();
|
|
AmlNodeList = AmlFindNodeInTheTree (
|
|
AmlPath,
|
|
AmlRootNodeList, // Root
|
|
CurrentAmlNodeList, // Parent
|
|
FALSE
|
|
);
|
|
} else {
|
|
AmlNodeList = NULL;
|
|
}
|
|
|
|
*Buffer = NULL;
|
|
Status = EFI_SUCCESS;
|
|
if (AmlNodeList != NULL && AmlNodeList->Buffer != NULL) {
|
|
*Buffer = AmlNodeList->Buffer;
|
|
}
|
|
|
|
//
|
|
// 3. free the tree
|
|
//
|
|
AmlDestructNodeList (AmlRootNodeList);
|
|
|
|
return Status;
|
|
}
|