Initial import.

git-svn-id: https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2@3 6f19259b-4bc3-4df7-8a09-765794883524
This commit is contained in:
bbahnsen
2006-04-21 22:54:32 +00:00
commit 878ddf1fc3
2651 changed files with 624620 additions and 0 deletions

View File

@@ -0,0 +1,592 @@
/** @file
Common functions used by PCD PEIM and PCD DXE.
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: PcdCommon.c
**/
#include "PcdCommon.h"
/**
The function retrieves the PCD data value according to
the PCD_DATA_TYPE specified.
@param[in] Type The PCD_DATA_TYPE used to interpret the data.
@param[in] InData The input data.
@param[in] OutData The output data.
@param[in] Len The length of the data; it is mainly used for PcdPointer type.
@retval VOID
--*/
VOID
GetDataBasedOnType (
IN PCD_DATA_TYPE Type,
IN VOID *InData,
OUT VOID *OutData,
IN UINTN Len
)
{
if (Type == PcdPointer) {
//
// When the Type is PcdPointer, we are returning
// the address of the internal buffer kpet by
// PCD database. Therefore, we treat OutData as
// a pointer to a "VOID *". Thus, the ugly type cast
// (VOID **) is used.
//
*((VOID **) OutData) = InData;
} else {
CopyMem (OutData, InData, Len);
}
return;
}
UINTN
GetExtendedDataOffset (
IN CONST PCD_INDEX *PcdIndex,
IN UINTN SkuIdx,
IN CONST PCD_DATABASE_HEADER *Info
)
{
UINT8 *OffsetAddress;
UINTN Offset;
OffsetAddress = GetAbsoluteAddress (PcdIndex->ExtendedDataOffset,
Info->ImageIndexOffset,
Info
);
OffsetAddress += (SkuIdx * Info->ExtendedOffsetLength);
CopyMem (&Offset, OffsetAddress, Info->ExtendedOffsetLength);
return Offset;
}
VOID
GetHiiDataProperty (
IN CONST PCD_INDEX *PcdIndex,
IN UINTN SkuIdx,
IN CONST PCD_DATABASE_HEADER *Info,
OUT EFI_GUID **VariableGuid,
OUT UINT16 **VariableName
)
{
UINT16 NameOffset;
UINT16 GuidOffset;
UINT8 *HiiDataOffset;
HiiDataOffset = GetAbsoluteAddress (PcdIndex->HiiData, Info->ImageIndexOffset, Info);
HiiDataOffset += (SkuIdx * (Info->HiiGuidOffsetLength + Info->HiiVariableOffsetLength));
CopyMem (&GuidOffset, HiiDataOffset, Info->HiiGuidOffsetLength);
CopyMem (&NameOffset, HiiDataOffset + Info->HiiGuidOffsetLength, Info->HiiVariableOffsetLength);
*VariableGuid = (EFI_GUID *) GetAbsoluteAddress (GuidOffset * sizeof (EFI_GUID), Info->GuidTableOffset, Info);
*VariableName = (UINT16 *) GetAbsoluteAddress (NameOffset * sizeof (UINT16) , Info->StringTableOffset, Info);
return;
}
UINTN
GetSkuIdIdx (
IN CONST PCD_INDEX *PcdIndex,
IN CONST PCD_DATABASE_HEADER *Info
)
{
UINT8 *SkuIdArray;
UINTN SkuIdx;
SkuIdArray = GetAbsoluteAddress (PcdIndex->SkuIdArray, Info->ImageIndexOffset, Info);
SkuIdx = 0;
if (PcdIndex->StateByte.SkuEnable) {
for (; SkuIdx < PcdIndex->SkuCount; SkuIdx++) {
if (SkuIdArray[SkuIdx] == Info->SkuId) {
break;
}
}
if (SkuIdx > PcdIndex->SkuCount) {
if (Info->SkuId == 0) {
//
// If no SKU_ID is set previously
// Just retrieve the first value
//
SkuIdx = 0;
} else {
//
// Just can't find the SKU_ID, ASSERT according to Spec.
//
ASSERT (FALSE);
}
}
}
return SkuIdx;
}
/**
The function is the worker function to get the data of a PCD entry.
@param[in] PcdIndex The PCD Index.
@param[in] Info The attributes of the PCD database.
@param[out] Data The output data.
@retval VOID
--*/
UINT8*
GetPcdDataPtr (
IN CONST PCD_INDEX *PcdIndex,
IN CONST PCD_DATABASE_HEADER *Info
)
{
UINTN VariableDataSize;
VOID *VariableData;
UINT16 *VariableName;
UINT8 *PcdData;
EFI_GUID *VariableGuid;
EFI_STATUS Status;
UINTN SkuIdx;
UINTN ExtendedOffset;
//
// If Sku is not enalbed for this PCD Entry.
// SkuIdx 0 will be used to compute PcdData
//
SkuIdx = GetSkuIdIdx (PcdIndex, Info);
if (PcdIndex->StateByte.HiiEnable) {
GetHiiDataProperty (PcdIndex, SkuIdx, Info, &VariableGuid, &VariableName);
Status = GetHiiVariable (VariableGuid, VariableName, &VariableData, &VariableDataSize);
ASSERT_EFI_ERROR (Status);
ASSERT (VariableDataSize >= (PcdIndex->DatumSize + PcdIndex->ExtendedDataOffset));
PcdData = (UINT8 *) VariableData + PcdIndex->ExtendedDataOffset;
return PcdData;
}
//
// For VPD and Data type, we need the ExtendedOffset.
// So get it here.
//
ExtendedOffset = GetExtendedDataOffset (PcdIndex, SkuIdx, Info);
if (PcdIndex->StateByte.VpdEnable) {
PcdData = (VOID *) (Info->VpdStart + ExtendedOffset);
return PcdData;
}
//
// For data type, we just need the pointer
//
PcdData = GetAbsoluteAddress (
ExtendedOffset,
Info->DataBufferOffset,
Info
);
return PcdData;
}
/**
The function locates the PCD_INDEX according to TokeNumber and GUID space given.
@param[in] TokenNumber The token number.
@param[in] Guid The GUID token space.
@param[out] Info The attributes of the PCD database.
@retval PCD_INDEX* The PCD_INDEX found.
--*/
PCD_INDEX *
FindPcdIndex (
IN UINTN TokenNumber,
IN CONST EFI_GUID *Guid,
IN CONST PCD_DATABASE_HEADER *Info,
OUT UINTN *Index
)
{
PCD_INDEX *PcdIndex;
UINTN Idx;
EFI_GUID *GuidSpace;
PcdIndex = (PCD_INDEX *) GetAbsoluteAddress (0, Info->PcdIndexOffset, Info);
for (Idx = 0; Idx < Info->EntryCount; Idx++, PcdIndex++) {
if (Index != NULL) {
*Index = Idx;
}
if (PcdIndex->TokenNumber == TokenNumber) {
if (Guid == NULL) {
if (!PcdIndex->StateByte.ExtendedGuidPresent) {
return PcdIndex;
}
} else {
if (PcdIndex->StateByte.ExtendedGuidPresent) {
GuidSpace = (EFI_GUID *) GetAbsoluteAddress (PcdIndex->DynamicExGuid, Info->GuidTableOffset, Info);
if (CompareGuid (GuidSpace, Guid)) {
return PcdIndex;
}
}
}
}
}
if (Index != NULL) {
*Index = 0;
}
return NULL;
}
/**
The function set the PCD Entry data value according to the
PCD_DATA_TYPE given.
@param[out] OutData The output data.
@param[in] InData The input data.
@param[in] Len The length of the 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
SetDataBasedOnType (
OUT VOID * OutData,
IN CONST VOID * InData,
IN UINTN Len
)
{
CopyMem (OutData, InData, Len);
return;
}
/**
The function returns the actual address of item in the PCD
database according to its Segment and Offset.
@param[out] Offset The offset within the segment.
@param[in] SegmentStart The starting address of the segment.
@param[in] DatabaseStart The base address of the PCD DataBase.
@retval UINT8* The absolute address.
--*/
UINT8 *
GetAbsoluteAddress (
IN UINTN Offset,
IN UINTN SegmentStart,
IN CONST PCD_DATABASE_HEADER *DatabaseStart
)
{
UINT8 *Address;
Address = (UINT8 *) DatabaseStart + SegmentStart + Offset;
return Address;
}
/**
The function retrieves 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[out] Data The output data.
@retval VOID
--*/
VOID
GetPcdEntryWorker (
IN CONST PCD_DATABASE_HEADER *Info,
IN UINTN TokenNumber,
IN CONST EFI_GUID *Guid, OPTIONAL
IN PCD_DATA_TYPE Type,
OUT VOID *Data
)
{
PCD_INDEX *PcdIndex;
UINT8 *PcdData;
ASSERT (Data != NULL);
//
// Find the PCD entry in list in memory first
//
PcdIndex = FindPcdIndex (TokenNumber, Guid, Info, NULL);
ASSERT (PcdIndex != NULL);
ASSERT (PcdIndex->StateByte.DataType == Type);
PcdData = GetPcdDataPtr (PcdIndex, Info);
GetDataBasedOnType (PcdIndex->StateByte.DataType, PcdData, Data, PcdIndex->DatumSize);
return;
}
/**
The function retrieves 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.
@retval UINTN The size of the PCD Entry.
--*/
UINTN
GetPcdEntrySizeWorker (
IN CONST PCD_DATABASE_HEADER *Info,
IN UINTN TokenNumber,
IN CONST EFI_GUID *Guid OPTIONAL
)
{
PCD_INDEX *PcdIndex;
//
// Find the PCD entry in list in memory first
//
PcdIndex = FindPcdIndex (TokenNumber, Guid, Info, NULL);
ASSERT (PcdIndex != NULL);
return PcdIndex->DatumSize;
}
/**
The function checks if given GUID space match the record
in the PCD_INDEX.
@param[in] Guid The GUID space.
@param[in] PcdIndex The PCD_INDEX.
@param[in] Info The attribute of the PCD DATABASE.
@retval TRUE The GUID space match the record.
@retval FALSE Othewise.
--*/
BOOLEAN
PeiImageIndexMatchGuidSpace (
IN CONST EFI_GUID *Guid,
IN CONST PCD_INDEX *PcdIndex,
IN CONST PCD_DATABASE_HEADER *Info
)
{
EFI_GUID *GuidSpace;
if (PcdIndex->StateByte.ExtendedGuidPresent) {
GuidSpace = (EFI_GUID *) GetAbsoluteAddress (PcdIndex->DynamicExGuid, Info->GuidTableOffset, Info);
return CompareGuid (GuidSpace, Guid);
}
return FALSE;
}
/**
The function looks for the next PCD ENTRY.
If *TokenNumber is 0, the first TokenNumber in
the GUID token space is return.
If there is no next TokenNumber found,
*TokenNumber will be 0.
@param[in] Database The PCD Database Instance.
@param[in,out] TokenNumber The token number.
@param[in] Guid The Guid space.
@retval EFI_NOT_FOUND Can't find the PCD_ENTRY.
@retval EFI_SUCCESS Operation succesful.
--*/
EFI_STATUS
GetNextTokenWorker (
IN CONST PCD_DATABASE_HEADER *Info,
IN OUT UINTN *TokenNumber,
IN CONST EFI_GUID *Guid OPTIONAL
)
{
PCD_INDEX *PcdIndex;
UINTN Idx;
BOOLEAN Found;
Idx = 0;
Found = FALSE;
PcdIndex = (PCD_INDEX *) GetAbsoluteAddress (0, Info->PcdIndexOffset, Info);
while ((Idx < Info->EntryCount) && !Found) {
if (*TokenNumber == 0) {
if (Guid == NULL || PeiImageIndexMatchGuidSpace (Guid, PcdIndex, Info)) {
*TokenNumber = PcdIndex->TokenNumber;
return EFI_SUCCESS;
}
} else {
if (PcdIndex->TokenNumber == *TokenNumber) {
if (Guid == NULL || PeiImageIndexMatchGuidSpace (Guid, PcdIndex, Info)) {
Found = TRUE;
}
}
}
PcdIndex++;
Idx++;
}
//
// No PCD Entry in the database match the GUID space given.
//
if (*TokenNumber == 0) {
return EFI_SUCCESS;
}
//
// Can't find the PCD Entry
//
if (!Found) {
return EFI_NOT_FOUND;
}
//
// Move to the Next Entry
//
Idx++;
PcdIndex++;
//
// Now look for the Next TokenNumber
//
while (Idx < Info->EntryCount) {
if (Guid == NULL || PeiImageIndexMatchGuidSpace (Guid, PcdIndex, Info)) {
*TokenNumber = PcdIndex->TokenNumber;
return EFI_SUCCESS;
}
PcdIndex++;
Idx++;
}
//
// Reache the last TokeNumber.
//
*TokenNumber = 0;
return EFI_SUCCESS;
}
/**
The function is the worker function to set the data of a PCD entry.
@param[in] PcdIndex The PCD Index.
@param[in] Info The attributes of the PCD database.
@param[in] Data The input data.
@retval VOID
--*/
EFI_STATUS
SetPcdData (
IN CONST PCD_INDEX *PcdIndex,
IN CONST PCD_DATABASE_HEADER *Info,
IN CONST VOID *Data
)
{
UINT16 *VariableName;
UINT8 *PcdData;
EFI_GUID *VariableGuid;
EFI_STATUS Status;
UINTN SkuIdx;
UINTN ExtendedOffset;
if (PcdIndex->StateByte.VpdEnable) {
ASSERT (FALSE);
return EFI_INVALID_PARAMETER;
}
SkuIdx = GetSkuIdIdx (PcdIndex, Info);
//
// For Hii and Data type, we need the ExtendedOffset.
// So get it here.
//
ExtendedOffset = GetExtendedDataOffset (PcdIndex, SkuIdx, Info);
if (PcdIndex->StateByte.HiiEnable) {
GetHiiDataProperty (PcdIndex, SkuIdx, Info, &VariableGuid, &VariableName);
Status = SetHiiVariable (VariableGuid,
VariableName,
Data,
PcdIndex->DatumSize,
ExtendedOffset
);
return Status;
}
PcdData = GetAbsoluteAddress (
ExtendedOffset,
Info->DataBufferOffset,
Info
);
CopyMem (PcdData, Data, PcdIndex->DatumSize);
return EFI_SUCCESS;
}

