| /** @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; | |
| } | |