自学教程：C++ GET_GUID_HOB_DATA函数代码示例

/**  This is the entrypoint of PEIM    @param  FileHandle  Handle of the file being invoked.  @param  PeiServices Describes the list of possible PEI Services.  @retval EFI_SUCCESS if it completed successfully.  **/EFI_STATUSEFIAPIPeiInitPlatform (  IN       EFI_PEI_FILE_HANDLE  FileHandle,  IN CONST EFI_PEI_SERVICES     **PeiServices  ){  EFI_STATUS                              Status;  EFI_BOOT_MODE                           BootMode;  EFI_PEI_STALL_PPI                       *StallPpi;  EFI_PEI_PPI_DESCRIPTOR                  *StallPeiPpiDescriptor;     EFI_FV_FILE_INFO                        FileInfo;  EFI_PLATFORM_INFO                       *PlatformInfo;  EFI_HOB_GUID_TYPE                       *GuidHob;  EFI_PLATFORM_TYPE                       PlatformType;  GuidHob = GetFirstGuidHob (&gEfiPlatformInfoGuid);  PlatformInfo  = GET_GUID_HOB_DATA (GuidHob);  ASSERT (PlatformInfo != NULL);  PlatformType = (EFI_PLATFORM_TYPE) PlatformInfo->Type;  //  // Initialize Firmware Volume security.  // This must be done before any firmware volume accesses (excl. BFV)  //  Status = PeiInitializeFvSecurity();  ASSERT_EFI_ERROR (Status);  //  // Allocate an initial buffer from heap for debugger use  //  DEBUG_CODE (    BpeDsAllocation ();  );

/**  Initializes the Intel VTd PMR for DMA buffer.  @retval EFI_SUCCESS            Usb bot driver is successfully initialized.  @retval EFI_OUT_OF_RESOURCES   Can't initialize the driver.**/EFI_STATUSInitVTdPmrForDma (  VOID  ){  EFI_STATUS                  Status;  VOID                        *Hob;  VTD_INFO                    *VTdInfo;  Hob = GetFirstGuidHob (&mVTdInfoGuid);  VTdInfo = GET_GUID_HOB_DATA(Hob);  //  // If there is RMRR memory, parse it here.  //  ParseDmarAcpiTableRmrr (VTdInfo);  //  // Allocate a range in PEI memory as DMA buffer  // Mark others to be DMA protected.  //  Status = InitDmaProtection (VTdInfo);  return Status;}

/**  This function handles S3 resume task at the end of PEI  @param[in] PeiServices    Pointer to PEI Services Table.  @param[in] NotifyDesc     Pointer to the descriptor for the Notification event that                            caused this function to execute.  @param[in] Ppi            Pointer to the PPI data associated with this function.  @retval EFI_STATUS        Always return EFI_SUCCESS**/EFI_STATUSEFIAPIS3EndOfPeiNotify(  IN EFI_PEI_SERVICES          **PeiServices,  IN EFI_PEI_NOTIFY_DESCRIPTOR *NotifyDesc,  IN VOID                      *Ppi  ){  VOID                        *Hob;  VTD_INFO                    *VTdInfo;  UINT64                      EngineMask;  DEBUG((DEBUG_INFO, "VTdPmr S3EndOfPeiNotify/n"));  if ((PcdGet8(PcdVTdPolicyPropertyMask) & BIT1) == 0) {    Hob = GetFirstGuidHob (&mVTdInfoGuid);    if (Hob == NULL) {      return EFI_SUCCESS;    }    VTdInfo = GET_GUID_HOB_DATA(Hob);    EngineMask = LShiftU64 (1, VTdInfo->VTdEngineCount) - 1;    DisableDmaProtection (VTdInfo, EngineMask);  }  return EFI_SUCCESS;}

/**  Initializes the Intel VTd PMR for all memory.  @retval EFI_SUCCESS            Usb bot driver is successfully initialized.  @retval EFI_OUT_OF_RESOURCES   Can't initialize the driver.**/EFI_STATUSInitVTdPmrForAll (  VOID  ){  EFI_STATUS                  Status;  VOID                        *Hob;  VTD_INFO                    *VTdInfo;  UINTN                       LowBottom;  UINTN                       LowTop;  UINTN                       HighBottom;  UINT64                      HighTop;  Hob = GetFirstGuidHob (&mVTdInfoGuid);  VTdInfo = GET_GUID_HOB_DATA(Hob);  LowBottom = 0;  LowTop = 0;  HighBottom = 0;  HighTop = LShiftU64 (1, VTdInfo->HostAddressWidth + 1);  Status = SetDmaProtectedRange (             VTdInfo,             VTdInfo->EngineMask,             (UINT32)LowBottom,             (UINT32)(LowTop - LowBottom),             HighBottom,             HighTop - HighBottom             );  return Status;}

/**  Frees memory that was allocated with AllocateBuffer().  @param  This                  The PPI instance pointer.  @param  Pages                 The number of pages to free.  @param  HostAddress           The base system memory address of the allocated range.  @retval EFI_SUCCESS           The requested memory pages were freed.  @retval EFI_INVALID_PARAMETER The memory range specified by HostAddress and Pages                                was not allocated with AllocateBuffer().  @retval EFI_NOT_AVAILABLE_YET DMA protection has been enabled, but DMA buffer are                                not available to be allocated yet.**/EFI_STATUSEFIAPIPeiIoMmuFreeBuffer (  IN  EDKII_IOMMU_PPI                          *This,  IN  UINTN                                    Pages,  IN  VOID                                     *HostAddress  ){  UINTN                       Length;  VOID                        *Hob;  DMA_BUFFER_INFO             *DmaBufferInfo;  Hob = GetFirstGuidHob (&mDmaBufferInfoGuid);  DmaBufferInfo = GET_GUID_HOB_DATA(Hob);  DEBUG ((DEBUG_VERBOSE, "PeiIoMmuFreeBuffer - page - %x, HostAddr - %x/n", Pages, HostAddress));  DEBUG ((DEBUG_VERBOSE, "  DmaBufferCurrentTop - %x/n", DmaBufferInfo->DmaBufferCurrentTop));  DEBUG ((DEBUG_VERBOSE, "  DmaBufferCurrentBottom - %x/n", DmaBufferInfo->DmaBufferCurrentBottom));  if (DmaBufferInfo->DmaBufferCurrentTop == 0) {    return EFI_NOT_AVAILABLE_YET;  }  Length = EFI_PAGES_TO_SIZE(Pages);  if ((UINTN)HostAddress == DmaBufferInfo->DmaBufferCurrentTop) {    DmaBufferInfo->DmaBufferCurrentTop += Length;  }  return EFI_SUCCESS;}

//// Initialization//EFI_STATUSEFIAPIInitializePnvDxe (  IN EFI_HANDLE           ImageHandle,  IN EFI_SYSTEM_TABLE     *SystemTable  ){  VOID                           *Hob;  VOID                           *DeviceTreeBase;  EFI_STATUS                     Status;  //  // Recover the DeviceTree HOB and install it in the configuration table  //  Hob = GetFirstGuidHob(&gFdtHobGuid);  if (Hob == NULL || GET_GUID_HOB_DATA_SIZE (Hob) != sizeof (UINT64)) {    DEBUG ((EFI_D_ERROR, "%a: No FDT HOB found/n", __FUNCTION__));    return EFI_NOT_FOUND;  }  DeviceTreeBase = (VOID *)(UINTN)*(UINT64 *)GET_GUID_HOB_DATA (Hob);  if (fdt_check_header (DeviceTreeBase) != 0) {    DEBUG ((EFI_D_ERROR, "%a: DTB Invalid @ 0x%p/n", __FUNCTION__, DeviceTreeBase));    return EFI_NOT_FOUND;  }  Status = gBS->InstallConfigurationTable (&gFdtTableGuid, DeviceTreeBase);  ASSERT_EFI_ERROR (Status);    DEBUG ((EFI_D_INFO, "%a: DTB @ 0x%p/n", __FUNCTION__, DeviceTreeBase));  return EFI_SUCCESS;}

/**  Process FSP HOB list  @param[in] FspHobList  Pointer to the HOB data structure produced by FSP.**/VOIDProcessFspHobList (  IN VOID                 *FspHobList  ){  EFI_PEI_HOB_POINTERS  FspHob;  FspHob.Raw = FspHobList;  //  // Add all the HOBs from FSP binary to FSP wrapper  //  while (!END_OF_HOB_LIST (FspHob)) {    if (FspHob.Header->HobType == EFI_HOB_TYPE_GUID_EXTENSION) {      //      // Skip FSP binary creates PcdDataBaseHobGuid      //      if (!CompareGuid(&FspHob.Guid->Name, &gPcdDataBaseHobGuid)) {         BuildGuidDataHob (          &FspHob.Guid->Name,          GET_GUID_HOB_DATA(FspHob),          GET_GUID_HOB_DATA_SIZE(FspHob)        );      }    }    FspHob.Raw = GET_NEXT_HOB (FspHob);  }}

EFI_STATUSPlatformHobCreateFromFsp (  IN CONST EFI_PEI_SERVICES     **PeiServices,  VOID                          *HobList  ){  VOID       *HobData;  VOID       *NewHobData;  UINTN      DataSize;  //  // Other hob, todo: put this into FspWrapPlatformLib  //  if ((HobList = GetNextGuidHob (&gEfiMemoryConfigDataGuid, HobList)) != NULL) {    HobData = GET_GUID_HOB_DATA (HobList);    DataSize = GET_GUID_HOB_DATA_SIZE(HobList);    DEBUG((EFI_D_ERROR, "gEfiMemoryConfigDataGuid Hob found: 0x%x./n", DataSize));    NewHobData = BuildGuidHob (&gEfiMemoryConfigDataGuid, DataSize);    (*PeiServices)->CopyMem (                      NewHobData,                      HobData,                      DataSize                      );  }  return EFI_SUCCESS;}

EFI_STATUSGetPlatformInfoHob (  IN CONST EFI_PEI_SERVICES           **PeiServices,  OUT EFI_PLATFORM_INFO_HOB     **PlatformInfoHob  ){  EFI_PEI_HOB_POINTERS        GuidHob;  //  // Find the PlatformInfo HOB  //  GuidHob.Raw = GetHobList ();  if (GuidHob.Raw == NULL) {    return EFI_NOT_FOUND;  }  if ((GuidHob.Raw = GetNextGuidHob (&gEfiPlatformInfoGuid, GuidHob.Raw)) != NULL) {    *PlatformInfoHob = GET_GUID_HOB_DATA (GuidHob.Guid);  }  //  // PlatformInfo PEIM should provide this HOB data, if not ASSERT and return error.  //  ASSERT (*PlatformInfoHob != NULL);  if (!(*PlatformInfoHob)) {    return EFI_NOT_FOUND;  }  return EFI_SUCCESS;}

//// Return list of cores in the system//EFI_STATUSPrePeiCoreGetMpCoreInfo (  OUT UINTN                   *ArmCoreCount,  OUT ARM_CORE_INFO           **ArmCoreInfoTable  ){  EFI_PEI_HOB_POINTERS    Hob;  if (ArmIsMpCore()) {    // Iterate through the HOBs and find if there is ARM PROCESSOR ENTRY HOB    for (Hob.Raw = GetHobList (); !END_OF_HOB_LIST(Hob); Hob.Raw = GET_NEXT_HOB(Hob)) {      // Check for Correct HOB type      if ((GET_HOB_TYPE (Hob)) == EFI_HOB_TYPE_GUID_EXTENSION) {        // Check for correct GUID type        if (CompareGuid(&(Hob.Guid->Name), &gAmdStyxMpCoreInfoGuid)) {          *ArmCoreInfoTable = (ARM_CORE_INFO *) GET_GUID_HOB_DATA(Hob);          *ArmCoreCount = GET_GUID_HOB_DATA_SIZE(Hob)/sizeof(ARM_CORE_INFO);          return EFI_SUCCESS;        }      }    }  }  return EFI_UNSUPPORTED;}

/**  Init SMM communication context.**/VOIDInitCommunicationContext (  VOID  ){  EFI_SMRAM_DESCRIPTOR                          *SmramDescriptor;  SMM_S3_RESUME_STATE                           *SmmS3ResumeState;  VOID                                          *GuidHob;  EFI_SMM_COMMUNICATION_CONTEXT                 *SmmCommunicationContext;  GuidHob = GetFirstGuidHob (&gEfiAcpiVariableGuid);  ASSERT (GuidHob != NULL);  SmramDescriptor = (EFI_SMRAM_DESCRIPTOR *) GET_GUID_HOB_DATA (GuidHob);  SmmS3ResumeState = (SMM_S3_RESUME_STATE *)(UINTN)SmramDescriptor->CpuStart;  DEBUG ((EFI_D_INFO, "InitCommunicationContext - SmmS3ResumeState: %x/n", SmmS3ResumeState));  DEBUG ((EFI_D_INFO, "InitCommunicationContext - Smst: %x/n", SmmS3ResumeState->Smst));    SmmCommunicationContext = (EFI_SMM_COMMUNICATION_CONTEXT *)InternalSmstGetVendorTableByGuid (                                                               SmmS3ResumeState->Signature,                                                               (EFI_SMM_SYSTEM_TABLE2 *)(UINTN)SmmS3ResumeState->Smst,                                                               &gEfiPeiSmmCommunicationPpiGuid                                                               );  ASSERT (SmmCommunicationContext != NULL);  SetCommunicationContext (SmmCommunicationContext);  return ;}

/**  Worker function to parse CPU BIST information from Guided HOB.  @param[out] StructureSize     Pointer to the variable describing size of the input buffer.  @param[out] StructureBuffer   Pointer to the buffer save CPU BIST information.  @retval EFI_SUCCESS           The data was successfully returned.  @retval EFI_BUFFER_TOO_SMALL  The buffer was too small.**/EFI_STATUSGetBistFromHob (  IN OUT UINT64           *StructureSize,  IN OUT VOID             *StructureBuffer  ){  EFI_HOB_GUID_TYPE       *GuidHob;  VOID                    *DataInHob;  UINTN                   DataSize;  GuidHob = GetFirstGuidHob (&gEfiCallerIdGuid);  if (GuidHob == NULL) {    *StructureSize = 0;    return EFI_SUCCESS;  }  DataInHob = GET_GUID_HOB_DATA (GuidHob);  DataSize  = GET_GUID_HOB_DATA_SIZE (GuidHob);  //  // return the information from BistHob  //  if ((*StructureSize) < (UINT64) DataSize) {    *StructureSize = (UINT64) DataSize;    return EFI_BUFFER_TOO_SMALL;  }  *StructureSize = (UINT64) DataSize;  CopyMem (StructureBuffer, DataInHob, DataSize);  return EFI_SUCCESS;}

/**  Remove a previously registered callback function from the notification list.  ReportStatusCode() messages will no longer be forwarded to the Callback function.  @param[in] Callback           A pointer to a function of type EFI_PEI_RSC_HANDLER_CALLBACK that is to be                                unregistered.  @retval EFI_SUCCESS           The function was successfully unregistered.  @retval EFI_INVALID_PARAMETER The callback function was NULL.  @retval EFI_NOT_FOUND         The callback function was not found to be unregistered.**/EFI_STATUSEFIAPIUnregister (  IN EFI_PEI_RSC_HANDLER_CALLBACK Callback  ){  EFI_PEI_HOB_POINTERS            Hob;  EFI_PEI_RSC_HANDLER_CALLBACK    *CallbackEntry;  UINTN                           *NumberOfEntries;  UINTN                           Index;  if (Callback == NULL) {    return EFI_INVALID_PARAMETER;  }  Hob.Raw  = GetFirstGuidHob (&gStatusCodeCallbackGuid);  while (Hob.Raw != NULL) {    NumberOfEntries = GET_GUID_HOB_DATA (Hob);    CallbackEntry   = (EFI_PEI_RSC_HANDLER_CALLBACK *) (NumberOfEntries + 1);    for (Index = 0; Index < *NumberOfEntries; Index++) {      if (CallbackEntry[Index] == Callback) {        //        // Set removed entry as NULL.        //        CallbackEntry[Index] = NULL;        return EFI_SUCCESS;      }    }    Hob.Raw = GET_NEXT_HOB (Hob);    Hob.Raw = GetNextGuidHob (&gStatusCodeCallbackGuid, Hob.Raw);  }  return EFI_NOT_FOUND;}

int fill_lb_framebuffer(struct lb_framebuffer *framebuffer){	VOID *hob_list_ptr;	hob_list_ptr = get_hob_list();	const EFI_GUID vbt_guid = EFI_PEI_GRAPHICS_INFO_HOB_GUID;	u32 *vbt_hob;	EFI_PEI_GRAPHICS_INFO_HOB *vbt_gop;	vbt_hob = get_next_guid_hob(&vbt_guid, hob_list_ptr);	if (vbt_hob == NULL) {		printk(BIOS_ERR, "FSP_ERR: Graphics Data HOB is not present/n");		return -1;	}	printk(BIOS_DEBUG, "FSP_DEBUG: Graphics Data HOB present/n");	vbt_gop = GET_GUID_HOB_DATA(vbt_hob);	framebuffer->physical_address = vbt_gop->FrameBufferBase;	framebuffer->x_resolution = vbt_gop->GraphicsMode.HorizontalResolution;	framebuffer->y_resolution = vbt_gop->GraphicsMode.VerticalResolution;	framebuffer->bytes_per_line = vbt_gop->GraphicsMode.PixelsPerScanLine		* 4;	framebuffer->bits_per_pixel = 32;	framebuffer->red_mask_pos = 16;	framebuffer->red_mask_size = 8;	framebuffer->green_mask_pos = 8;	framebuffer->green_mask_size = 8;	framebuffer->blue_mask_pos = 0;	framebuffer->blue_mask_size = 8;	framebuffer->reserved_mask_pos = 24;	framebuffer->reserved_mask_size = 8;	return 0;}

/**  Worker function to get CPU_FEATURES_DATA pointer.  @return Pointer to CPU_FEATURES_DATA.**/CPU_FEATURES_DATA *GetCpuFeaturesData (  VOID  ){  CPU_FEATURES_DATA       *CpuInitData;  EFI_HOB_GUID_TYPE       *GuidHob;  VOID                    *DataInHob;  UINT64                  Data64;  CpuInitData = NULL;  GuidHob = GetFirstGuidHob (&mRegisterCpuFeaturesHobGuid);  if (GuidHob != NULL) {    DataInHob = GET_GUID_HOB_DATA (GuidHob);    CpuInitData = (CPU_FEATURES_DATA *) (*(UINTN *) DataInHob);    ASSERT (CpuInitData != NULL);  } else {    CpuInitData = AllocateZeroPool (sizeof (CPU_FEATURES_DATA));    ASSERT (CpuInitData != NULL);    //    // Build location of CPU MP DATA buffer in HOB    //    Data64 = (UINT64) (UINTN) CpuInitData;    BuildGuidDataHob (      &mRegisterCpuFeaturesHobGuid,      (VOID *) &Data64,      sizeof (UINT64)      );  }  return CpuInitData;}

/**  Implementation of the PlatformInformation2 service in EFI_SEC_PLATFORM_INFORMATION2_PPI.  @param  PeiServices                The pointer to the PEI Services Table.  @param  StructureSize              The pointer to the variable describing size of the input buffer.  @param  PlatformInformationRecord2 The pointer to the EFI_SEC_PLATFORM_INFORMATION_RECORD2.  @retval EFI_SUCCESS                The data was successfully returned.  @retval EFI_BUFFER_TOO_SMALL       The buffer was too small. The current buffer size needed to                                     hold the record is returned in StructureSize.**/EFI_STATUSEFIAPISecPlatformInformation2 (  IN CONST EFI_PEI_SERVICES                   **PeiServices,  IN OUT UINT64                               *StructureSize,     OUT EFI_SEC_PLATFORM_INFORMATION_RECORD2 *PlatformInformationRecord2  ){  EFI_HOB_GUID_TYPE       *GuidHob;  VOID                    *DataInHob;  UINTN                   DataSize;  GuidHob = GetFirstGuidHob (&gEfiSecPlatformInformation2PpiGuid);  if (GuidHob == NULL) {    *StructureSize = 0;    return EFI_SUCCESS;  }  DataInHob = GET_GUID_HOB_DATA (GuidHob);  DataSize  = GET_GUID_HOB_DATA_SIZE (GuidHob);  //  // return the information from BistHob  //  if ((*StructureSize) < (UINT64) DataSize) {    *StructureSize = (UINT64) DataSize;    return EFI_BUFFER_TOO_SMALL;  }  *StructureSize = (UINT64) DataSize;  CopyMem (PlatformInformationRecord2, DataInHob, DataSize);  return EFI_SUCCESS;}

/* *  Save the FSP memory HOB (mrc data) to the MRC area in CBMEM */int save_mrc_data(void *hob_start){	u32 *mrc_hob;	u32 *mrc_hob_data;	u32 mrc_hob_size;	struct mrc_data_container *mrc_data;	int output_len;	const EFI_GUID mrc_guid = FSP_NON_VOLATILE_STORAGE_HOB_GUID;	mrc_hob = get_next_guid_hob(&mrc_guid, hob_start);	if (mrc_hob == NULL) {		printk(BIOS_DEBUG,			"Memory Configure Data Hob is not present/n");		return 0;	}	mrc_hob_data = GET_GUID_HOB_DATA(mrc_hob);	mrc_hob_size = (u32) GET_HOB_LENGTH(mrc_hob);	printk(BIOS_DEBUG, "Memory Configure Data Hob at %p (size = 0x%x)./n",			(void *)mrc_hob_data, mrc_hob_size);	output_len = ALIGN(mrc_hob_size, 16);	/* Save the MRC S3/fast boot/ADR restore data to cbmem */	mrc_data = cbmem_add(CBMEM_ID_MRCDATA,			output_len + sizeof(struct mrc_data_container));	/* Just return if there was a problem with getting CBMEM */	if (mrc_data == NULL) {		printk(BIOS_WARNING,			"CBMEM was not available to save the fast boot cache data./n");		return 0;	}	printk(BIOS_DEBUG,		"Copy FSP MRC DATA to HOB (source addr %p, dest addr %p, %u bytes)/n",		(void *)mrc_hob_data, mrc_data, output_len);	mrc_data->mrc_signature = MRC_DATA_SIGNATURE;	mrc_data->mrc_data_size = output_len;	mrc_data->reserved = 0;	memcpy(mrc_data->mrc_data, (const void *)mrc_hob_data, mrc_hob_size);	/* Zero the unused space in aligned buffer. */	if (output_len > mrc_hob_size)		memset((mrc_data->mrc_data + mrc_hob_size), 0,				output_len - mrc_hob_size);	mrc_data->mrc_checksum = compute_ip_checksum(mrc_data->mrc_data,			mrc_data->mrc_data_size);#if IS_ENABLED(CONFIG_DISPLAY_FAST_BOOT_DATA)	printk(BIOS_SPEW, "Fast boot data (includes align and checksum):/n");	hexdump32(BIOS_SPEW, (void *)mrc_data->mrc_data, output_len);#endif	return 1;}

/**  Dumps all the PEI performance log to DXE performance gauge array.  This internal function dumps all the PEI performance log to the DXE performance gauge array.  It retrieves the optional GUID HOB for PEI performance and then saves the performance data  to DXE performance data structures.**/VOIDInternalGetPeiPerformance (  VOID  ){  EFI_HOB_GUID_TYPE                 *GuidHob;  PEI_PERFORMANCE_LOG_HEADER        *LogHob;  PEI_PERFORMANCE_LOG_ENTRY         *LogEntryArray;  UINT32                            *LogIdArray;  GAUGE_DATA_ENTRY_EX               *GaugeEntryExArray;  UINT32                            Index;  UINT32                            NumberOfEntries;  NumberOfEntries = 0;  GaugeEntryExArray = (GAUGE_DATA_ENTRY_EX *) (mGaugeData + 1);  //  // Dump PEI Log Entries to DXE Guage Data structure.  //  GuidHob = GetFirstGuidHob (&gPerformanceProtocolGuid);  if (GuidHob != NULL) {    LogHob          = GET_GUID_HOB_DATA (GuidHob);    LogEntryArray   = (PEI_PERFORMANCE_LOG_ENTRY *) (LogHob + 1);    NumberOfEntries = LogHob->NumberOfEntries;    for (Index = 0; Index < NumberOfEntries; Index++) {      GaugeEntryExArray[Index].Handle         = LogEntryArray[Index].Handle;      AsciiStrCpyS (GaugeEntryExArray[Index].Token,  DXE_PERFORMANCE_STRING_SIZE, LogEntryArray[Index].Token);      AsciiStrCpyS (GaugeEntryExArray[Index].Module, DXE_PERFORMANCE_STRING_SIZE, LogEntryArray[Index].Module);      GaugeEntryExArray[Index].StartTimeStamp = LogEntryArray[Index].StartTimeStamp;      GaugeEntryExArray[Index].EndTimeStamp   = LogEntryArray[Index].EndTimeStamp;      GaugeEntryExArray[Index].Identifier     = 0;    }    GuidHob = GetFirstGuidHob (&gPerformanceExProtocolGuid);    if (GuidHob != NULL) {      LogIdArray    = GET_GUID_HOB_DATA (GuidHob);      for (Index = 0; Index < NumberOfEntries; Index++) {        GaugeEntryExArray[Index].Identifier   = LogIdArray[Index];      }    }  }  mGaugeData->NumberOfEntries = NumberOfEntries;}

/**************************************************************************** 函 数 名  : SaveMemoryConfigDxeEntry 功能描述  : 读取Memory相关配置hob数据，存入Flash 输入参数  : IN EFI_HANDLE         ImageHandle,             IN EFI_SYSTEM_TABLE  *SystemTable 输出参数  : 无 返 回 值  : EFI_STATUS 修改历史  : 1.日    期   : 2014年12月18日  作    者   : l00228991  修改内容   : 新生成函数****************************************************************************/EFI_STATUSEFIAPI SaveMemoryConfigDxeEntry (  IN EFI_HANDLE         ImageHandle,  IN EFI_SYSTEM_TABLE  *SystemTable){    EFI_STATUS      Status = EFI_SUCCESS;    NVRAM           *Nvram;    GBL_DATA        *Gbl_Data;    SPI_FLASH_PROTOCOL        *Flash;    VOID*           HobList;    UINT32          NvramCrc;        HobList = GetHobList();    Gbl_Data = (GBL_DATA*)GetNextGuidHob(&gEfiMemoryMapGuid, HobList);    Gbl_Data = GET_GUID_HOB_DATA(Gbl_Data);    Nvram = &(Gbl_Data->nvram);    Status = gBS->CalculateCrc32(((UINT8 *)Nvram+sizeof(UINT32)),(sizeof(NVRAM)-sizeof(UINT32)),&NvramCrc);    if(EFI_ERROR(Status))    {        DEBUG((EFI_D_ERROR,"Nvram CalculateCrc32 Failed/n"));        return Status;    }        if( Nvram->NvramCrc != NvramCrc)    {        Nvram->NvramCrc = NvramCrc;                Status = gBS->LocateProtocol (&gSpiFlashProtocolGuid, NULL, (VOID *) &Flash);        if (EFI_ERROR(Status))        {            DEBUG((EFI_D_ERROR, "%a - %d Status=%r/n", __FILE__, __LINE__, Status));            return Status;        }                Status = Flash->Erase(Flash,NVRAM_ADDR,sizeof(NVRAM));        if (EFI_ERROR(Status))        {            DEBUG((EFI_D_ERROR, "%a - %d SpiFlash Erase Error,Status=%r/n", __FILE__, __LINE__,Status));            return Status;        }        Status = Flash->Write(Flash, NVRAM_ADDR, (UINT8*)(Nvram), sizeof(NVRAM));        if (EFI_ERROR(Status))        {            DEBUG((EFI_D_ERROR, "%a - %d Flash Write Error,Status=%r/n", __FILE__, __LINE__,Status));            return Status;        }    }    return EFI_SUCCESS;}

UINT64GetPciExpressBaseAddressForRootBridge (  IN UINTN    HostBridgeNumber,  IN UINTN    RootBridgeNumber  )/*++Routine Description:  This routine is to get PciExpress Base Address for this RootBridgeArguments:  HostBridgeNumber - The number of HostBridge  RootBridgeNumber - The number of RootBridge    Returns:  UINT64 - PciExpressBaseAddress for this HostBridge and RootBridge--*/{  EFI_PCI_EXPRESS_BASE_ADDRESS_INFORMATION *PciExpressBaseAddressInfo;  UINTN                                    BufferSize;  UINT32                                   Index;  UINT32                                   Number;  EFI_PEI_HOB_POINTERS                     GuidHob;  //  // Get PciExpressAddressInfo Hob  //  PciExpressBaseAddressInfo = NULL;  BufferSize                = 0;  GuidHob.Raw = GetFirstGuidHob (&gEfiPciExpressBaseAddressGuid);  if (GuidHob.Raw != NULL) {    PciExpressBaseAddressInfo = GET_GUID_HOB_DATA (GuidHob.Guid);    BufferSize                = GET_GUID_HOB_DATA_SIZE (GuidHob.Guid);  } else {    return 0;  }  //  // Search the PciExpress Base Address in the Hob for current RootBridge  //  Number = (UINT32)(BufferSize / sizeof(EFI_PCI_EXPRESS_BASE_ADDRESS_INFORMATION));  for (Index = 0; Index < Number; Index++) {    if ((PciExpressBaseAddressInfo[Index].HostBridgeNumber == HostBridgeNumber) &&        (PciExpressBaseAddressInfo[Index].RootBridgeNumber == RootBridgeNumber)) {      return PciExpressBaseAddressInfo[Index].PciExpressBaseAddress;    }  }  //  // Do not find the PciExpress Base Address in the Hob  //  return 0;}

/**  Gets the GUID HOB for PEI performance.  This internal function searches for the GUID HOB for PEI performance.  If that GUID HOB is not found, it will build a new one.  It outputs the data area of that GUID HOB to record performance log.  @param    PeiPerformanceLog           Pointer to Pointer to PEI performance log header.  @param    PeiPerformanceIdArray       Pointer to Pointer to PEI performance identifier array.**/VOIDInternalGetPerformanceHobLog (  OUT PEI_PERFORMANCE_LOG_HEADER    **PeiPerformanceLog,  OUT UINT32                        **PeiPerformanceIdArray  ){  EFI_HOB_GUID_TYPE           *GuidHob;  UINTN                       PeiPerformanceSize;  UINT16                      PeiPerformanceLogEntries;  ASSERT (PeiPerformanceLog != NULL);  ASSERT (PeiPerformanceIdArray != NULL);  PeiPerformanceLogEntries = (UINT16) (PcdGet16 (PcdMaxPeiPerformanceLogEntries16) != 0 ?                                       PcdGet16 (PcdMaxPeiPerformanceLogEntries16) :                                       PcdGet8 (PcdMaxPeiPerformanceLogEntries));  GuidHob = GetFirstGuidHob (&gPerformanceProtocolGuid);  if (GuidHob != NULL) {    //    // PEI Performance HOB was found, then return the existing one.    //    *PeiPerformanceLog = GET_GUID_HOB_DATA (GuidHob);    GuidHob = GetFirstGuidHob (&gPerformanceExProtocolGuid);    ASSERT (GuidHob != NULL);    *PeiPerformanceIdArray = GET_GUID_HOB_DATA (GuidHob);  } else {    //    // PEI Performance HOB was not found, then build one.    //    PeiPerformanceSize     = sizeof (PEI_PERFORMANCE_LOG_HEADER) +                             sizeof (PEI_PERFORMANCE_LOG_ENTRY) * PeiPerformanceLogEntries;    *PeiPerformanceLog     = BuildGuidHob (&gPerformanceProtocolGuid, PeiPerformanceSize);    *PeiPerformanceLog     = ZeroMem (*PeiPerformanceLog, PeiPerformanceSize);    PeiPerformanceSize     = sizeof (UINT32) * PeiPerformanceLogEntries;    *PeiPerformanceIdArray = BuildGuidHob (&gPerformanceExProtocolGuid, PeiPerformanceSize);    *PeiPerformanceIdArray = ZeroMem (*PeiPerformanceIdArray, PeiPerformanceSize);  }}

/**  Completes the Map() operation and releases any corresponding resources.  @param  This                  The PPI instance pointer.  @param  Mapping               The mapping value returned from Map().  @retval EFI_SUCCESS           The range was unmapped.  @retval EFI_INVALID_PARAMETER Mapping is not a value that was returned by Map().  @retval EFI_DEVICE_ERROR      The data was not committed to the target system memory.  @retval EFI_NOT_AVAILABLE_YET DMA protection has been enabled, but DMA buffer are                                not available to be allocated yet.**/EFI_STATUSEFIAPIPeiIoMmuUnmap (  IN  EDKII_IOMMU_PPI                          *This,  IN  VOID                                     *Mapping  ){  MAP_INFO                    *MapInfo;  UINTN                       Length;  VOID                        *Hob;  DMA_BUFFER_INFO             *DmaBufferInfo;  Hob = GetFirstGuidHob (&mDmaBufferInfoGuid);  DmaBufferInfo = GET_GUID_HOB_DATA(Hob);  DEBUG ((DEBUG_VERBOSE, "PeiIoMmuUnmap - Mapping - %x/n", Mapping));  DEBUG ((DEBUG_VERBOSE, "  DmaBufferCurrentTop - %x/n", DmaBufferInfo->DmaBufferCurrentTop));  DEBUG ((DEBUG_VERBOSE, "  DmaBufferCurrentBottom - %x/n", DmaBufferInfo->DmaBufferCurrentBottom));  if (DmaBufferInfo->DmaBufferCurrentTop == 0) {    return EFI_NOT_AVAILABLE_YET;  }  if (Mapping == NULL) {    return EFI_SUCCESS;  }  MapInfo = Mapping;  ASSERT (MapInfo->Signature == MAP_INFO_SIGNATURE);  DEBUG ((DEBUG_VERBOSE, "  Op(%x):DeviceAddress - %x, NumberOfBytes - %x/n", MapInfo->Operation, (UINTN)MapInfo->DeviceAddress, MapInfo->NumberOfBytes));  //  // If this is a write operation from the Bus Master's point of view,  // then copy the contents of the mapped buffer into the real buffer  // so the processor can read the contents of the real buffer.  //  if (MapInfo->Operation == EdkiiIoMmuOperationBusMasterWrite ||      MapInfo->Operation == EdkiiIoMmuOperationBusMasterWrite64) {    CopyMem (      (VOID *) (UINTN) MapInfo->HostAddress,      (VOID *) (UINTN) MapInfo->DeviceAddress,      MapInfo->NumberOfBytes      );  }  Length = MapInfo->NumberOfBytes + sizeof(MAP_INFO);  if (DmaBufferInfo->DmaBufferCurrentBottom == MapInfo->DeviceAddress + Length) {    DmaBufferInfo->DmaBufferCurrentBottom -= Length;  }  return EFI_SUCCESS;}

/**  Get the location of Mailbox pointer from the GUIDed HOB.  @return Pointer to the location saved Mailbox pointer.**/UINT64 *GetMailboxLocationFromHob (  VOID  ){  EFI_HOB_GUID_TYPE        *GuidHob;  GuidHob = GetFirstGuidHob (&gEfiDebugAgentGuid);  if (GuidHob == NULL) {    return NULL;  }  return (UINT64 *) (GET_GUID_HOB_DATA(GuidHob));}

/**  Get the pointer to Mailbox from the GUIDed HOB.  @param[in]  HobStart      The starting HOB pointer to search from.  @return Pointer to Mailbox.**/DEBUG_AGENT_MAILBOX *GetMailboxFromHob (  IN VOID                  *HobStart  ){  EFI_HOB_GUID_TYPE        *GuidHob;  GuidHob = GetNextGuidHob (&gEfiDebugAgentGuid, HobStart);  if (GuidHob == NULL) {    return NULL;  }  return (DEBUG_AGENT_MAILBOX *) (GET_GUID_HOB_DATA(GuidHob));}

/**  Invoke the callback function when dynamic PCD entry was set, if this PCD entry   has registered callback function.  @param ExTokenNumber   DynamicEx PCD's token number, if this PCD entry is dyanmicEx                         type PCD.  @param Guid            DynamicEx PCD's guid, if this PCD entry is dynamicEx type                         PCD.  @param TokenNumber     PCD token number generated by build tools.  @param Data            Value want to be set for this PCD entry  @param Size            The size of value**/VOIDInvokeCallbackOnSet (  UINTN             ExTokenNumber,  CONST EFI_GUID    *Guid, OPTIONAL  UINTN             TokenNumber,  VOID              *Data,  UINTN             Size  ){  EFI_HOB_GUID_TYPE   *GuidHob;  PCD_PPI_CALLBACK    *CallbackTable;  UINTN               Idx;  PEI_PCD_DATABASE    *PeiPcdDb;  UINT32              LocalTokenCount;  //  // TokenNumber Zero is reserved as PCD_INVALID_TOKEN_NUMBER.  // We have to decrement TokenNumber by 1 to make it usable  // as the array index.  //  TokenNumber--;  PeiPcdDb        = GetPcdDatabase ();  LocalTokenCount = PeiPcdDb->LocalTokenCount;  if (Guid == NULL) {    // EBC compiler is very choosy. It may report warning about comparison    // between UINTN and 0 . So we add 1 in each size of the     // comparison.    ASSERT (TokenNumber + 1 < (LocalTokenCount + 1));  }  GuidHob = GetFirstGuidHob (&gEfiCallerIdGuid);  ASSERT (GuidHob != NULL);    CallbackTable = GET_GUID_HOB_DATA (GuidHob);  CallbackTable += (TokenNumber * PcdGet32 (PcdMaxPeiPcdCallBackNumberPerPcdEntry));  for (Idx = 0; Idx < PcdGet32 (PcdMaxPeiPcdCallBackNumberPerPcdEntry); Idx++) {    if (CallbackTable[Idx] != NULL) {      CallbackTable[Idx] (Guid,                          (Guid == NULL) ? (TokenNumber + 1) : ExTokenNumber,                          Data,                          Size                          );    }  }}

/**  Get SMM communication context.  @return SMM communication context.**/EFI_SMM_COMMUNICATION_CONTEXT *GetCommunicationContext (  VOID  ){  EFI_HOB_GUID_TYPE                *GuidHob;  EFI_SMM_COMMUNICATION_CONTEXT    *SmmCommunicationContext;  GuidHob = GetFirstGuidHob (&gEfiPeiSmmCommunicationPpiGuid);  ASSERT (GuidHob != NULL);  SmmCommunicationContext = (EFI_SMM_COMMUNICATION_CONTEXT *)GET_GUID_HOB_DATA (GuidHob);  return SmmCommunicationContext;}

EFI_STATUSXenHyperpageInit (  IN OUT XENBUS_DEVICE *Dev  ){  EFI_HOB_GUID_TYPE   *GuidHob;  EFI_XEN_INFO        *XenInfo;  GuidHob = GetFirstGuidHob (&gEfiXenInfoGuid);  if (GuidHob == NULL) {    return EFI_NOT_FOUND;  }  XenInfo = (EFI_XEN_INFO *) GET_GUID_HOB_DATA (GuidHob);  Dev->Hyperpage = XenInfo->HyperPages;  return EFI_SUCCESS;}

/**  Report status code into GUID'ed HOB.  This function reports status code into GUID'ed HOB. If not all packets are full, then  write status code into available entry. Otherwise, create a new packet for it.  @param  CodeType         Indicates the type of status code being reported.  @param  Value            Describes the current status of a hardware or                           software entity. This includes information about the class and                           subclass that is used to classify the entity as well as an operation.                           For progress codes, the operation is the current activity.                           For error codes, it is the exception.For debug codes,it is not defined at this time.  @param  Instance         The enumeration of a hardware or software entity within                           the system. A system may contain multiple entities that match a class/subclass                           pairing. The instance differentiates between them. An instance of 0 indicates                           that instance information is unavailable, not meaningful, or not relevant.                           Valid instance numbers start with 1.  @retval EFI_SUCCESS      The function always return EFI_SUCCESS.**/EFI_STATUSMemoryStatusCodeReportWorker (  IN EFI_STATUS_CODE_TYPE     CodeType,  IN EFI_STATUS_CODE_VALUE    Value,  IN UINT32                   Instance  ){  EFI_PEI_HOB_POINTERS              Hob;  MEMORY_STATUSCODE_PACKET_HEADER   *PacketHeader;  MEMORY_STATUSCODE_RECORD          *Record;  //  // Find GUID'ed HOBs to locate current record buffer.   //  Hob.Raw = GetFirstGuidHob (&gMemoryStatusCodeRecordGuid);  ASSERT (Hob.Raw != NULL);  PacketHeader = (MEMORY_STATUSCODE_PACKET_HEADER *) GET_GUID_HOB_DATA (Hob.Guid);  Record = (MEMORY_STATUSCODE_RECORD *) (PacketHeader + 1);  Record = &Record[PacketHeader->RecordIndex++];  //  // Save status code.  //  Record->CodeType = CodeType;  Record->Instance = Instance;  Record->Value    = Value;  //  // If record index equals to max record number, then wrap around record index to zero.  //  // The reader of status code should compare the number of records with max records number,  // If it is equal to or larger than the max number, then the wrap-around had happened,  // so the first record is pointed by record index.  // If it is less then max number, index of the first record is zero.  //  if (PacketHeader->RecordIndex == PacketHeader->MaxRecordsNumber) {    //    // Wrap around record index.    //    PacketHeader->RecordIndex = 0;    PacketHeader->PacketIndex ++;  }  return EFI_SUCCESS;}