View File

@@ -0,0 +1,386 @@
/** @file
Common functions used by PCD PEIM and PCD DXE.
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: PcdCommon.h
**/
#ifndef __PCD_COMMON_H__
#define __PCD_COMMON_H__
//
// Enumeration for PCD_DATA_TYPE
//
typedef enum {
PcdByte8,
PcdByte16,
PcdByte32,
PcdByte64,
PcdPointer,
PcdBoolean
} PCD_DATA_TYPE;
//
// The definitions for Global PCD Length Fields
//
#define PCD_LENGTH_BIT8 0x01
#define PCD_LENGTH_BIT16 0x02
#define PCD_LENGTH_BIT24 0x03
#define PCD_LENGTH_BIT32 0x04
/*
* This data structure is used in <PCD_IMAGE> transverse
*/
typedef struct {
UINTN EntryCount;
UINTN GlobalOffsetLength;
UINTN GlobalTokenLength;
UINTN GlobalGuidTabIdxLength;
UINTN GlobalDatumLength;
UINTN GlobalStrTabIdxLength;
CONST UINT8 *DataDefaultStart;
UINTN DataDefaultLength;
UINTN WholeDataDefaultLength;
CONST UINT8 *IndexStart;
UINTN IndexLength;
CONST GUID *GuidTableStart;
UINTN GuidTableLength;
CONST UINT16 *StringTableStart;
UINTN StringTableLength;
/* Length of the <PCD_IMAGE> in byte.
This info is from Section header
in FFS */
UINTN ImageLength;
CONST UINT8 *ImageStart;
} PCD_IMAGE_RECORD;
typedef struct {
BOOLEAN HiiEnable;
BOOLEAN SkuEnable;
BOOLEAN VpdEnable;
BOOLEAN SkuDataArrayEnable;
PCD_DATA_TYPE DataType;
BOOLEAN ExtendedGuidPresent;
} PCD_STATEBYTE;
typedef struct {
//
// All Pointer's Offset in byte
//
UINT32 TokenNumber;
PCD_STATEBYTE StateByte;
UINT32 HiiData;
UINT32 SkuIdArray; //Pointer
UINT32 ExtendedDataOffset;
UINT32 DatumSize;
UINT16 DynamicExGuid; //Pointer
UINT8 SkuCount;
} PCD_INDEX;
/*
* PCD Image Definition according PCD Specification 0.51.
*
*/
#pragma pack(1)
typedef struct {
UINT8 ImageLength[3];
//
// The length of PCD_FFS_ENCODING is included
// in ImageLength
//
UINT8 DataBufferLength[3];
UINT8 WholeDataBufferLength[3];
UINT8 PcdIndexLength[3];
UINT8 GuidTableLength[3];
//
// The StringTable can be computed using:
// ImageLength, DataBufferLength, PcdIndexLength, GuidTableLength,
// and length of PCD_FFS_ENCODING
//
UINT8 EntryCount[3];
UINT8 GlobalOffsetLength[1];
UINT8 GlobalTokenLength[1];
UINT8 GuidLength[1];
UINT8 GlobalDatumLength[1];
UINT8 GlobalStrTabIdxLength[1];
} PCD_FFS_ENCODING;
#pragma pack()
typedef struct {
UINTN DatabaseLen;
UINTN EntryCount;
UINTN InfoLength;
UINTN GuidTableOffset;
UINTN PcdIndexOffset;
UINTN StringTableOffset;
UINTN CallbackTableOffset;
UINTN ImageIndexOffset;
UINTN DataBufferOffset;
UINTN MaxCallbackNum;
UINTN HiiVariableOffsetLength;
UINTN HiiGuidOffsetLength;
UINTN ExtendedOffsetLength;
UINT8 *VpdStart;
UINTN SkuId;
} PCD_DATABASE_HEADER;
typedef struct {
PCD_DATABASE_HEADER Info;
EFI_GUID GuidTable[1];
} PCD_DATABASE;
extern EFI_GUID gPcdDataBaseHobGuid;
/**
The function returns the actual address of item in the PCD
database according to its Segment and Offset.
@param[out] Offset The offset within the segment.
@param[in] SegmentStart The starting address of the segment.
@param[in] DatabaseStart The base address of the PCD DataBase.
@retval EFI_SUCESS If data value is found according to SKU_ID.
@retval EFI_NOT_FOUND If not such a value is found.
--*/
UINT8 *
GetAbsoluteAddress (
IN UINTN Offset,
IN UINTN SegmentStart,
IN CONST VOID *Base
)
;
/**
The function return the number of Unicode Character in a NULL terminated string.
The NULL is NOT counted.
@param[in] String The unicode string starts from an unaligned address.
@retval UINTN The number of Unicode characters.
--*/
UINTN
GetUnalignedStrLen (
UINT16 *String
);
/**
The function retrieves the PCD data value according to
TokenNumber and Guid space given.
@param[in] Info The PCD Database Info.
@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 VOID
--*/
VOID
GetPcdEntryWorker (
IN CONST PCD_DATABASE_HEADER *Info,
IN UINTN TokenNumber,
IN CONST GUID *Guid, OPTIONAL
IN PCD_DATA_TYPE Type,
OUT VOID *Data
)
;
/**
The function retrieves the PCD data value according to
TokenNumber and Guid space given.
@param[in] Info The PCD Database info.
@param[in] TokenNumber The token number.
@param[in] Guid The Guid space.
@retval UINTN The size of the PCD Entry.
--*/
UINTN
GetPcdEntrySizeWorker (
IN CONST PCD_DATABASE_HEADER *Info,
IN UINTN TokenNumber,
IN CONST GUID *Guid OPTIONAL
)
;
/**
The function looks for the next PCD ENTRY.
If *TokenNumber is 0, the first TokenNumber in
the GUID token space is return.
If there is no next TokenNumber found,
*TokenNumber will be 0.
@param[in] Info The PCD Database info.
@param[in,out] TokenNumber The token number.
@param[in] Guid The Guid space.
@retval EFI_NOT_FOUND Can't find the PCD_ENTRY.
@retval EFI_SUCCESS Operation succesful.
--*/
EFI_STATUS
GetNextTokenWorker (
IN CONST PCD_DATABASE_HEADER *Info,
IN OUT UINTN *TokenNumber,
IN CONST GUID *Guid OPTIONAL
)
;
/**
The function is the worker function to set the data of a PCD entry.
@param[in] PcdIndex The PCD Index.
@param[in] Info The attributes of the PCD database.
@param[in] Data The input data.
@retval VOID
--*/
EFI_STATUS
SetPcdData (
IN CONST PCD_INDEX *PcdIndex,
IN CONST PCD_DATABASE_HEADER *Info,
IN CONST VOID *Data
)
;
/**
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
)
;
/**
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
)
;
/**
The function locates the PCD_INDEX according to TokeNumber and GUID space given.
@param[in] TokenNumber The token number.
@param[in] Guid The GUID token space.
@param[out] Info The attributes of the PCD database.
@retval PCD_INDEX* The PCD_INDEX found.
--*/
PCD_INDEX *
FindPcdIndex (
IN UINTN TokenNumber,
IN CONST GUID *Guid,
IN CONST PCD_DATABASE_HEADER *Info,
OUT UINTN *Index
)
;
/**
(WQBUGBUG: You must handle the new SKU_ID encoding.
The function is the worker function to get the data of a PCD entry.
@param[in] PcdIndex The PCD Index.
@param[in] Info The attributes of the PCD database.
@param[out] Data The output data.
@retval VOID
--*/
UINT8*
GetPcdDataPtr (
IN CONST PCD_INDEX *PcdIndex,
IN CONST PCD_DATABASE_HEADER *Info
)
;
/**
The function retrieves the PCD data value according to
the PCD_DATA_TYPE specified.
@param[in] Type The PCD_DATA_TYPE used to interpret the data.
@param[in] InData The input data.
@param[in] OutData The output data.
@param[in] Len The length of the data; it is mainly used for PcdPointer type.
@retval VOID
--*/
VOID
GetDataBasedOnType (
IN PCD_DATA_TYPE Type,
IN VOID *InData,
OUT VOID *OutData,
IN UINTN Len
)
;
#endif

