EFI_STATUS
EFIAPI
PeimInitializeWinNtStuff (
IN EFI_FFS_FILE_HEADER *FfsHeader,
IN EFI_PEI_SERVICES **PeiServices
)
/*++
Routine Description:
Perform a call-back into the SEC simulator to get NT Stuff
Arguments:
PeiServices - General purpose services available to every PEIM.
Returns:
None
--*/
// TODO: FfsHeader - add argument and description to function comment
{
EFI_STATUS Status;
EFI_PEI_PPI_DESCRIPTOR *PpiDescriptor;
PEI_NT_THUNK_PPI *PeiNtService;
UINT64 InterfaceSize;
EFI_PHYSICAL_ADDRESS InterfaceBase;
Status = (**PeiServices).LocatePpi (
PeiServices,
&gPeiNtThunkPpiGuid, // GUID
0, // INSTANCE
&PpiDescriptor, // EFI_PEI_PPI_DESCRIPTOR
&PeiNtService // PPI
);
ASSERT_PEI_ERROR (PeiServices, Status);
Status = PeiNtService->NtThunk (&InterfaceSize, &InterfaceBase);
ASSERT_PEI_ERROR (PeiServices, Status);
Status = PeiBuildHobGuidData (
PeiServices,
&mEfiPeiWinNtThunkProtocolGuid, // Guid
&InterfaceBase, // Buffer
(UINTN) InterfaceSize // BufferSize
);
return Status;
}
/**
*
* CopyHeapToTempRamAtPost
*
* This function copies BSP heap content to RAM
*
* @param[in,out] StdHeader - Pointer to AMD_CONFIG_PARAMS struct.
*
* @retval AGESA_STATUS
*
*/
AGESA_STATUS
CopyHeapToTempRamAtPost (
IN OUT AMD_CONFIG_PARAMS *StdHeader
)
{
EFI_PEI_SERVICES **PeiServices;
EFI_STATUS Status;
UINT32 SizeOfHeapNode;
UINT32 HeapBaseInCache;
UINT8 *HeapBaseInTempMem;
UINT8 *Source;
UINT8 *Destination;
UINT8 AlignTo16ByteInCache;
UINT32 SizeOfNodeData;
UINT32 TotalSize;
UINT32 HeapInCacheOffset;
HEAP_MANAGER *HeapManagerInCache;
BUFFER_NODE *HeapInCache;
HEAP_MANAGER *HeapManagerInTempMem;
BUFFER_NODE *HeapInTempMem;
BUFFER_NODE *EndNodeInTempMem;
//
// Only BSP is expected to run this routine
//
if (IsBsp (StdHeader)) {
if (StdHeader->HeapStatus != HEAP_LOCAL_CACHE) {
//
// System memory range is out of PEI, we don't have to copy any thing into HOB.
//
return AGESA_UNSUPPORTED;
}
PeiServices = (EFI_PEI_SERVICES **) StdHeader->ImageBasePtr;
Status = EFI_SUCCESS;
HeapInCache = NULL;
HeapManagerInCache = NULL;
SizeOfHeapNode = 0;
TotalSize = sizeof (HEAP_MANAGER);
SizeOfNodeData = 0;
// Heap in cache variables
HeapBaseInCache = (UINT32) StdHeader->HeapBasePtr;
HeapManagerInCache = (HEAP_MANAGER *) HeapBaseInCache;
HeapInCacheOffset = HeapManagerInCache->FirstActiveBufferOffset;
HeapInCache = (BUFFER_NODE*) (HeapBaseInCache + HeapInCacheOffset);
// Heap in temp buffer variables
HeapBaseInTempMem = (UINT8 *) GLOBAL_CPU_UEFI_HOB_LIST_TEMP_ADDR;
HeapManagerInTempMem = (HEAP_MANAGER *) HeapBaseInTempMem;
HeapInTempMem = (BUFFER_NODE *) (HeapBaseInTempMem + TotalSize);
EndNodeInTempMem = HeapInTempMem;
//
// Calculate the whole size of heap that need to transferred.
//
while (HeapInCacheOffset != AMD_HEAP_INVALID_HEAP_OFFSET) {
//
// Copy nodes that will persist in system memory
//
if (HeapInCache->Persist > HEAP_LOCAL_CACHE) {
AlignTo16ByteInCache = HeapInCache->PadSize;
SizeOfNodeData = HeapInCache->BufferSize - AlignTo16ByteInCache;
SizeOfHeapNode = SizeOfNodeData + sizeof (BUFFER_NODE);
TotalSize += SizeOfHeapNode;
//
// Copy heap in cache with 16-byte alignment to temp buffer compactly.
//
Source = (UINT8 *) HeapInCache + sizeof (BUFFER_NODE) + AlignTo16ByteInCache;
Destination = (UINT8 *) HeapInTempMem + sizeof (BUFFER_NODE);
LibAmdMemCopy (HeapInTempMem, HeapInCache, sizeof (BUFFER_NODE), StdHeader);
LibAmdMemCopy (Destination, Source, SizeOfNodeData, StdHeader);
//
// Fix buffer size in temp memory which has no 16-byte alignment.
// Next node offset is the total size used.
//
HeapInTempMem->BufferSize = SizeOfNodeData;
HeapInTempMem->OffsetOfNextNode = TotalSize;
HeapInTempMem->PadSize = 0;
EndNodeInTempMem = HeapInTempMem;
HeapInTempMem = (BUFFER_NODE *) (HeapBaseInTempMem + TotalSize);
}
//
// Point to the next buffer node
//
HeapInCacheOffset = HeapInCache->OffsetOfNextNode;
HeapInCache = (BUFFER_NODE *) (HeapBaseInCache + HeapInCacheOffset);
}
//
// Finalize new heap manager in temp memory
// No free space node is reserved for temp memory.
//
HeapManagerInTempMem->FirstFreeSpaceOffset = AMD_HEAP_INVALID_HEAP_OFFSET;
if (TotalSize == sizeof (HEAP_MANAGER)) {
HeapManagerInTempMem->UsedSize = sizeof (HEAP_MANAGER);
HeapManagerInTempMem->FirstActiveBufferOffset = AMD_HEAP_INVALID_HEAP_OFFSET;
} else {
HeapManagerInTempMem->UsedSize = TotalSize;
HeapManagerInTempMem->FirstActiveBufferOffset = sizeof (HEAP_MANAGER);
//
// Last Node has no next node.
//
EndNodeInTempMem->OffsetOfNextNode = AMD_HEAP_INVALID_HEAP_OFFSET;
}
HeapManagerInCache->Signature = HEAP_SIGNATURE_INVALID;
HeapManagerInTempMem->Signature = HEAP_SIGNATURE_VALID;
//
// Start to copy data into UEFI HOB.
//
Status = PeiBuildHobGuidData (PeiServices, &gAmdHeapHobGuid, HeapBaseInTempMem, (UINTN) TotalSize);
if (EFI_ERROR (Status)) {
return AGESA_ERROR;
}
//
// Update StdHeader with new heap status and base address
//
StdHeader->HeapStatus = HEAP_TEMP_MEM;
StdHeader->HeapBasePtr = HeapGetBaseAddressInTempMem (StdHeader);
}
return AGESA_SUCCESS;
}
EFI_STATUS
PeimInitializeFlashMap (
IN EFI_FFS_FILE_HEADER *FfsHeader,
IN EFI_PEI_SERVICES **PeiServices
)
{
UINTN Index;
EFI_FLASH_AREA_HOB_DATA FlashHobData;
//
// Build flash area entries as GUIDed HOBs.
//
for (Index = 0; Index < NUM_FLASH_AREA_DATA; Index++) {
ZeroMem(&FlashHobData, sizeof (EFI_FLASH_AREA_HOB_DATA));
FlashHobData.AreaType = mFlashAreaData[Index].AreaType;
FlashHobData.NumberOfEntries = 1;
FlashHobData.SubAreaData.Attributes = mFlashAreaData[Index].Attributes;
FlashHobData.SubAreaData.Base = (EFI_PHYSICAL_ADDRESS) (UINTN) mFlashAreaData[Index].Base;
FlashHobData.SubAreaData.Length = (EFI_PHYSICAL_ADDRESS) (UINTN) mFlashAreaData[Index].Length;
switch (FlashHobData.AreaType) {
case EFI_FLASH_AREA_RECOVERY_BIOS:
case EFI_FLASH_AREA_MAIN_BIOS:
CopyMem (
&FlashHobData.AreaTypeGuid,
&mFfsGuid,
sizeof (EFI_GUID)
);
CopyMem (
&FlashHobData.SubAreaData.FileSystem,
&mFvBlockGuid,
sizeof (EFI_GUID)
);
break;
case EFI_FLASH_AREA_GUID_DEFINED:
CopyMem (
&FlashHobData.AreaTypeGuid,
&mSystemDataGuid,
sizeof (EFI_GUID)
);
CopyMem (
&FlashHobData.SubAreaData.FileSystem,
&mFvBlockGuid,
sizeof (EFI_GUID)
);
break;
default:
break;
}
PeiBuildHobGuidData(PeiServices,
&gEfiFlashMapHobGuid,
&FlashHobData,
sizeof (EFI_FLASH_AREA_HOB_DATA)
);
}
return EFI_SUCCESS;
}
