xinb
/
alder_lake_bios
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
alder_lake_bios/Insyde/InsydeModulePkg/Library/PeiVerbTableCfgLib/VerbTableCfgGetVerbTable.c

471 lines
16 KiB
C
Raw Blame History

/** @file
Search and parse verbtable binary in FD.
;******************************************************************************
;* Copyright (c) 2016 - 2019, Insyde Software Corp. All Rights Reserved.
;*
;* You may not reproduce, distribute, publish, display, perform, modify, adapt,
;* transmit, broadcast, present, recite, release, license or otherwise exploit
;* any part of this publication in any form, by any means, without the prior
;* written permission of Insyde Software Corporation.
;*
;******************************************************************************
*/
#include "VerbTableCfgGetVerbTable.h"
STATIC CHAR8 mFdmSignature[] = {'H', 'F', 'D', 'M'};
/**
Check if this FDM entry supports the target board.
This method works with board-id value over 0xFF.
The board-id value less than 0xFF may compare with region id in each fdm entry.
@param[in] BoardId The qword size board id.
@param[in] RegionIndex The index of fdm entry.
@retval TRUE The entry supports this board.
@retval FALSE The entry does not support this board
or Fdm not found or Unsupported fdm version
or invalid fdm header discovered.
**/
BOOLEAN
DoesRegionSupportBoardId (
IN CONST UINT64 BoardId,
IN CONST UINT32 RegionIndex
)
{
H2O_FLASH_DEVICE_MAP_HEADER *FdmHeader;
H2O_FLASH_DEVICE_MAP_EXTS *FdmExt;
H2O_FLASH_DEVICE_MAP_REGION_BOARD_ID_MAP *Map;
UINT32 Index;
UINT32 Index2;
UINT64 *BoardIds;
UINT32 BoardIdCount;
FdmHeader = (H2O_FLASH_DEVICE_MAP_HEADER *)(UINTN) PcdGet64(PcdH2OFlashDeviceMapStart);
if (FdmHeader == NULL) {
return FALSE;
}
if (CompareMem(FdmHeader, mFdmSignature, sizeof(mFdmSignature))) {
return FALSE;
}
//
// In Revision 3, reserved byte in Fdm header will be ExtensionCount.See BTR 3.17.1.
// The second ext block indicates the location of the first region-to-board-id-map.
//
if (FdmHeader->Revision != 3 || FdmHeader->ExtensionCount < 2) {
return FALSE;
}
FdmExt = (H2O_FLASH_DEVICE_MAP_EXTS *)(FdmHeader + 1);
//
// Jump to second ext block.
//
FdmExt = FdmExt + 1;
Map = (H2O_FLASH_DEVICE_MAP_REGION_BOARD_ID_MAP *)((UINT8 *)FdmHeader + FdmExt->ExtOffset);
for (Index = 0; Index < FdmExt->ExtCount; Index++) {
BoardIdCount = Map->BoardIdCount;
if (Map->RegionIndex == RegionIndex) {
BoardIds = (UINT64 *)((UINT8 *)Map + sizeof(H2O_FLASH_DEVICE_MAP_REGION_BOARD_ID_MAP));
for (Index2 = 0; Index2 < BoardIdCount; Index2++) {
if (BoardIds[Index2] == BoardId) {
return TRUE;
}
}
}
Map = Map + 1;
Map = (H2O_FLASH_DEVICE_MAP_REGION_BOARD_ID_MAP *)((UINT64 *)Map + BoardIdCount);
}
return FALSE;
}
/**
Search and return the "entry" and the "index of the entry" in FDM.
User may specify the instance number by 1 or greater if there are multiple instances available.
@param[in] RegionType A pointer to the guid of target region.
@param[in] Instance The Nth instace of specified region type.
@param[out] RegionIndex The index of target FDM entries.
@param[out] Entry A pointer to address of target Entry.
@retval EFI_NOT_FOUND Entry not found.
@retval EFI_UNSUPPORTED Unsupported fdm version or invalid fdm header discovered.
**/
EFI_STATUS
FdmGetNIndex (
IN CONST EFI_GUID *RegionType,
IN CONST UINT32 Instance,
OUT UINT32 *RegionIndex,
OUT H2O_FLASH_DEVICE_MAP_ENTRY **Entry
)
{
H2O_FLASH_DEVICE_MAP_HEADER *FdmHeader;
H2O_FLASH_DEVICE_MAP_ENTRY *FdmEntry;
UINT32 EntryArraySize;
UINT32 EntryCount;
UINT32 Index;
UINT32 MatchCount;
FdmHeader = NULL;
FdmHeader = (H2O_FLASH_DEVICE_MAP_HEADER *)(UINTN) PcdGet64(PcdH2OFlashDeviceMapStart);
if (FdmHeader == NULL) {
return EFI_NOT_FOUND;
}
FdmEntry = (H2O_FLASH_DEVICE_MAP_ENTRY *)((UINT8 *)FdmHeader + FdmHeader->Offset);
EntryArraySize = FdmHeader->Size - FdmHeader->Offset;
EntryCount = EntryArraySize / FdmHeader->EntrySize;
MatchCount = 0;
//
// Search each fdm entry. If search hit, return entry address and its index.
//
for (Index = 0; Index < EntryCount; Index++) {
if (CompareGuid(RegionType, &FdmEntry->RegionType)) {
MatchCount++;
if (MatchCount == Instance) {
*RegionIndex = Index;
*Entry = FdmEntry;
return EFI_SUCCESS;
}
}
FdmEntry = (H2O_FLASH_DEVICE_MAP_ENTRY *)((UINT8 *)FdmEntry + FdmHeader->EntrySize);
}
return EFI_NOT_FOUND;
}
/*
Search fdm using dword board-id, if search hit,
allocate space and fill it with varbtable data.
@param[in] BoardId Qword board-id.
@param[out] VerbTable A pointer to address of verbtable.
@retval EFI_OUT_OF_RESOURCES Memory allocation failed.
@retval EFI_SUCCESS Get verbtable successfully.
@retval EFI_NOT_FOUND Target not found.
*/
EFI_STATUS
GetVerbTableQwordBoard (
UINT64 BoardId,
COMMON_CHIPSET_AZALIA_VERB_TABLE **VerbTable
)
{
EFI_STATUS Status;
UINT32 RegionIndex;
UINT32 Instance;
H2O_FLASH_DEVICE_MAP_ENTRY *FdmEntry;
UINT32 RegionOffset;
UINT8 *Data;
UINT8 CodecCount;
UINT8 Index;
UINT32 DwordDataCount;
COMMON_CHIPSET_AZALIA_VERB_TABLE *AzaliaVerbTable;
COMMON_VERB_TABLE_BIN_HEADER *CommonVerbTableBinHeader;
Status = EFI_SUCCESS;
Instance = 1;
while (TRUE) {
Status = FdmGetNIndex(&gH2OFlashMapRegionVerbTableGuid, Instance, &RegionIndex, &FdmEntry);
if (!EFI_ERROR(Status)) {
if (DoesRegionSupportBoardId((UINT64)BoardId, RegionIndex)) {
//
// Use this Fdm Entry.
//
RegionOffset = (UINT32)FdmEntry->RegionOffset;
Data = (UINT8 *)(UINT32)(FdmGetBaseAddr() + RegionOffset);
CodecCount = *Data;
AzaliaVerbTable = AllocateZeroPool (sizeof (COMMON_CHIPSET_AZALIA_VERB_TABLE) * (CodecCount + 1));
if (AzaliaVerbTable == NULL) {
*VerbTable = NULL;
return EFI_OUT_OF_RESOURCES;
}
//
// Binary format :
// ---------------------------------------------
// 1Byte | Number of codecs |
// ---------------------------------------------
// 14Byte | COMMON_CHIPSET_AZALIA_VERB_TABLE_HEADER | --
// --------------------------------------------- |
// 2Byte | Data size in Dword | | codec1
// --------------------------------------------- |
// non-fixed | Verb table data | --
// ---------------------------------------------
// 14Byte | COMMON_CHIPSET_AZALIA_VERB_TABLE_HEADER | --
// --------------------------------------------- |
// 2Byte | Data size in Dword | | codec2
// --------------------------------------------- |
// non-fixed | Verb table data | --
// ---------------------------------------------
// | ... | -- codec n
//
CommonVerbTableBinHeader = (COMMON_VERB_TABLE_BIN_HEADER *)(Data + 1);
for (Index = 0; Index < CodecCount; Index++) {
AzaliaVerbTable[Index].VerbTableHeader = (COMMON_CHIPSET_AZALIA_VERB_TABLE_HEADER *)&CommonVerbTableBinHeader->Header;
AzaliaVerbTable[Index].VerbTableData = (UINT32 *)(CommonVerbTableBinHeader + 1);
DwordDataCount = CommonVerbTableBinHeader->DataSizeDword;
CommonVerbTableBinHeader = CommonVerbTableBinHeader + 1;
CommonVerbTableBinHeader = (COMMON_VERB_TABLE_BIN_HEADER *)((UINT32 *)CommonVerbTableBinHeader + DwordDataCount);
}
AzaliaVerbTable[CodecCount].VerbTableHeader = NULL;
AzaliaVerbTable[CodecCount].VerbTableData = NULL;
*VerbTable = AzaliaVerbTable;
return EFI_SUCCESS;
}
} else {
break;
}
Instance++;
}
return Status;
}
/**
Find matched region by board id, and contruct a COMMON_CHIPSET_AZALIA_VERB_TABLE.
If match not found, upate VerbTableHeaderDataAddress to NULL.
@param[in] BoardId 8-bit length board-id.
@param[out] VerbTableHeaderDataAddress A pointer to address of verbtable.
@retval EFI_SUCCESS Get verbtable entry successfully.
@retval EFI_OUT_OF_RESOURCES Memory alloccation failed.
@retval EFI_NOT_FOUND Target not found.
**/
EFI_STATUS
GetVerbTableByteBoardId (
IN UINT8 BoardId,
OUT COMMON_CHIPSET_AZALIA_VERB_TABLE **VerbTableHeaderDataAddress
)
{
COMMON_CHIPSET_AZALIA_VERB_TABLE *AzaliaVerbTable;
EFI_STATUS Status;
UINT8 Instance;
VOID *VerbTableRaw;
UINT16 DwordOffset;
UINT8 RegionId[FDM_ENTRY_REGION_ID_SIZE];
UINT64 RegionOffset;
UINT64 RegionSize;
UINT32 Attribs;
UINT8 Index;
UINT8 NumberOfCodecs;
COMMON_VERB_TABLE_BIN_HEADER *CommonVerbTableBinHeader;
AzaliaVerbTable = NULL;
Status = EFI_NOT_FOUND;
Instance = 1;
VerbTableRaw = NULL;
DwordOffset = 0;
Index = 0;
NumberOfCodecs = 0;
CommonVerbTableBinHeader = NULL;
//
// Enumerate each verbtable RegionType in FDM
//
while (TRUE) {
Status = FdmGetNAt (
&gH2OFlashMapRegionVerbTableGuid,
Instance,
RegionId,
&RegionOffset,
&RegionSize,
&Attribs
);
if (EFI_ERROR (Status)) {
*VerbTableHeaderDataAddress = NULL;
return Status;
}
//
// Search within Boards [ SUPPORT_BOARD_COUNT ]
// Expected SUPPORT_BOARD_COUNT is 6.
// See BTR 3.17.3.6
// typedef struct _H2O_FLASH_MAP_VERB_TABLE_ID {
// UINT8 Reserved[10];
// UINT8 Boards[6];
// } H2O_FLASH_MAP_VERB_TABLE_ID;
//
for (Index = 0; Index < SUPPORT_BOARD_COUNT; Index++) {
if (((H2O_FLASH_MAP_VERB_TABLE_ID *)(RegionId))->Boards[Index] == 0xff) {
break;
}
//
// Compare BoardId with Boards array with platform board-id.
//
if (((H2O_FLASH_MAP_VERB_TABLE_ID *)(RegionId))->Boards[Index] == (UINT8)BoardId) {
//
// VerbTableRaw : a pointer to matched verbtable binary entry.
//
VerbTableRaw = (VOID *)(UINTN)(FdmGetBaseAddr () + RegionOffset);
//
// First byte of verbtable binary indicate total codec numbers.
// Ex. If there are two codecs exist, then two pairs of common table required to store pointers to its header and data,
// plus extra one to store NULL pointer.
//
// NOTE: This pool is allocated to store pointers to meet the requirement of chipset init code.
// (COMMON_CHIPSET_AZALIA_VERB_TABLE is a common table to store pointers point to verbtable header and data)
// If pointer lengh in pei is 32bit long, in most of cases, the pool cost about 32bit * 4 ~ 32bit * 6 (16byte ~ 24byte).
// Memorymanagement in pei phase could be different from other phases, user need to careffully control the usage of memory.
// Any Violation of this function can resualt in unexpected memory issues.
// Caller has responsibility to free this pool when COMMON_CHIPSET_AZALIA_VERB_TABLE is nolonger used
// and the verb setting process in chipset init is finished.
//
NumberOfCodecs = *((UINT8 *)VerbTableRaw);
AzaliaVerbTable = AllocateZeroPool (sizeof (COMMON_CHIPSET_AZALIA_VERB_TABLE) * (NumberOfCodecs + 1));
if (AzaliaVerbTable == NULL) {
*VerbTableHeaderDataAddress = NULL;
Status = EFI_OUT_OF_RESOURCES;
return Status;
}
//
// Binary format :
// ---------------------------------------------
// 1Byte | Number of codecs |
// ---------------------------------------------
// 14Byte | COMMON_CHIPSET_AZALIA_VERB_TABLE_HEADER | --
// --------------------------------------------- |
// 2Byte | Data size in Dword | | codec1
// --------------------------------------------- |
// non-fixed | Verb table data | --
// ---------------------------------------------
// 14Byte | COMMON_CHIPSET_AZALIA_VERB_TABLE_HEADER | --
// --------------------------------------------- |
// 2Byte | Data size in Dword | | codec2
// --------------------------------------------- |
// non-fixed | Verb table data | --
// ---------------------------------------------
// | ... | -- codec n
//
//
// Move pointer to header of first codec.
//
CommonVerbTableBinHeader = (VOID *)(((UINT8 *)VerbTableRaw) + 1);
//
// Install address of each header and data into COMMON_CHIPSET_AZALIA_VERB_TABLE.
//
for (Index = 0; Index < NumberOfCodecs; Index++) {
AzaliaVerbTable[Index].VerbTableHeader = (VOID *)CommonVerbTableBinHeader;
AzaliaVerbTable[Index].VerbTableData = (VOID *)(CommonVerbTableBinHeader + 1);
DwordOffset = CommonVerbTableBinHeader->DataSizeDword;
//
// Move pointer to header of next codec.
//
CommonVerbTableBinHeader = CommonVerbTableBinHeader + 1;
CommonVerbTableBinHeader = (VOID *)(((UINT32 *)CommonVerbTableBinHeader) + DwordOffset);
}
//
// The last pair must be NULL
//
AzaliaVerbTable[NumberOfCodecs].VerbTableHeader = NULL;
AzaliaVerbTable[NumberOfCodecs].VerbTableData = NULL;
*VerbTableHeaderDataAddress = AzaliaVerbTable;
return EFI_SUCCESS;
}
}
Instance++;
}
}
/**
Find matched region by board-id, and contruct a COMMON_CHIPSET_AZALIA_VERB_TABLE.
If match not found, upate VerbTableHeaderDataAddress to NULL
@param[out] VerbTableHeaderDataAddress A pointer to address of verbtable.
@retval EFI_SUCCESS Get verbtable entry successfully.
@retval EFI_NOT_FOUND Target not found.
**/
EFI_STATUS
EFIAPI
GetVerbTable (
OUT COMMON_CHIPSET_AZALIA_VERB_TABLE **VerbTableHeaderDataAddress
)
{
EFI_STATUS Status;
UINT64 BoardId;
Status = EFI_NOT_FOUND;
BoardId = LibPcdGetSku();
//
// Search original FDM entry array, compare each UINT8 boards[] in regionid,
// if not found, use "0" to search default item.
//
Status = GetVerbTableByteBoardId((UINT8)BoardId, VerbTableHeaderDataAddress);
if (EFI_ERROR(Status)) {
Status = GetVerbTableByteBoardId(0, VerbTableHeaderDataAddress);
}
return Status;
}
/**
This function searches fdm 3 extension area if board-id > 0xff,
or it searches fdm original area, if target not found, it searches
default item with board-id "0".
@param[out] VerbTable A pointer to the address of common verbtable entry.
@retval EFI_SUCCESS Get verbtable successfully.
@retval EFI_NOT_FOUND Target not found.
**/
EFI_STATUS
EFIAPI
GetVerbTableEx (
OUT COMMON_CHIPSET_AZALIA_VERB_TABLE **VerbTable
)
{
EFI_STATUS Status;
UINT64 BoardId;
H2O_FLASH_DEVICE_MAP_ENTRY *Entry;
Entry = NULL;
Status = EFI_NOT_FOUND;
BoardId = LibPcdGetSku();
if (BoardId > 0xFF) {
Status = GetVerbTableQwordBoard(BoardId, VerbTable);
if (EFI_ERROR(Status)) {
//
// Use board id "0" search again.
//
Status = GetVerbTableByteBoardId(0, VerbTable);
}
} else {
//
// Search using 8bit board-id.
//
Status = GetVerbTableByteBoardId((UINT8)BoardId, VerbTable);
if (EFI_ERROR(Status)) {
//
// Use board id "0" search again.
//
Status = GetVerbTableByteBoardId(0, VerbTable);
}
}
return Status;
}
Reference in New Issue View Git Blame Copy Permalink