View File

@@ -0,0 +1,472 @@
/** @file
PCD DXE driver
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: Pcd.c
**/
#include "../Common/PcdCommon.h"
#include "Service.h"
PCD_PROTOCOL mPcdInstance = {
DxePcdSetSku,
DxePcdGet8,
DxePcdGet16,
DxePcdGet32,
DxePcdGet64,
DxePcdGetPtr,
DxePcdGetBool,
DxePcdGetSize,
DxePcdGet8Ex,
DxePcdGet16Ex,
DxePcdGet32Ex,
DxePcdGet64Ex,
DxePcdGetPtrEx,
DxePcdGetBoolEx,
DxePcdGetSizeEx,
DxePcdSet8,
DxePcdSet16,
DxePcdSet32,
DxePcdSet64,
DxePcdSetPtr,
DxePcdSetBool,
DxePcdSet8Ex,
DxePcdSet16Ex,
DxePcdSet32Ex,
DxePcdSet64Ex,
DxePcdSetPtrEx,
DxePcdSetBoolEx,
PcdRegisterCallBackOnSet,
PcdUnRegisterCallBackOnSet,
DxePcdGetNextToken
};
//
// Static global to reduce the code size
//
static EFI_HANDLE NewHandle = NULL;
EFI_STATUS
EFIAPI
PcdDxeInit (
IN EFI_HANDLE ImageHandle,
IN EFI_SYSTEM_TABLE *SystemTable
)
{
EFI_STATUS Status;
InitPcdDxeDataBase ();
Status = gBS->InstallProtocolInterface (
&NewHandle,
&gPcdProtocolGuid,
EFI_NATIVE_INTERFACE,
&mPcdInstance
);
ASSERT_EFI_ERROR (Status);
return EFI_SUCCESS;
}
EFI_STATUS
EFIAPI
DxePcdSetSku (
IN UINTN SkuId
)
{
return DxeSetSku(SkuId);
}
UINT8
EFIAPI
DxePcdGet8 (
IN UINTN TokenNumber
)
{
return DxePcdGet8Ex (NULL, TokenNumber);
}
UINT16
EFIAPI
DxePcdGet16 (
IN UINTN TokenNumber
)
{
return DxePcdGet16Ex (NULL, TokenNumber);
}
UINT32
EFIAPI
DxePcdGet32 (
IN UINTN TokenNumber
)
{
return DxePcdGet32Ex (NULL, TokenNumber);
}
UINT64
EFIAPI
DxePcdGet64 (
IN UINTN TokenNumber
)
{
return DxePcdGet32Ex (NULL, TokenNumber);
}
VOID *
EFIAPI
DxePcdGetPtr (
IN UINTN TokenNumber
)
{
return DxePcdGetPtrEx (NULL, TokenNumber);
}
BOOLEAN
EFIAPI
DxePcdGetBool (
IN UINTN TokenNumber
)
{
return DxePcdGetBoolEx (NULL, TokenNumber);
}
UINTN
EFIAPI
DxePcdGetSize (
IN UINTN TokenNumber
)
{
return DxePcdGetSizeEx (NULL, TokenNumber);
}
UINT8
EFIAPI
DxePcdGet8Ex (
IN CONST EFI_GUID *Guid,
IN UINTN TokenNumber
)
{
UINT8 Data;
DxeGetPcdEntryWorker (TokenNumber, Guid, PcdByte8, &Data);
return Data;
}
UINT16
EFIAPI
DxePcdGet16Ex (
IN CONST EFI_GUID *Guid,
IN UINTN TokenNumber
)
{
UINT16 Data;
DxeGetPcdEntryWorker (TokenNumber, Guid, PcdByte16, &Data);
return Data;
}
UINT32
EFIAPI
DxePcdGet32Ex (
IN CONST EFI_GUID *Guid,
IN UINTN TokenNumber
)
{
UINT32 Data;
DxeGetPcdEntryWorker (TokenNumber, Guid, PcdByte32, &Data);
return Data;
}
UINT64
EFIAPI
DxePcdGet64Ex (
IN CONST EFI_GUID *Guid,
IN UINTN TokenNumber
)
{
UINT64 Data;
DxeGetPcdEntryWorker (TokenNumber, Guid, PcdByte64, &Data);
return Data;
}
VOID *
EFIAPI
DxePcdGetPtrEx (
IN CONST EFI_GUID *Guid,
IN UINTN TokenNumber
)
{
VOID *Data;
DxeGetPcdEntryWorker (TokenNumber, Guid, PcdPointer, &Data);
return Data;
}
BOOLEAN
EFIAPI
DxePcdGetBoolEx (
IN CONST EFI_GUID *Guid,
IN UINTN TokenNumber
)
{
BOOLEAN Data;
DxeGetPcdEntryWorker (TokenNumber, Guid, PcdBoolean, &Data);
return Data;
}
UINTN
EFIAPI
DxePcdGetSizeEx (
IN CONST EFI_GUID *Guid,
IN UINTN TokenNumber
)
{
return DxeGetPcdEntrySizeWorker (TokenNumber, Guid);
}
EFI_STATUS
EFIAPI
DxePcdSet8 (
IN UINTN TokenNumber,
IN UINT8 Value
)
{
return DxePcdSet8Ex (NULL, TokenNumber, Value);
}
EFI_STATUS
EFIAPI
DxePcdSet16 (
IN UINTN TokenNumber,
IN UINT16 Value
)
{
return DxePcdSet16Ex (NULL, TokenNumber, Value);
}
EFI_STATUS
EFIAPI
DxePcdSet32 (
IN UINTN TokenNumber,
IN UINT32 Value
)
{
return DxePcdSet32Ex (NULL, TokenNumber, Value);
}
EFI_STATUS
EFIAPI
DxePcdSet64 (
IN UINTN TokenNumber,
IN UINT64 Value
)
{
return DxePcdSet64Ex (NULL, TokenNumber, Value);
}
EFI_STATUS
EFIAPI
DxePcdSetPtr (
IN UINTN TokenNumber,
IN CONST VOID *Value
)
{
return DxePcdSetPtrEx (NULL, TokenNumber, Value);
}
EFI_STATUS
EFIAPI
DxePcdSetBool (
IN UINTN TokenNumber,
IN BOOLEAN Value
)
{
return DxePcdSetBoolEx (NULL, TokenNumber, Value);
}
EFI_STATUS
EFIAPI
DxePcdSet8Ex (
IN CONST EFI_GUID *Guid,
IN UINTN TokenNumber,
IN UINT8 Value
)
{
return DxeSetPcdEntryWorker (TokenNumber, Guid, PcdByte8, &Value);
}
EFI_STATUS
EFIAPI
DxePcdSet16Ex (
IN CONST EFI_GUID *Guid,
IN UINTN TokenNumber,
IN UINT16 Value
)
{
return DxeSetPcdEntryWorker (TokenNumber, Guid, PcdByte16, &Value);
}
EFI_STATUS
EFIAPI
DxePcdSet32Ex (
IN CONST EFI_GUID *Guid,
IN UINTN TokenNumber,
IN UINT32 Value
)
{
return DxeSetPcdEntryWorker (TokenNumber, Guid, PcdByte32, &Value);
}
EFI_STATUS
EFIAPI
DxePcdSet64Ex (
IN CONST EFI_GUID *Guid,
IN UINTN TokenNumber,
IN UINT64 Value
)
{
return DxeSetPcdEntryWorker (TokenNumber, Guid, PcdByte64, &Value);
}
EFI_STATUS
EFIAPI
DxePcdSetPtrEx (
IN CONST EFI_GUID *Guid,
IN UINTN TokenNumber,
IN CONST VOID *Value
)
{
return DxeSetPcdEntryWorker (TokenNumber, Guid, PcdPointer, Value);
}
EFI_STATUS
EFIAPI
DxePcdSetBoolEx (
IN CONST EFI_GUID *Guid,
IN UINTN TokenNumber,
IN BOOLEAN Value
)
{
return DxeSetPcdEntryWorker (TokenNumber, Guid, PcdBoolean, &Value);
}
EFI_STATUS
EFIAPI
PcdRegisterCallBackOnSet (
IN UINTN TokenNumber,
IN CONST EFI_GUID *Guid, OPTIONAL
IN PCD_PROTOCOL_CALLBACK CallBackFunction
)
{
return DxeRegisterCallBackWorker (TokenNumber, Guid, CallBackFunction, TRUE);
}
EFI_STATUS
EFIAPI
PcdUnRegisterCallBackOnSet (
IN UINTN TokenNumber,
IN CONST EFI_GUID *Guid, OPTIONAL
IN PCD_PROTOCOL_CALLBACK CallBackFunction
)
{
return DxeRegisterCallBackWorker (TokenNumber, Guid, CallBackFunction, FALSE);
}
EFI_STATUS
EFIAPI
DxePcdGetNextToken (
IN CONST EFI_GUID *Guid, OPTIONAL
IN OUT UINTN *TokenNumber
)
{
return DxeGetNextTokenWorker (TokenNumber, Guid);
}

