tyler.durden
/
audk
mirror of https://github.com/acidanthera/audk.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
audk/EdkModulePkg/Universal/PCD/Pei/Service.c

813 lines
22 KiB
C
Raw Blame History

/** @file
Private functions used by PCD PEIM.
Copyright (c) 2006, Intel Corporation
All rights reserved. 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.
Module Name: Service.c
**/
#include "../Common/PcdCommon.h"
#include "Service.h"
/**
This function expand the StateByte
@param[out] StateByte The output StateByte information.
@param[in] Byte The StateByte.
@retval VOID
--*/
VOID
PcdImageExpandStateByte (
OUT PCD_STATEBYTE *StateByte,
IN UINT8 Byte
)
{
switch (Byte & PCD_STATEBYTE_DATUMTYPE) {
case PCD_BYTE8:
StateByte->DataType = PcdByte8;
break;
case PCD_BYTE16:
StateByte->DataType = PcdByte16;
break;
case PCD_BYTE32:
StateByte->DataType = PcdByte32;
break;
case PCD_BYTE64:
StateByte->DataType = PcdByte64;
break;
case PCD_POINTER:
StateByte->DataType = PcdPointer;
break;
case PCD_BOOLEAN:
StateByte->DataType = PcdBoolean;
break;
default:
ASSERT (FALSE);
}
StateByte->ExtendedGuidPresent = (BOOLEAN) ((Byte & PCD_STATEBYTE_EXTENDEDGUIDPRESENT) != 0);
StateByte->HiiEnable = (BOOLEAN) ((Byte & PCD_STATEBYTE_HIIENABLE) != 0);
StateByte->SkuDataArrayEnable = (BOOLEAN) ((Byte & PCD_STATEBYTE_SKUDATAARRAYENABLE) != 0);
StateByte->SkuEnable = (BOOLEAN) ((Byte & PCD_STATEBYTE_SKUENABLE) != 0);
StateByte->VpdEnable = (BOOLEAN) ((Byte & PCD_STATEBYTE_VPDENABLE) != 0);
}
/**
This function locates the <PCD_IMAGE> on the flash and
return a pointer to the Section Data on flash.
@param[in] VOID
@retval VOID
--*/
UINT8 *
LocatePcdImage (
VOID
)
{
EFI_STATUS Status;
EFI_FIRMWARE_VOLUME_HEADER *FvHdr;
EFI_FFS_FILE_HEADER *FfsHdr;
VOID *SectionData;
Status = PeiCoreFfsFindNextVolume (0, &FvHdr);
ASSERT_EFI_ERROR (Status);
do {
FfsHdr = NULL;
Status = PeiCoreFfsFindNextFile (EFI_FV_FILETYPE_FREEFORM, FvHdr, &FfsHdr);
if (Status == EFI_SUCCESS) {
if (CompareGuid (&gPcdImageFileGuid, &FfsHdr->Name)) {
Status = PeiCoreFfsFindSectionData (EFI_SECTION_RAW, FfsHdr, &SectionData);
ASSERT_EFI_ERROR (Status);
return (UINT8 *)SectionData;
}
}
} while (Status == EFI_SUCCESS);
ASSERT (FALSE);
return NULL;
}
/**
The function retrieves the PCD data value according to
TokenNumber and Guid space given.
@param[in] TokenNumber The token number.
@param[in] Guid The Guid space.
@param[in] Type The storage type.
@param[out] Data The output data.
@retval EFI_SUCESS If data value is found according to SKU_ID.
@retval EFI_NOT_FOUND If not such a value is found.
--*/
VOID
PeiGetPcdEntryWorker (
IN UINTN TokenNumber,
IN CONST EFI_GUID *Guid, OPTIONAL
IN PCD_DATA_TYPE Type,
OUT VOID *Data
)
{
PCD_DATABASE *Database;
EFI_HOB_GUID_TYPE *GuidHob;
ASSERT (Data != NULL);
GuidHob = GetFirstGuidHob (&gPcdDataBaseHobGuid);
ASSERT (GuidHob != NULL);
Database = GET_GUID_HOB_DATA (GuidHob);
GetPcdEntryWorker ( &Database->Info,
TokenNumber,
Guid,
Type,
Data
);
return;
}
/**
The function set the PCD data value according to
TokenNumber and Guid space given.
@param[in] Database The PCD Database Instance.
@param[in] TokenNumber The token number.
@param[in] Guid The Guid space.
@param[in] Type The storage type.
@param[in] Data The output data.
@retval EFI_SUCESS If data value is found according to SKU_ID.
@retval EFI_NOT_FOUND If not such a value is found.
--*/
EFI_STATUS
SetPcdEntryWorker (
IN CONST PCD_DATABASE *Database,
IN UINTN TokenNumber,
IN CONST EFI_GUID *Guid, OPTIONAL
IN PCD_DATA_TYPE Type,
IN VOID *Data
)
{
PCD_INDEX *PcdIndex;
EFI_STATUS Status;
PCD_PPI_CALLBACK *CallbackTable;
UINTN Idx;
ASSERT (Data != NULL);
//
// Find the PCD entry in list in memory first
//
PcdIndex = FindPcdIndex (TokenNumber, Guid, &Database->Info, &Idx);
ASSERT (PcdIndex != NULL);
ASSERT (PcdIndex->StateByte.DataType == Type);
//
// Invoke the callback function.
//
CallbackTable = (PCD_PPI_CALLBACK *)
GetAbsoluteAddress (Idx * Database->Info.MaxCallbackNum * sizeof(PCD_PPI_CALLBACK),
Database->Info.CallbackTableOffset,
&Database->Info
);
for (Idx = 0; Idx < Database->Info.MaxCallbackNum; Idx++) {
if (CallbackTable[Idx] != NULL) {
CallbackTable[Idx] (Guid,
PcdIndex->TokenNumber,
Data,
PcdIndex->DatumSize
);
}
}
Status = SetPcdData (PcdIndex, &Database->Info, Data);
return Status;
}
/**
(reviewed) The function set the PCD data value according to
TokenNumber and Guid space given.
@param[in] TokenNumber The token number.
@param[in] Guid The Guid space.
@param[in] Type The storage type.
@param[in] Data The output data.
@retval EFI_SUCESS If data value is found according to SKU_ID.
@retval EFI_NOT_FOUND If not such a value is found.
--*/
EFI_STATUS
PeiSetPcdEntryWorker (
IN UINTN TokenNumber,
IN CONST EFI_GUID *Guid, OPTIONAL
IN PCD_DATA_TYPE Type,
IN VOID *Data
)
{
PCD_DATABASE *Database;
EFI_HOB_GUID_TYPE *GuidHob;
ASSERT (Data != NULL);
GuidHob = GetFirstGuidHob (&gPcdDataBaseHobGuid);
ASSERT (GuidHob != NULL);
Database = GET_GUID_HOB_DATA (GuidHob);
SetPcdEntryWorker (Database,
TokenNumber,
Guid,
Type,
Data
);
return EFI_SUCCESS;
}
UINTN
PeiGetPcdEntrySizeWorker (
IN UINTN TokenNumber,
IN CONST EFI_GUID *Guid OPTIONAL
)
{
PCD_DATABASE *Database;
EFI_HOB_GUID_TYPE *GuidHob;
GuidHob = GetFirstGuidHob (&gPcdDataBaseHobGuid);
ASSERT (GuidHob != NULL);
Database = GET_GUID_HOB_DATA (GuidHob);
return GetPcdEntrySizeWorker (&Database->Info,
TokenNumber,
Guid
);
}
/**
The function registers the CallBackOnSet fucntion
according to TokenNumber and EFI_GUID space.
@param[in] TokenNumber The token number.
@param[in] Guid The GUID space.
@param[in] CallBackFunction The Callback function to be registered.
@retval EFI_SUCCESS If the Callback function is registered.
@retval EFI_NOT_FOUND If the PCD Entry is not found according to Token Number and GUID space.
--*/
EFI_STATUS
PeiRegisterCallBackWorker (
IN UINTN TokenNumber,
IN CONST EFI_GUID *Guid, OPTIONAL
IN PCD_PPI_CALLBACK CallBackFunction,
IN BOOLEAN Register
)
{
PCD_DATABASE *Database;
EFI_HOB_GUID_TYPE *GuidHob;
PCD_INDEX *PcdIndex;
UINTN Idx;
PCD_PPI_CALLBACK *CallbackTable;
PCD_PPI_CALLBACK Compare;
PCD_PPI_CALLBACK Assign;
GuidHob = GetFirstGuidHob (&gPcdDataBaseHobGuid);
ASSERT (GuidHob != NULL);
Database = GET_GUID_HOB_DATA (GuidHob);
PcdIndex = FindPcdIndex (TokenNumber, Guid, &Database->Info, NULL);
ASSERT (PcdIndex != NULL);
if (PcdIndex->StateByte.VpdEnable) {
return EFI_INVALID_PARAMETER;
}
Idx = ((UINTN) PcdIndex - Database->Info.CallbackTableOffset) / sizeof(PCD_INDEX);
CallbackTable = (PCD_PPI_CALLBACK *) GetAbsoluteAddress (
sizeof (PCD_PPI_CALLBACK) * Idx * Database->Info.MaxCallbackNum,
Database->Info.CallbackTableOffset,
&Database->Info
);
Compare = Register? NULL: CallBackFunction;
Assign = Register? CallBackFunction: NULL;
for (Idx = 0; Idx < Database->Info.MaxCallbackNum; Idx++) {
if (CallbackTable[Idx] == Compare) {
CallbackTable[Idx] = Assign;
return EFI_SUCCESS;
}
}
return Register? EFI_OUT_OF_RESOURCES : EFI_NOT_FOUND;
}
EFI_STATUS
PeiGetNextTokenWorker (
IN OUT UINTN *TokenNumber,
IN CONST EFI_GUID *Guid OPTIONAL
)
{
PCD_DATABASE *Database;
EFI_HOB_GUID_TYPE *GuidHob;
GuidHob = GetFirstGuidHob (&gPcdDataBaseHobGuid);
ASSERT (GuidHob != NULL);
Database = GET_GUID_HOB_DATA (GuidHob);
return GetNextTokenWorker (&Database->Info,
TokenNumber,
Guid
);
}
VOID
GetPcdImageInfo (
IN CONST UINT8 *PcdImageOnFlash,
OUT PCD_IMAGE_RECORD *ImageInfo
)
{
PCD_FFS_ENCODING *PcdFfsHdr;
PcdFfsHdr = (PCD_FFS_ENCODING *) PcdImageOnFlash;
ZeroMem (ImageInfo, sizeof (*ImageInfo));
ImageInfo->ImageStart = PcdImageOnFlash;
CopyMem (&ImageInfo->EntryCount, PcdFfsHdr->EntryCount, 3);
CopyMem (&ImageInfo->GlobalDatumLength, PcdFfsHdr->GlobalDatumLength, 1);
ASSERT (ImageInfo->GlobalDatumLength <= 3);
CopyMem (&ImageInfo->GlobalOffsetLength, PcdFfsHdr->GlobalOffsetLength, 1);
ASSERT (ImageInfo->GlobalOffsetLength <= 3);
CopyMem (&ImageInfo->GlobalTokenLength, PcdFfsHdr->GlobalTokenLength, 1);
ASSERT (ImageInfo->GlobalTokenLength <= 4);
CopyMem (&ImageInfo->GlobalGuidTabIdxLength, PcdFfsHdr->GuidLength, 1);
ASSERT (ImageInfo->GlobalGuidTabIdxLength <= 2);
CopyMem (&ImageInfo->GlobalStrTabIdxLength, PcdFfsHdr->GlobalStrTabIdxLength, 1);
ASSERT (ImageInfo->GlobalStrTabIdxLength <= 2);
CopyMem (&ImageInfo->ImageLength, PcdFfsHdr->ImageLength, 3);
CopyMem (&ImageInfo->IndexLength, PcdFfsHdr->PcdIndexLength, 3);
CopyMem (&ImageInfo->WholeDataDefaultLength, PcdFfsHdr->WholeDataBufferLength, 3);
CopyMem (&ImageInfo->DataDefaultLength, PcdFfsHdr->DataBufferLength, 3);
CopyMem (&ImageInfo->GuidTableLength, PcdFfsHdr->GuidTableLength, 3);
ImageInfo->StringTableLength = ImageInfo->ImageLength
- sizeof (PCD_FFS_ENCODING)
- ImageInfo->DataDefaultLength
- ImageInfo->IndexLength
- ImageInfo->GuidTableLength;
ImageInfo->DataDefaultStart = PcdImageOnFlash + sizeof (PCD_FFS_ENCODING);
ImageInfo->IndexStart = ImageInfo->DataDefaultStart + ImageInfo->DataDefaultLength;
ImageInfo->GuidTableStart = (CONST EFI_GUID *)(ImageInfo->IndexStart + ImageInfo->IndexLength);
ImageInfo->StringTableStart = (CONST UINT16 *) ((UINT8 *) ImageInfo->GuidTableStart + ImageInfo->GuidTableLength);
return;
}
/**
The function builds the PCD database based on the
PCD_IMAGE on the flash.
The layout of the PCD_DATABASE is as follows:
---------------------------
| PCD_DATABASE_HEADER |
---------------------------
| GUID_TABLE | Aligned on GUID (128 bits)
---------------------------
| PCD_CALL_BACK_TABLE | Aligned on Pointer (32 bits or 64 bits)
---------------------------
| PCD_INDEX_TABLE | Aligned on PCD_INDEX (see PCD_INDEX's declaration)
---------------------------
| IMAGE_STRING_TABLE | Aligned on 16 Bits
---------------------------
| IMAGE_PCD_INDEX | Unaligned
---------------------------
| Data Defaults | Unaligned
---------------------------
| Data Buffer |
| for entries without |
| defaults |
---------------------------
@param[in] PcdImageOnFlash The PCD image on flash.
@retval VOID
--*/
UINTN
GetPcdDatabaseLen (
IN CONST UINT8 *PcdImageOnFlash,
OUT PCD_DATABASE_HEADER *Info,
OUT PCD_IMAGE_RECORD *ImageInfo
)
{
UINTN DatabaseLen;
UINTN DatabaseHeaderLength;
UINTN PcdIndexLength;
UINTN CallbackBufferLength;
GetPcdImageInfo (PcdImageOnFlash, ImageInfo);
Info->MaxCallbackNum = FixedPcdGet32(PcdMaxPcdCallBackNumber) ;
DatabaseHeaderLength = sizeof (PCD_DATABASE) - sizeof(UINT8);
PcdIndexLength = sizeof (PCD_INDEX) * ImageInfo->EntryCount;
CallbackBufferLength = sizeof (PCD_PPI_CALLBACK) * Info->MaxCallbackNum * ImageInfo->EntryCount;
Info->EntryCount = ImageInfo->EntryCount;
Info->GuidTableOffset = DatabaseHeaderLength;
Info->CallbackTableOffset = Info->GuidTableOffset + ImageInfo->GuidTableLength;
Info->PcdIndexOffset = Info->PcdIndexOffset + PcdIndexLength;
Info->ImageIndexOffset = Info->CallbackTableOffset + CallbackBufferLength;
Info->DataBufferOffset = Info->ImageIndexOffset + ImageInfo->DataDefaultLength;
Info->HiiGuidOffsetLength = ImageInfo->GlobalGuidTabIdxLength;
Info->HiiVariableOffsetLength = ImageInfo->GlobalStrTabIdxLength;
Info->ExtendedOffsetLength = ImageInfo->GlobalOffsetLength;
Info->SkuId = 0;
DatabaseLen = DatabaseHeaderLength
+ ImageInfo->GuidTableLength
+ PcdIndexLength
+ CallbackBufferLength
+ ImageInfo->IndexLength
+ ImageInfo->WholeDataDefaultLength;
Info->DatabaseLen = DatabaseLen;
return DatabaseLen;
}
/**
The function constructs a single PCD_INDEX according a index in
<PCD_IMAGE>.
@param[in] ImageIndex The starting address of a PCD index defined in PCD spec 0.51.
@param[in] Index The output PCD_INDEX.
@param[in] ImageInfo The attributes of the PCD_IMAGE as this binary stream is highly
optimized for size.
@retval UINTN The length of the current PCD index.
**/
UINTN
BuildPcdIndex (
IN CONST UINT8 *ImageIndex,
OUT PCD_INDEX *Index,
IN CONST PCD_IMAGE_RECORD *ImageInfo
)
{
UINTN SkuCount;
CONST UINT8 *ImageIndexBackUp;
ImageIndexBackUp = ImageIndex;
//
// Token Number
//
CopyMem (&Index->TokenNumber,
ImageIndex,
ImageInfo->GlobalTokenLength
);
ImageIndex += ImageInfo->GlobalTokenLength;
//
// State Byte
//
PcdImageExpandStateByte (&Index->StateByte,
*ImageIndex
);
ImageIndex += 1;
//
// Dataum Size
//
CopyMem (&Index->DatumSize,
ImageIndex,
ImageInfo->GlobalDatumLength
);
ImageIndex += ImageInfo->GlobalDatumLength;
//
// SKU_DATA
//
if (Index->StateByte.SkuEnable) {
Index->SkuCount = *ImageIndex;
SkuCount = *ImageIndex;
ImageIndex++;
Index->SkuIdArray = (UINT32) ImageIndex - (UINT32) ImageInfo->IndexStart;
ImageIndex += Index->SkuCount;
} else {
//
// There is always a default SKU_ID of zero even
// if SKU is not enabled for this PCD entry.
//
//
SkuCount = 1;
}
//
// Extended Offset
//
CopyMem (&Index->ExtendedDataOffset,
ImageIndex,
ImageInfo->GlobalOffsetLength
);
ImageIndex += ImageInfo->GlobalOffsetLength * SkuCount;
//
// DynamicEX Guid Offset
//
if (Index->StateByte.ExtendedGuidPresent) {
CopyMem (&Index->DynamicExGuid,
ImageIndex,
ImageInfo->GlobalGuidTabIdxLength
);
ImageIndex += ImageInfo->GlobalGuidTabIdxLength;
}
//
// HII_DATA
//
if (Index->StateByte.HiiEnable) {
Index->HiiData = (UINT32) ImageIndex - (UINT32) ImageInfo->IndexStart;
ImageIndex += ((ImageInfo->GlobalStrTabIdxLength + ImageInfo->GlobalGuidTabIdxLength) * SkuCount);
}
return (UINTN) (ImageIndex - ImageIndexBackUp);
}
/**
The function builds the PCD database based on the
PCD_IMAGE on the flash.
@param[in] Database The database instance.
@param[in] ImageIndex The starting address of a PCD index defined in PCD spec 0.51.
@param[in] ImageInfo The attributes of the PCD_IMAGE as this binary stream is highly
optimized for size.
@retval VOID
**/
VOID
BuildPcdDatabaseIndex (
PCD_DATABASE *Database,
UINT8 *ImageIndex,
PCD_IMAGE_RECORD *ImageInfo
)
{
UINTN Idx;
UINTN Len;
PCD_INDEX *IndexTable;
IndexTable = (PCD_INDEX *) GetAbsoluteAddress (0, Database->Info.PcdIndexOffset, Database);
for (Idx = 0; Idx < Database->Info.EntryCount; Idx++) {
Len = BuildPcdIndex (ImageIndex, &IndexTable[Idx], ImageInfo);
ImageIndex += Len;
}
return;
}
/**
The function builds the PCD database based on the
PCD_IMAGE on the flash.
@param[in] PcdImageOnFlash The PCD image on flash.
@retval VOID
--*/
VOID
BuildPcdDatabase (
UINT8 *PcdImageOnFlash
)
{
PCD_DATABASE *Database;
UINTN Len;
PCD_IMAGE_RECORD ImageInfo;
UINT8 *ImageIndex;
PCD_DATABASE_HEADER DatabaseHeader;
Len = GetPcdDatabaseLen(PcdImageOnFlash, &DatabaseHeader, &ImageInfo);
Database = BuildGuidHob (&gPcdDataBaseHobGuid, Len);
ASSERT (Database != NULL);
ZeroMem (Database, Len);
//
// Update Database header
//
CopyMem (&Database->Info, &DatabaseHeader, sizeof (DatabaseHeader));
//
// I need this to get the GuidTableOffset as we don't
// know if Database field of PCD_DATABASE starts from an aligned
// address. The compilor may add padding after PCD_DATABASE_HEADER field.
//
Database->Info.GuidTableOffset = ((UINTN) &Database->GuidTable) - (UINTN)Database;
//
// Copy Guid Table from Flash
//
CopyMem ((UINT8 *) Database + Database->Info.GuidTableOffset,
ImageInfo.GuidTableStart,
ImageInfo.GuidTableLength
);
//
// Copy ImageIndex from Flash
//
CopyMem ((UINT8 *) Database + Database->Info.ImageIndexOffset,
ImageInfo.IndexStart,
ImageInfo.IndexLength
);
//
// Copy Default Value
//
CopyMem ((UINT8 *) Database + Database->Info.DataBufferOffset,
ImageInfo.DataDefaultStart,
ImageInfo.DataDefaultLength
);
//
// Copy String Table
//
CopyMem ((UINT8 *) Database + Database->Info.StringTableOffset,
ImageInfo.StringTableStart,
ImageInfo.StringTableLength
);
ImageIndex = GetAbsoluteAddress (0, Database->Info.ImageIndexOffset, Database);
BuildPcdDatabaseIndex (Database, ImageIndex, &ImageInfo);
return;
}
/**
The function is provided by PCD PEIM and PCD DXE driver to
do the work of reading a HII variable from variable service.
@param[in] VariableGuid The Variable GUID.
@param[in] VariableName The Variable Name.
@param[out] VariableData The output data.
@param[out] VariableSize The size of the variable.
@retval EFI_SUCCESS Operation successful.
@retval EFI_SUCCESS Variablel not found.
--*/
EFI_STATUS
GetHiiVariable (
IN EFI_GUID *VariableGuid,
IN UINT16 *VariableName,
OUT VOID **VariableData,
OUT UINTN *VariableSize
)
{
UINTN Size;
EFI_STATUS Status;
VOID *Buffer;
EFI_PEI_READ_ONLY_VARIABLE_PPI *VariablePpi;
Status = PeiCoreLocatePpi (&gEfiPeiReadOnlyVariablePpiGuid, 0, NULL, &VariablePpi);
ASSERT_EFI_ERROR (Status);
Size = 0;
Status = VariablePpi->PeiGetVariable (
GetPeiServicesTablePointer (),
VariableName,
VariableGuid,
NULL,
&Size,
NULL
);
ASSERT (Status == EFI_BUFFER_TOO_SMALL);
Status = PeiCoreAllocatePool (Size, &Buffer);
ASSERT_EFI_ERROR (Status);
// declare a local for STP.
//
Status = VariablePpi->PeiGetVariable (
GetPeiServicesTablePointer (),
(UINT16 *) VariableName,
VariableGuid,
NULL,
&Size,
Buffer
);
ASSERT_EFI_ERROR (Status);
*VariableSize = Size;
*VariableData = Buffer;
return EFI_SUCCESS;
}
/**
The function is provided by PCD PEIM and PCD DXE driver to
do the work of reading a HII variable from variable service.
@param[in] VariableGuid The Variable GUID.
@param[in] VariableName The Variable Name.
@param[in] Data The input data.
@param[out] VariableSize The size of the variable.
@param[in] Offset The offset of the variable data that a PCD entry will starts from.
@retval EFI_SUCCESS Operation successful.
@retval EFI_SUCCESS Variablel not found.
--*/
EFI_STATUS
SetHiiVariable (
IN EFI_GUID *VariableGuid,
IN UINT16 *VariableName,
IN CONST VOID *Data,
IN UINTN VariableSize,
IN UINTN Offset
)
{
ASSERT (FALSE);
return EFI_INVALID_PARAMETER;
}
Reference in New Issue View Git Blame Copy Permalink