mirror of
https://github.com/acidanthera/audk.git
synced 2025-07-08 14:24:24 +02:00
107d0c3800
As of now, the field-validator implemented by FNPTR_FIELD_VALIDATOR function pointer takes two parameters, the pointer to the field and a context pointer. For cases where the validator has to have access to the length of the field, there is no clean way to currently do it. In order to resolve this, this commit updates the field-validator's prototype to take the length of the field as an additional parameter. This enhancement allows field validators to perform more comprehensive validation, especially when the length of the field is critical to the validation logic. This change should improve the overall robustness and flexibility of AcpiView. Signed-off-by: Rohit Mathew <Rohit.Mathew@arm.com> Cc: James Morse <james.Morse@arm.com> Cc: Sami Mujawar <sami.mujawar@arm.com> Cc: Thomas Abraham <thomas.abraham@arm.com> Cc: Zhichao Gao <zhichao.gao@intel.com> Reviewed-by: Sami Mujawar <sami.mujawar@arm.com>
982 lines
27 KiB
C
982 lines
27 KiB
C
/** @file
|
|
IORT table parser
|
|
|
|
Copyright (c) 2016 - 2024, Arm Limited. All rights reserved.
|
|
SPDX-License-Identifier: BSD-2-Clause-Patent
|
|
|
|
@par Reference(s):
|
|
- IO Remapping Table, Platform Design Document, Revision E.d, Feb 2022
|
|
(https://developer.arm.com/documentation/den0049/)
|
|
|
|
@par Glossary:
|
|
- Ref - Reference
|
|
- Desc - Descriptor
|
|
**/
|
|
|
|
#include <IndustryStandard/IoRemappingTable.h>
|
|
#include <Library/PrintLib.h>
|
|
#include <Library/UefiLib.h>
|
|
#include "AcpiParser.h"
|
|
#include "AcpiTableParser.h"
|
|
#include "AcpiViewConfig.h"
|
|
|
|
// Local variables
|
|
STATIC ACPI_DESCRIPTION_HEADER_INFO AcpiHdrInfo;
|
|
|
|
STATIC CONST UINT32 *IortNodeCount;
|
|
STATIC CONST UINT32 *IortNodeOffset;
|
|
|
|
STATIC CONST UINT8 *IortNodeType;
|
|
STATIC CONST UINT16 *IortNodeLength;
|
|
STATIC CONST UINT8 *IortNodeRevision;
|
|
STATIC CONST UINT32 *IortIdMappingCount;
|
|
STATIC CONST UINT32 *IortIdMappingOffset;
|
|
|
|
STATIC CONST UINT32 *InterruptContextCount;
|
|
STATIC CONST UINT32 *InterruptContextOffset;
|
|
STATIC CONST UINT32 *PmuInterruptCount;
|
|
STATIC CONST UINT32 *PmuInterruptOffset;
|
|
|
|
STATIC CONST UINT32 *ItsCount;
|
|
|
|
STATIC CONST UINT32 *RmrMemDescCount;
|
|
STATIC CONST UINT32 *RmrMemDescOffset;
|
|
|
|
/**
|
|
This function validates the ID Mapping array count for the ITS node.
|
|
|
|
@param [in] Ptr Pointer to the start of the field data.
|
|
@param [in] Length Length of the field.
|
|
@param [in] Context Pointer to context specific information e.g. this
|
|
could be a pointer to the ACPI table header.
|
|
**/
|
|
STATIC
|
|
VOID
|
|
EFIAPI
|
|
ValidateItsIdMappingCount (
|
|
IN UINT8 *Ptr,
|
|
IN UINT32 Length,
|
|
IN VOID *Context
|
|
)
|
|
{
|
|
if (*(UINT32 *)Ptr != 0) {
|
|
IncrementErrorCount ();
|
|
Print (L"\nERROR: IORT ID Mapping count must be zero.");
|
|
}
|
|
}
|
|
|
|
/**
|
|
This function validates the ID Mapping array count for the Performance
|
|
Monitoring Counter Group (PMCG) node.
|
|
|
|
@param [in] Ptr Pointer to the start of the field data.
|
|
@param [in] Length Length of the field.
|
|
@param [in] Context Pointer to context specific information e.g. this
|
|
could be a pointer to the ACPI table header.
|
|
**/
|
|
STATIC
|
|
VOID
|
|
EFIAPI
|
|
ValidatePmcgIdMappingCount (
|
|
IN UINT8 *Ptr,
|
|
IN UINT32 Length,
|
|
IN VOID *Context
|
|
)
|
|
{
|
|
if (*(UINT32 *)Ptr > 1) {
|
|
IncrementErrorCount ();
|
|
Print (L"\nERROR: IORT ID Mapping count must not be greater than 1.");
|
|
}
|
|
}
|
|
|
|
/**
|
|
This function validates the ID Mapping array offset for the ITS node.
|
|
|
|
@param [in] Ptr Pointer to the start of the field data.
|
|
@param [in] Length Length of the field.
|
|
@param [in] Context Pointer to context specific information e.g. this
|
|
could be a pointer to the ACPI table header.
|
|
**/
|
|
STATIC
|
|
VOID
|
|
EFIAPI
|
|
ValidateItsIdArrayReference (
|
|
IN UINT8 *Ptr,
|
|
IN UINT32 Length,
|
|
IN VOID *Context
|
|
)
|
|
{
|
|
if (*(UINT32 *)Ptr != 0) {
|
|
IncrementErrorCount ();
|
|
Print (L"\nERROR: IORT ID Mapping offset must be zero.");
|
|
}
|
|
}
|
|
|
|
/**
|
|
This function validates that the Physical Range address or length is not zero
|
|
and is 64K aligned.
|
|
|
|
@param [in] Ptr Pointer to the start of the field data.
|
|
@param [in] Length Length of the field.
|
|
@param [in] Context Pointer to context specific information e.g. this
|
|
could be a pointer to the ACPI table header.
|
|
**/
|
|
STATIC
|
|
VOID
|
|
EFIAPI
|
|
ValidatePhysicalRange (
|
|
IN UINT8 *Ptr,
|
|
IN UINT32 Length,
|
|
IN VOID *Context
|
|
)
|
|
{
|
|
UINT64 Value;
|
|
|
|
Value = *(UINT64 *)Ptr;
|
|
if ((Value == 0) || ((Value & (SIZE_64KB - 1)) != 0)) {
|
|
IncrementErrorCount ();
|
|
Print (L"\nERROR: Physical Range must be 64K aligned and cannot be zero.");
|
|
}
|
|
}
|
|
|
|
/**
|
|
This function validates that the RMR memory range descriptor count.
|
|
|
|
@param [in] Ptr Pointer to the start of the field data.
|
|
@param [in] Length Length of the field.
|
|
@param [in] Context Pointer to context specific information e.g. this
|
|
could be a pointer to the ACPI table header.
|
|
**/
|
|
STATIC
|
|
VOID
|
|
EFIAPI
|
|
ValidateRmrMemDescCount (
|
|
IN UINT8 *Ptr,
|
|
IN UINT32 Length,
|
|
IN VOID *Context
|
|
)
|
|
{
|
|
if (*(UINT32 *)Ptr == 0) {
|
|
IncrementErrorCount ();
|
|
Print (L"\nERROR: Memory Range Descriptor count must be >=1.");
|
|
}
|
|
}
|
|
|
|
/**
|
|
Helper Macro for populating the IORT Node header in the ACPI_PARSER array.
|
|
|
|
@param [out] ValidateIdMappingCount Optional pointer to a function for
|
|
validating the ID Mapping count.
|
|
@param [out] ValidateIdArrayReference Optional pointer to a function for
|
|
validating the ID Array reference.
|
|
**/
|
|
#define PARSE_IORT_NODE_HEADER(ValidateIdMappingCount, \
|
|
ValidateIdArrayReference) \
|
|
{ L"Type", 1, 0, L"%d", NULL, (VOID**)&IortNodeType, NULL, NULL }, \
|
|
{ L"Length", 2, 1, L"%d", NULL, (VOID**)&IortNodeLength, NULL, NULL }, \
|
|
{ L"Revision", 1, 3, L"%d", NULL, (VOID**)&IortNodeRevision, NULL, NULL }, \
|
|
{ L"Identifier", 4, 4, L"0x%x", NULL, NULL, NULL, NULL }, \
|
|
{ L"Number of ID mappings", 4, 8, L"%d", NULL, \
|
|
(VOID**)&IortIdMappingCount, ValidateIdMappingCount, NULL }, \
|
|
{ L"Reference to ID Array", 4, 12, L"0x%x", NULL, \
|
|
(VOID**)&IortIdMappingOffset, ValidateIdArrayReference, NULL }
|
|
|
|
/**
|
|
An ACPI_PARSER array describing the ACPI IORT Table
|
|
**/
|
|
STATIC CONST ACPI_PARSER IortParser[] = {
|
|
PARSE_ACPI_HEADER (&AcpiHdrInfo),
|
|
{ L"Number of IORT Nodes", 4, 36, L"%d", NULL,
|
|
(VOID **)&IortNodeCount, NULL, NULL },
|
|
{ L"Offset to Array of IORT Nodes",4, 40, L"0x%x", NULL,
|
|
(VOID **)&IortNodeOffset, NULL, NULL },
|
|
{ L"Reserved", 4, 44, L"0x%x", NULL,NULL,NULL, NULL }
|
|
};
|
|
|
|
/**
|
|
An ACPI_PARSER array describing the IORT node header structure.
|
|
**/
|
|
STATIC CONST ACPI_PARSER IortNodeHeaderParser[] = {
|
|
PARSE_IORT_NODE_HEADER (NULL, NULL)
|
|
};
|
|
|
|
/**
|
|
An ACPI_PARSER array describing the IORT SMMUv1/2 node.
|
|
**/
|
|
STATIC CONST ACPI_PARSER IortNodeSmmuV1V2Parser[] = {
|
|
PARSE_IORT_NODE_HEADER (NULL, NULL),
|
|
{ L"Base Address", 8, 16, L"0x%lx", NULL, NULL, NULL, NULL },
|
|
{ L"Span", 8, 24, L"0x%lx", NULL, NULL, NULL, NULL },
|
|
{ L"Model", 4, 32, L"%d", NULL, NULL, NULL, NULL },
|
|
{ L"Flags", 4, 36, L"0x%x", NULL, NULL, NULL, NULL },
|
|
{ L"Global Interrupt Array Ref", 4, 40, L"0x%x", NULL, NULL, NULL,
|
|
NULL },
|
|
{ L"Number of context interrupts", 4, 44, L"%d", NULL,
|
|
(VOID **)&InterruptContextCount, NULL, NULL },
|
|
{ L"Context Interrupt Array Ref", 4, 48, L"0x%x", NULL,
|
|
(VOID **)&InterruptContextOffset, NULL, NULL },
|
|
{ L"Number of PMU Interrupts", 4, 52, L"%d", NULL,
|
|
(VOID **)&PmuInterruptCount, NULL, NULL },
|
|
{ L"PMU Interrupt Array Ref", 4, 56, L"0x%x", NULL,
|
|
(VOID **)&PmuInterruptOffset, NULL, NULL },
|
|
|
|
// Interrupt Array
|
|
{ L"SMMU_NSgIrpt", 4, 60, L"0x%x", NULL, NULL, NULL, NULL },
|
|
{ L"SMMU_NSgIrpt interrupt flags", 4, 64, L"0x%x", NULL, NULL, NULL, NULL },
|
|
{ L"SMMU_NSgCfgIrpt", 4, 68, L"0x%x", NULL, NULL, NULL, NULL },
|
|
{ L"SMMU_NSgCfgIrpt interrupt flags",4, 72, L"0x%x", NULL, NULL, NULL, NULL }
|
|
};
|
|
|
|
/**
|
|
An ACPI_PARSER array describing the SMMUv1/2 Node Interrupt Array.
|
|
**/
|
|
STATIC CONST ACPI_PARSER InterruptArrayParser[] = {
|
|
{ L"Interrupt GSIV", 4, 0, L"0x%x", NULL, NULL, NULL, NULL },
|
|
{ L"Flags", 4, 4, L"0x%x", NULL, NULL, NULL, NULL }
|
|
};
|
|
|
|
/**
|
|
An ACPI_PARSER array describing the IORT ID Mapping.
|
|
**/
|
|
STATIC CONST ACPI_PARSER IortNodeIdMappingParser[] = {
|
|
{ L"Input base", 4, 0, L"0x%x", NULL, NULL, NULL, NULL },
|
|
{ L"Number of IDs", 4, 4, L"0x%x", NULL, NULL, NULL, NULL },
|
|
{ L"Output base", 4, 8, L"0x%x", NULL, NULL, NULL, NULL },
|
|
{ L"Output reference", 4, 12, L"0x%x", NULL, NULL, NULL, NULL },
|
|
{ L"Flags", 4, 16, L"0x%x", NULL, NULL, NULL, NULL }
|
|
};
|
|
|
|
/**
|
|
An ACPI_PARSER array describing the IORT SMMUv3 node.
|
|
**/
|
|
STATIC CONST ACPI_PARSER IortNodeSmmuV3Parser[] = {
|
|
PARSE_IORT_NODE_HEADER (NULL, NULL),
|
|
{ L"Base Address", 8, 16, L"0x%lx", NULL, NULL, NULL, NULL },
|
|
{ L"Flags", 4, 24, L"0x%x", NULL, NULL, NULL, NULL },
|
|
{ L"Reserved", 4, 28, L"0x%x", NULL, NULL, NULL, NULL },
|
|
{ L"VATOS Address", 8, 32, L"0x%lx", NULL, NULL, NULL, NULL },
|
|
{ L"Model", 4, 40, L"%d", NULL, NULL, NULL, NULL },
|
|
{ L"Event", 4, 44, L"0x%x", NULL, NULL, NULL, NULL },
|
|
{ L"PRI", 4, 48, L"0x%x", NULL, NULL, NULL, NULL },
|
|
{ L"GERR", 4, 52, L"0x%x", NULL, NULL, NULL, NULL },
|
|
{ L"Sync", 4, 56, L"0x%x", NULL, NULL, NULL, NULL },
|
|
{ L"Proximity domain", 4, 60, L"0x%x", NULL, NULL, NULL, NULL },
|
|
{ L"Device ID mapping index", 4, 64, L"%d", NULL, NULL, NULL, NULL }
|
|
};
|
|
|
|
/**
|
|
An ACPI_PARSER array describing the IORT ITS node.
|
|
**/
|
|
STATIC CONST ACPI_PARSER IortNodeItsParser[] = {
|
|
PARSE_IORT_NODE_HEADER (
|
|
ValidateItsIdMappingCount,
|
|
ValidateItsIdArrayReference
|
|
),
|
|
{ L"Number of ITSs", 4,16, L"%d", NULL, (VOID **)&ItsCount, NULL }
|
|
};
|
|
|
|
/**
|
|
An ACPI_PARSER array describing the ITS ID.
|
|
**/
|
|
STATIC CONST ACPI_PARSER ItsIdParser[] = {
|
|
{ L"GIC ITS Identifier", 4, 0, L"%d", NULL, NULL, NULL }
|
|
};
|
|
|
|
/**
|
|
An ACPI_PARSER array describing the IORT Names Component node.
|
|
**/
|
|
STATIC CONST ACPI_PARSER IortNodeNamedComponentParser[] = {
|
|
PARSE_IORT_NODE_HEADER (NULL, NULL),
|
|
{ L"Node Flags", 4, 16, L"%d", NULL, NULL, NULL, NULL },
|
|
{ L"Memory access properties",8, 20, L"0x%lx", NULL, NULL, NULL, NULL },
|
|
{ L"Device memory address size limit",1, 28, L"%d", NULL, NULL, NULL, NULL }
|
|
};
|
|
|
|
/**
|
|
An ACPI_PARSER array describing the IORT Root Complex node.
|
|
**/
|
|
STATIC CONST ACPI_PARSER IortNodeRootComplexParser[] = {
|
|
PARSE_IORT_NODE_HEADER (NULL, NULL),
|
|
{ L"Memory access properties",8, 16, L"0x%lx", NULL, NULL, NULL, NULL },
|
|
{ L"ATS Attribute", 4, 24, L"0x%x", NULL, NULL, NULL, NULL },
|
|
{ L"PCI Segment number", 4, 28, L"0x%x", NULL, NULL, NULL, NULL },
|
|
{ L"Memory access size limit",1, 32, L"0x%x", NULL, NULL, NULL, NULL },
|
|
{ L"PASID capabilities", 2, 33, L"0x%x", NULL, NULL, NULL, NULL },
|
|
{ L"Reserved", 1, 35, L"%x", NULL, NULL, NULL, NULL },
|
|
{ L"Flags", 4, 36, L"0x%x", NULL, NULL, NULL, NULL },
|
|
};
|
|
|
|
/**
|
|
An ACPI_PARSER array describing the IORT PMCG node.
|
|
**/
|
|
STATIC CONST ACPI_PARSER IortNodePmcgParser[] = {
|
|
PARSE_IORT_NODE_HEADER (ValidatePmcgIdMappingCount, NULL),
|
|
{ L"Page 0 Base Address", 8, 16, L"0x%lx", NULL, NULL, NULL, NULL },
|
|
{ L"Overflow interrupt GSIV", 4, 24, L"0x%x", NULL, NULL, NULL, NULL },
|
|
{ L"Node reference", 4, 28, L"0x%x", NULL, NULL, NULL, NULL },
|
|
{ L"Page 1 Base Address", 8, 32, L"0x%lx", NULL, NULL, NULL, NULL }
|
|
};
|
|
|
|
/**
|
|
An ACPI_PARSER array describing the IORT RMR node.
|
|
**/
|
|
STATIC CONST ACPI_PARSER IortNodeRmrParser[] = {
|
|
PARSE_IORT_NODE_HEADER (NULL, NULL),
|
|
{ L"Flags", 4, 16, L"0x%x", NULL, NULL, NULL, NULL },
|
|
{ L"Memory Range Desc count", 4, 20, L"%d", NULL,
|
|
(VOID **)&RmrMemDescCount, ValidateRmrMemDescCount,NULL },
|
|
{ L"Memory Range Desc Ref", 4, 24, L"0x%x", NULL,
|
|
(VOID **)&RmrMemDescOffset, NULL, NULL }
|
|
};
|
|
|
|
/**
|
|
An ACPI_PARSER array describing the IORT RMR Memory Range Descriptor.
|
|
**/
|
|
STATIC CONST ACPI_PARSER IortNodeRmrMemRangeDescParser[] = {
|
|
{ L"Physical Range offset", 8, 0, L"0x%lx", NULL, NULL, ValidatePhysicalRange,
|
|
NULL },
|
|
{ L"Physical Range length", 8, 8, L"0x%lx", NULL, NULL, ValidatePhysicalRange,
|
|
NULL },
|
|
{ L"Reserved", 4, 16, L"0x%x", NULL, NULL, NULL, NULL}
|
|
};
|
|
|
|
/**
|
|
This function parses the IORT Node Id Mapping array.
|
|
|
|
@param [in] Ptr Pointer to the start of the ID mapping array.
|
|
@param [in] Length Length of the buffer.
|
|
@param [in] MappingCount The ID Mapping count.
|
|
**/
|
|
STATIC
|
|
VOID
|
|
DumpIortNodeIdMappings (
|
|
IN UINT8 *Ptr,
|
|
IN UINT32 Length,
|
|
IN UINT32 MappingCount
|
|
)
|
|
{
|
|
UINT32 Index;
|
|
UINT32 Offset;
|
|
CHAR8 Buffer[40]; // Used for AsciiName param of ParseAcpi
|
|
|
|
Index = 0;
|
|
Offset = 0;
|
|
|
|
while ((Index < MappingCount) &&
|
|
(Offset < Length))
|
|
{
|
|
AsciiSPrint (
|
|
Buffer,
|
|
sizeof (Buffer),
|
|
"ID Mapping [%d]",
|
|
Index
|
|
);
|
|
Offset += ParseAcpi (
|
|
TRUE,
|
|
4,
|
|
Buffer,
|
|
Ptr + Offset,
|
|
Length - Offset,
|
|
PARSER_PARAMS (IortNodeIdMappingParser)
|
|
);
|
|
Index++;
|
|
}
|
|
}
|
|
|
|
/**
|
|
This function parses the IORT SMMUv1/2 node.
|
|
|
|
@param [in] Ptr Pointer to the start of the buffer.
|
|
@param [in] Length Length of the buffer.
|
|
@param [in] MappingCount The ID Mapping count.
|
|
@param [in] MappingOffset The offset of the ID Mapping array
|
|
from the start of the IORT table.
|
|
**/
|
|
STATIC
|
|
VOID
|
|
DumpIortNodeSmmuV1V2 (
|
|
IN UINT8 *Ptr,
|
|
IN UINT16 Length,
|
|
IN UINT32 MappingCount,
|
|
IN UINT32 MappingOffset
|
|
)
|
|
{
|
|
UINT32 Index;
|
|
UINT32 Offset;
|
|
CHAR8 Buffer[50]; // Used for AsciiName param of ParseAcpi
|
|
|
|
ParseAcpi (
|
|
TRUE,
|
|
2,
|
|
"SMMUv1 or SMMUv2 Node",
|
|
Ptr,
|
|
Length,
|
|
PARSER_PARAMS (IortNodeSmmuV1V2Parser)
|
|
);
|
|
|
|
// Check if the values used to control the parsing logic have been
|
|
// successfully read.
|
|
if ((InterruptContextCount == NULL) ||
|
|
(InterruptContextOffset == NULL) ||
|
|
(PmuInterruptCount == NULL) ||
|
|
(PmuInterruptOffset == NULL))
|
|
{
|
|
IncrementErrorCount ();
|
|
Print (
|
|
L"ERROR: Insufficient SMMUv1/2 node length. Length = %d\n",
|
|
Length
|
|
);
|
|
return;
|
|
}
|
|
|
|
Offset = *InterruptContextOffset;
|
|
Index = 0;
|
|
|
|
while ((Index < *InterruptContextCount) &&
|
|
(Offset < Length))
|
|
{
|
|
AsciiSPrint (
|
|
Buffer,
|
|
sizeof (Buffer),
|
|
"Context Interrupts Array [%d]",
|
|
Index
|
|
);
|
|
Offset += ParseAcpi (
|
|
TRUE,
|
|
4,
|
|
Buffer,
|
|
Ptr + Offset,
|
|
Length - Offset,
|
|
PARSER_PARAMS (InterruptArrayParser)
|
|
);
|
|
Index++;
|
|
}
|
|
|
|
Offset = *PmuInterruptOffset;
|
|
Index = 0;
|
|
|
|
while ((Index < *PmuInterruptCount) &&
|
|
(Offset < Length))
|
|
{
|
|
AsciiSPrint (
|
|
Buffer,
|
|
sizeof (Buffer),
|
|
"PMU Interrupts Array [%d]",
|
|
Index
|
|
);
|
|
Offset += ParseAcpi (
|
|
TRUE,
|
|
4,
|
|
Buffer,
|
|
Ptr + Offset,
|
|
Length - Offset,
|
|
PARSER_PARAMS (InterruptArrayParser)
|
|
);
|
|
Index++;
|
|
}
|
|
|
|
DumpIortNodeIdMappings (
|
|
Ptr + MappingOffset,
|
|
Length - MappingOffset,
|
|
MappingCount
|
|
);
|
|
}
|
|
|
|
/**
|
|
This function parses the IORT SMMUv3 node.
|
|
|
|
@param [in] Ptr Pointer to the start of the buffer.
|
|
@param [in] Length Length of the buffer.
|
|
@param [in] MappingCount The ID Mapping count.
|
|
@param [in] MappingOffset The offset of the ID Mapping array
|
|
from the start of the IORT table.
|
|
**/
|
|
STATIC
|
|
VOID
|
|
DumpIortNodeSmmuV3 (
|
|
IN UINT8 *Ptr,
|
|
IN UINT16 Length,
|
|
IN UINT32 MappingCount,
|
|
IN UINT32 MappingOffset
|
|
)
|
|
{
|
|
ParseAcpi (
|
|
TRUE,
|
|
2,
|
|
"SMMUV3 Node",
|
|
Ptr,
|
|
Length,
|
|
PARSER_PARAMS (IortNodeSmmuV3Parser)
|
|
);
|
|
|
|
DumpIortNodeIdMappings (
|
|
Ptr + MappingOffset,
|
|
Length - MappingOffset,
|
|
MappingCount
|
|
);
|
|
}
|
|
|
|
/**
|
|
This function parses the IORT ITS node.
|
|
|
|
@param [in] Ptr Pointer to the start of the buffer.
|
|
@param [in] Length Length of the buffer.
|
|
**/
|
|
STATIC
|
|
VOID
|
|
DumpIortNodeIts (
|
|
IN UINT8 *Ptr,
|
|
IN UINT16 Length
|
|
)
|
|
{
|
|
UINT32 Offset;
|
|
UINT32 Index;
|
|
CHAR8 Buffer[80]; // Used for AsciiName param of ParseAcpi
|
|
|
|
Offset = ParseAcpi (
|
|
TRUE,
|
|
2,
|
|
"ITS Node",
|
|
Ptr,
|
|
Length,
|
|
PARSER_PARAMS (IortNodeItsParser)
|
|
);
|
|
|
|
// Check if the values used to control the parsing logic have been
|
|
// successfully read.
|
|
if (ItsCount == NULL) {
|
|
IncrementErrorCount ();
|
|
Print (
|
|
L"ERROR: Insufficient ITS group length. Length = %d.\n",
|
|
Length
|
|
);
|
|
return;
|
|
}
|
|
|
|
Index = 0;
|
|
|
|
while ((Index < *ItsCount) &&
|
|
(Offset < Length))
|
|
{
|
|
AsciiSPrint (
|
|
Buffer,
|
|
sizeof (Buffer),
|
|
"GIC ITS Identifier Array [%d]",
|
|
Index
|
|
);
|
|
Offset += ParseAcpi (
|
|
TRUE,
|
|
4,
|
|
Buffer,
|
|
Ptr + Offset,
|
|
Length - Offset,
|
|
PARSER_PARAMS (ItsIdParser)
|
|
);
|
|
Index++;
|
|
}
|
|
|
|
// Note: ITS does not have the ID Mappings Array
|
|
}
|
|
|
|
/**
|
|
This function parses the IORT Named Component node.
|
|
|
|
@param [in] Ptr Pointer to the start of the buffer.
|
|
@param [in] Length Length of the buffer.
|
|
@param [in] MappingCount The ID Mapping count.
|
|
@param [in] MappingOffset The offset of the ID Mapping array
|
|
from the start of the IORT table.
|
|
**/
|
|
STATIC
|
|
VOID
|
|
DumpIortNodeNamedComponent (
|
|
IN UINT8 *Ptr,
|
|
IN UINT16 Length,
|
|
IN UINT32 MappingCount,
|
|
IN UINT32 MappingOffset
|
|
)
|
|
{
|
|
UINT32 Offset;
|
|
|
|
Offset = ParseAcpi (
|
|
TRUE,
|
|
2,
|
|
"Named Component Node",
|
|
Ptr,
|
|
Length,
|
|
PARSER_PARAMS (IortNodeNamedComponentParser)
|
|
);
|
|
|
|
// Estimate the Device Name length
|
|
PrintFieldName (2, L"Device Object Name");
|
|
|
|
while ((*(Ptr + Offset) != 0) &&
|
|
(Offset < Length))
|
|
{
|
|
Print (L"%c", *(Ptr + Offset));
|
|
Offset++;
|
|
}
|
|
|
|
Print (L"\n");
|
|
|
|
DumpIortNodeIdMappings (
|
|
Ptr + MappingOffset,
|
|
Length - MappingOffset,
|
|
MappingCount
|
|
);
|
|
}
|
|
|
|
/**
|
|
This function parses the IORT Root Complex node.
|
|
|
|
@param [in] Ptr Pointer to the start of the buffer.
|
|
@param [in] Length Length of the buffer.
|
|
@param [in] MappingCount The ID Mapping count.
|
|
@param [in] MappingOffset The offset of the ID Mapping array
|
|
from the start of the IORT table.
|
|
**/
|
|
STATIC
|
|
VOID
|
|
DumpIortNodeRootComplex (
|
|
IN UINT8 *Ptr,
|
|
IN UINT16 Length,
|
|
IN UINT32 MappingCount,
|
|
IN UINT32 MappingOffset
|
|
)
|
|
{
|
|
ParseAcpi (
|
|
TRUE,
|
|
2,
|
|
"Root Complex Node",
|
|
Ptr,
|
|
Length,
|
|
PARSER_PARAMS (IortNodeRootComplexParser)
|
|
);
|
|
|
|
DumpIortNodeIdMappings (
|
|
Ptr + MappingOffset,
|
|
Length - MappingOffset,
|
|
MappingCount
|
|
);
|
|
}
|
|
|
|
/**
|
|
This function parses the IORT PMCG node.
|
|
|
|
@param [in] Ptr Pointer to the start of the buffer.
|
|
@param [in] Length Length of the buffer.
|
|
@param [in] MappingCount The ID Mapping count.
|
|
@param [in] MappingOffset The offset of the ID Mapping array
|
|
from the start of the IORT table.
|
|
**/
|
|
STATIC
|
|
VOID
|
|
DumpIortNodePmcg (
|
|
IN UINT8 *Ptr,
|
|
IN UINT16 Length,
|
|
IN UINT32 MappingCount,
|
|
IN UINT32 MappingOffset
|
|
)
|
|
{
|
|
ParseAcpi (
|
|
TRUE,
|
|
2,
|
|
"PMCG Node",
|
|
Ptr,
|
|
Length,
|
|
PARSER_PARAMS (IortNodePmcgParser)
|
|
);
|
|
|
|
DumpIortNodeIdMappings (
|
|
Ptr + MappingOffset,
|
|
Length - MappingOffset,
|
|
MappingCount
|
|
);
|
|
}
|
|
|
|
/**
|
|
This function parses the IORT RMR Node Memory Range Descriptor array.
|
|
|
|
@param [in] Ptr Pointer to the start of the Memory Range Descriptor
|
|
array.
|
|
@param [in] Length Length of the buffer.
|
|
@param [in] DescCount Memory Range Descriptor count.
|
|
**/
|
|
STATIC
|
|
VOID
|
|
DumpIortNodeRmrMemRangeDesc (
|
|
IN UINT8 *Ptr,
|
|
IN UINT32 Length,
|
|
IN UINT32 DescCount
|
|
)
|
|
{
|
|
UINT32 Index;
|
|
UINT32 Offset;
|
|
CHAR8 Buffer[40]; // Used for AsciiName param of ParseAcpi
|
|
|
|
Index = 0;
|
|
Offset = 0;
|
|
|
|
while ((Index < DescCount) &&
|
|
(Offset < Length))
|
|
{
|
|
AsciiSPrint (
|
|
Buffer,
|
|
sizeof (Buffer),
|
|
"Mem range Descriptor [%d]",
|
|
Index
|
|
);
|
|
Offset += ParseAcpi (
|
|
TRUE,
|
|
4,
|
|
Buffer,
|
|
Ptr + Offset,
|
|
Length - Offset,
|
|
PARSER_PARAMS (IortNodeRmrMemRangeDescParser)
|
|
);
|
|
Index++;
|
|
}
|
|
}
|
|
|
|
/**
|
|
This function parses the IORT RMR node.
|
|
|
|
@param [in] Ptr Pointer to the start of the buffer.
|
|
@param [in] Length Length of the buffer.
|
|
@param [in] MappingCount The ID Mapping count.
|
|
@param [in] MappingOffset The offset of the ID Mapping array
|
|
from the start of the IORT table.
|
|
**/
|
|
STATIC
|
|
VOID
|
|
DumpIortNodeRmr (
|
|
IN UINT8 *Ptr,
|
|
IN UINT16 Length,
|
|
IN UINT32 MappingCount,
|
|
IN UINT32 MappingOffset
|
|
)
|
|
{
|
|
ParseAcpi (
|
|
TRUE,
|
|
2,
|
|
"RMR Node",
|
|
Ptr,
|
|
Length,
|
|
PARSER_PARAMS (IortNodeRmrParser)
|
|
);
|
|
|
|
if (*IortNodeRevision == EFI_ACPI_IORT_RMR_NODE_REVISION_02) {
|
|
IncrementErrorCount ();
|
|
Print (
|
|
L"ERROR: RMR node Rev 2 (defined in IORT Rev E.c) must not be used."
|
|
L" IORT tabe Revision E.c is deprecated and must not be used.\n"
|
|
);
|
|
}
|
|
|
|
DumpIortNodeIdMappings (
|
|
Ptr + MappingOffset,
|
|
Length - MappingOffset,
|
|
MappingCount
|
|
);
|
|
|
|
DumpIortNodeRmrMemRangeDesc (
|
|
Ptr + (*RmrMemDescOffset),
|
|
Length - (*RmrMemDescOffset),
|
|
*RmrMemDescCount
|
|
);
|
|
}
|
|
|
|
/**
|
|
This function parses the ACPI IORT table.
|
|
When trace is enabled this function parses the IORT table and traces the ACPI
|
|
fields.
|
|
|
|
This function also parses the following nodes:
|
|
- ITS Group
|
|
- Named Component
|
|
- Root Complex
|
|
- SMMUv1/2
|
|
- SMMUv3
|
|
- PMCG
|
|
- RMR
|
|
|
|
This function also performs validation of the ACPI table fields.
|
|
|
|
@param [in] Trace If TRUE, trace the ACPI fields.
|
|
@param [in] Ptr Pointer to the start of the buffer.
|
|
@param [in] AcpiTableLength Length of the ACPI table.
|
|
@param [in] AcpiTableRevision Revision of the ACPI table.
|
|
**/
|
|
VOID
|
|
EFIAPI
|
|
ParseAcpiIort (
|
|
IN BOOLEAN Trace,
|
|
IN UINT8 *Ptr,
|
|
IN UINT32 AcpiTableLength,
|
|
IN UINT8 AcpiTableRevision
|
|
)
|
|
{
|
|
UINT32 Offset;
|
|
UINT32 Index;
|
|
UINT8 *NodePtr;
|
|
|
|
if (!Trace) {
|
|
return;
|
|
}
|
|
|
|
if ((AcpiTableRevision > EFI_ACPI_IO_REMAPPING_TABLE_REVISION_00) &&
|
|
(AcpiTableRevision < EFI_ACPI_IO_REMAPPING_TABLE_REVISION_05))
|
|
{
|
|
Print (
|
|
L"ERROR: Parsing not supported for IORT tabe Revision E, E.<a,b,c>.\n"
|
|
);
|
|
if (AcpiTableRevision == EFI_ACPI_IO_REMAPPING_TABLE_REVISION_04) {
|
|
IncrementErrorCount ();
|
|
Print (
|
|
L"ERROR: IORT tabe Revision E.c is deprecated and must not be used.\n"
|
|
);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
ParseAcpi (
|
|
TRUE,
|
|
0,
|
|
"IORT",
|
|
Ptr,
|
|
AcpiTableLength,
|
|
PARSER_PARAMS (IortParser)
|
|
);
|
|
|
|
// Check if the values used to control the parsing logic have been
|
|
// successfully read.
|
|
if ((IortNodeCount == NULL) ||
|
|
(IortNodeOffset == NULL))
|
|
{
|
|
IncrementErrorCount ();
|
|
Print (
|
|
L"ERROR: Insufficient table length. AcpiTableLength = %d.\n",
|
|
AcpiTableLength
|
|
);
|
|
return;
|
|
}
|
|
|
|
Offset = *IortNodeOffset;
|
|
NodePtr = Ptr + Offset;
|
|
Index = 0;
|
|
|
|
// Parse the specified number of IORT nodes or the IORT table buffer length.
|
|
// Whichever is minimum.
|
|
while ((Index++ < *IortNodeCount) &&
|
|
(Offset < AcpiTableLength))
|
|
{
|
|
// Parse the IORT Node Header
|
|
ParseAcpi (
|
|
FALSE,
|
|
0,
|
|
"IORT Node Header",
|
|
NodePtr,
|
|
AcpiTableLength - Offset,
|
|
PARSER_PARAMS (IortNodeHeaderParser)
|
|
);
|
|
|
|
// Check if the values used to control the parsing logic have been
|
|
// successfully read.
|
|
if ((IortNodeType == NULL) ||
|
|
(IortNodeLength == NULL) ||
|
|
(IortIdMappingCount == NULL) ||
|
|
(IortIdMappingOffset == NULL))
|
|
{
|
|
IncrementErrorCount ();
|
|
Print (
|
|
L"ERROR: Insufficient remaining table buffer length to read the " \
|
|
L"IORT node header. Length = %d.\n",
|
|
AcpiTableLength - Offset
|
|
);
|
|
return;
|
|
}
|
|
|
|
// Validate IORT Node length
|
|
if ((*IortNodeLength == 0) ||
|
|
((Offset + (*IortNodeLength)) > AcpiTableLength))
|
|
{
|
|
IncrementErrorCount ();
|
|
Print (
|
|
L"ERROR: Invalid IORT Node length. " \
|
|
L"Length = %d. Offset = %d. AcpiTableLength = %d.\n",
|
|
*IortNodeLength,
|
|
Offset,
|
|
AcpiTableLength
|
|
);
|
|
return;
|
|
}
|
|
|
|
PrintFieldName (2, L"* Node Offset *");
|
|
Print (L"0x%x\n", Offset);
|
|
|
|
switch (*IortNodeType) {
|
|
case EFI_ACPI_IORT_TYPE_ITS_GROUP:
|
|
DumpIortNodeIts (
|
|
NodePtr,
|
|
*IortNodeLength
|
|
);
|
|
break;
|
|
case EFI_ACPI_IORT_TYPE_NAMED_COMP:
|
|
DumpIortNodeNamedComponent (
|
|
NodePtr,
|
|
*IortNodeLength,
|
|
*IortIdMappingCount,
|
|
*IortIdMappingOffset
|
|
);
|
|
break;
|
|
case EFI_ACPI_IORT_TYPE_ROOT_COMPLEX:
|
|
DumpIortNodeRootComplex (
|
|
NodePtr,
|
|
*IortNodeLength,
|
|
*IortIdMappingCount,
|
|
*IortIdMappingOffset
|
|
);
|
|
break;
|
|
case EFI_ACPI_IORT_TYPE_SMMUv1v2:
|
|
DumpIortNodeSmmuV1V2 (
|
|
NodePtr,
|
|
*IortNodeLength,
|
|
*IortIdMappingCount,
|
|
*IortIdMappingOffset
|
|
);
|
|
break;
|
|
case EFI_ACPI_IORT_TYPE_SMMUv3:
|
|
DumpIortNodeSmmuV3 (
|
|
NodePtr,
|
|
*IortNodeLength,
|
|
*IortIdMappingCount,
|
|
*IortIdMappingOffset
|
|
);
|
|
break;
|
|
case EFI_ACPI_IORT_TYPE_PMCG:
|
|
DumpIortNodePmcg (
|
|
NodePtr,
|
|
*IortNodeLength,
|
|
*IortIdMappingCount,
|
|
*IortIdMappingOffset
|
|
);
|
|
break;
|
|
case EFI_ACPI_IORT_TYPE_RMR:
|
|
DumpIortNodeRmr (
|
|
NodePtr,
|
|
*IortNodeLength,
|
|
*IortIdMappingCount,
|
|
*IortIdMappingOffset
|
|
);
|
|
break;
|
|
default:
|
|
IncrementErrorCount ();
|
|
Print (L"ERROR: Unsupported IORT Node type = %d\n", *IortNodeType);
|
|
} // switch
|
|
|
|
NodePtr += (*IortNodeLength);
|
|
Offset += (*IortNodeLength);
|
|
} // while
|
|
}
|