View File

@@ -0,0 +1,491 @@
/** @file
Private functions used by PCD DXE driver.s
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"
static PCD_DATABASE *PrivatePcdDxeDatabase;
static LIST_ENTRY mPcdDatabaseListHead = INITIALIZE_LIST_HEAD_VARIABLE(mPcdDatabaseListHead);
LIST_ENTRY *
GetPcdDatabaseListHead (
VOID
)
{
return &mPcdDatabaseListHead;
}
PCD_DATABASE *
GetPcdDxeDataBaseInstance (
VOID
)
{
return PrivatePcdDxeDatabase;
}
PCD_DATABASE *
SetPcdDxeDataBaseInstance (
PCD_DATABASE *PcdDatabase
)
{
return PrivatePcdDxeDatabase = PcdDatabase;
}
VOID
DxeGetPcdEntryWorker (
IN UINTN TokenNumber,
IN CONST GUID *Guid, OPTIONAL
IN PCD_DATA_TYPE Type,
OUT VOID *Data
)
{
PCD_DATABASE *Database;
Database = GetPcdDxeDataBaseInstance ();
GetPcdEntryWorker ( &Database->Info,
TokenNumber,
Guid,
Type,
Data
);
return;
}
EFI_STATUS
DxeSetPcdEntryWorker (
IN UINTN TokenNumber,
IN CONST GUID *Guid, OPTIONAL
IN PCD_DATA_TYPE Type,
IN CONST VOID *Data
)
{
PCD_DATABASE *Database;
PCD_INDEX *PcdIndex;
EFI_STATUS Status;
Database = GetPcdDxeDataBaseInstance ();
ASSERT (Data != NULL);
PcdIndex = FindPcdIndex (TokenNumber, Guid, &Database->Info, NULL);
ASSERT (PcdIndex != NULL);
ASSERT (PcdIndex->StateByte.DataType == Type);
//
// Invoke the callback function.
//
Status = SetPcdData (PcdIndex, &Database->Info, Data);
return Status;
}
UINTN
DxeGetPcdEntrySizeWorker (
IN UINTN TokenNumber,
IN CONST GUID *Guid OPTIONAL
)
{
PCD_DATABASE *Database;
Database = GetPcdDxeDataBaseInstance ();
return GetPcdEntrySizeWorker (&Database->Info,
TokenNumber,
Guid
);
}
LIST_ENTRY *
InsertToGuidSpaceListI (
IN LIST_ENTRY *GuidSpaceListHead,
IN CONST EFI_GUID *Guid
)
{
PCD_GUID_SPACE *GuidSpaceEntry;
GuidSpaceEntry = AllocatePool (sizeof (PCD_GUID_SPACE));
ASSERT (GuidSpaceEntry != NULL);
GuidSpaceEntry->GuidSpace= Guid;
InitializeListHead (&GuidSpaceEntry->TokenSpaceHead);
InsertTailList (GuidSpaceListHead, &GuidSpaceEntry->ListNode);
return &GuidSpaceEntry->TokenSpaceHead;
}
LIST_ENTRY *
InsertToTokenSpaceListI (
IN LIST_ENTRY *TokenSpaceListHead,
IN UINTN TokenNumber
)
{
PCD_TOKEN_SPACE *TokenSpaceEntry;
TokenSpaceEntry = AllocatePool (sizeof (PCD_TOKEN_SPACE));
ASSERT (TokenSpaceEntry != NULL);
TokenSpaceEntry->TokeNumber = TokenNumber;
InitializeListHead (&TokenSpaceEntry->CallbackListHead);
InsertTailList (TokenSpaceListHead, &TokenSpaceEntry->ListNode);
return &TokenSpaceEntry->CallbackListHead;
}
VOID
InsertToCallbackListI (
IN LIST_ENTRY *CallbackListHead,
IN PCD_PROTOCOL_CALLBACK CallBackFunction
)
{
PCD_CALLBACK_ENTRY *CallbackEntry;
CallbackEntry = AllocatePool (sizeof (PCD_CALLBACK_ENTRY));
ASSERT (CallbackEntry != NULL);
CallbackEntry->CallbackFunction = CallBackFunction;
InsertTailList (CallbackListHead, &CallbackEntry->ListNode);
return;
}
VOID
InsertToCallbackList (
IN UINTN TokenNumber,
IN CONST EFI_GUID *Guid,
IN PCD_PROTOCOL_CALLBACK CallBackFunction
)
{
LIST_ENTRY *GuidListNode;
LIST_ENTRY *GuidListHead;
LIST_ENTRY *TokenListNode;
LIST_ENTRY *TokenListHead;
LIST_ENTRY *CallbackListHead;
PCD_GUID_SPACE *GuidSpaceEntry;
PCD_TOKEN_SPACE *TokenSpaceEntry;
GuidListHead = GetPcdDatabaseListHead ();
GuidListNode = GetFirstNode (GuidListHead);
while (!IsNull (GuidListNode, GuidListHead)) {
GuidSpaceEntry = PCD_GUID_SPACE_FROM_LISTNODE(GuidListNode);
if (CompareGuid (GuidSpaceEntry->GuidSpace, Guid)) {
TokenListHead = &GuidSpaceEntry->TokenSpaceHead;
TokenListNode = GetFirstNode (TokenListHead);
while (!IsNull (TokenListNode, TokenListHead)) {
TokenSpaceEntry = PCD_TOKEN_SPACE_FROM_LISTNODE(TokenListNode);
if (TokenSpaceEntry->TokeNumber == TokenNumber) {
InsertToCallbackListI (&TokenSpaceEntry->CallbackListHead , CallBackFunction);
}
}
//
// No TokenNumber match input found in this GuidSpace
//
CallbackListHead = InsertToTokenSpaceListI (TokenListHead, TokenNumber);
InsertToCallbackListI (CallbackListHead , CallBackFunction);
}
GuidListNode = GetNextNode (GuidListHead, GuidListNode);
}
//
// No GuidSpace match the input Guid, so build the GuidSpace, TokenNumberSpace and Callback
//
TokenListHead = InsertToGuidSpaceListI (GuidListHead, Guid);
CallbackListHead = InsertToTokenSpaceListI (TokenListHead, TokenNumber);
InsertToCallbackListI (CallbackListHead , CallBackFunction);
return;
}
EFI_STATUS
RemoveFromCallbackListI (
IN LIST_ENTRY *CallbackListHead,
IN PCD_PROTOCOL_CALLBACK CallBackFunction
)
{
LIST_ENTRY *ListNode;
PCD_CALLBACK_ENTRY *CallbackEntry;
ListNode = GetFirstNode (CallbackListHead);
while (!IsNull(CallbackListHead, ListNode)) {
CallbackEntry = PCD_CALLBACK_ENTRY_FROM_LISTNODE(ListNode);
if (CallbackEntry->CallbackFunction == CallBackFunction) {
RemoveEntryList (ListNode);
FreePool (CallbackEntry);
return EFI_SUCCESS;
}
ListNode = GetNextNode (CallbackListHead, ListNode);
}
return EFI_NOT_FOUND;
}
EFI_STATUS
RemoveFromCallbackList (
IN UINTN TokenNumber,
IN CONST GUID *Guid,
IN PCD_PROTOCOL_CALLBACK CallBackFunction
)
{
LIST_ENTRY *GuidListNode;
LIST_ENTRY *GuidListHead;
LIST_ENTRY *TokenListNode;
LIST_ENTRY *TokenListHead;
PCD_GUID_SPACE *GuidSpaceEntry;
PCD_TOKEN_SPACE *TokenSpaceEntry;
GuidListHead = GetPcdDatabaseListHead ();
GuidListNode = GetFirstNode (GuidListHead);
while (!IsNull (GuidListNode, GuidListHead)) {
GuidSpaceEntry = PCD_GUID_SPACE_FROM_LISTNODE(GuidListNode);
if (CompareGuid (GuidSpaceEntry->GuidSpace, Guid)) {
TokenListHead = &GuidSpaceEntry->TokenSpaceHead;
TokenListNode = GetFirstNode (TokenListHead);
while (!IsNull (TokenListNode, TokenListHead)) {
TokenSpaceEntry = PCD_TOKEN_SPACE_FROM_LISTNODE(TokenListNode);
if (TokenSpaceEntry->TokeNumber == TokenNumber) {
return RemoveFromCallbackListI (&TokenSpaceEntry->CallbackListHead , CallBackFunction);
}
}
//
// No TokenNumber match input found in this GuidSpace
//
return EFI_NOT_FOUND;
}
GuidListNode = GetNextNode (GuidListHead, GuidListNode);
}
return EFI_NOT_FOUND;
}
EFI_STATUS
DxeRegisterCallBackWorker (
IN UINTN TokenNumber,
IN CONST GUID *Guid, OPTIONAL
IN PCD_PROTOCOL_CALLBACK CallBackFunction,
IN BOOLEAN Register
)
{
PCD_DATABASE *Database;
PCD_INDEX *PcdIndex;
Database = GetPcdDxeDataBaseInstance ();
PcdIndex = FindPcdIndex (TokenNumber, Guid, &Database->Info, NULL);
if (PcdIndex == NULL) {
return EFI_NOT_FOUND;
}
if (Register) {
InsertToCallbackList (TokenNumber, Guid, CallBackFunction);
return EFI_SUCCESS;
} else {
return RemoveFromCallbackList (TokenNumber, Guid, CallBackFunction);
}
}
EFI_STATUS
DxeSetSku (
UINTN Id
)
{
PCD_DATABASE * Database;
Database = GetPcdDxeDataBaseInstance ();
return Database->Info.SkuId = Id;
}
EFI_STATUS
DxeGetNextTokenWorker (
IN OUT UINTN *TokenNumber,
IN CONST GUID *Guid OPTIONAL
)
{
PCD_DATABASE * Database;
Database = GetPcdDxeDataBaseInstance ();
return GetNextTokenWorker (&Database->Info,
TokenNumber,
Guid
);
}
VOID
InitPcdDxeDataBase (
VOID
)
{
PCD_DATABASE *PeiDatabase;
PCD_DATABASE *DxeDatabase;
EFI_HOB_GUID_TYPE *GuidHob;
GuidHob = GetFirstGuidHob (&gPcdDataBaseHobGuid);
ASSERT (GuidHob != NULL);
PeiDatabase = (PCD_DATABASE *) GET_GUID_HOB_DATA (GuidHob);
DxeDatabase = AllocateCopyPool (PeiDatabase->Info.DatabaseLen, PeiDatabase);
ASSERT (DxeDatabase != NULL);
SetPcdDxeDataBaseInstance (DxeDatabase);
return;
}
EFI_STATUS
GetHiiVariable (
IN EFI_GUID *VariableGuid,
IN UINT16 *VariableName,
OUT VOID ** VariableData,
OUT UINTN *VariableSize
)
{
UINTN Size;
EFI_STATUS Status;
VOID *Buffer;
Status = EfiGetVariable (
(UINT16 *)VariableName,
VariableGuid,
NULL,
&Size,
NULL
);
ASSERT (Status == EFI_BUFFER_TOO_SMALL);
Buffer = AllocatePool (Size);
ASSERT (Buffer != NULL);
Status = EfiGetVariable (
VariableName,
VariableGuid,
NULL,
&Size,
Buffer
);
return Status;
}
EFI_STATUS
SetHiiVariable (
IN EFI_GUID *VariableGuid,
IN UINT16 *VariableName,
IN CONST VOID *Data,
IN UINTN DataSize,
IN UINTN Offset
)
{
UINTN Size;
VOID *Buffer;
EFI_STATUS Status;
Size = 0;
Status = EfiGetVariable (
(UINT16 *)VariableName,
VariableGuid,
NULL,
&Size,
NULL
);
ASSERT (Status == EFI_BUFFER_TOO_SMALL);
Buffer = AllocatePool (Size);
ASSERT (Buffer != NULL);
Status = EfiGetVariable (
VariableName,
VariableGuid,
NULL,
&Size,
Buffer
);
CopyMem ((UINT8 *)Buffer + Offset, Data, DataSize);
return EfiSetVariable (
VariableName,
VariableGuid,
0,
Size,
Buffer
);
}

View File

@@ -0,0 +1,399 @@
/** @file
Private functions used by PCD DXE driver.
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.h
**/
#ifndef _SERVICE_H
#define _SERVICE_H
VOID
DxeGetPcdEntryWorker (
IN UINTN Token,
IN CONST EFI_GUID *Guid, OPTIONAL
IN PCD_DATA_TYPE Type,
OUT VOID *Data
);
EFI_STATUS
DxeSetPcdEntryWorker (
IN UINTN Token,
IN CONST EFI_GUID *Guid, OPTIONAL
IN PCD_DATA_TYPE Type,
IN CONST VOID *Data
);
UINTN
DxeGetPcdEntrySizeWorker (
IN UINTN Token,
IN CONST EFI_GUID *Guid OPTIONAL
);
EFI_STATUS
DxeRegisterCallBackWorker (
IN UINTN TokenNumber,
IN CONST EFI_GUID *Guid, OPTIONAL
IN PCD_PROTOCOL_CALLBACK CallBackFunction,
IN BOOLEAN Reigster
);
EFI_STATUS
DxeSetSku (
UINTN Id
);
EFI_STATUS
DxeGetNextTokenWorker (
IN OUT UINTN *Token,
IN CONST EFI_GUID *Guid OPTIONAL
);
VOID
InitPcdDxeDataBase (
VOID
);
//
// Protocol Interface function declaration.
//
EFI_STATUS
EFIAPI
DxePcdSetSku (
IN UINTN SkuId
)
;
UINT8
EFIAPI
DxePcdGet8 (
IN UINTN TokenNumber
)
;
UINT16
EFIAPI
DxePcdGet16 (
IN UINTN TokenNumber
)
;
UINT32
EFIAPI
DxePcdGet32 (
IN UINTN TokenNumber
)
;
UINT64
EFIAPI
DxePcdGet64 (
IN UINTN TokenNumber
)
;
VOID *
EFIAPI
DxePcdGetPtr (
IN UINTN TokenNumber
)
;
BOOLEAN
EFIAPI
DxePcdGetBool (
IN UINTN TokenNumber
)
;
UINTN
EFIAPI
DxePcdGetSize (
IN UINTN TokenNumber
)
;
UINT8
EFIAPI
DxePcdGet8Ex (
IN CONST EFI_GUID *Guid,
IN UINTN TokenNumber
)
;
UINT16
EFIAPI
DxePcdGet16Ex (
IN CONST EFI_GUID *Guid,
IN UINTN TokenNumber
)
;
UINT32
EFIAPI
DxePcdGet32Ex (
IN CONST EFI_GUID *Guid,
IN UINTN TokenNumber
)
;
UINT64
EFIAPI
DxePcdGet64Ex (
IN CONST EFI_GUID *Guid,
IN UINTN TokenNumber
)
;
VOID *
EFIAPI
DxePcdGetPtrEx (
IN CONST EFI_GUID *Guid,
IN UINTN TokenNumber
)
;
BOOLEAN
EFIAPI
DxePcdGetBoolEx (
IN CONST EFI_GUID *Guid,
IN UINTN TokenNumber
)
;
UINTN
EFIAPI
DxePcdGetSizeEx (
IN CONST EFI_GUID *Guid,
IN UINTN TokenNumber
)
;
EFI_STATUS
EFIAPI
DxePcdSet8 (
IN UINTN TokenNumber,
IN UINT8 Value
)
;
EFI_STATUS
EFIAPI
DxePcdSet16 (
IN UINTN TokenNumber,
IN UINT16 Value
)
;
EFI_STATUS
EFIAPI
DxePcdSet32 (
IN UINTN TokenNumber,
IN UINT32 Value
)
;
EFI_STATUS
EFIAPI
DxePcdSet64 (
IN UINTN TokenNumber,
IN UINT64 Value
)
;
EFI_STATUS
EFIAPI
DxePcdSetPtr (
IN UINTN TokenNumber,
IN CONST VOID *Value
)
;
EFI_STATUS
EFIAPI
DxePcdSetBool (
IN UINTN TokenNumber,
IN BOOLEAN Value
)
;
EFI_STATUS
EFIAPI
DxePcdSet8Ex (
IN CONST EFI_GUID *Guid,
IN UINTN TokenNumber,
IN UINT8 Value
)
;
EFI_STATUS
EFIAPI
DxePcdSet16Ex (
IN CONST EFI_GUID *Guid,
IN UINTN TokenNumber,
IN UINT16 Value
)
;
EFI_STATUS
EFIAPI
DxePcdSet32Ex (
IN CONST EFI_GUID *Guid,
IN UINTN TokenNumber,
IN UINT32 Value
)
;
EFI_STATUS
EFIAPI
DxePcdSet64Ex (
IN CONST EFI_GUID *Guid,
IN UINTN TokenNumber,
IN UINT64 Value
)
;
EFI_STATUS
EFIAPI
DxePcdSetPtrEx (
IN CONST EFI_GUID *Guid,
IN UINTN TokenNumber,
IN CONST VOID *Value
)
;
EFI_STATUS
EFIAPI
DxePcdSetBoolEx (
IN CONST EFI_GUID *Guid,
IN UINTN TokenNumber,
IN BOOLEAN Value
)
;
EFI_STATUS
EFIAPI
PcdRegisterCallBackOnSet (
IN UINTN TokenNumber,
IN CONST EFI_GUID *Guid, OPTIONAL
IN PCD_PROTOCOL_CALLBACK CallBackFunction
)
;
EFI_STATUS
EFIAPI
PcdUnRegisterCallBackOnSet (
IN UINTN TokenNumber,
IN CONST EFI_GUID *Guid, OPTIONAL
IN PCD_PROTOCOL_CALLBACK CallBackFunction
)
;
EFI_STATUS
EFIAPI
DxePcdGetNextToken (
IN CONST EFI_GUID *Guid, OPTIONAL
IN OUT UINTN *TokenNumber
)
;
/*
This DXE_PCD_DATABASE layout. The difference of DXE_PCD_DATABASE
and PEI_PCD_DATABASE is as follows:
1) No PCD_CALL_BACK_TABLE; DXE_PCD_DATABASE maintain a LinkList for the
callback function registered.
---------------------------
| LIST_ENTRY GuidSpaceHead|
---------------------------
| PCD_DATABASE_HEADER |
---------------------------
| GUID_TABLE | Aligned on GUID (128 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 |
---------------------------
*/
typedef struct {
LIST_ENTRY ListNode;
LIST_ENTRY TokenSpaceHead;
CONST EFI_GUID *GuidSpace;
} PCD_GUID_SPACE;
typedef struct {
LIST_ENTRY ListNode;
LIST_ENTRY CallbackListHead;
UINTN TokeNumber;
} PCD_TOKEN_SPACE;
typedef struct {
LIST_ENTRY ListNode;
PCD_PROTOCOL_CALLBACK CallbackFunction;
} PCD_CALLBACK_ENTRY;
#define PCD_GUID_SPACE_FROM_LISTNODE(a) \
_CR(a, PCD_GUID_SPACE, ListNode)
#define PCD_TOKEN_SPACE_FROM_LISTNODE(a) \
_CR(a, PCD_TOKEN_SPACE, ListNode)
#define PCD_CALLBACK_ENTRY_FROM_LISTNODE(a) \
_CR(a, PCD_CALLBACK_ENTRY, ListNode)
#endif

