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; }