/** Do FSP initialization. @return FSP initialization status. **/ EFI_STATUS FspsWrapperInit ( VOID ) { EFI_STATUS Status; EFI_BOOT_MODE BootMode; // // Register MemoryDiscovered Nofity to run FspSiliconInit // Status = PeiServicesNotifyPpi (&mPeiMemoryDiscoveredNotifyDesc); ASSERT_EFI_ERROR (Status); // // Register EndOfPei Notify for S3 to run FSP NotifyPhase // PeiServicesGetBootMode (&BootMode); if (BootMode == BOOT_ON_S3_RESUME) { Status = PeiServicesNotifyPpi (&mS3EndOfPeiNotifyDesc); ASSERT_EFI_ERROR (Status); } return EFI_SUCCESS; }
/** Do measurement after memory is ready. @param[in] PeiServices Describes the list of possible PEI Services. @retval EFI_SUCCESS Operation completed successfully. @retval EFI_OUT_OF_RESOURCES No enough memory to log the new event. @retval EFI_DEVICE_ERROR The command was unsuccessful. **/ EFI_STATUS EFIAPI PeimEntryMP ( IN EFI_PEI_SERVICES **PeiServices ) { EFI_STATUS Status; TIS_TPM_HANDLE TpmHandle; TpmHandle = (TIS_TPM_HANDLE)(UINTN)TPM_BASE_ADDRESS; Status = TisPcRequestUseTpm ((TIS_PC_REGISTERS_PTR)TpmHandle); if (EFI_ERROR (Status)) { return Status; } if (IsTpmUsable (PeiServices, TpmHandle)) { Status = MeasureCRTMVersion (PeiServices, TpmHandle); ASSERT_EFI_ERROR (Status); Status = MeasureMainBios (PeiServices, TpmHandle); } // // Post callbacks: // 1). for the FvInfoPpi services to measure and record // the additional Fvs to TPM // 2). for the OperatorPresencePpi service to determine whether to // lock the TPM // Status = PeiServicesNotifyPpi (&mNotifyList[0]); ASSERT_EFI_ERROR (Status); return Status; }
/** Do measurement after memory is ready. @param[in] PeiServices Describes the list of possible PEI Services. @retval EFI_SUCCESS Operation completed successfully. @retval EFI_OUT_OF_RESOURCES No enough memory to log the new event. @retval EFI_DEVICE_ERROR The command was unsuccessful. **/ EFI_STATUS PeimEntryMP ( IN EFI_PEI_SERVICES **PeiServices ) { EFI_STATUS Status; Status = PeiServicesLocatePpi ( &gEfiPeiFirmwareVolumeInfoMeasurementExcludedPpiGuid, 0, NULL, (VOID**)&mMeasurementExcludedFvPpi ); // Do not check status, because it is optional if (PcdGet8 (PcdTpm2ScrtmPolicy) == 1) { Status = MeasureCRTMVersion (); ASSERT_EFI_ERROR (Status); } Status = MeasureMainBios (); // // Post callbacks: // for the FvInfoPpi services to measure and record // the additional Fvs to TPM // Status = PeiServicesNotifyPpi (&mNotifyList[0]); ASSERT_EFI_ERROR (Status); return Status; }
VOID InstallFeatureControlCallback ( VOID ) { EFI_STATUS Status; FIRMWARE_CONFIG_ITEM FwCfgItem; UINTN FwCfgSize; Status = QemuFwCfgFindFile ("etc/msr_feature_control", &FwCfgItem, &FwCfgSize); if (EFI_ERROR (Status) || FwCfgSize != sizeof mFeatureControlValue) { // // Nothing to do. // return; } QemuFwCfgSelectItem (FwCfgItem); QemuFwCfgReadBytes (sizeof mFeatureControlValue, &mFeatureControlValue); Status = PeiServicesNotifyPpi (&mMpServicesNotify); if (EFI_ERROR (Status)) { DEBUG ((EFI_D_ERROR, "%a: failed to set up MP Services callback: %r\n", __FUNCTION__, Status)); } }
/** Initializes the Intel VTd PMR PEIM. @param FileHandle Handle of the file being invoked. @param PeiServices Describes the list of possible PEI Services. @retval EFI_SUCCESS Usb bot driver is successfully initialized. @retval EFI_OUT_OF_RESOURCES Can't initialize the driver. **/ EFI_STATUS EFIAPI IntelVTdPmrInitialize ( IN EFI_PEI_FILE_HANDLE FileHandle, IN CONST EFI_PEI_SERVICES **PeiServices ) { EFI_STATUS Status; EFI_BOOT_MODE BootMode; DMA_BUFFER_INFO *DmaBufferInfo; DEBUG ((DEBUG_INFO, "IntelVTdPmrInitialize\n")); if ((PcdGet8(PcdVTdPolicyPropertyMask) & BIT0) == 0) { return EFI_UNSUPPORTED; } DmaBufferInfo = BuildGuidHob (&mDmaBufferInfoGuid, sizeof(DMA_BUFFER_INFO)); ASSERT(DmaBufferInfo != NULL); if (DmaBufferInfo == NULL) { return EFI_OUT_OF_RESOURCES; } ZeroMem (DmaBufferInfo, sizeof(DMA_BUFFER_INFO)); PeiServicesGetBootMode (&BootMode); if (BootMode == BOOT_ON_S3_RESUME) { DmaBufferInfo->DmaBufferSize = PcdGet32 (PcdVTdPeiDmaBufferSizeS3); } else { DmaBufferInfo->DmaBufferSize = PcdGet32 (PcdVTdPeiDmaBufferSize); } Status = PeiServicesNotifyPpi (&mVTdInfoNotifyDesc); ASSERT_EFI_ERROR (Status); // // Register EndOfPei Notify for S3 // if (BootMode == BOOT_ON_S3_RESUME) { Status = PeiServicesNotifyPpi (&mS3EndOfPeiNotifyDesc); ASSERT_EFI_ERROR (Status); } return EFI_SUCCESS; }
/** This is the entrypoint of PEIM @param[in] FileHandle Handle of the file being invoked. @param[in] PeiServices Describes the list of possible PEI Services. @retval EFI_SUCCESS if it completed successfully. **/ EFI_STATUS EFIAPI FspPeiEntryPoint ( IN EFI_PEI_FILE_HANDLE FileHandle, IN CONST EFI_PEI_SERVICES **PeiServices ) { FSP_INFO_HEADER *FspHeader; EFI_STATUS Status; FSP_INIT_DONE_PPI *FspInitDone; VOID *FspHobList; EFI_BOOT_MODE BootMode; DEBUG ((DEBUG_INFO, "FspPeiEntryPoint\n")); Status = PeiServicesLocatePpi ( &gFspInitDonePpiGuid, 0, NULL, (VOID **) &FspInitDone ); if (EFI_ERROR (Status)) { // // 1st entry // DEBUG ((DEBUG_INFO, "1st entry\n")); FspHeader = FspFindFspHeader (PcdGet32 (PcdFlashFvFspBase)); DEBUG ((DEBUG_INFO, "FspHeader - 0x%x\n", FspHeader)); if (FspHeader == NULL) { return EFI_DEVICE_ERROR; } SecFspInit (FspHeader); // // Never return here // CpuDeadLoop (); } else { // // 2nd entry // DEBUG ((DEBUG_INFO, "2nd entry\n")); Status = FspInitDone->GetFspHobList (PeiServices, FspInitDone, &FspHobList); DEBUG ((DEBUG_INFO, "FspHobList - 0x%x\n", FspHobList)); FspHobProcess (FspHobList); PeiServicesGetBootMode (&BootMode); if (BootMode == BOOT_ON_S3_RESUME) { Status = PeiServicesNotifyPpi (&mS3EndOfPeiNotifyDesc); ASSERT_EFI_ERROR (Status); } } return EFI_SUCCESS; }
/** Initialize the security services. @param PeiServices An indirect pointer to the EFI_PEI_SERVICES table published by the PEI Foundation. @param OldCoreData Pointer to the old core data. NULL if being run in non-permament memory mode. **/ VOID InitializeSecurityServices ( IN EFI_PEI_SERVICES **PeiServices, IN PEI_CORE_INSTANCE *OldCoreData ) { if (OldCoreData == NULL) { PeiServicesNotifyPpi (&mNotifyList); } return; }
VOID InstallClearCacheCallback ( VOID ) { EFI_STATUS Status; Status = PeiServicesNotifyPpi (&mMpServicesNotify); if (EFI_ERROR (Status)) { DEBUG ((DEBUG_ERROR, "%a: failed to set up MP Services callback: %r\n", __FUNCTION__, Status)); } }
/** Do FSP initialization based on FspApi version 1. @param[in] FspHeader FSP header pointer. @return FSP initialization status. **/ EFI_STATUS PeiFspInitV1 ( IN FSP_INFO_HEADER *FspHeader ) { EFI_STATUS Status; FSP_INIT_DONE_PPI *FspInitDone; VOID *FspHobList; EFI_BOOT_MODE BootMode; Status = PeiServicesLocatePpi ( &gFspInitDonePpiGuid, 0, NULL, (VOID **) &FspInitDone ); if (EFI_ERROR (Status)) { // // 1st entry // DEBUG ((DEBUG_INFO, "1st entry\n")); PeiFspInit (FspHeader); // // Never return here, for FspApi version 1. // CpuDeadLoop (); } else { // // 2nd entry for FspApi version 1 only. // DEBUG ((DEBUG_INFO, "2nd entry\n")); Status = FspInitDone->GetFspHobList (GetPeiServicesTablePointer (), FspInitDone, &FspHobList); ASSERT_EFI_ERROR (Status); DEBUG ((DEBUG_INFO, "FspHobList - 0x%x\n", FspHobList)); FspHobProcess (FspHobList); // // Register EndOfPei Notify for S3 to run FspNotifyPhase // PeiServicesGetBootMode (&BootMode); if (BootMode == BOOT_ON_S3_RESUME) { Status = PeiServicesNotifyPpi (&mS3EndOfPeiNotifyDesc); ASSERT_EFI_ERROR (Status); } } return EFI_SUCCESS; }
/** Initialize global data for MP support. @param[in] CpuMpData The pointer to CPU MP Data structure. **/ VOID InitMpGlobalData ( IN CPU_MP_DATA *CpuMpData ) { EFI_STATUS Status; SaveCpuMpData (CpuMpData); // // Register an event for EndOfPei // Status = PeiServicesNotifyPpi (&mMpInitLibNotifyList); ASSERT_EFI_ERROR (Status); }
/** 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_STATUS EFIAPI PeiInitBoard ( IN EFI_PEI_FILE_HANDLE FileHandle, IN CONST EFI_PEI_SERVICES **PeiServices ) { EFI_STATUS Status; // // Register board detection callback function. // Status = PeiServicesNotifyPpi(&mDetectionStartNotifyList); return Status; }
/** Initialize global data for MP support. @param[in] CpuMpData The pointer to CPU MP Data structure. **/ VOID InitMpGlobalData ( IN CPU_MP_DATA *CpuMpData ) { EFI_STATUS Status; SaveCpuMpData (CpuMpData); /// /// Install Notify /// Status = PeiServicesNotifyPpi (&mS3SmmInitDoneNotifyDesc); ASSERT_EFI_ERROR (Status); }
/** Do measurement after memory is ready. @param[in] PeiServices Describes the list of possible PEI Services. @retval EFI_SUCCESS Operation completed successfully. @retval EFI_OUT_OF_RESOURCES No enough memory to log the new event. @retval EFI_DEVICE_ERROR The command was unsuccessful. **/ EFI_STATUS EFIAPI PeimEntryMP ( IN EFI_PEI_SERVICES **PeiServices ) { EFI_STATUS Status; Status = PeiServicesLocatePpi ( &gEfiPeiFirmwareVolumeInfoMeasurementExcludedPpiGuid, 0, NULL, (VOID**)&mMeasurementExcludedFvPpi ); // Do not check status, because it is optional mMeasuredBaseFvInfo = (EFI_PLATFORM_FIRMWARE_BLOB *) AllocateZeroPool (sizeof (EFI_PLATFORM_FIRMWARE_BLOB) * PcdGet32 (PcdPeiCoreMaxFvSupported)); ASSERT (mMeasuredBaseFvInfo != NULL); mMeasuredChildFvInfo = (EFI_PLATFORM_FIRMWARE_BLOB *) AllocateZeroPool (sizeof (EFI_PLATFORM_FIRMWARE_BLOB) * PcdGet32 (PcdPeiCoreMaxFvSupported)); ASSERT (mMeasuredChildFvInfo != NULL); Status = Tpm12RequestUseTpm (); if (EFI_ERROR (Status)) { return Status; } if (IsTpmUsable ()) { if (PcdGet8 (PcdTpmScrtmPolicy) == 1) { Status = MeasureCRTMVersion (PeiServices); } Status = MeasureMainBios (PeiServices); } // // Post callbacks: // 1). for the FvInfoPpi services to measure and record // the additional Fvs to TPM // 2). for the OperatorPresencePpi service to determine whether to // lock the TPM // Status = PeiServicesNotifyPpi (&mNotifyList[0]); ASSERT_EFI_ERROR (Status); return Status; }
/** Do measurement after memory is ready. @param[in] PeiServices Describes the list of possible PEI Services. @retval EFI_SUCCESS Operation completed successfully. @retval EFI_OUT_OF_RESOURCES No enough memory to log the new event. @retval EFI_DEVICE_ERROR The command was unsuccessful. **/ EFI_STATUS EFIAPI PeimEntryMP ( IN EFI_PEI_SERVICES **PeiServices ) { EFI_STATUS Status; TIS_TPM_HANDLE TpmHandle; Status = PeiServicesLocatePpi ( &gEfiPeiFirmwareVolumeInfoMeasurementExcludedPpiGuid, 0, NULL, (VOID**)&mMeasurementExcludedFvPpi ); // Do not check status, because it is optional TpmHandle = (TIS_TPM_HANDLE)(UINTN)TPM_BASE_ADDRESS; Status = TisPcRequestUseTpm ((TIS_PC_REGISTERS_PTR)TpmHandle); if (EFI_ERROR (Status)) { return Status; } if (IsTpmUsable (PeiServices, TpmHandle)) { if (PcdGet8 (PcdTpmScrtmPolicy) == 1) { Status = MeasureCRTMVersion (PeiServices, TpmHandle); ASSERT_EFI_ERROR (Status); } Status = MeasureMainBios (PeiServices, TpmHandle); } // // Post callbacks: // 1). for the FvInfoPpi services to measure and record // the additional Fvs to TPM // 2). for the OperatorPresencePpi service to determine whether to // lock the TPM // Status = PeiServicesNotifyPpi (&mNotifyList[0]); ASSERT_EFI_ERROR (Status); return Status; }
/** The Entry point of the CPU PEIM This function is the Entry point of the CPU PEIM which will install the CachePpi and BuildBISTHob notifier. And also the function will deal with the relocation to memory when permanent memory is ready @param FileHandle Handle of the file being invoked. @param PeiServices Describes the list of possible PEI Services. @retval EFI_SUCCESS CachePpi and BIST hob build notification is installed successfully. **/ EFI_STATUS EFIAPI CpuPeimInit ( IN EFI_PEI_FILE_HANDLE FileHandle, IN CONST EFI_PEI_SERVICES **PeiServices ) { EFI_STATUS Status; // // Report Status Code to indicate the start of CPU PEIM // REPORT_STATUS_CODE ( EFI_PROGRESS_CODE, EFI_COMPUTING_UNIT_HOST_PROCESSOR + EFI_CU_HP_PC_POWER_ON_INIT ); // // Install PPIs // Status = PeiServicesInstallPpi(&mPpiList[0]); ASSERT_EFI_ERROR (Status); // // Register for PPI Notifications // Status = PeiServicesNotifyPpi (&mNotifyList[0]); ASSERT_EFI_ERROR (Status); // // Report Status Code to indicate the start of CPU PEI initialization // REPORT_STATUS_CODE ( EFI_PROGRESS_CODE, EFI_COMPUTING_UNIT_HOST_PROCESSOR + EFI_CU_PC_INIT_BEGIN ); InitXMM (); return Status; }
/** Initialize global data for MP support. @param[in] CpuMpData The pointer to CPU MP Data structure. **/ VOID InitMpGlobalData ( IN CPU_MP_DATA *CpuMpData ) { EFI_STATUS Status; SaveCpuMpData (CpuMpData); if (CpuMpData->CpuCount == 1) { // // If only BSP exists, return // return; } // // Register an event for EndOfPei // Status = PeiServicesNotifyPpi (&mMpInitLibNotifyList); ASSERT_EFI_ERROR (Status); }
/** Initializes the Usb Bot. @param FileHandle Handle of the file being invoked. @param PeiServices Describes the list of possible PEI Services. @retval EFI_SUCCESS Usb bot driver is successfully initialized. @retval EFI_OUT_OF_RESOURCES Can't initialize the driver. **/ EFI_STATUS EFIAPI PeimInitializeUsbBot ( IN EFI_PEI_FILE_HANDLE FileHandle, IN CONST EFI_PEI_SERVICES **PeiServices ) { EFI_STATUS Status; UINTN UsbIoPpiInstance; EFI_PEI_PPI_DESCRIPTOR *TempPpiDescriptor; PEI_USB_IO_PPI *UsbIoPpi; // // Shadow this PEIM to run from memory // if (!EFI_ERROR (PeiServicesRegisterForShadow (FileHandle))) { return EFI_SUCCESS; } // // locate all usb io PPIs // for (UsbIoPpiInstance = 0; UsbIoPpiInstance < PEI_FAT_MAX_USB_IO_PPI; UsbIoPpiInstance++) { Status = PeiServicesLocatePpi ( &gPeiUsbIoPpiGuid, UsbIoPpiInstance, &TempPpiDescriptor, (VOID **) &UsbIoPpi ); if (EFI_ERROR (Status)) { break; } } // // Register a notify function // return PeiServicesNotifyPpi (&mNotifyList); }
/** Do measurement after memory is ready. @param[in] PeiServices Describes the list of possible PEI Services. @retval EFI_SUCCESS Operation completed successfully. @retval EFI_OUT_OF_RESOURCES No enough memory to log the new event. @retval EFI_DEVICE_ERROR The command was unsuccessful. **/ EFI_STATUS PeimEntryMP ( IN EFI_PEI_SERVICES **PeiServices ) { EFI_STATUS Status; Status = PeiServicesLocatePpi ( &gEfiPeiFirmwareVolumeInfoMeasurementExcludedPpiGuid, 0, NULL, (VOID**)&mMeasurementExcludedFvPpi ); // Do not check status, because it is optional mMeasuredBaseFvInfo = (EFI_PLATFORM_FIRMWARE_BLOB *) AllocateZeroPool (sizeof (EFI_PLATFORM_FIRMWARE_BLOB) * PcdGet32 (PcdPeiCoreMaxFvSupported)); ASSERT (mMeasuredBaseFvInfo != NULL); mMeasuredChildFvInfo = (EFI_PLATFORM_FIRMWARE_BLOB *) AllocateZeroPool (sizeof (EFI_PLATFORM_FIRMWARE_BLOB) * PcdGet32 (PcdPeiCoreMaxFvSupported)); ASSERT (mMeasuredChildFvInfo != NULL); if (PcdGet8 (PcdTpm2ScrtmPolicy) == 1) { Status = MeasureCRTMVersion (); ASSERT_EFI_ERROR (Status); } Status = MeasureMainBios (); // // Post callbacks: // for the FvInfoPpi services to measure and record // the additional Fvs to TPM // Status = PeiServicesNotifyPpi (&mNotifyList[0]); ASSERT_EFI_ERROR (Status); return Status; }
/** Entry point of the PEIM. @param[in] FileHandle Handle of the file being invoked. @param[in] PeiServices Describes the list of possible PEI Services. @retval EFI_SUCCESS PPI successfully installed. **/ EFI_STATUS EFIAPI NvmExpressPeimEntry ( IN EFI_PEI_FILE_HANDLE FileHandle, IN CONST EFI_PEI_SERVICES **PeiServices ) { EFI_STATUS Status; EFI_BOOT_MODE BootMode; EDKII_NVM_EXPRESS_HOST_CONTROLLER_PPI *NvmeHcPpi; UINT8 Controller; UINTN MmioBase; UINTN DevicePathLength; EFI_DEVICE_PATH_PROTOCOL *DevicePath; PEI_NVME_CONTROLLER_PRIVATE_DATA *Private; EFI_PHYSICAL_ADDRESS DeviceAddress; DEBUG ((DEBUG_INFO, "%a: Enters.\n", __FUNCTION__)); // // Get the current boot mode. // Status = PeiServicesGetBootMode (&BootMode); if (EFI_ERROR (Status)) { DEBUG ((DEBUG_ERROR, "%a: Fail to get the current boot mode.\n", __FUNCTION__)); return Status; } // // Locate the NVME host controller PPI // Status = PeiServicesLocatePpi ( &gEdkiiPeiNvmExpressHostControllerPpiGuid, 0, NULL, (VOID **) &NvmeHcPpi ); if (EFI_ERROR (Status)) { DEBUG ((DEBUG_ERROR, "%a: Fail to locate NvmeHostControllerPpi.\n", __FUNCTION__)); return EFI_UNSUPPORTED; } Controller = 0; MmioBase = 0; while (TRUE) { Status = NvmeHcPpi->GetNvmeHcMmioBar ( NvmeHcPpi, Controller, &MmioBase ); // // When status is error, meant no controller is found // if (EFI_ERROR (Status)) { break; } Status = NvmeHcPpi->GetNvmeHcDevicePath ( NvmeHcPpi, Controller, &DevicePathLength, &DevicePath ); if (EFI_ERROR (Status)) { DEBUG (( DEBUG_ERROR, "%a: Fail to allocate get the device path for Controller %d.\n", __FUNCTION__, Controller )); return Status; } // // Check validity of the device path of the NVM Express controller. // Status = NvmeIsHcDevicePathValid (DevicePath, DevicePathLength); if (EFI_ERROR (Status)) { DEBUG (( DEBUG_ERROR, "%a: The device path is invalid for Controller %d.\n", __FUNCTION__, Controller )); Controller++; continue; } // // For S3 resume performance consideration, not all NVM Express controllers // will be initialized. The driver consumes the content within // S3StorageDeviceInitList LockBox to see if a controller will be skipped // during S3 resume. // if ((BootMode == BOOT_ON_S3_RESUME) && (NvmeS3SkipThisController (DevicePath, DevicePathLength))) { DEBUG (( DEBUG_ERROR, "%a: Controller %d is skipped during S3.\n", __FUNCTION__, Controller )); Controller++; continue; } // // Memory allocation for controller private data // Private = AllocateZeroPool (sizeof (PEI_NVME_CONTROLLER_PRIVATE_DATA)); if (Private == NULL) { DEBUG (( DEBUG_ERROR, "%a: Fail to allocate private data for Controller %d.\n", __FUNCTION__, Controller )); return EFI_OUT_OF_RESOURCES; } // // Memory allocation for transfer-related data // Status = IoMmuAllocateBuffer ( NVME_MEM_MAX_PAGES, &Private->Buffer, &DeviceAddress, &Private->BufferMapping ); if (EFI_ERROR (Status)) { DEBUG (( DEBUG_ERROR, "%a: Fail to allocate DMA buffers for Controller %d.\n", __FUNCTION__, Controller )); return Status; } ASSERT (DeviceAddress == ((EFI_PHYSICAL_ADDRESS) (UINTN) Private->Buffer)); DEBUG ((DEBUG_INFO, "%a: DMA buffer base at 0x%x\n", __FUNCTION__, Private->Buffer)); // // Initialize controller private data // Private->Signature = NVME_PEI_CONTROLLER_PRIVATE_DATA_SIGNATURE; Private->MmioBase = MmioBase; Private->DevicePathLength = DevicePathLength; Private->DevicePath = DevicePath; // // Initialize the NVME controller // Status = NvmeControllerInit (Private); if (EFI_ERROR (Status)) { DEBUG (( DEBUG_ERROR, "%a: Controller initialization fail for Controller %d with Status - %r.\n", __FUNCTION__, Controller, Status )); NvmeFreeDmaResource (Private); Controller++; continue; } // // Enumerate the NVME namespaces on the controller // Status = NvmeDiscoverNamespaces (Private); if (EFI_ERROR (Status)) { // // No active namespace was found on the controller // DEBUG (( DEBUG_ERROR, "%a: Namespaces discovery fail for Controller %d with Status - %r.\n", __FUNCTION__, Controller, Status )); NvmeFreeDmaResource (Private); Controller++; continue; } Private->BlkIoPpi.GetNumberOfBlockDevices = NvmeBlockIoPeimGetDeviceNo; Private->BlkIoPpi.GetBlockDeviceMediaInfo = NvmeBlockIoPeimGetMediaInfo; Private->BlkIoPpi.ReadBlocks = NvmeBlockIoPeimReadBlocks; CopyMem ( &Private->BlkIoPpiList, &mNvmeBlkIoPpiListTemplate, sizeof (EFI_PEI_PPI_DESCRIPTOR) ); Private->BlkIoPpiList.Ppi = &Private->BlkIoPpi; Private->BlkIo2Ppi.Revision = EFI_PEI_RECOVERY_BLOCK_IO2_PPI_REVISION; Private->BlkIo2Ppi.GetNumberOfBlockDevices = NvmeBlockIoPeimGetDeviceNo2; Private->BlkIo2Ppi.GetBlockDeviceMediaInfo = NvmeBlockIoPeimGetMediaInfo2; Private->BlkIo2Ppi.ReadBlocks = NvmeBlockIoPeimReadBlocks2; CopyMem ( &Private->BlkIo2PpiList, &mNvmeBlkIo2PpiListTemplate, sizeof (EFI_PEI_PPI_DESCRIPTOR) ); Private->BlkIo2PpiList.Ppi = &Private->BlkIo2Ppi; PeiServicesInstallPpi (&Private->BlkIoPpiList); // // Check if the NVME controller supports the Security Receive/Send commands // if ((Private->ControllerData->Oacs & SECURITY_SEND_RECEIVE_SUPPORTED) != 0) { DEBUG (( DEBUG_INFO, "%a: Security Security Command PPI will be produced for Controller %d.\n", __FUNCTION__, Controller )); Private->StorageSecurityPpi.Revision = EDKII_STORAGE_SECURITY_PPI_REVISION; Private->StorageSecurityPpi.GetNumberofDevices = NvmeStorageSecurityGetDeviceNo; Private->StorageSecurityPpi.GetDevicePath = NvmeStorageSecurityGetDevicePath; Private->StorageSecurityPpi.ReceiveData = NvmeStorageSecurityReceiveData; Private->StorageSecurityPpi.SendData = NvmeStorageSecuritySendData; CopyMem ( &Private->StorageSecurityPpiList, &mNvmeStorageSecurityPpiListTemplate, sizeof (EFI_PEI_PPI_DESCRIPTOR) ); Private->StorageSecurityPpiList.Ppi = &Private->StorageSecurityPpi; PeiServicesInstallPpi (&Private->StorageSecurityPpiList); } CopyMem ( &Private->EndOfPeiNotifyList, &mNvmeEndOfPeiNotifyListTemplate, sizeof (EFI_PEI_NOTIFY_DESCRIPTOR) ); PeiServicesNotifyPpi (&Private->EndOfPeiNotifyList); DEBUG (( DEBUG_INFO, "%a: Controller %d has been successfully initialized.\n", __FUNCTION__, Controller )); Controller++; } return EFI_SUCCESS; }
/** Installs the Device Recovery Module PPI, Initialize BlockIo Ppi installation notification @param FileHandle The file handle of the image. @param PeiServices General purpose services available to every PEIM. @retval EFI_SUCCESS The function completed successfully. @retval EFI_OUT_OF_RESOURCES There is not enough system memory. **/ EFI_STATUS EFIAPI CdExpressPeimEntry ( IN EFI_PEI_FILE_HANDLE FileHandle, IN CONST EFI_PEI_SERVICES **PeiServices ) { EFI_STATUS Status; PEI_CD_EXPRESS_PRIVATE_DATA *PrivateData; if (!EFI_ERROR (PeiServicesRegisterForShadow (FileHandle))) { return EFI_SUCCESS; } PrivateData = AllocatePages (EFI_SIZE_TO_PAGES (sizeof (*PrivateData))); if (PrivateData == NULL) { return EFI_OUT_OF_RESOURCES; } // // Initialize Private Data (to zero, as is required by subsequent operations) // ZeroMem (PrivateData, sizeof (*PrivateData)); PrivateData->Signature = PEI_CD_EXPRESS_PRIVATE_DATA_SIGNATURE; PrivateData->BlockBuffer = AllocatePages (EFI_SIZE_TO_PAGES (PEI_CD_BLOCK_SIZE)); if (PrivateData->BlockBuffer == NULL) { return EFI_OUT_OF_RESOURCES; } PrivateData->CapsuleCount = 0; Status = UpdateBlocksAndVolumes (PrivateData, TRUE); Status = UpdateBlocksAndVolumes (PrivateData, FALSE); // // Installs Ppi // PrivateData->DeviceRecoveryPpi.GetNumberRecoveryCapsules = GetNumberRecoveryCapsules; PrivateData->DeviceRecoveryPpi.GetRecoveryCapsuleInfo = GetRecoveryCapsuleInfo; PrivateData->DeviceRecoveryPpi.LoadRecoveryCapsule = LoadRecoveryCapsule; PrivateData->PpiDescriptor.Flags = (EFI_PEI_PPI_DESCRIPTOR_PPI | EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST); PrivateData->PpiDescriptor.Guid = &gEfiPeiDeviceRecoveryModulePpiGuid; PrivateData->PpiDescriptor.Ppi = &PrivateData->DeviceRecoveryPpi; Status = PeiServicesInstallPpi (&PrivateData->PpiDescriptor); if (EFI_ERROR (Status)) { return EFI_OUT_OF_RESOURCES; } // // PrivateData is allocated now, set it to the module variable // mPrivateData = PrivateData; // // Installs Block Io Ppi notification function // PrivateData->NotifyDescriptor.Flags = ( EFI_PEI_PPI_DESCRIPTOR_NOTIFY_CALLBACK ); PrivateData->NotifyDescriptor.Guid = &gEfiPeiVirtualBlockIoPpiGuid; PrivateData->NotifyDescriptor.Notify = BlockIoNotifyEntry; PrivateData->NotifyDescriptor2.Flags = ( EFI_PEI_PPI_DESCRIPTOR_NOTIFY_CALLBACK | EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST ); PrivateData->NotifyDescriptor2.Guid = &gEfiPeiVirtualBlockIo2PpiGuid; PrivateData->NotifyDescriptor2.Notify = BlockIoNotifyEntry; return PeiServicesNotifyPpi (&PrivateData->NotifyDescriptor); }
/** Installs the Device Recovery Module PPI, Initialize BlockIo Ppi installation notification @param FileHandle Handle of the file being invoked. Type EFI_PEI_FILE_HANDLE is defined in FfsFindNextFile(). @param PeiServices Describes the list of possible PEI Services. @retval EFI_SUCCESS The entry point was executed successfully. @retval EFI_OUT_OF_RESOURCES There is no enough memory to complete the operations. **/ EFI_STATUS EFIAPI FatPeimEntry ( IN EFI_PEI_FILE_HANDLE FileHandle, IN CONST EFI_PEI_SERVICES **PeiServices ) { EFI_STATUS Status; EFI_PHYSICAL_ADDRESS Address; PEI_FAT_PRIVATE_DATA *PrivateData; Status = PeiServicesRegisterForShadow (FileHandle); if (!EFI_ERROR (Status)) { return Status; } Status = PeiServicesAllocatePages ( EfiBootServicesCode, (sizeof (PEI_FAT_PRIVATE_DATA) - 1) / PEI_FAT_MEMMORY_PAGE_SIZE + 1, &Address ); if (EFI_ERROR (Status)) { return EFI_OUT_OF_RESOURCES; } PrivateData = (PEI_FAT_PRIVATE_DATA *) (UINTN) Address; // // Initialize Private Data (to zero, as is required by subsequent operations) // ZeroMem ((UINT8 *) PrivateData, sizeof (PEI_FAT_PRIVATE_DATA)); PrivateData->Signature = PEI_FAT_PRIVATE_DATA_SIGNATURE; // // Installs Ppi // PrivateData->DeviceRecoveryPpi.GetNumberRecoveryCapsules = GetNumberRecoveryCapsules; PrivateData->DeviceRecoveryPpi.GetRecoveryCapsuleInfo = GetRecoveryCapsuleInfo; PrivateData->DeviceRecoveryPpi.LoadRecoveryCapsule = LoadRecoveryCapsule; PrivateData->PpiDescriptor.Flags = (EFI_PEI_PPI_DESCRIPTOR_PPI | EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST); PrivateData->PpiDescriptor.Guid = &gEfiPeiDeviceRecoveryModulePpiGuid; PrivateData->PpiDescriptor.Ppi = &PrivateData->DeviceRecoveryPpi; Status = PeiServicesInstallPpi (&PrivateData->PpiDescriptor); if (EFI_ERROR (Status)) { return EFI_OUT_OF_RESOURCES; } // // Other initializations // PrivateData->BlockDeviceCount = 0; UpdateBlocksAndVolumes (PrivateData, TRUE); UpdateBlocksAndVolumes (PrivateData, FALSE); // // PrivateData is allocated now, set it to the module variable // mPrivateData = PrivateData; // // Installs Block Io Ppi notification function // PrivateData->NotifyDescriptor[0].Flags = ( EFI_PEI_PPI_DESCRIPTOR_NOTIFY_CALLBACK ); PrivateData->NotifyDescriptor[0].Guid = &gEfiPeiVirtualBlockIoPpiGuid; PrivateData->NotifyDescriptor[0].Notify = BlockIoNotifyEntry; PrivateData->NotifyDescriptor[1].Flags = ( EFI_PEI_PPI_DESCRIPTOR_NOTIFY_CALLBACK | EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST ); PrivateData->NotifyDescriptor[1].Guid = &gEfiPeiVirtualBlockIo2PpiGuid; PrivateData->NotifyDescriptor[1].Notify = BlockIoNotifyEntry; return PeiServicesNotifyPpi (&PrivateData->NotifyDescriptor[0]); }
/** Initialize debug agent. This function is used to set up debug environment for SEC and PEI phase. If InitFlag is DEBUG_AGENT_INIT_PREMEM_SEC, it will overirde IDT table entries and initialize debug port. It will enable interrupt to support break-in feature. It will set up debug agent Mailbox in cache-as-ramfrom. It will be called before physical memory is ready. If InitFlag is DEBUG_AGENT_INIT_POSTMEM_SEC, debug agent will build one GUIDed HOB to copy debug agent Mailbox. It will be called after physical memory is ready. This function is used to set up debug environment to support source level debugging. If certain Debug Agent Library instance has to save some private data in the stack, this function must work on the mode that doesn't return to the caller, then the caller needs to wrap up all rest of logic after InitializeDebugAgent() into one function and pass it into InitializeDebugAgent(). InitializeDebugAgent() is responsible to invoke the passing-in function at the end of InitializeDebugAgent(). If the parameter Function is not NULL, Debug Agent Library instance will invoke it by passing in the Context to be its parameter. If Function() is NULL, Debug Agent Library instance will return after setup debug environment. @param[in] InitFlag Init flag is used to decide the initialize process. @param[in] Context Context needed according to InitFlag; it was optional. @param[in] Function Continue function called by debug agent library; it was optional. **/ VOID EFIAPI InitializeDebugAgent ( IN UINT32 InitFlag, IN VOID *Context, OPTIONAL IN DEBUG_AGENT_CONTINUE Function OPTIONAL ) { DEBUG_AGENT_MAILBOX *Mailbox; DEBUG_AGENT_MAILBOX *NewMailbox; DEBUG_AGENT_MAILBOX MailboxInStack; DEBUG_AGENT_PHASE2_CONTEXT Phase2Context; DEBUG_AGENT_CONTEXT_POSTMEM_SEC *DebugAgentContext; EFI_STATUS Status; IA32_DESCRIPTOR *Ia32Idtr; IA32_IDT_ENTRY *Ia32IdtEntry; UINT64 DebugPortHandle; UINT64 MailboxLocation; UINT64 *MailboxLocationPointer; EFI_PHYSICAL_ADDRESS Address; UINT32 DebugTimerFrequency; BOOLEAN CpuInterruptState; // // Disable interrupts and save current interrupt state // CpuInterruptState = SaveAndDisableInterrupts(); switch (InitFlag) { case DEBUG_AGENT_INIT_PREMEM_SEC: InitializeDebugIdt (); MailboxLocation = (UINT64)(UINTN)&MailboxInStack; Mailbox = &MailboxInStack; ZeroMem ((VOID *) Mailbox, sizeof (DEBUG_AGENT_MAILBOX)); // // Get and save debug port handle and set the length of memory block. // SetLocationSavedMailboxPointerInIdtEntry (&MailboxLocation); // // Force error message could be printed during the first shakehand between Target/HOST. // SetDebugFlag (DEBUG_AGENT_FLAG_PRINT_ERROR_LEVEL, DEBUG_AGENT_ERROR); // // Save init arch type when debug agent initialized // SetDebugFlag (DEBUG_AGENT_FLAG_INIT_ARCH, DEBUG_ARCH_SYMBOL); // // Initialize Debug Timer hardware and save its frequency // InitializeDebugTimer (&DebugTimerFrequency, TRUE); UpdateMailboxContent (Mailbox, DEBUG_MAILBOX_DEBUG_TIMER_FREQUENCY, DebugTimerFrequency); Phase2Context.InitFlag = InitFlag; Phase2Context.Context = Context; Phase2Context.Function = Function; DebugPortInitialize ((VOID *) &Phase2Context, InitializeDebugAgentPhase2); // // If reaches here, it means Debug Port initialization failed. // DEBUG ((EFI_D_ERROR, "Debug Agent: Debug port initialization failed.\n")); break; case DEBUG_AGENT_INIT_POSTMEM_SEC: Mailbox = GetMailboxPointer (); // // Memory has been ready // SetDebugFlag (DEBUG_AGENT_FLAG_MEMORY_READY, 1); if (IsHostAttached ()) { // // Trigger one software interrupt to inform HOST // TriggerSoftInterrupt (MEMORY_READY_SIGNATURE); } // // Install Vector Handoff Info PPI to persist vectors used by Debug Agent // Status = PeiServicesInstallPpi (&mVectorHandoffInfoPpiList[0]); if (EFI_ERROR (Status)) { DEBUG ((EFI_D_ERROR, "DebugAgent: Failed to install Vector Handoff Info PPI!\n")); CpuDeadLoop (); } // // Fix up Debug Port handle address and mailbox address // DebugAgentContext = (DEBUG_AGENT_CONTEXT_POSTMEM_SEC *) Context; if (DebugAgentContext != NULL) { DebugPortHandle = (UINT64)(UINT32)(Mailbox->DebugPortHandle + DebugAgentContext->StackMigrateOffset); UpdateMailboxContent (Mailbox, DEBUG_MAILBOX_DEBUG_PORT_HANDLE_INDEX, DebugPortHandle); Mailbox = (DEBUG_AGENT_MAILBOX *) ((UINTN) Mailbox + DebugAgentContext->StackMigrateOffset); MailboxLocation = (UINT64)(UINTN)Mailbox; // // Build mailbox location in HOB and fix-up its address // MailboxLocationPointer = BuildGuidDataHob ( &gEfiDebugAgentGuid, &MailboxLocation, sizeof (UINT64) ); MailboxLocationPointer = (UINT64 *) ((UINTN) MailboxLocationPointer + DebugAgentContext->HeapMigrateOffset); } else { // // DebugAgentContext is NULL. Then, Mailbox can directly be copied into memory. // Allocate ACPI NVS memory for new Mailbox and Debug Port Handle buffer // Status = PeiServicesAllocatePages ( EfiACPIMemoryNVS, EFI_SIZE_TO_PAGES (sizeof(DEBUG_AGENT_MAILBOX) + PcdGet16(PcdDebugPortHandleBufferSize)), &Address ); if (EFI_ERROR (Status)) { DEBUG ((EFI_D_ERROR, "DebugAgent: Failed to allocate pages!\n")); CpuDeadLoop (); } NewMailbox = (DEBUG_AGENT_MAILBOX *) (UINTN) Address; // // Copy Mailbox and Debug Port Handle buffer to new location in ACPI NVS memory, because original Mailbox // and Debug Port Handle buffer in the allocated pool that may be marked as free by DXE Core after DXE Core // reallocates the HOB. // CopyMem (NewMailbox, Mailbox, sizeof (DEBUG_AGENT_MAILBOX)); CopyMem (NewMailbox + 1, (VOID *)(UINTN)Mailbox->DebugPortHandle, PcdGet16(PcdDebugPortHandleBufferSize)); UpdateMailboxContent (NewMailbox, DEBUG_MAILBOX_DEBUG_PORT_HANDLE_INDEX, (UINT64)(UINTN)(NewMailbox + 1)); MailboxLocation = (UINT64)(UINTN)NewMailbox; // // Build mailbox location in HOB // MailboxLocationPointer = BuildGuidDataHob ( &gEfiDebugAgentGuid, &MailboxLocation, sizeof (UINT64) ); } // // Update IDT entry to save the location saved mailbox pointer // SetLocationSavedMailboxPointerInIdtEntry (MailboxLocationPointer); break; case DEBUG_AGENT_INIT_PEI: if (Context == NULL) { DEBUG ((EFI_D_ERROR, "DebugAgent: Input parameter Context cannot be NULL!\n")); CpuDeadLoop (); } // // Check if Debug Agent has initialized before // if (IsDebugAgentInitialzed()) { DEBUG ((EFI_D_WARN, "Debug Agent: It has already initialized in SEC Core!\n")); break; } // // Install Vector Handoff Info PPI to persist vectors used by Debug Agent // Status = PeiServicesInstallPpi (&mVectorHandoffInfoPpiList[0]); if (EFI_ERROR (Status)) { DEBUG ((EFI_D_ERROR, "DebugAgent: Failed to install Vector Handoff Info PPI!\n")); CpuDeadLoop (); } // // Set up IDT entries // InitializeDebugIdt (); // // Build mailbox in HOB and setup Mailbox Set In Pei flag // Mailbox = AllocateZeroPool (sizeof (DEBUG_AGENT_MAILBOX)); if (Mailbox == NULL) { DEBUG ((EFI_D_ERROR, "DebugAgent: Failed to allocate memory!\n")); CpuDeadLoop (); } else { MailboxLocation = (UINT64)(UINTN)Mailbox; MailboxLocationPointer = BuildGuidDataHob ( &gEfiDebugAgentGuid, &MailboxLocation, sizeof (UINT64) ); // // Initialize Debug Timer hardware and save its frequency // InitializeDebugTimer (&DebugTimerFrequency, TRUE); UpdateMailboxContent (Mailbox, DEBUG_MAILBOX_DEBUG_TIMER_FREQUENCY, DebugTimerFrequency); // // Update IDT entry to save the location pointer saved mailbox pointer // SetLocationSavedMailboxPointerInIdtEntry (MailboxLocationPointer); } // // Save init arch type when debug agent initialized // SetDebugFlag (DEBUG_AGENT_FLAG_INIT_ARCH, DEBUG_ARCH_SYMBOL); // // Register for a callback once memory has been initialized. // If memery has been ready, the callback funtion will be invoked immediately // Status = PeiServicesNotifyPpi (&mMemoryDiscoveredNotifyList[0]); if (EFI_ERROR (Status)) { DEBUG ((EFI_D_ERROR, "DebugAgent: Failed to register memory discovered callback function!\n")); CpuDeadLoop (); } // // Set HOB check flag if memory has not been ready yet // if (GetDebugFlag (DEBUG_AGENT_FLAG_MEMORY_READY) == 0) { SetDebugFlag (DEBUG_AGENT_FLAG_CHECK_MAILBOX_IN_HOB, 1); } Phase2Context.InitFlag = InitFlag; Phase2Context.Context = Context; Phase2Context.Function = Function; DebugPortInitialize ((VOID *) &Phase2Context, InitializeDebugAgentPhase2); FindAndReportModuleImageInfo (4); break; case DEBUG_AGENT_INIT_THUNK_PEI_IA32TOX64: if (Context == NULL) { DEBUG ((EFI_D_ERROR, "DebugAgent: Input parameter Context cannot be NULL!\n")); CpuDeadLoop (); } else { Ia32Idtr = (IA32_DESCRIPTOR *) Context; Ia32IdtEntry = (IA32_IDT_ENTRY *)(Ia32Idtr->Base); MailboxLocationPointer = (UINT64 *) (UINTN) (Ia32IdtEntry[DEBUG_MAILBOX_VECTOR].Bits.OffsetLow + (UINT32) (Ia32IdtEntry[DEBUG_MAILBOX_VECTOR].Bits.OffsetHigh << 16)); Mailbox = (DEBUG_AGENT_MAILBOX *) (UINTN)(*MailboxLocationPointer); // // Mailbox should valid and setup before executing thunk code // VerifyMailboxChecksum (Mailbox); DebugPortHandle = (UINT64) (UINTN)DebugPortInitialize ((VOID *)(UINTN)Mailbox->DebugPortHandle, NULL); UpdateMailboxContent (Mailbox, DEBUG_MAILBOX_DEBUG_PORT_HANDLE_INDEX, DebugPortHandle); // // Set up IDT entries // InitializeDebugIdt (); // // Update IDT entry to save location pointer saved the mailbox pointer // SetLocationSavedMailboxPointerInIdtEntry (MailboxLocationPointer); FindAndReportModuleImageInfo (4); } break; default: // // Only DEBUG_AGENT_INIT_PREMEM_SEC and DEBUG_AGENT_INIT_POSTMEM_SEC are allowed for this // Debug Agent library instance. // DEBUG ((EFI_D_ERROR, "Debug Agent: The InitFlag value is not allowed!\n")); CpuDeadLoop (); break; } if (InitFlag == DEBUG_AGENT_INIT_POSTMEM_SEC) { // // Restore CPU Interrupt state and keep debug timer interrupt state as is // in DEBUG_AGENT_INIT_POSTMEM_SEC case // SetInterruptState (CpuInterruptState); } else { // // Enable Debug Timer interrupt // SaveAndSetDebugTimerInterrupt (TRUE); // // Enable CPU interrupts so debug timer interrupts can be delivered // EnableInterrupts (); } // // If Function is not NULL, invoke it always whatever debug agent was initialized sucesssfully or not. // if (Function != NULL) { Function (Context); } // // Set return status for DEBUG_AGENT_INIT_PEI // if (InitFlag == DEBUG_AGENT_INIT_PEI && Context != NULL) { *(EFI_STATUS *)Context = EFI_SUCCESS; } }
/** Entry point of DXE IPL PEIM. This function installs DXE IPL PPI. It also reloads itself to memory on non-S3 resume boot path. @param FileHandle Handle of the file being invoked. @param PeiServices Describes the list of possible PEI Services. @retval EFI_SUCESS The entry point of DXE IPL PEIM executes successfully. @retval Others Some error occurs during the execution of this function. **/ EFI_STATUS EFIAPI PeimInitializeDxeIpl ( IN EFI_PEI_FILE_HANDLE FileHandle, IN CONST EFI_PEI_SERVICES **PeiServices ) { EFI_STATUS Status; EFI_BOOT_MODE BootMode; VOID *Dummy; BootMode = GetBootModeHob (); if (BootMode != BOOT_ON_S3_RESUME) { Status = PeiServicesRegisterForShadow (FileHandle); if (Status == EFI_SUCCESS) { // // EFI_SUCESS means it is the first time to call register for shadow. // return Status; } // // Ensure that DXE IPL is shadowed to permanent memory. // ASSERT (Status == EFI_ALREADY_STARTED); // // DXE core load requires permanent memory. // Status = PeiServicesLocatePpi ( &gEfiPeiMemoryDiscoveredPpiGuid, 0, NULL, (VOID **) &Dummy ); ASSERT_EFI_ERROR (Status); if (EFI_ERROR (Status)) { return Status; } // // Now the permanent memory exists, install the PPIs for decompression // and section extraction. // Status = InstallIplPermanentMemoryPpis (NULL, NULL, NULL); ASSERT_EFI_ERROR (Status); } else { // // Install memory discovered PPI notification to install PPIs for // decompression and section extraction. // Status = PeiServicesNotifyPpi (&mMemoryDiscoveredNotifyList); ASSERT_EFI_ERROR (Status); } // // Install DxeIpl PPI. // Status = PeiServicesInstallPpi (&mDxeIplPpiList); ASSERT_EFI_ERROR(Status); return Status; }