View File

@@ -0,0 +1,486 @@
/** @file
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: Pcd.c
**/
#include "../Common/PcdCommon.h"
#include "Service.h"
PCD_PPI mPcdPpiInstance = {
PeiPcdSetSku,
PeiPcdGet8,
PeiPcdGet16,
PeiPcdGet32,
PeiPcdGet64,
PeiPcdGetPtr,
PeiPcdGetBool,
PeiPcdGetSize,
PeiPcdGet8Ex,
PeiPcdGet16Ex,
PeiPcdGet32Ex,
PeiPcdGet64Ex,
PeiPcdGetPtrEx,
PeiPcdGetBoolEx,
PeiPcdGetSizeEx,
PeiPcdSet8,
PeiPcdSet16,
PeiPcdSet32,
PeiPcdSet64,
PeiPcdSetPtr,
PeiPcdSetBool,
PeiPcdSet8Ex,
PeiPcdSet16Ex,
PeiPcdSet32Ex,
PeiPcdSet64Ex,
PeiPcdSetPtrEx,
PeiPcdSetBoolEx,
PcdRegisterCallBackOnSet,
PcdUnRegisterCallBackOnSet,
PeiPcdGetNextToken
};
STATIC EFI_PEI_PPI_DESCRIPTOR mPpiPCD = {
(EFI_PEI_PPI_DESCRIPTOR_PPI | EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST),
&gPcdPpiGuid,
&mPcdPpiInstance
};
EFI_STATUS
EFIAPI
PcdPeimInit (
IN EFI_FFS_FILE_HEADER *FfsHeader,
IN EFI_PEI_SERVICES **PeiServices
)
{
EFI_STATUS Status;
UINT8 *PcdImage;
PcdImage = (UINT8 *) LocatePcdImage ();
BuildPcdDatabase (PcdImage);
Status = PeiCoreInstallPpi (&mPpiPCD);
ASSERT_EFI_ERROR (Status);
return EFI_SUCCESS;
}
EFI_STATUS
EFIAPI
PeiPcdSetSku (
IN UINTN SkuId
)
{
PCD_DATABASE *Database;
EFI_HOB_GUID_TYPE *GuidHob;
GuidHob = GetFirstGuidHob (&gPcdDataBaseHobGuid);
ASSERT (GuidHob != NULL);
Database = (PCD_DATABASE *) GET_GUID_HOB_DATA (GuidHob);
Database->Info.SkuId = SkuId;
return SkuId;
}
UINT8
EFIAPI
PeiPcdGet8 (
IN UINTN TokenNumber
)
{
return PeiPcdGet8Ex (NULL, TokenNumber);
}
UINT16
EFIAPI
PeiPcdGet16 (
IN UINTN TokenNumber
)
{
return PeiPcdGet16Ex (NULL, TokenNumber);
}
UINT32
EFIAPI
PeiPcdGet32 (
IN UINTN TokenNumber
)
{
return PeiPcdGet32Ex (NULL, TokenNumber);
}
UINT64
EFIAPI
PeiPcdGet64 (
IN UINTN TokenNumber
)
{
return PeiPcdGet64Ex (NULL, TokenNumber);
}
VOID *
EFIAPI
PeiPcdGetPtr (
IN UINTN TokenNumber
)
{
return PeiPcdGetPtrEx (NULL, TokenNumber);
}
BOOLEAN
EFIAPI
PeiPcdGetBool (
IN UINTN TokenNumber
)
{
return PeiPcdGetBoolEx (NULL, TokenNumber);
}
UINTN
EFIAPI
PeiPcdGetSize (
IN UINTN TokenNumber
)
{
return PeiPcdGetSizeEx (NULL, TokenNumber);
}
UINT8
EFIAPI
PeiPcdGet8Ex (
IN CONST EFI_GUID *Guid,
IN UINTN TokenNumber
)
{
UINT8 Data;
PeiGetPcdEntryWorker (TokenNumber, Guid, PcdByte8, &Data);
return Data;
}
UINT16
EFIAPI
PeiPcdGet16Ex (
IN CONST EFI_GUID *Guid,
IN UINTN TokenNumber
)
{
UINT16 Data;
PeiGetPcdEntryWorker (TokenNumber, Guid, PcdByte16, &Data);
return Data;
}
UINT32
EFIAPI
PeiPcdGet32Ex (
IN CONST EFI_GUID *Guid,
IN UINTN TokenNumber
)
{
UINT32 Data;
PeiGetPcdEntryWorker (TokenNumber, Guid, PcdByte32, &Data);
return Data;
}
UINT64
EFIAPI
PeiPcdGet64Ex (
IN CONST EFI_GUID *Guid,
IN UINTN TokenNumber
)
{
UINT64 Data;
PeiGetPcdEntryWorker (TokenNumber, Guid, PcdByte64, &Data);
return Data;
}
VOID *
EFIAPI
PeiPcdGetPtrEx (
IN CONST EFI_GUID *Guid,
IN UINTN TokenNumber
)
{
VOID *Data;
PeiGetPcdEntryWorker (TokenNumber, Guid, PcdPointer, &Data);
return Data;
}
BOOLEAN
EFIAPI
PeiPcdGetBoolEx (
IN CONST EFI_GUID *Guid,
IN UINTN TokenNumber
)
{
BOOLEAN Data;
PeiGetPcdEntryWorker (TokenNumber, Guid, PcdBoolean, &Data);
return Data;
}
UINTN
EFIAPI
PeiPcdGetSizeEx (
IN CONST EFI_GUID *Guid,
IN UINTN TokenNumber
)
{
return PeiGetPcdEntrySizeWorker (TokenNumber, Guid);
}
EFI_STATUS
EFIAPI
PeiPcdSet8 (
IN UINTN TokenNumber,
IN UINT8 Value
)
{
return PeiPcdSet8Ex (NULL, TokenNumber, Value);
}
EFI_STATUS
EFIAPI
PeiPcdSet16 (
IN UINTN TokenNumber,
IN UINT16 Value
)
{
return PeiPcdSet16Ex (NULL, TokenNumber, Value);
}
EFI_STATUS
EFIAPI
PeiPcdSet32 (
IN UINTN TokenNumber,
IN UINT32 Value
)
{
return PeiPcdSet32Ex (NULL, TokenNumber, Value);
}
EFI_STATUS
EFIAPI
PeiPcdSet64 (
IN UINTN TokenNumber,
IN UINT64 Value
)
{
return PeiPcdSet64Ex (NULL, TokenNumber, Value);
}
EFI_STATUS
EFIAPI
PeiPcdSetPtr (
IN UINTN TokenNumber,
IN CONST VOID *Value
)
{
return PeiPcdSetPtrEx (NULL, TokenNumber, Value);
}
EFI_STATUS
EFIAPI
PeiPcdSetBool (
IN UINTN TokenNumber,
IN BOOLEAN Value
)
{
return PeiPcdSetBoolEx (NULL, TokenNumber, Value);
}
EFI_STATUS
EFIAPI
PeiPcdSet8Ex (
IN CONST EFI_GUID *Guid,
IN UINTN TokenNumber,
IN UINT8 Value
)
{
return PeiSetPcdEntryWorker (TokenNumber, Guid, PcdByte8, &Value);
}
EFI_STATUS
EFIAPI
PeiPcdSet16Ex (
IN CONST EFI_GUID *Guid,
IN UINTN TokenNumber,
IN UINT16 Value
)
{
return PeiSetPcdEntryWorker (TokenNumber, Guid, PcdByte16, &Value);
}
EFI_STATUS
EFIAPI
PeiPcdSet32Ex (
IN CONST EFI_GUID *Guid,
IN UINTN TokenNumber,
IN UINT32 Value
)
{
return PeiSetPcdEntryWorker (TokenNumber, Guid, PcdByte32, &Value);
}
EFI_STATUS
EFIAPI
PeiPcdSet64Ex (
IN CONST EFI_GUID *Guid,
IN UINTN TokenNumber,
IN UINT64 Value
)
{
return PeiSetPcdEntryWorker (TokenNumber, Guid, PcdByte64, &Value);
}
EFI_STATUS
EFIAPI
PeiPcdSetPtrEx (
IN CONST EFI_GUID *Guid,
IN UINTN TokenNumber,
IN CONST VOID *Value
)
{
return PeiSetPcdEntryWorker (TokenNumber, Guid, PcdPointer, (VOID *)Value);
}
EFI_STATUS
EFIAPI
PeiPcdSetBoolEx (
IN CONST EFI_GUID *Guid,
IN UINTN TokenNumber,
IN BOOLEAN Value
)
{
return PeiSetPcdEntryWorker (TokenNumber, Guid, PcdBoolean, &Value);
}
EFI_STATUS
EFIAPI
PcdRegisterCallBackOnSet (
IN UINTN TokenNumber,
IN CONST EFI_GUID *Guid, OPTIONAL
IN PCD_PPI_CALLBACK CallBackFunction
)
{
return PeiRegisterCallBackWorker (TokenNumber, Guid, CallBackFunction, TRUE);
}
EFI_STATUS
EFIAPI
PcdUnRegisterCallBackOnSet (
IN UINTN TokenNumber,
IN CONST EFI_GUID *Guid, OPTIONAL
IN PCD_PPI_CALLBACK CallBackFunction
)
{
return PeiRegisterCallBackWorker (TokenNumber, Guid, CallBackFunction, FALSE);
}
EFI_STATUS
EFIAPI
PeiPcdGetNextToken (
IN CONST EFI_GUID *Guid, OPTIONAL
IN OUT UINTN *TokenNumber
)
{
return PeiGetNextTokenWorker (TokenNumber, Guid);
}

