From 52e1905d39d71e013d253845cf8f2cdabea7c4f9 Mon Sep 17 00:00:00 2001 From: qwang12 Date: Wed, 24 May 2006 08:16:20 +0000 Subject: Check in the Pcd service Driver/PEIM according to the new way of generating PCD Database LIMITATION: 1) ONLY dynamic type PCD is supported for now. DynamicEx is not supported. 2) HII enable and VPD is not tested. git-svn-id: https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2@253 6f19259b-4bc3-4df7-8a09-765794883524 --- EdkModulePkg/Universal/PCD/Dxe/Service.c | 712 +++++++++++++++++-------------- 1 file changed, 403 insertions(+), 309 deletions(-) (limited to 'EdkModulePkg/Universal/PCD/Dxe/Service.c') diff --git a/EdkModulePkg/Universal/PCD/Dxe/Service.c b/EdkModulePkg/Universal/PCD/Dxe/Service.c index 280a45ea31..52097ade7e 100644 --- a/EdkModulePkg/Universal/PCD/Dxe/Service.c +++ b/EdkModulePkg/Universal/PCD/Dxe/Service.c @@ -14,427 +14,463 @@ 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; -} +// +// Build Tool will generate DXE_PCD_DB_INIT_VALUE in Autogen.h +// Compression Algorithm will take care of the size optimization. +// -PCD_DATABASE * -SetPcdDxeDataBaseInstance ( - PCD_DATABASE *PcdDatabase -) -{ - return PrivatePcdDxeDatabase = PcdDatabase; -} +/* +DXE_PCD_DATABASE_INIT gDXEPcdDbInit = { + DXE_PCD_DB_INIT_VALUE +}; +*/ +PCD_DATABASE * gPcdDatabase; -VOID -DxeGetPcdEntryWorker ( - IN UINTN TokenNumber, - IN CONST GUID *Guid, OPTIONAL - IN PCD_DATA_TYPE Type, - OUT VOID *Data - ) +VOID * +GetWorkerByLocalTokenNumber ( + UINT32 LocalTokenNumber, + BOOLEAN IsPeiDb, + UINTN Size + ) { - PCD_DATABASE *Database; - Database = GetPcdDxeDataBaseInstance (); + UINT32 Offset; + EFI_GUID *GuidTable; + UINT16 *StringTable; + EFI_GUID *Guid; + UINT16 *Name; + VARIABLE_HEAD *VariableHead; + EFI_STATUS Status; + UINTN DataSize; + VOID *Data; + VPD_HEAD *VpdHead; + UINT8 *PcdDb; + UINT16 StringTableIdx; + + if ((LocalTokenNumber & PCD_TYPE_SKU_ENABLED) == PCD_TYPE_SKU_ENABLED) { + LocalTokenNumber = GetSkuEnabledTokenNumber (LocalTokenNumber & ~PCD_TYPE_SKU_ENABLED, Size, IsPeiDb); + } + + PcdDb = IsPeiDb ? ((UINT8 *) &gPcdDatabase->PeiDb) : ((UINT8 *) &gPcdDatabase->DxeDb); + StringTable = IsPeiDb ? gPcdDatabase->PeiDb.Init.StringTable : + gPcdDatabase->DxeDb.Init.StringTable; + + Offset = LocalTokenNumber & PCD_DATABASE_OFFSET_MASK; + + switch (LocalTokenNumber & ~PCD_DATABASE_OFFSET_MASK) { + case PCD_TYPE_VPD: + VpdHead = (VPD_HEAD *) ((UINT8 *) PcdDb + Offset); + return (VOID *) (FixedPcdGet32(PcdVpdBaseAddress) + VpdHead->Offset); + + case PCD_TYPE_HII: + GuidTable = IsPeiDb ? gPcdDatabase->PeiDb.Init.GuidTable : + gPcdDatabase->DxeDb.Init.GuidTable; + + VariableHead = (VARIABLE_HEAD *) (PcdDb + Offset); + + Guid = &(GuidTable[VariableHead->GuidTableIndex]); + Name = &(StringTable[VariableHead->StringIndex]); - GetPcdEntryWorker ( &Database->Info, - TokenNumber, - Guid, - Type, - Data - ); + Status = GetHiiVariable (Guid, Name, &Data, &DataSize); + ASSERT_EFI_ERROR (Status); + ASSERT (DataSize >= (UINTN) (VariableHead->Offset + Size)); + return (UINT8 *) Data + VariableHead->Offset; - return; -} + case PCD_TYPE_STRING: + StringTableIdx = (UINT16) *((UINT8 *) PcdDb + Offset); + return (VOID *) &StringTable[StringTableIdx]; + case PCD_TYPE_DATA: + return (VOID *) ((UINT8 *) PcdDb + Offset); + break; + default: + ASSERT (FALSE); + break; + + } -EFI_STATUS -DxeSetPcdEntryWorker ( - IN UINTN TokenNumber, - IN CONST GUID *Guid, OPTIONAL - IN PCD_DATA_TYPE Type, - IN CONST VOID *Data + ASSERT (FALSE); + + return NULL; +} + +VOID * +GetWorker ( + UINTN TokenNumber ) { - PCD_DATABASE *Database; - PCD_INDEX *PcdIndex; - EFI_STATUS Status; - - Database = GetPcdDxeDataBaseInstance (); - - - ASSERT (Data != NULL); - - PcdIndex = FindPcdIndex (TokenNumber, Guid, &Database->Info, NULL); + UINT32 *LocalTokenNumberTable; + UINT16 *SizeTable; + BOOLEAN IsPeiDb; - ASSERT (PcdIndex != NULL); + ASSERT (TokenNumber < PCD_TOTAL_TOKEN_NUMBER); + + IsPeiDb = (TokenNumber <= PEI_LOCAL_TOKEN_NUMBER) ? TRUE : FALSE; - ASSERT (PcdIndex->StateByte.DataType == Type); + LocalTokenNumberTable = IsPeiDb ? gPcdDatabase->PeiDb.Init.LocalTokenNumberTable : + gPcdDatabase->DxeDb.Init.LocalTokenNumberTable; - // - // Invoke the callback function. - // + SizeTable = IsPeiDb ? gPcdDatabase->PeiDb.Init.SizeTable: + gPcdDatabase->DxeDb.Init.SizeTable; - Status = SetPcdData (PcdIndex, &Database->Info, Data); + TokenNumber = IsPeiDb ? TokenNumber : + TokenNumber - PEI_LOCAL_TOKEN_NUMBER; + return GetWorkerByLocalTokenNumber (LocalTokenNumberTable[TokenNumber], IsPeiDb, SizeTable[TokenNumber]); +} - return Status; +EFI_STATUS +DxeRegisterCallBackWorker ( + IN UINTN TokenNumber, + IN CONST GUID *Guid, OPTIONAL + IN PCD_PROTOCOL_CALLBACK CallBackFunction, + IN BOOLEAN Register +) +{ + + return EFI_SUCCESS; } - -UINTN -DxeGetPcdEntrySizeWorker ( - IN UINTN TokenNumber, - IN CONST GUID *Guid OPTIONAL +EFI_STATUS +DxeGetNextTokenWorker ( + IN OUT UINTN *TokenNumber, + IN CONST GUID *Guid OPTIONAL ) { - PCD_DATABASE *Database; - Database = GetPcdDxeDataBaseInstance (); - - return GetPcdEntrySizeWorker (&Database->Info, - TokenNumber, - Guid - ); + return EFI_SUCCESS; } -LIST_ENTRY * -InsertToGuidSpaceListI ( - IN LIST_ENTRY *GuidSpaceListHead, - IN CONST EFI_GUID *Guid - ) +VOID +BuildPcdDxeDataBase ( + VOID +) { - PCD_GUID_SPACE *GuidSpaceEntry; + PEI_PCD_DATABASE *PeiDatabase; + EFI_HOB_GUID_TYPE *GuidHob; - GuidSpaceEntry = AllocatePool (sizeof (PCD_GUID_SPACE)); - ASSERT (GuidSpaceEntry != NULL); + gPcdDatabase = AllocateZeroPool (sizeof(PCD_DATABASE)); + ASSERT (gPcdDatabase != NULL); - GuidSpaceEntry->GuidSpace= Guid; - InitializeListHead (&GuidSpaceEntry->TokenSpaceHead); - - InsertTailList (GuidSpaceListHead, &GuidSpaceEntry->ListNode); + GuidHob = GetFirstGuidHob (&gPcdDataBaseHobGuid); + ASSERT (GuidHob != NULL); - return &GuidSpaceEntry->TokenSpaceHead; + PeiDatabase = (PEI_PCD_DATABASE *) GET_GUID_HOB_DATA (GuidHob); + // + // Copy PCD Entries refereneced in PEI phase to PCD DATABASE + // + CopyMem (&gPcdDatabase->PeiDb, PeiDatabase, sizeof (PEI_PCD_DATABASE)); + + // + // Copy PCD Entries with default value to PCD DATABASE + // + CopyMem (&gPcdDatabase->DxeDb.Init, &gDXEPcdDbInit, sizeof(DXE_PCD_DATABASE_INIT)); + + return; } -LIST_ENTRY * -InsertToTokenSpaceListI ( - IN LIST_ENTRY *TokenSpaceListHead, - IN UINTN TokenNumber +EFI_STATUS +GetHiiVariable ( + IN EFI_GUID *VariableGuid, + IN UINT16 *VariableName, + OUT VOID ** VariableData, + OUT UINTN *VariableSize ) { - PCD_TOKEN_SPACE *TokenSpaceEntry; + UINTN Size; + EFI_STATUS Status; + VOID *Buffer; - TokenSpaceEntry = AllocatePool (sizeof (PCD_TOKEN_SPACE)); - ASSERT (TokenSpaceEntry != NULL); + Status = EfiGetVariable ( + (UINT16 *)VariableName, + VariableGuid, + NULL, + &Size, + NULL + ); + ASSERT (Status == EFI_BUFFER_TOO_SMALL); - TokenSpaceEntry->TokeNumber = TokenNumber; - InitializeListHead (&TokenSpaceEntry->CallbackListHead); - - InsertTailList (TokenSpaceListHead, &TokenSpaceEntry->ListNode); + Buffer = AllocatePool (Size); - return &TokenSpaceEntry->CallbackListHead; -} + ASSERT (Buffer != NULL); + Status = EfiGetVariable ( + VariableName, + VariableGuid, + NULL, + &Size, + Buffer + ); + return Status; -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; } +UINT32 +GetSkuEnabledTokenNumber ( + UINT32 LocalTokenNumber, + UINTN Size, + BOOLEAN IsPeiDb + ) +{ + SKU_HEAD *SkuHead; + SKU_ID *SkuIdTable; + INTN i; + UINT8 *Value; + SKU_ID *PhaseSkuIdTable; + UINT8 *PcdDb; + ASSERT ((LocalTokenNumber & PCD_TYPE_SKU_ENABLED) == 0); -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; + PcdDb = IsPeiDb ? (UINT8 *) &gPcdDatabase->PeiDb : (UINT8 *) &gPcdDatabase->DxeDb; - - 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); - } - } + SkuHead = (SKU_HEAD *) (PcdDb + (LocalTokenNumber & PCD_DATABASE_OFFSET_MASK)); + Value = (UINT8 *) (PcdDb + SkuHead->SkuDataStartOffset); - // - // No TokenNumber match input found in this GuidSpace - // - CallbackListHead = InsertToTokenSpaceListI (TokenListHead, TokenNumber); - InsertToCallbackListI (CallbackListHead , CallBackFunction); + PhaseSkuIdTable = IsPeiDb ? gPcdDatabase->PeiDb.Init.SkuIdTable : + gPcdDatabase->DxeDb.Init.SkuIdTable; + + SkuIdTable = &PhaseSkuIdTable[SkuHead->SkuIdTableOffset]; + + for (i = 0; i < SkuIdTable[0]; i++) { + if (gPcdDatabase->PeiDb.Init.SystemSkuId == SkuIdTable[i + 1]) { + break; } - - GuidListNode = GetNextNode (GuidListHead, GuidListNode); } + ASSERT (i < SkuIdTable[0]); - // - // No GuidSpace match the input Guid, so build the GuidSpace, TokenNumberSpace and Callback - // - TokenListHead = InsertToGuidSpaceListI (GuidListHead, Guid); - CallbackListHead = InsertToTokenSpaceListI (TokenListHead, TokenNumber); - InsertToCallbackListI (CallbackListHead , CallBackFunction); + switch (LocalTokenNumber & ~PCD_DATABASE_OFFSET_MASK) { + case PCD_TYPE_VPD: + Value = (UINT8 *) &(((VPD_HEAD *) Value)[i]); + return ((Value - PcdDb) | PCD_TYPE_VPD); - return; + case PCD_TYPE_HII: + Value = (UINT8 *) &(((VARIABLE_HEAD *) Value)[i]); + return ((Value - PcdDb) | PCD_TYPE_HII); + + case PCD_TYPE_DATA: + Value += Size * i; + return (Value - PcdDb); + + default: + ASSERT (FALSE); + } + + ASSERT (FALSE); + + return 0; } -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; +VOID +InvokeCallbackOnSet ( + UINT32 ExTokenNumber, + CONST EFI_GUID *Guid, OPTIONAL + UINTN TokenNumber, + VOID *Data, + UINTN Size + ) +{ + return; } + EFI_STATUS -RemoveFromCallbackList ( - IN UINTN TokenNumber, - IN CONST GUID *Guid, - IN PCD_PROTOCOL_CALLBACK CallBackFunction +SetWorker ( + UINTN TokenNumber, + VOID *Data, + UINTN Size, + BOOLEAN PtrType ) { - LIST_ENTRY *GuidListNode; - LIST_ENTRY *GuidListHead; - LIST_ENTRY *TokenListNode; - LIST_ENTRY *TokenListHead; - PCD_GUID_SPACE *GuidSpaceEntry; - PCD_TOKEN_SPACE *TokenSpaceEntry; + UINT32 *LocalTokenNumberTable; + BOOLEAN IsPeiDb; - - 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); - } - } + ASSERT (TokenNumber < PCD_TOTAL_TOKEN_NUMBER); - // - // No TokenNumber match input found in this GuidSpace - // - return EFI_NOT_FOUND; - } - - GuidListNode = GetNextNode (GuidListHead, GuidListNode); + if (PtrType) { + ASSERT (Size <= DxePcdGetSize (TokenNumber)); + } else { + ASSERT (Size == DxePcdGetSize (TokenNumber)); } - - - return EFI_NOT_FOUND; -} - + IsPeiDb = (TokenNumber <= PEI_LOCAL_TOKEN_NUMBER) ? TRUE : FALSE; + LocalTokenNumberTable = IsPeiDb ? gPcdDatabase->PeiDb.Init.LocalTokenNumberTable : + gPcdDatabase->DxeDb.Init.LocalTokenNumberTable; -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; + TokenNumber = IsPeiDb ? TokenNumber + : TokenNumber - PEI_LOCAL_TOKEN_NUMBER; - Database = GetPcdDxeDataBaseInstance (); + InvokeCallbackOnSet (0, NULL, TokenNumber, Data, Size); - PcdIndex = FindPcdIndex (TokenNumber, Guid, &Database->Info, NULL); + return SetWorkerByLocalTokenNumber (LocalTokenNumberTable[TokenNumber], Data, Size, PtrType, IsPeiDb); - 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 -) +VOID * +ExGetWorker ( + IN CONST EFI_GUID *Guid, + IN UINTN ExTokenNumber, + IN UINTN GetSize + ) { - PCD_DATABASE * Database; + EX_PCD_ENTRY_ATTRIBUTE Attr; - Database = GetPcdDxeDataBaseInstance (); + GetExPcdTokenAttributes (Guid, ExTokenNumber, &Attr); - return Database->Info.SkuId = Id; + ASSERT ((GetSize == Attr.Size) || (GetSize == 0)); + return GetWorkerByLocalTokenNumber (Attr.LocalTokenNumberAlias, + Attr.IsPeiDb, + Attr.Size + ); } + + EFI_STATUS -DxeGetNextTokenWorker ( - IN OUT UINTN *TokenNumber, - IN CONST GUID *Guid OPTIONAL +ExSetWorker ( + IN UINT32 ExTokenNumber, + IN CONST EFI_GUID *Guid, + VOID *Data, + UINTN SetSize, + BOOLEAN PtrType ) { - PCD_DATABASE * Database; + EX_PCD_ENTRY_ATTRIBUTE Attr; - Database = GetPcdDxeDataBaseInstance (); + GetExPcdTokenAttributes (Guid, ExTokenNumber, &Attr); - return GetNextTokenWorker (&Database->Info, - TokenNumber, - Guid - ); -} + ASSERT (!PtrType && (SetSize == Attr.Size)); + ASSERT (PtrType && (SetSize <= Attr.Size)); + InvokeCallbackOnSet (ExTokenNumber, Guid, Attr.TokenNumber, Data, Attr.Size); -VOID -InitPcdDxeDataBase ( - VOID -) -{ - PCD_DATABASE *PeiDatabase; - PCD_DATABASE *DxeDatabase; - EFI_HOB_GUID_TYPE *GuidHob; + SetWorkerByLocalTokenNumber (Attr.LocalTokenNumberAlias, Data, Attr.Size, PtrType, Attr.IsPeiDb); - GuidHob = GetFirstGuidHob (&gPcdDataBaseHobGuid); - ASSERT (GuidHob != NULL); + return EFI_SUCCESS; + +} - PeiDatabase = (PCD_DATABASE *) GET_GUID_HOB_DATA (GuidHob); - DxeDatabase = AllocateCopyPool (PeiDatabase->Info.DatabaseLen, PeiDatabase); - ASSERT (DxeDatabase != NULL); - SetPcdDxeDataBaseInstance (DxeDatabase); +EFI_STATUS +SetWorkerByLocalTokenNumber ( + UINT32 LocalTokenNumber, + VOID *Data, + UINTN Size, + BOOLEAN PtrType, + BOOLEAN IsPeiDb + ) +{ + EFI_GUID *GuidTable; + UINT16 *StringTable; + EFI_GUID *Guid; + UINT16 *Name; + VOID *InternalData; + VARIABLE_HEAD *VariableHead; + UINTN Offset; + UINT8 *PcdDb; + + + if ((LocalTokenNumber & PCD_TYPE_SKU_ENABLED) == PCD_TYPE_SKU_ENABLED) { + LocalTokenNumber = GetSkuEnabledTokenNumber (LocalTokenNumber & ~PCD_TYPE_SKU_ENABLED, Size, IsPeiDb); + } - return; -} + Offset = LocalTokenNumber & PCD_DATABASE_OFFSET_MASK; + PcdDb = IsPeiDb ? ((UINT8 *) &gPcdDatabase->PeiDb) : ((UINT8 *) &gPcdDatabase->DxeDb); + StringTable = IsPeiDb ? gPcdDatabase->PeiDb.Init.StringTable : + gPcdDatabase->DxeDb.Init.StringTable; + + InternalData = PcdDb + Offset; -EFI_STATUS -GetHiiVariable ( - IN EFI_GUID *VariableGuid, - IN UINT16 *VariableName, - OUT VOID ** VariableData, - OUT UINTN *VariableSize - ) -{ - UINTN Size; - EFI_STATUS Status; - VOID *Buffer; + switch (LocalTokenNumber & ~PCD_DATABASE_OFFSET_MASK) { + case PCD_TYPE_VPD: + ASSERT (FALSE); + return EFI_INVALID_PARAMETER; + + case PCD_TYPE_STRING: + CopyMem (&StringTable[*((UINT16 *)InternalData)], Data, Size); + break; - Status = EfiGetVariable ( - (UINT16 *)VariableName, - VariableGuid, - NULL, - &Size, - NULL - ); - ASSERT (Status == EFI_BUFFER_TOO_SMALL); + case PCD_TYPE_HII: + // + // Bug Bug: Please implement this + // + GuidTable = IsPeiDb ? gPcdDatabase->PeiDb.Init.GuidTable : + gPcdDatabase->DxeDb.Init.GuidTable; + + VariableHead = (VARIABLE_HEAD *) (PcdDb + Offset); + + Guid = &(GuidTable[VariableHead->GuidTableIndex]); + Name = &(StringTable[VariableHead->StringIndex]); - Buffer = AllocatePool (Size); + return EFI_SUCCESS; - ASSERT (Buffer != NULL); + case PCD_TYPE_DATA: + if (PtrType) { + CopyMem (InternalData, Data, Size); + return EFI_SUCCESS; + } - Status = EfiGetVariable ( - VariableName, - VariableGuid, - NULL, - &Size, - Buffer - ); + switch (Size) { + case sizeof(UINT8): + *((UINT8 *) InternalData) = *((UINT8 *) Data); + return EFI_SUCCESS; - return Status; + case sizeof(UINT16): + *((UINT16 *) InternalData) = *((UINT16 *) Data); + return EFI_SUCCESS; + + case sizeof(UINT32): + *((UINT32 *) InternalData) = *((UINT32 *) Data); + return EFI_SUCCESS; + + case sizeof(UINT64): + *((UINT64 *) InternalData) = *((UINT64 *) Data); + return EFI_SUCCESS; + default: + ASSERT (FALSE); + return EFI_NOT_FOUND; + } + + default: + ASSERT (FALSE); + break; + } + + ASSERT (FALSE); + return EFI_NOT_FOUND; } @@ -448,16 +484,17 @@ SetHiiVariable ( IN UINTN Offset ) { - UINTN Size; - VOID *Buffer; - EFI_STATUS Status; + UINTN Size; + VOID *Buffer; + EFI_STATUS Status; + UINT32 Attribute; Size = 0; Status = EfiGetVariable ( (UINT16 *)VariableName, VariableGuid, - NULL, + &Attribute, &Size, NULL ); @@ -471,7 +508,7 @@ SetHiiVariable ( Status = EfiGetVariable ( VariableName, VariableGuid, - NULL, + &Attribute, &Size, Buffer ); @@ -482,10 +519,67 @@ SetHiiVariable ( return EfiSetVariable ( VariableName, VariableGuid, - 0, + Attribute, Size, Buffer ); } + + + + +VOID +GetExPcdTokenAttributes ( + IN CONST EFI_GUID *Guid, + IN UINT32 ExTokenNumber, + OUT EX_PCD_ENTRY_ATTRIBUTE *ExAttr + ) +{ + UINT32 i; + DYNAMICEX_MAPPING *ExMap; + EFI_GUID *GuidTable; + UINT16 *SizeTable; + + ExMap = gPcdDatabase->PeiDb.Init.ExMapTable; + GuidTable = gPcdDatabase->PeiDb.Init.GuidTable; + SizeTable = gPcdDatabase->PeiDb.Init.SizeTable; + + for (i = 0; i < PEI_EXMAPPING_TABLE_SIZE; i++) { + if ((ExTokenNumber == ExMap[i].ExTokenNumber) && + CompareGuid (Guid, (CONST EFI_GUID *) &GuidTable[ExMap[i].ExGuidIndex]) + ) { + + ExAttr->IsPeiDb = TRUE; + ExAttr->Size = SizeTable[i + PEI_NEX_TOKEN_NUMBER]; + ExAttr->TokenNumber = i + PEI_NEX_TOKEN_NUMBER; + ExAttr->LocalTokenNumberAlias = ExMap[i].LocalTokenNumber; + return; + + } + } + + ExMap = gPcdDatabase->DxeDb.Init.ExMapTable; + GuidTable = gPcdDatabase->DxeDb.Init.GuidTable; + SizeTable = gPcdDatabase->DxeDb.Init.SizeTable; + + for (i = 0; i < DXE_EXMAPPING_TABLE_SIZE; i++) { + if ((ExTokenNumber == ExMap[i].ExTokenNumber) && + CompareGuid (Guid, (CONST EFI_GUID *) &GuidTable[ExMap[i].ExGuidIndex]) + ) { + + ExAttr->IsPeiDb = FALSE; + ExAttr->Size = SizeTable[i + DXE_NEX_TOKEN_NUMBER]; + ExAttr->TokenNumber = i + DXE_NEX_TOKEN_NUMBER; + ExAttr->LocalTokenNumberAlias = ExMap[i].LocalTokenNumber; + return; + + } + } + + ASSERT (FALSE); + + return; +} + -- cgit v1.2.3