View File

@@ -0,0 +1,812 @@
/** @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;
}

View File

@@ -0,0 +1,371 @@
/** @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.h
**/
#ifndef _SERVICE_H
#define _SERVICE_H
//
// Offset of StateByte
//
#define PCD_STATEBYTE_HIIENABLE 0x01
#define PCD_STATEBYTE_SKUENABLE 0x02
#define PCD_STATEBYTE_VPDENABLE 0x04
#define PCD_STATEBYTE_SKUDATAARRAYENABLE 0x08
#define PCD_STATEBYTE_DATUMTYPE 0x70
#define PCD_STATEBYTE_EXTENDEDGUIDPRESENT 0x80
#define PCD_DATUMTYPE_OFFSET 4
//
// The definitions for interpreting DatumType
//
#define PCD_BYTE8 (0x00 << PCD_DATUMTYPE_OFFSET)
#define PCD_BYTE16 (0x01 << PCD_DATUMTYPE_OFFSET)
#define PCD_BYTE32 (0x02 << PCD_DATUMTYPE_OFFSET)
#define PCD_BYTE64 (0x03 << PCD_DATUMTYPE_OFFSET)
#define PCD_POINTER (0x04 << PCD_DATUMTYPE_OFFSET)
#define PCD_BOOLEAN (0x05 << PCD_DATUMTYPE_OFFSET)
extern GUID gEfiPcdImageHobGuid;
/* Internal Function definitions */
VOID
PeiGetPcdEntryWorker (
IN UINTN Token,
IN CONST GUID *Guid, OPTIONAL
IN PCD_DATA_TYPE Type,
OUT VOID *Data
);
EFI_STATUS
PeiSetPcdEntryWorker (
IN UINTN Token,
IN CONST GUID *Guid, OPTIONAL
IN PCD_DATA_TYPE Type,
IN VOID *Data
);
UINTN
PeiGetPcdEntrySizeWorker (
IN UINTN Token,
IN CONST GUID *Guid OPTIONAL
);
EFI_STATUS
PeiRegisterCallBackWorker (
IN UINTN TokenNumber,
IN CONST GUID *Guid, OPTIONAL
IN PCD_PPI_CALLBACK CallBackFunction,
IN BOOLEAN Register
);
EFI_STATUS
PeiSetSku (
UINTN Id
);
EFI_STATUS
PeiGetNextTokenWorker (
IN OUT UINTN *Token,
IN CONST GUID *Guid OPTIONAL
);
UINT8 *
LocatePcdImage (
VOID
);
VOID
BuildPcdDatabase (
UINT8 *PcdImageOnFlash
)
;
extern EFI_GUID gPcdImageFileGuid;
//
// PPI Interface Implementation Declaration.
//
EFI_STATUS
EFIAPI
PeiPcdSetSku (
IN UINTN SkuId
)
;
UINT8
EFIAPI
PeiPcdGet8 (
IN UINTN TokenNumber
)
;
UINT16
EFIAPI
PeiPcdGet16 (
IN UINTN TokenNumber
)
;
UINT32
EFIAPI
PeiPcdGet32 (
IN UINTN TokenNumber
)
;
UINT64
EFIAPI
PeiPcdGet64 (
IN UINTN TokenNumber
)
;
VOID *
EFIAPI
PeiPcdGetPtr (
IN UINTN TokenNumber
)
;
BOOLEAN
EFIAPI
PeiPcdGetBool (
IN UINTN TokenNumber
)
;
UINTN
EFIAPI
PeiPcdGetSize (
IN UINTN TokenNumber
)
;
UINT8
EFIAPI
PeiPcdGet8Ex (
IN CONST EFI_GUID *Guid,
IN UINTN TokenNumber
)
;
UINT16
EFIAPI
PeiPcdGet16Ex (
IN CONST EFI_GUID *Guid,
IN UINTN TokenNumber
)
;
UINT32
EFIAPI
PeiPcdGet32Ex (
IN CONST EFI_GUID *Guid,
IN UINTN TokenNumber
)
;
UINT64
EFIAPI
PeiPcdGet64Ex (
IN CONST EFI_GUID *Guid,
IN UINTN TokenNumber
)
;
VOID *
EFIAPI
PeiPcdGetPtrEx (
IN CONST EFI_GUID *Guid,
IN UINTN TokenNumber
)
;
BOOLEAN
EFIAPI
PeiPcdGetBoolEx (
IN CONST EFI_GUID *Guid,
IN UINTN TokenNumber
)
;
UINTN
EFIAPI
PeiPcdGetSizeEx (
IN CONST EFI_GUID *Guid,
IN UINTN TokenNumber
)
;
EFI_STATUS
EFIAPI
PeiPcdSet8 (
IN UINTN TokenNumber,
IN UINT8 Value
)
;
EFI_STATUS
EFIAPI
PeiPcdSet16 (
IN UINTN TokenNumber,
IN UINT16 Value
)
;
EFI_STATUS
EFIAPI
PeiPcdSet32 (
IN UINTN TokenNumber,
IN UINT32 Value
)
;
EFI_STATUS
EFIAPI
PeiPcdSet64 (
IN UINTN TokenNumber,
IN UINT64 Value
)
;
EFI_STATUS
EFIAPI
PeiPcdSetPtr (
IN UINTN TokenNumber,
IN CONST VOID *Value
)
;
EFI_STATUS
EFIAPI
PeiPcdSetBool (
IN UINTN TokenNumber,
IN BOOLEAN Value
)
;
EFI_STATUS
EFIAPI
PeiPcdSet8Ex (
IN CONST EFI_GUID *Guid,
IN UINTN TokenNumber,
IN UINT8 Value
)
;
EFI_STATUS
EFIAPI
PeiPcdSet16Ex (
IN CONST EFI_GUID *Guid,
IN UINTN TokenNumber,
IN UINT16 Value
)
;
EFI_STATUS
EFIAPI
PeiPcdSet32Ex (
IN CONST EFI_GUID *Guid,
IN UINTN TokenNumber,
IN UINT32 Value
)
;
EFI_STATUS
EFIAPI
PeiPcdSet64Ex (
IN CONST EFI_GUID *Guid,
IN UINTN TokenNumber,
IN UINT64 Value
)
;
EFI_STATUS
EFIAPI
PeiPcdSetPtrEx (
IN CONST EFI_GUID *Guid,
IN UINTN TokenNumber,
IN CONST VOID *Value
)
;
EFI_STATUS
EFIAPI
PeiPcdSetBoolEx (
IN CONST EFI_GUID *Guid,
IN UINTN TokenNumber,
IN BOOLEAN Value
)
;
EFI_STATUS
EFIAPI
PcdRegisterCallBackOnSet (
IN UINTN TokenNumber,
IN CONST EFI_GUID *Guid, OPTIONAL
IN PCD_PPI_CALLBACK CallBackFunction
)
;
EFI_STATUS
EFIAPI
PcdUnRegisterCallBackOnSet (
IN UINTN TokenNumber,
IN CONST EFI_GUID *Guid, OPTIONAL
IN PCD_PPI_CALLBACK CallBackFunction
)
;
EFI_STATUS
EFIAPI
PeiPcdGetNextToken (
IN CONST EFI_GUID *Guid, OPTIONAL
IN OUT UINTN *TokenNumber
)
;
#endif

View File

@@ -0,0 +1,110 @@
/** @file
PCD TEST 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: PcdTest.c
**/
#define GUID1 \
{0xF9349C58, 0xB767, 0x42c8, 0xB3, 0x6B, 0x41, 0x25, 0xDE, 0x3A, 0xEF, 0xEB}
CONST GUID Guid1 = GUID1;
EFI_STATUS
EFIAPI
OnsetCallback1 (
IN UINT32 CallBackToken,
IN VOID *TokenData,
IN UINTN TokenDataSize
)
{
DebugPrint (0x80000000, "In CallbackOnSet %x %d\n", * ((UINT32 *)TokenData), TokenDataSize);
return EFI_SUCCESS;
}
VOID
DoTest(
VOID
)
{
PCD_TOKEN_NUMBER tn;
UINTN Size;
VOID * Ptr;
UINT32 Uint32;
UINT32 Uint32a;
UINT64 Uint64;
UINT64 Uint64a;
INTN i;
tn = 0x00001000;
Size = LibPcdGetSize (tn);
Ptr = LibPcdGetPtr (tn); /* a:RW;2880;512!e:RW;262144;512 */
tn = 0x00001001;
Size = LibPcdGetSize (tn); /* FW;40960;512 */
tn = 0x00001002;
Size = LibPcdGetSize (tn); /* FW;40960;512 */
Ptr = LibPcdGetPtr (tn);
LibPcdSetSku (0x0a);
tn = 0x2233;
Uint64 = LibPcdGet64 (tn);
LibPcdSetSku (0x0b);
Uint64 = LibPcdGet64 (tn);
LibPcdSetSku (0x0c);
Uint64a = LibPcdGet64 (tn);
LibPcdSetSku (0);
tn = 0x2233;
Uint64 = LibPcdGet64 (tn);
tn = 0xfaceface;
Size = LibPcdGetExSize (&Guid1, tn);
Uint32 = LibPcdGetEx32 (&Guid1, tn);
LibPcdCallBackOnSet (&Guid1, tn, OnsetCallback1);
LibPcdCancelCallBackOnSet (&Guid1, tn, OnsetCallback1);
for (i = 0; i < 2; i++) {
Uint32a = LibPcdSetEx32 (&Guid1, tn, Uint32 + i);
DebugPrint (0x80000000, "%x\n", Uint32a);
}
Uint32 = LibPcdGet32 (tn);
return;
}
EFI_STATUS
EFIAPI
PcdTestPeimInit (
IN EFI_FFS_FILE_HEADER *FfsHeader,
IN EFI_PEI_SERVICES **PeiServices
)
{
DoTest();
return EFI_SUCCESS;
}

View File

@@ -0,0 +1,28 @@
/*++
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:
Variable.dxs
Abstract:
Dependency expression file for PcdTest PEIM.
--*/
#include <AutoGen.h>
#include <PeimDepex.h>
DEPENDENCY_START
PCD_PPI_GUID
DEPENDENCY_END