From nobody Mon Feb 9 12:44:14 2026 Delivered-To: importer@patchew.org Received-SPF: pass (zohomail.com: domain of groups.io designates 66.175.222.108 as permitted sender) client-ip=66.175.222.108; envelope-from=bounce+27952+93896+1787277+3901457@groups.io; helo=mail02.groups.io; Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of groups.io designates 66.175.222.108 as permitted sender) smtp.mailfrom=bounce+27952+93896+1787277+3901457@groups.io ARC-Seal: i=1; a=rsa-sha256; t=1663299410; cv=none; d=zohomail.com; s=zohoarc; b=YbBSyHN6kbudNgvR8tBhXG59LoR/FhV4fjRSPU6V2quDBYkGCsjf+t/OW1PccI+8tLESzjWam9zoRBtArzXqlwnWutx7eWJavtepGqTFGg7PxnESGdfzoK7lr1A098MEBqdUY1xbKEHgcuQ3cSSO5n9CAJSwyE3218kLK2oZxBE= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1663299410; h=Content-Transfer-Encoding:Cc:Date:From:In-Reply-To:List-Subscribe:List-Id:List-Help:List-Unsubscribe:MIME-Version:Message-ID:Reply-To:References:Sender:Subject:To; bh=uU/VabDi11pn4eYoWCyR1ZLjBfvcgaDpW7SJPvBKwKs=; b=TIlY9gW7xlliuWCLjRgY9i5t4bueJAMB8+P5HLAmawt1Mu+woMeyRMuuDuLj1UBmUuWe7Sp+ZIeukEuKhoc9+bZKjhSC+2sCg3+ivfCfJEKXsCbwLlDtsrhGWSvPI50dpALFMuWF0l/19PD4QD0jYwqOxoyvWeG5daA8JIcTkGs= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of groups.io designates 66.175.222.108 as permitted sender) smtp.mailfrom=bounce+27952+93896+1787277+3901457@groups.io Received: from mail02.groups.io (mail02.groups.io [66.175.222.108]) by mx.zohomail.com with SMTPS id 1663299410567777.4400721527353; Thu, 15 Sep 2022 20:36:50 -0700 (PDT) Return-Path: X-Received: by 127.0.0.2 with SMTP id Q3HeYY1788612x68kHw6JKZT; Thu, 15 Sep 2022 20:36:49 -0700 X-Received: from loongson.cn (loongson.cn [114.242.206.163]) by mx.groups.io with SMTP id smtpd.web09.2233.1663299407662309031 for ; Thu, 15 Sep 2022 20:36:48 -0700 X-Received: from localhost.localdomain (unknown [10.2.5.185]) by localhost.localdomain (Coremail) with SMTP id AQAAf8DxPGtB7yNj984aAA--.41628S17; Fri, 16 Sep 2022 11:36:45 +0800 (CST) From: "xianglai" To: devel@edk2.groups.io Cc: quic_llindhol@quicinc.com, michael.d.kinney@intel.com, maobibo@loongson.cn Subject: [edk2-devel] [edk2-platforms][PATCH V2 15/16] Platform/Loongson: Add QemuFlashFvbServicesRuntimeDxe driver. Date: Fri, 16 Sep 2022 11:36:32 +0800 Message-Id: In-Reply-To: References: MIME-Version: 1.0 X-CM-TRANSID: AQAAf8DxPGtB7yNj984aAA--.41628S17 X-Coremail-Antispam: 1UD129KBjvAXoWDXryxCr48Zr1UJw47AF13Jwb_yoW7WFWDGo WxtFyIkw18tw1kZryrGryqk3yjqFyrWFsaqr4rZr9Fy3Z5Jwn0kFZav3W5W393tw18Jrnx J3yrXr93AF43J3s5n29KB7ZKAUJUUUUU529EdanIXcx71UUUUU7v73VFW2AGmfu7bjvjm3 AaLaJ3UjIYCTnIWjDUYxBIdaVFxhVjvjDU0xZFpf9x0zRUUUUUUUUU= X-CM-SenderInfo: 5ol0xt5qjotxo6or00hjvr0hdfq/ Precedence: Bulk List-Unsubscribe: List-Subscribe: List-Help: Sender: devel@edk2.groups.io List-Id: Mailing-List: list devel@edk2.groups.io; contact devel+owner@edk2.groups.io Reply-To: devel@edk2.groups.io,lixianglai@loongson.cn X-Gm-Message-State: dToO1X5ZuD3FeefPEEctzJALx1787277AA= Content-Transfer-Encoding: quoted-printable DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=groups.io; q=dns/txt; s=20140610; t=1663299409; bh=RJsTSzQwROj5W/utkfksgnzK8eDWYzfEN4d7EuqZppk=; h=Cc:Date:From:Reply-To:Subject:To; b=WKQbmOcW1fL0AsSNjAbI3fY3FjeK08ULDz8dPUrxMf8zXztlidFQHHcLy8Wvmai60BC GZsYZyPK9XOIMCjzwcdBj5yXuCXoi6zaMnt1i5+rZEvagFd0ihhEcpOJQcS/51M9Dg3Cl nY4V0HlCMWgxwT3p0ynPyiGAtJwLmJXtqGw= X-ZohoMail-DKIM: pass (identity @groups.io) X-ZM-MESSAGEID: 1663299412398100040 Content-Type: text/plain; charset="utf-8" This library provides flash read and write functionality and supports writing variables to flash. REF: https://bugzilla.tianocore.org/show_bug.cgi?id=3D4054 Signed-off-by: xianglai li --- .../QemuFlashFvbServicesRuntimeDxe/FvbInfo.c | 115 ++ .../FvbServicesRuntimeDxe.inf | 73 ++ .../FwBlockService.c | 1158 +++++++++++++++++ .../FwBlockService.h | 178 +++ .../FwBlockServiceDxe.c | 152 +++ .../QemuFlash.c | 251 ++++ .../QemuFlash.h | 86 ++ .../QemuFlashDxe.c | 21 + .../Loongson/LoongArchQemuPkg/Loongson.dsc | 4 +- 9 files changed, 2036 insertions(+), 2 deletions(-) create mode 100644 Platform/Loongson/LoongArchQemuPkg/Drivers/QemuFlashFvb= ServicesRuntimeDxe/FvbInfo.c create mode 100644 Platform/Loongson/LoongArchQemuPkg/Drivers/QemuFlashFvb= ServicesRuntimeDxe/FvbServicesRuntimeDxe.inf create mode 100644 Platform/Loongson/LoongArchQemuPkg/Drivers/QemuFlashFvb= ServicesRuntimeDxe/FwBlockService.c create mode 100644 Platform/Loongson/LoongArchQemuPkg/Drivers/QemuFlashFvb= ServicesRuntimeDxe/FwBlockService.h create mode 100644 Platform/Loongson/LoongArchQemuPkg/Drivers/QemuFlashFvb= ServicesRuntimeDxe/FwBlockServiceDxe.c create mode 100644 Platform/Loongson/LoongArchQemuPkg/Drivers/QemuFlashFvb= ServicesRuntimeDxe/QemuFlash.c create mode 100644 Platform/Loongson/LoongArchQemuPkg/Drivers/QemuFlashFvb= ServicesRuntimeDxe/QemuFlash.h create mode 100644 Platform/Loongson/LoongArchQemuPkg/Drivers/QemuFlashFvb= ServicesRuntimeDxe/QemuFlashDxe.c diff --git a/Platform/Loongson/LoongArchQemuPkg/Drivers/QemuFlashFvbService= sRuntimeDxe/FvbInfo.c b/Platform/Loongson/LoongArchQemuPkg/Drivers/QemuFlas= hFvbServicesRuntimeDxe/FvbInfo.c new file mode 100644 index 0000000000..df772f72be --- /dev/null +++ b/Platform/Loongson/LoongArchQemuPkg/Drivers/QemuFlashFvbServicesRuntim= eDxe/FvbInfo.c @@ -0,0 +1,115 @@ +/** @file + Defines data structure that is the volume header found.These data is int= ent + to decouple FVB driver with FV header. + + Copyright (c) 2021 Loongson Technology Corporation Limited. All rights r= eserved.
+ + SPDX-License-Identifier: BSD-2-Clause-Patent + +**/ + +// +// The package level header files this module uses +// +#include + +// +// The protocols, PPI and GUID definitions for this module +// +#include +// +// The Library classes this module consumes +// +#include +#include + +typedef struct { + UINT64 FvLength; + EFI_FIRMWARE_VOLUME_HEADER FvbInfo; + // + // EFI_FV_BLOCK_MAP_ENTRY ExtraBlockMap[n];//n=3D0 + // + EFI_FV_BLOCK_MAP_ENTRY End[1]; +} EFI_FVB_MEDIA_INFO; + +EFI_FVB_MEDIA_INFO mPlatformFvbMediaInfo[] =3D { + // + // System NvStorage FVB + // + { + FixedPcdGet32 (PcdAllVarSize), + { + { + 0, + }, // ZeroVector[16] + EFI_SYSTEM_NV_DATA_FV_GUID, + FixedPcdGet32 (PcdAllVarSize), + EFI_FVH_SIGNATURE, + EFI_FVB2_MEMORY_MAPPED | + EFI_FVB2_READ_ENABLED_CAP | + EFI_FVB2_READ_STATUS | + EFI_FVB2_WRITE_ENABLED_CAP | + EFI_FVB2_WRITE_STATUS | + EFI_FVB2_ERASE_POLARITY | + EFI_FVB2_ALIGNMENT_16, + sizeof (EFI_FIRMWARE_VOLUME_HEADER) + sizeof (EFI_FV_BLOCK_MAP_ENTRY= ), + 0, // CheckSum + 0, // ExtHeaderOffset + { + 0, + }, // Reserved[1] + 2, // Revision + { + { + (FixedPcdGet32 (PcdAllVarSize))/ + FixedPcdGet32 (PcdFlashBlockSize), + FixedPcdGet32 (PcdFlashBlockSize), + } + } // BlockMap[1] + }, + { + { + 0, + 0 + } + } // End[1] + } +}; + +EFI_STATUS +GetFvbInfo ( + IN UINT64 FvLength, + OUT EFI_FIRMWARE_VOLUME_HEADER **FvbInfo + ) +{ + STATIC BOOLEAN Checksummed =3D FALSE; + UINTN Index; + + if (!Checksummed) { + for (Index =3D 0; + Index < sizeof (mPlatformFvbMediaInfo) / sizeof (EFI_FVB_MEDIA_IN= FO); + Index +=3D 1) + { + UINT16 Checksum; + mPlatformFvbMediaInfo[Index].FvbInfo.Checksum =3D 0; + Checksum =3D CalculateCheckSum1= 6 ( + (UINT16 *)&mPlatfo= rmFvbMediaInfo[Index].FvbInfo, + mPlatformFvbMediaI= nfo[Index].FvbInfo.HeaderLength + ); + mPlatformFvbMediaInfo[Index].FvbInfo.Checksum =3D Checksum; + } + Checksummed =3D TRUE; + } + + for (Index =3D 0; + Index < sizeof (mPlatformFvbMediaInfo) / sizeof (EFI_FVB_MEDIA_INFO= ); + Index +=3D 1) + { + if (mPlatformFvbMediaInfo[Index].FvLength =3D=3D FvLength) { + *FvbInfo =3D &mPlatformFvbMediaInfo[Index].FvbInfo; + return EFI_SUCCESS; + } + } + + return EFI_NOT_FOUND; +} diff --git a/Platform/Loongson/LoongArchQemuPkg/Drivers/QemuFlashFvbService= sRuntimeDxe/FvbServicesRuntimeDxe.inf b/Platform/Loongson/LoongArchQemuPkg/= Drivers/QemuFlashFvbServicesRuntimeDxe/FvbServicesRuntimeDxe.inf new file mode 100644 index 0000000000..4b0c42b075 --- /dev/null +++ b/Platform/Loongson/LoongArchQemuPkg/Drivers/QemuFlashFvbServicesRuntim= eDxe/FvbServicesRuntimeDxe.inf @@ -0,0 +1,73 @@ +## @file +# Component description file for Emu Fimware Volume Block DXE driver modul= e. +# +# Copyright (c) 2021 Loongson Technology Corporation Limited. All rights = reserved.
+# +# SPDX-License-Identifier: BSD-2-Clause-Patent +# +## + + +[Defines] + INF_VERSION =3D 0x00010005 + BASE_NAME =3D FvbServicesRuntimeDxe + FILE_GUID =3D 733cbac2-b23f-4b92-bc8e-fb01ce5907b7 + MODULE_TYPE =3D DXE_RUNTIME_DRIVER + VERSION_STRING =3D 1.0 + ENTRY_POINT =3D FvbInitialize + +# +# The following information is for reference only and not required by the = build +# tools. +# +# VALID_ARCHITECTURES =3D IA32 X64 +# + +[Sources] + FvbInfo.c + FwBlockService.c + FwBlockServiceDxe.c + QemuFlash.c + QemuFlashDxe.c + +[Packages] + MdePkg/MdePkg.dec + MdeModulePkg/MdeModulePkg.dec + OvmfPkg/OvmfPkg.dec + Platform/Loongson/LoongArchQemuPkg/Loongson.dec + +[LibraryClasses] + BaseLib + BaseMemoryLib + DebugLib + DevicePathLib + DxeServicesTableLib + MemoryAllocationLib + PcdLib + UefiBootServicesTableLib + UefiDriverEntryPoint + UefiRuntimeLib + +[Guids] + gEfiEventVirtualAddressChangeGuid # ALWAYS_CONSUMED + # gEfiEventVirtualAddressChangeGuid # Create Event: EVENT_GROUP_GUID + +[Protocols] + gEfiFirmwareVolumeBlockProtocolGuid # PROTOCOL SOMETIMES_PRODU= CED + gEfiDevicePathProtocolGuid # PROTOCOL SOMETIMES_PRODU= CED + +[FixedPcd] + gLoongArchQemuPkgTokenSpaceGuid.PcdOvmfFlashNvStorageVariableBase + gLoongArchQemuPkgTokenSpaceGuid.PcdOvmfFlashNvStorageFtwWorkingBase + gLoongArchQemuPkgTokenSpaceGuid.PcdOvmfFlashNvStorageFtwSpareBase + gLoongArchQemuPkgTokenSpaceGuid.PcdFlashFdBase + gLoongArchQemuPkgTokenSpaceGuid.PcdAllVarSize + gLoongArchQemuPkgTokenSpaceGuid.PcdFlashBlockSize +[Pcd] + gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageVariableBase64 + gUefiOvmfPkgTokenSpaceGuid.PcdOvmfFlashVariablesEnable + gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageFtwWorkingBase64 + gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageFtwSpareBase64 + +[Depex] + TRUE diff --git a/Platform/Loongson/LoongArchQemuPkg/Drivers/QemuFlashFvbService= sRuntimeDxe/FwBlockService.c b/Platform/Loongson/LoongArchQemuPkg/Drivers/Q= emuFlashFvbServicesRuntimeDxe/FwBlockService.c new file mode 100644 index 0000000000..d44f2b460c --- /dev/null +++ b/Platform/Loongson/LoongArchQemuPkg/Drivers/QemuFlashFvbServicesRuntim= eDxe/FwBlockService.c @@ -0,0 +1,1158 @@ +/** @file + Implementations for Firmware Volume Block protocol. + + Copyright (c) 2021 Loongson Technology Corporation Limited. All rights r= eserved.
+ + SPDX-License-Identifier: BSD-2-Clause-Patent + +**/ + +// +// The protocols, PPI and GUID definitions for this module +// +#include +#include + +// +// The Library classes this module consumes +// +#include +#include +#include +#include +#include +#include +#include + +#include "FwBlockService.h" +#include "QemuFlash.h" + +#define EFI_FVB2_STATUS \ + (EFI_FVB2_READ_STATUS | EFI_FVB2_WRITE_STATUS | EFI_FVB2_LOCK_ST= ATUS) + +ESAL_FWB_GLOBAL *mFvbModuleGlobal; + +FV_MEMMAP_DEVICE_PATH mFvMemmapDevicePathTemplate =3D { + { + { + HARDWARE_DEVICE_PATH, + HW_MEMMAP_DP, + { + (UINT8)(sizeof (MEMMAP_DEVICE_PATH)), + (UINT8)(sizeof (MEMMAP_DEVICE_PATH) >> 8) + } + }, + EfiMemoryMappedIO, + (EFI_PHYSICAL_ADDRESS)0, + (EFI_PHYSICAL_ADDRESS)0, + }, + { + END_DEVICE_PATH_TYPE, + END_ENTIRE_DEVICE_PATH_SUBTYPE, + { + END_DEVICE_PATH_LENGTH, + 0 + } + } +}; + +FV_PIWG_DEVICE_PATH mFvPIWGDevicePathTemplate =3D { + { + { + MEDIA_DEVICE_PATH, + MEDIA_PIWG_FW_VOL_DP, + { + (UINT8)(sizeof (MEDIA_FW_VOL_DEVICE_PATH)), + (UINT8)(sizeof (MEDIA_FW_VOL_DEVICE_PATH) >> 8) + } + }, + { 0 } + }, + { + END_DEVICE_PATH_TYPE, + END_ENTIRE_DEVICE_PATH_SUBTYPE, + { + END_DEVICE_PATH_LENGTH, + 0 + } + } +}; + +EFI_FW_VOL_BLOCK_DEVICE mFvbDeviceTemplate =3D { + FVB_DEVICE_SIGNATURE, + NULL, + 0, + { + FvbProtocolGetAttributes, + FvbProtocolSetAttributes, + FvbProtocolGetPhysicalAddress, + FvbProtocolGetBlockSize, + FvbProtocolRead, + FvbProtocolWrite, + FvbProtocolEraseBlocks, + NULL + } +}; + + +EFI_STATUS +GetFvbInstance ( + IN UINTN Instance, + IN ESAL_FWB_GLOBAL *Global, + OUT EFI_FW_VOL_INSTANCE **FwhInstance + ) +/*++ + + Routine Description: + Retrieves the physical address of a memory mapped FV + + Arguments: + Instance - The FV instance whose base address is going to= be + returned + Global - Pointer to ESAL_FWB_GLOBAL that contains all + instance data + FwhInstance - The EFI_FW_VOL_INSTANCE firmware instance stru= cture + + Returns: + EFI_SUCCESS - Successfully returns + EFI_INVALID_PARAMETER - Instance not found + +--*/ +{ + EFI_FW_VOL_INSTANCE *FwhRecord; + + *FwhInstance =3D NULL; + if (Instance >=3D Global->NumFv) { + return EFI_INVALID_PARAMETER; + } + // + // Find the right instance of the FVB private data + // + FwhRecord =3D Global->FvInstance; + while (Instance > 0) { + FwhRecord =3D (EFI_FW_VOL_INSTANCE *) + ( + (UINTN)((UINT8 *)FwhRecord) + FwhRecord->VolumeHeader.Hea= derLength + + (sizeof (EFI_FW_VOL_INSTANCE) - sizeof (EFI_FIRMWARE_VOLU= ME_HEADER)) + ); + Instance--; + } + + *FwhInstance =3D FwhRecord; + + return EFI_SUCCESS; +} + +EFI_STATUS +FvbGetPhysicalAddress ( + IN UINTN Instance, + OUT EFI_PHYSICAL_ADDRESS *Address, + IN ESAL_FWB_GLOBAL *Global + ) +/*++ + + Routine Description: + Retrieves the physical address of a memory mapped FV + + Arguments: + Instance - The FV instance whose base address is going to= be + returned + Address - Pointer to a caller allocated EFI_PHYSICAL_ADD= RESS + that on successful return, contains the base + address of the firmware volume. + Global - Pointer to ESAL_FWB_GLOBAL that contains all + instance data + + Returns: + EFI_SUCCESS - Successfully returns + EFI_INVALID_PARAMETER - Instance not found + +--*/ +{ + EFI_FW_VOL_INSTANCE *FwhInstance; + EFI_STATUS Status; + + // + // Find the right instance of the FVB private data + // + Status =3D GetFvbInstance (Instance, Global, &FwhInstance); + ASSERT_EFI_ERROR (Status); + *Address =3D FwhInstance->FvBase; + + return EFI_SUCCESS; +} + +EFI_STATUS +FvbGetVolumeAttributes ( + IN UINTN Instance, + OUT EFI_FVB_ATTRIBUTES_2 *Attributes, + IN ESAL_FWB_GLOBAL *Global + ) +/*++ + + Routine Description: + Retrieves attributes, insures positive polarity of attribute bits, ret= urns + resulting attributes in output parameter + + Arguments: + Instance - The FV instance whose attributes is going to be + returned + Attributes - Output buffer which contains attributes + Global - Pointer to ESAL_FWB_GLOBAL that contains all + instance data + + Returns: + EFI_SUCCESS - Successfully returns + EFI_INVALID_PARAMETER - Instance not found + +--*/ +{ + EFI_FW_VOL_INSTANCE *FwhInstance; + EFI_STATUS Status; + + // + // Find the right instance of the FVB private data + // + Status =3D GetFvbInstance (Instance, Global, &FwhInstance); + ASSERT_EFI_ERROR (Status); + *Attributes =3D FwhInstance->VolumeHeader.Attributes; + + return EFI_SUCCESS; +} + +EFI_STATUS +FvbGetLbaAddress ( + IN UINTN Instance, + IN EFI_LBA Lba, + OUT UINTN *LbaAddress, + OUT UINTN *LbaLength, + OUT UINTN *NumOfBlocks, + IN ESAL_FWB_GLOBAL *Global + ) +/*++ + + Routine Description: + Retrieves the starting address of an LBA in an FV + + Arguments: + Instance - The FV instance which the Lba belongs to + Lba - The logical block address + LbaAddress - On output, contains the physical starting addr= ess + of the Lba + LbaLength - On output, contains the length of the block + NumOfBlocks - A pointer to a caller allocated UINTN in which= the + number of consecutive blocks starting with Lba= is + returned. All blocks in this range have a size= of + BlockSize + Global - Pointer to ESAL_FWB_GLOBAL that contains all + instance data + + Returns: + EFI_SUCCESS - Successfully returns + EFI_INVALID_PARAMETER - Instance not found + +--*/ +{ + UINT32 NumBlocks; + UINT32 BlockLength; + UINTN Offset; + EFI_LBA StartLba; + EFI_LBA NextLba; + EFI_FW_VOL_INSTANCE *FwhInstance; + EFI_FV_BLOCK_MAP_ENTRY *BlockMap; + EFI_STATUS Status; + + // + // Find the right instance of the FVB private data + // + Status =3D GetFvbInstance (Instance, Global, &FwhInstance); + ASSERT_EFI_ERROR (Status); + + StartLba =3D 0; + Offset =3D 0; + BlockMap =3D &(FwhInstance->VolumeHeader.BlockMap[0]); + + // + // Parse the blockmap of the FV to find which map entry the Lba belongs = to + // + while (TRUE) { + NumBlocks =3D BlockMap->NumBlocks; + BlockLength =3D BlockMap->Length; + + if ((NumBlocks =3D=3D 0) || (BlockLength =3D=3D 0)) { + return EFI_INVALID_PARAMETER; + } + + NextLba =3D StartLba + NumBlocks; + + // + // The map entry found + // + if ((Lba >=3D StartLba) && (Lba < NextLba)) { + Offset =3D Offset + (UINTN)MultU64x32 ((Lba - StartLba), BlockLength= ); + if (LbaAddress !=3D NULL) { + *LbaAddress =3D FwhInstance->FvBase + Offset; + } + + if (LbaLength !=3D NULL) { + *LbaLength =3D BlockLength; + } + + if (NumOfBlocks !=3D NULL) { + *NumOfBlocks =3D (UINTN)(NextLba - Lba); + } + + return EFI_SUCCESS; + } + + StartLba =3D NextLba; + Offset =3D Offset + NumBlocks * BlockLength; + BlockMap++; + } +} + +EFI_STATUS +FvbSetVolumeAttributes ( + IN UINTN Instance, + IN OUT EFI_FVB_ATTRIBUTES_2 *Attributes, + IN ESAL_FWB_GLOBAL *Global + ) +/*++ + + Routine Description: + Modifies the current settings of the firmware volume according to the + input parameter, and returns the new setting of the volume + + Arguments: + Instance - The FV instance whose attributes is going to be + modified + Attributes - On input, it is a pointer to EFI_FVB_ATTRIBUTE= S_2 + containing the desired firmware volume setting= s. + On successful return, it contains the new sett= ings + of the firmware volume + Global - Pointer to ESAL_FWB_GLOBAL that contains all + instance data + + Returns: + EFI_SUCCESS - Successfully returns + EFI_ACCESS_DENIED - The volume setting is locked and cannot be mod= ified + EFI_INVALID_PARAMETER - Instance not found, or The attributes requeste= d are + in conflict with the capabilities as declared = in + the firmware volume header + +--*/ +{ + EFI_FW_VOL_INSTANCE *FwhInstance; + EFI_FVB_ATTRIBUTES_2 OldAttributes; + EFI_FVB_ATTRIBUTES_2 *AttribPtr; + UINT32 Capabilities; + UINT32 OldStatus; + UINT32 NewStatus; + EFI_STATUS Status; + EFI_FVB_ATTRIBUTES_2 UnchangedAttributes; + + // + // Find the right instance of the FVB private data + // + Status =3D GetFvbInstance (Instance, Global, &FwhInstance); + ASSERT_EFI_ERROR (Status); + + AttribPtr =3D + (EFI_FVB_ATTRIBUTES_2 *)&(FwhInstance->VolumeHeader.Attributes); + OldAttributes =3D *AttribPtr; + Capabilities =3D OldAttributes & (EFI_FVB2_READ_DISABLED_CAP | \ + EFI_FVB2_READ_ENABLED_CAP | \ + EFI_FVB2_WRITE_DISABLED_CAP | \ + EFI_FVB2_WRITE_ENABLED_CAP | \ + EFI_FVB2_LOCK_CAP \ + ); + OldStatus =3D OldAttributes & EFI_FVB2_STATUS; + NewStatus =3D *Attributes & EFI_FVB2_STATUS; + + UnchangedAttributes =3D EFI_FVB2_READ_DISABLED_CAP | \ + EFI_FVB2_READ_ENABLED_CAP | \ + EFI_FVB2_WRITE_DISABLED_CAP | \ + EFI_FVB2_WRITE_ENABLED_CAP | \ + EFI_FVB2_LOCK_CAP | \ + EFI_FVB2_STICKY_WRITE | \ + EFI_FVB2_MEMORY_MAPPED | \ + EFI_FVB2_ERASE_POLARITY | \ + EFI_FVB2_READ_LOCK_CAP | \ + EFI_FVB2_WRITE_LOCK_CAP | \ + EFI_FVB2_ALIGNMENT; + + // + // Some attributes of FV is read only can *not* be set + // + if ((OldAttributes & UnchangedAttributes) ^ + (*Attributes & UnchangedAttributes)) + { + return EFI_INVALID_PARAMETER; + } + // + // If firmware volume is locked, no status bit can be updated + // + if (OldAttributes & EFI_FVB2_LOCK_STATUS) { + if (OldStatus ^ NewStatus) { + return EFI_ACCESS_DENIED; + } + } + // + // Test read disable + // + if ((Capabilities & EFI_FVB2_READ_DISABLED_CAP) =3D=3D 0) { + if ((NewStatus & EFI_FVB2_READ_STATUS) =3D=3D 0) { + return EFI_INVALID_PARAMETER; + } + } + // + // Test read enable + // + if ((Capabilities & EFI_FVB2_READ_ENABLED_CAP) =3D=3D 0) { + if (NewStatus & EFI_FVB2_READ_STATUS) { + return EFI_INVALID_PARAMETER; + } + } + // + // Test write disable + // + if ((Capabilities & EFI_FVB2_WRITE_DISABLED_CAP) =3D=3D 0) { + if ((NewStatus & EFI_FVB2_WRITE_STATUS) =3D=3D 0) { + return EFI_INVALID_PARAMETER; + } + } + // + // Test write enable + // + if ((Capabilities & EFI_FVB2_WRITE_ENABLED_CAP) =3D=3D 0) { + if (NewStatus & EFI_FVB2_WRITE_STATUS) { + return EFI_INVALID_PARAMETER; + } + } + // + // Test lock + // + if ((Capabilities & EFI_FVB2_LOCK_CAP) =3D=3D 0) { + if (NewStatus & EFI_FVB2_LOCK_STATUS) { + return EFI_INVALID_PARAMETER; + } + } + + *AttribPtr =3D (*AttribPtr) & (0xFFFFFFFF & (~EFI_FVB2_STATUS)); + *AttribPtr =3D (*AttribPtr) | NewStatus; + *Attributes =3D *AttribPtr; + + return EFI_SUCCESS; +} + +// +// FVB protocol APIs +// +EFI_STATUS +EFIAPI +FvbProtocolGetPhysicalAddress ( + IN CONST EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *This, + OUT EFI_PHYSICAL_ADDRESS *Address + ) +/*++ + + Routine Description: + + Retrieves the physical address of the device. + + Arguments: + + This - Calling context + Address - Output buffer containing the address. + + Returns: + EFI_SUCCESS - Successfully returns + +--*/ +{ + EFI_FW_VOL_BLOCK_DEVICE *FvbDevice; + + FvbDevice =3D FVB_DEVICE_FROM_THIS (This); + + return FvbGetPhysicalAddress ( + FvbDevice->Instance, + Address, + mFvbModuleGlobal + ); +} + +EFI_STATUS +EFIAPI +FvbProtocolGetBlockSize ( + IN CONST EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *This, + IN CONST EFI_LBA Lba, + OUT UINTN *BlockSize, + OUT UINTN *NumOfBlocks + ) +/*++ + + Routine Description: + Retrieve the size of a logical block + + Arguments: + This - Calling context + Lba - Indicates which block to return the size for. + BlockSize - A pointer to a caller allocated UINTN in which + the size of the block is returned + NumOfBlocks - a pointer to a caller allocated UINTN in which= the + number of consecutive blocks starting with Lba= is + returned. All blocks in this range have a size= of + BlockSize + + Returns: + EFI_SUCCESS - The firmware volume was read successfully and + contents are in Buffer + +--*/ +{ + EFI_FW_VOL_BLOCK_DEVICE *FvbDevice; + + FvbDevice =3D FVB_DEVICE_FROM_THIS (This); + + return FvbGetLbaAddress ( + FvbDevice->Instance, + Lba, + NULL, + BlockSize, + NumOfBlocks, + mFvbModuleGlobal + ); +} + +EFI_STATUS +EFIAPI +FvbProtocolGetAttributes ( + IN CONST EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *This, + OUT EFI_FVB_ATTRIBUTES_2 *Attributes + ) +/*++ + + Routine Description: + Retrieves Volume attributes. No polarity translations are done. + + Arguments: + This - Calling context + Attributes - output buffer which contains attributes + + Returns: + EFI_SUCCESS - Successfully returns + +--*/ +{ + EFI_FW_VOL_BLOCK_DEVICE *FvbDevice; + + FvbDevice =3D FVB_DEVICE_FROM_THIS (This); + + return FvbGetVolumeAttributes ( + FvbDevice->Instance, + Attributes, + mFvbModuleGlobal + ); +} + +EFI_STATUS +EFIAPI +FvbProtocolSetAttributes ( + IN CONST EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *This, + IN OUT EFI_FVB_ATTRIBUTES_2 *Attributes + ) +/*++ + + Routine Description: + Sets Volume attributes. No polarity translations are done. + + Arguments: + This - Calling context + Attributes - output buffer which contains attributes + + Returns: + EFI_SUCCESS - Successfully returns + +--*/ +{ + EFI_FW_VOL_BLOCK_DEVICE *FvbDevice; + + FvbDevice =3D FVB_DEVICE_FROM_THIS (This); + + return FvbSetVolumeAttributes ( + FvbDevice->Instance, + Attributes, + mFvbModuleGlobal + ); +} + +EFI_STATUS +EFIAPI +FvbProtocolEraseBlocks ( + IN CONST EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *This, + ... + ) +/*++ + + Routine Description: + + The EraseBlock() function erases one or more blocks as denoted by the + variable argument list. The entire parameter list of blocks must be + verified prior to erasing any blocks. If a block is requested that do= es + not exist within the associated firmware volume (it has a larger index= than + the last block of the firmware volume), the EraseBlock() function must + return EFI_INVALID_PARAMETER without modifying the contents of the fir= mware + volume. + + Arguments: + This - Calling context + ... - Starting LBA followed by Number of Lba to eras= e. + a -1 to terminate the list. + + Returns: + EFI_SUCCESS - The erase request was successfully completed + EFI_ACCESS_DENIED - The firmware volume is in the WriteDisabled st= ate + EFI_DEVICE_ERROR - The block device is not functioning correctly = and + could not be written. Firmware device may have= been + partially erased + +--*/ +{ + EFI_FW_VOL_BLOCK_DEVICE *FvbDevice; + EFI_FW_VOL_INSTANCE *FwhInstance; + UINTN NumOfBlocks; + VA_LIST args; + EFI_LBA StartingLba; + UINTN NumOfLba; + EFI_STATUS Status; + + FvbDevice =3D FVB_DEVICE_FROM_THIS (This); + + Status =3D GetFvbInstance ( + FvbDevice->Instance, + mFvbModuleGlobal, + &FwhInstance + ); + ASSERT_EFI_ERROR (Status); + + NumOfBlocks =3D FwhInstance->NumOfBlocks; + + VA_START (args, This); + + do { + StartingLba =3D VA_ARG (args, EFI_LBA); + if (StartingLba =3D=3D EFI_LBA_LIST_TERMINATOR) { + break; + } + + NumOfLba =3D VA_ARG (args, UINTN); + + // + // Check input parameters + // + if ((NumOfLba =3D=3D 0) || ((StartingLba + NumOfLba) > NumOfBlocks)) { + VA_END (args); + return EFI_INVALID_PARAMETER; + } + } while (1); + + VA_END (args); + + VA_START (args, This); + do { + StartingLba =3D VA_ARG (args, EFI_LBA); + if (StartingLba =3D=3D EFI_LBA_LIST_TERMINATOR) { + break; + } + + NumOfLba =3D VA_ARG (args, UINTN); + + while (NumOfLba > 0) { + Status =3D QemuFlashEraseBlock (StartingLba); + if (EFI_ERROR (Status)) { + VA_END (args); + return Status; + } + + StartingLba++; + NumOfLba--; + } + + } while (1); + + VA_END (args); + + return EFI_SUCCESS; +} + +EFI_STATUS +EFIAPI +FvbProtocolWrite ( + IN CONST EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *This, + IN EFI_LBA Lba, + IN UINTN Offset, + IN OUT UINTN *NumBytes, + IN UINT8 *Buffer + ) +/*++ + + Routine Description: + + Writes data beginning at Lba:Offset from FV. The write terminates eith= er + when *NumBytes of data have been written, or when a block boundary is + reached. *NumBytes is updated to reflect the actual number of bytes + written. The write operation does not include erase. This routine will + attempt to write only the specified bytes. If the writes do not stick, + it will return an error. + + Arguments: + This - Calling context + Lba - Block in which to begin write + Offset - Offset in the block at which to begin write + NumBytes - On input, indicates the requested write size. = On + output, indicates the actual number of bytes + written + Buffer - Buffer containing source data for the write. + + Returns: + EFI_SUCCESS - The firmware volume was written successfully + EFI_BAD_BUFFER_SIZE - Write attempted across a LBA boundary. On outp= ut, + NumBytes contains the total number of bytes + actually written + EFI_ACCESS_DENIED - The firmware volume is in the WriteDisabled st= ate + EFI_DEVICE_ERROR - The block device is not functioning correctly = and + could not be written + EFI_INVALID_PARAMETER - NumBytes or Buffer are NULL + +--*/ +{ + return QemuFlashWrite ( + (EFI_LBA)Lba, + (UINTN)Offset, + NumBytes, + (UINT8 *)Buffer + ); +} + +EFI_STATUS +EFIAPI +FvbProtocolRead ( + IN CONST EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *This, + IN CONST EFI_LBA Lba, + IN CONST UINTN Offset, + IN OUT UINTN *NumBytes, + IN UINT8 *Buffer + ) +/*++ + + Routine Description: + + Reads data beginning at Lba:Offset from FV. The Read terminates either + when *NumBytes of data have been read, or when a block boundary is + reached. *NumBytes is updated to reflect the actual number of bytes + written. The write operation does not include erase. This routine will + attempt to write only the specified bytes. If the writes do not stick, + it will return an error. + + Arguments: + This - Calling context + Lba - Block in which to begin Read + Offset - Offset in the block at which to begin Read + NumBytes - On input, indicates the requested write size. = On + output, indicates the actual number of bytes R= ead + Buffer - Buffer containing source data for the Read. + + Returns: + EFI_SUCCESS - The firmware volume was read successfully and + contents are in Buffer + EFI_BAD_BUFFER_SIZE - Read attempted across a LBA boundary. On outpu= t, + NumBytes contains the total number of bytes + returned in Buffer + EFI_ACCESS_DENIED - The firmware volume is in the ReadDisabled sta= te + EFI_DEVICE_ERROR - The block device is not functioning correctly = and + could not be read + EFI_INVALID_PARAMETER - NumBytes or Buffer are NULL + +--*/ +{ + return QemuFlashRead ( + (EFI_LBA)Lba, + (UINTN)Offset, + NumBytes, + (UINT8 *)Buffer + ); +} + +EFI_STATUS +ValidateFvHeader ( + EFI_FIRMWARE_VOLUME_HEADER *FwVolHeader + ) +/*++ + + Routine Description: + Check the integrity of firmware volume header + + Arguments: + FwVolHeader - A pointer to a firmware volume header + + Returns: + EFI_SUCCESS - The firmware volume is consistent + EFI_NOT_FOUND - The firmware volume has corrupted. So it is no= t an + FV + +--*/ +{ + UINT16 Checksum; + + // + // Verify the header revision, header signature, length + // Length of FvBlock cannot be 2**64-1 + // HeaderLength cannot be an odd number + // + if ((FwVolHeader->Revision !=3D EFI_FVH_REVISION) || + (FwVolHeader->Signature !=3D EFI_FVH_SIGNATURE) || + (FwVolHeader->FvLength =3D=3D ((UINTN)-1)) || + ((FwVolHeader->HeaderLength & 0x01) !=3D 0) + ) + { + return EFI_NOT_FOUND; + } + + // + // Verify the header checksum + // + + Checksum =3D CalculateSum16 ( + (UINT16 *)FwVolHeader, + FwVolHeader->HeaderLength + ); + if (Checksum !=3D 0) { + UINT16 Expected; + + Expected =3D + (UINT16)(((UINTN)FwVolHeader->Checksum + 0x10000 - Checksum) & 0xfff= f); + + DEBUG (( + DEBUG_INFO, + "FV@%p Checksum is 0x%x, expected 0x%x\n", + FwVolHeader, + FwVolHeader->Checksum, + Expected + )); + return EFI_NOT_FOUND; + } + + return EFI_SUCCESS; +} + +STATIC +EFI_STATUS +MarkMemoryRangeForRuntimeAccess ( + EFI_PHYSICAL_ADDRESS BaseAddress, + UINTN Length + ) +{ + EFI_STATUS Status; + + // + // Mark flash region as runtime memory + // + Status =3D gDS->RemoveMemorySpace ( + BaseAddress, + Length + ); + + Status =3D gDS->AddMemorySpace ( + EfiGcdMemoryTypeSystemMemory, + BaseAddress, + Length, + EFI_MEMORY_UC | EFI_MEMORY_RUNTIME + ); + ASSERT_EFI_ERROR (Status); + + Status =3D gBS->AllocatePages ( + AllocateAddress, + EfiRuntimeServicesData, + EFI_SIZE_TO_PAGES (Length), + &BaseAddress + ); + ASSERT_EFI_ERROR (Status); + + return Status; +} + +STATIC +EFI_STATUS +InitializeVariableFvHeader ( + VOID + ) +{ + EFI_STATUS Status; + EFI_FIRMWARE_VOLUME_HEADER *GoodFwVolHeader; + EFI_FIRMWARE_VOLUME_HEADER *FwVolHeader; + UINTN Length; + UINTN WriteLength; + UINTN BlockSize; + + FwVolHeader =3D + (EFI_FIRMWARE_VOLUME_HEADER *)(UINTN) + PcdGet64 (PcdOvmfFlashNvStorageVariableBase); + + Length =3D FixedPcdGet32 (PcdAllVarSize); + BlockSize =3D PcdGet32 (PcdFlashBlockSize); + + Status =3D ValidateFvHeader (FwVolHeader); + if (!EFI_ERROR (Status)) { + if ((FwVolHeader->FvLength !=3D Length) || + (FwVolHeader->BlockMap[0].Length !=3D BlockSize)) + { + Status =3D EFI_VOLUME_CORRUPTED; + } + } + if (EFI_ERROR (Status)) { + UINTN Offset; + UINTN Start; + + DEBUG (( + DEBUG_INFO, + "Variable FV header is not valid. It will be reinitialized.\n" + )); + + // + // Get FvbInfo to provide in FwhInstance. + // + Status =3D GetFvbInfo (Length, &GoodFwVolHeader); + ASSERT (!EFI_ERROR (Status)); + + Start =3D (UINTN)(UINT8*) FwVolHeader - PcdGet64 (PcdFlashFdBase); + ASSERT (Start % BlockSize =3D=3D 0 && Length % BlockSize =3D=3D 0); + ASSERT (GoodFwVolHeader->HeaderLength <=3D BlockSize); + + // + // Erase all the blocks + // + for (Offset =3D Start; Offset < Start + Length; Offset +=3D BlockSize)= { + Status =3D QemuFlashEraseBlock (Offset / BlockSize); + ASSERT_EFI_ERROR (Status); + } + + // + // Write good FV header + // + WriteLength =3D GoodFwVolHeader->HeaderLength; + Status =3D QemuFlashWrite ( + Start / BlockSize, + 0, + &WriteLength, + (UINT8 *)GoodFwVolHeader + ); + ASSERT_EFI_ERROR (Status); + ASSERT (WriteLength =3D=3D GoodFwVolHeader->HeaderLength); + } + + return Status; +} + +EFI_STATUS +EFIAPI +FvbInitialize ( + IN EFI_HANDLE ImageHandle, + IN EFI_SYSTEM_TABLE *SystemTable + ) +/*++ + + Routine Description: + This function does common initialization for FVB services + + Arguments: + + Returns: + +--*/ +{ + EFI_STATUS Status; + EFI_FW_VOL_INSTANCE *FwhInstance; + EFI_FIRMWARE_VOLUME_HEADER *FwVolHeader; + UINT32 BufferSize; + EFI_FV_BLOCK_MAP_ENTRY *PtrBlockMapEntry; + EFI_FW_VOL_BLOCK_DEVICE *FvbDevice; + UINT32 MaxLbaSize; + EFI_PHYSICAL_ADDRESS BaseAddress; + UINTN Length; + UINTN NumOfBlocks; + RETURN_STATUS PcdStatus; + + if (EFI_ERROR (QemuFlashInitialize ())) { + // + // Return an error so image will be unloaded + // + DEBUG (( + DEBUG_INFO, + "QEMU flash was not detected. Writable FVB is not being installed.\n" + )); + return EFI_WRITE_PROTECTED; + } + + // + // Allocate runtime services data for global variable, which contains + // the private data of all firmware volume block instances + // + mFvbModuleGlobal =3D AllocateRuntimePool (sizeof (ESAL_FWB_GLOBAL)); + ASSERT (mFvbModuleGlobal !=3D NULL); + + BaseAddress =3D (UINTN) PcdGet64 (PcdOvmfFlashNvStorageVariableBase); + Length =3D PcdGet32 (PcdAllVarSize); + + Status =3D InitializeVariableFvHeader (); + if (EFI_ERROR (Status)) { + DEBUG (( + DEBUG_INFO, + "QEMU Flash: Unable to initialize variable FV header\n" + )); + return EFI_WRITE_PROTECTED; + } + + FwVolHeader =3D (EFI_FIRMWARE_VOLUME_HEADER *)(UINTN)BaseAddress; + Status =3D ValidateFvHeader (FwVolHeader); + if (EFI_ERROR (Status)) { + // + // Get FvbInfo + // + Status =3D GetFvbInfo (Length, &FwVolHeader); + if (EFI_ERROR (Status)) { + DEBUG ((DEBUG_INFO, "EFI_ERROR (GetFvbInfo (Length, &FwVolHeader))\n= ")); + return EFI_WRITE_PROTECTED; + } + } + + BufferSize =3D (sizeof (EFI_FW_VOL_INSTANCE) + + FwVolHeader->HeaderLength - + sizeof (EFI_FIRMWARE_VOLUME_HEADER) + ); + mFvbModuleGlobal->FvInstance =3D AllocateRuntimePool (BufferSize); + ASSERT (mFvbModuleGlobal->FvInstance !=3D NULL); + + FwhInstance =3D mFvbModuleGlobal->FvInstance; + + mFvbModuleGlobal->NumFv =3D 0; + MaxLbaSize =3D 0; + + FwVolHeader =3D + (EFI_FIRMWARE_VOLUME_HEADER *)(UINTN) + PcdGet64 (PcdOvmfFlashNvStorageVariableBase); + + FwhInstance->FvBase =3D (UINTN)BaseAddress; + + CopyMem ( + (UINTN *)&(FwhInstance->VolumeHeader), + (UINTN *)FwVolHeader, + FwVolHeader->HeaderLength + ); + FwVolHeader =3D &(FwhInstance->VolumeHeader); + + NumOfBlocks =3D 0; + + for (PtrBlockMapEntry =3D FwVolHeader->BlockMap; + PtrBlockMapEntry->NumBlocks !=3D 0; + PtrBlockMapEntry++) + { + // + // Get the maximum size of a block. + // + if (MaxLbaSize < PtrBlockMapEntry->Length) { + MaxLbaSize =3D PtrBlockMapEntry->Length; + } + + NumOfBlocks =3D NumOfBlocks + PtrBlockMapEntry->NumBlocks; + } + + // + // The total number of blocks in the FV. + // + FwhInstance->NumOfBlocks =3D NumOfBlocks; + + // + // Add a FVB Protocol Instance + // + FvbDevice =3D AllocateRuntimePool (sizeof (EFI_FW_VOL_BLOCK_DEVICE)); + ASSERT (FvbDevice !=3D NULL); + + CopyMem (FvbDevice, &mFvbDeviceTemplate, sizeof (EFI_FW_VOL_BLOCK_DEVICE= )); + + FvbDevice->Instance =3D mFvbModuleGlobal->NumFv; + mFvbModuleGlobal->NumFv++; + + // + // Set up the devicepath + // + if (FwVolHeader->ExtHeaderOffset =3D=3D 0) { + FV_MEMMAP_DEVICE_PATH *FvMemmapDevicePath; + + // + // FV does not contains extension header, then produce MEMMAP_DEVICE_P= ATH + // + FvMemmapDevicePath =3D AllocateCopyPool ( + sizeof (FV_MEMMAP_DEVICE_PATH), + &mFvMemmapDevicePathTemplate + ); + FvMemmapDevicePath->MemMapDevPath.StartingAddress =3D BaseAddress; + FvMemmapDevicePath->MemMapDevPath.EndingAddress =3D + BaseAddress + FwVolHeader->FvLength - 1; + FvbDevice->DevicePath =3D (EFI_DEVICE_PATH_PROTOCOL *)FvMemmapDevicePa= th; + } else { + FV_PIWG_DEVICE_PATH *FvPiwgDevicePath; + + FvPiwgDevicePath =3D AllocateCopyPool ( + sizeof (FV_PIWG_DEVICE_PATH), + &mFvPIWGDevicePathTemplate + ); + CopyGuid ( + &FvPiwgDevicePath->FvDevPath.FvName, + (GUID *)(UINTN)(BaseAddress + FwVolHeader->ExtHeaderOffset) + ); + FvbDevice->DevicePath =3D (EFI_DEVICE_PATH_PROTOCOL *)FvPiwgDevicePath; + } + + // + // Module type specific hook. + // + InstallProtocolInterfaces (FvbDevice); + + MarkMemoryRangeForRuntimeAccess (BaseAddress, Length); + + // + // Set several PCD values to point to flash + // + + + PcdStatus =3D PcdSet64S ( + PcdFlashNvStorageVariableBase64, + (UINTN) PcdGet64 (PcdOvmfFlashNvStorageVariableBase) + ); + ASSERT_RETURN_ERROR (PcdStatus); + PcdStatus =3D PcdSet64S ( + PcdFlashNvStorageFtwWorkingBase64, + PcdGet64 (PcdOvmfFlashNvStorageFtwWorkingBase) + ); + ASSERT_RETURN_ERROR (PcdStatus); + PcdStatus =3D PcdSet64S ( + PcdFlashNvStorageFtwSpareBase64, + PcdGet64 (PcdOvmfFlashNvStorageFtwSpareBase) + ); + ASSERT_RETURN_ERROR (PcdStatus); + + FwhInstance =3D (EFI_FW_VOL_INSTANCE *) + ( + (UINTN)((UINT8 *)FwhInstance) + FwVolHeader->HeaderLength= + + (sizeof (EFI_FW_VOL_INSTANCE) - sizeof (EFI_FIRMWARE_VOLU= ME_HEADER)) + ); + + // + // Module type specific hook. + // + InstallVirtualAddressChangeHandler (); + + PcdStatus =3D PcdSetBoolS (PcdOvmfFlashVariablesEnable, TRUE); + ASSERT_RETURN_ERROR (PcdStatus); + return EFI_SUCCESS; +} diff --git a/Platform/Loongson/LoongArchQemuPkg/Drivers/QemuFlashFvbService= sRuntimeDxe/FwBlockService.h b/Platform/Loongson/LoongArchQemuPkg/Drivers/Q= emuFlashFvbServicesRuntimeDxe/FwBlockService.h new file mode 100644 index 0000000000..e7234a0c5e --- /dev/null +++ b/Platform/Loongson/LoongArchQemuPkg/Drivers/QemuFlashFvbServicesRuntim= eDxe/FwBlockService.h @@ -0,0 +1,178 @@ +/** @file + Firmware volume block driver for Intel Firmware Hub (FWH) device + + Copyright (c) 2021 Loongson Technology Corporation Limited. All rights r= eserved.
+ + SPDX-License-Identifier: BSD-2-Clause-Patent + +**/ +#ifndef _FW_BLOCK_SERVICE_H +#define _FW_BLOCK_SERVICE_H + +typedef struct { + UINTN FvBase; + UINTN NumOfBlocks; + EFI_FIRMWARE_VOLUME_HEADER VolumeHeader; +} EFI_FW_VOL_INSTANCE; + +typedef struct { + UINT32 NumFv; + EFI_FW_VOL_INSTANCE *FvInstance; +} ESAL_FWB_GLOBAL; + +extern ESAL_FWB_GLOBAL *mFvbModuleGlobal; + +// +// Fvb Protocol instance data +// +#define FVB_DEVICE_FROM_THIS(a) CR (a, EFI_FW_VOL_BLOCK_DEVICE,\ + FwVolBlockInstance, FVB_DEVICE_SIGNATURE) + +#define FVB_EXTEND_DEVICE_FROM_THIS(a) CR (a, EFI_FW_VOL_BLOCK_DEVICE,\ + FvbExtension, FVB_DEVICE_SIGNATUR= E) + +#define FVB_DEVICE_SIGNATURE SIGNATURE_32 ('F', 'V', 'B', 'N') + +typedef struct { + MEDIA_FW_VOL_DEVICE_PATH FvDevPath; + EFI_DEVICE_PATH_PROTOCOL EndDevPath; +} FV_PIWG_DEVICE_PATH; + +typedef struct { + MEMMAP_DEVICE_PATH MemMapDevPath; + EFI_DEVICE_PATH_PROTOCOL EndDevPath; +} FV_MEMMAP_DEVICE_PATH; + +typedef struct { + UINTN Signature; + EFI_DEVICE_PATH_PROTOCOL *DevicePath; + UINTN Instance; + EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL FwVolBlockInstance; +} EFI_FW_VOL_BLOCK_DEVICE; + +EFI_STATUS +GetFvbInfo ( + IN UINT64 FvLength, + OUT EFI_FIRMWARE_VOLUME_HEADER **FvbInfo + ); + +EFI_STATUS +FvbSetVolumeAttributes ( + IN UINTN Instance, + IN OUT EFI_FVB_ATTRIBUTES_2 *Attributes, + IN ESAL_FWB_GLOBAL *Global + ); + +EFI_STATUS +FvbGetVolumeAttributes ( + IN UINTN Instance, + OUT EFI_FVB_ATTRIBUTES_2 *Attributes, + IN ESAL_FWB_GLOBAL *Global + ); + +EFI_STATUS +FvbGetPhysicalAddress ( + IN UINTN Instance, + OUT EFI_PHYSICAL_ADDRESS *Address, + IN ESAL_FWB_GLOBAL *Global + ); + +EFI_STATUS +EFIAPI +FvbInitialize ( + IN EFI_HANDLE ImageHandle, + IN EFI_SYSTEM_TABLE *SystemTable + ); + + +VOID +EFIAPI +FvbClassAddressChangeEvent ( + IN EFI_EVENT Event, + IN VOID *Context + ); + +EFI_STATUS +FvbGetLbaAddress ( + IN UINTN Instance, + IN EFI_LBA Lba, + OUT UINTN *LbaAddress, + OUT UINTN *LbaLength, + OUT UINTN *NumOfBlocks, + IN ESAL_FWB_GLOBAL *Global + ); + +// +// Protocol APIs +// +EFI_STATUS +EFIAPI +FvbProtocolGetAttributes ( + IN CONST EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *This, + OUT EFI_FVB_ATTRIBUTES_2 *Attributes + ); + +EFI_STATUS +EFIAPI +FvbProtocolSetAttributes ( + IN CONST EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *This, + IN OUT EFI_FVB_ATTRIBUTES_2 *Attributes + ); + +EFI_STATUS +EFIAPI +FvbProtocolGetPhysicalAddress ( + IN CONST EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *This, + OUT EFI_PHYSICAL_ADDRESS *Address + ); + +EFI_STATUS +EFIAPI +FvbProtocolGetBlockSize ( + IN CONST EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *This, + IN CONST EFI_LBA Lba, + OUT UINTN *BlockSize, + OUT UINTN *NumOfBlocks + ); + +EFI_STATUS +EFIAPI +FvbProtocolRead ( + IN CONST EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *This, + IN CONST EFI_LBA Lba, + IN CONST UINTN Offset, + IN OUT UINTN *NumBytes, + IN UINT8 *Buffer + ); + +EFI_STATUS +EFIAPI +FvbProtocolWrite ( + IN CONST EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *This, + IN EFI_LBA Lba, + IN UINTN Offset, + IN OUT UINTN *NumBytes, + IN UINT8 *Buffer + ); + +EFI_STATUS +EFIAPI +FvbProtocolEraseBlocks ( + IN CONST EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *This, + ... + ); + +// +// The following functions have different implementations dependent on the +// module type chosen for building this driver. +// +VOID +InstallProtocolInterfaces ( + IN EFI_FW_VOL_BLOCK_DEVICE *FvbDevice + ); + +VOID +InstallVirtualAddressChangeHandler ( + VOID + ); +#endif diff --git a/Platform/Loongson/LoongArchQemuPkg/Drivers/QemuFlashFvbService= sRuntimeDxe/FwBlockServiceDxe.c b/Platform/Loongson/LoongArchQemuPkg/Driver= s/QemuFlashFvbServicesRuntimeDxe/FwBlockServiceDxe.c new file mode 100644 index 0000000000..cb85499539 --- /dev/null +++ b/Platform/Loongson/LoongArchQemuPkg/Drivers/QemuFlashFvbServicesRuntim= eDxe/FwBlockServiceDxe.c @@ -0,0 +1,152 @@ +/** @file + Functions related to the Firmware Volume Block service whose + implementation is specific to the runtime DXE driver build. + + Copyright (c) 2021 Loongson Technology Corporation Limited. All rights r= eserved.
+ + SPDX-License-Identifier: BSD-2-Clause-Patent + +**/ + +#include +#include +#include +#include +#include +#include +#include +#include + +#include "FwBlockService.h" +#include "QemuFlash.h" + +VOID +InstallProtocolInterfaces ( + IN EFI_FW_VOL_BLOCK_DEVICE *FvbDevice + ) +{ + EFI_STATUS Status; + EFI_HANDLE FwbHandle; + EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *OldFwbInterface; + + // + // Find a handle with a matching device path that has supports FW Block + // protocol + // + Status =3D gBS->LocateDevicePath ( + &gEfiFirmwareVolumeBlockProtocolGuid, + &FvbDevice->DevicePath, + &FwbHandle + ); + if (EFI_ERROR (Status)) { + // + // LocateDevicePath fails so install a new interface and device path + // + FwbHandle =3D NULL; + DEBUG ((DEBUG_INFO, "Installing QEMU flash FVB\n")); + Status =3D gBS->InstallMultipleProtocolInterfaces ( + &FwbHandle, + &gEfiFirmwareVolumeBlockProtocolGuid, + &FvbDevice->FwVolBlockInstance, + &gEfiDevicePathProtocolGuid, + FvbDevice->DevicePath, + NULL + ); + ASSERT_EFI_ERROR (Status); + } else if (IsDevicePathEnd (FvbDevice->DevicePath)) { + // + // Device already exists, so reinstall the FVB protocol + // + Status =3D gBS->HandleProtocol ( + FwbHandle, + &gEfiFirmwareVolumeBlockProtocolGuid, + (VOID **)&OldFwbInterface + ); + ASSERT_EFI_ERROR (Status); + + DEBUG ((DEBUG_INFO, "Reinstalling FVB for QEMU flash region\n")); + Status =3D gBS->ReinstallProtocolInterface ( + FwbHandle, + &gEfiFirmwareVolumeBlockProtocolGuid, + OldFwbInterface, + &FvbDevice->FwVolBlockInstance + ); + ASSERT_EFI_ERROR (Status); + } else { + // + // There was a FVB protocol on an End Device Path node + // + ASSERT (FALSE); + } +} + + +STATIC +VOID +EFIAPI +FvbVirtualAddressChangeEvent ( + IN EFI_EVENT Event, + IN VOID *Context + ) +/*++ + + Routine Description: + + Fixup internal data so that EFI and SAL can be call in virtual mode. + Call the passed in Child Notify event and convert the mFvbModuleGlobal + date items to there virtual address. + + Arguments: + + (Standard EFI notify event - EFI_EVENT_NOTIFY) + + Returns: + + None + +--*/ +{ + EFI_FW_VOL_INSTANCE *FwhInstance; + UINTN Index; + + FwhInstance =3D mFvbModuleGlobal->FvInstance; + EfiConvertPointer (0x0, (VOID **)&mFvbModuleGlobal->FvInstance); + + // + // Convert the base address of all the instances + // + Index =3D 0; + while (Index < mFvbModuleGlobal->NumFv) { + EfiConvertPointer (0x0, (VOID **)&FwhInstance->FvBase); + FwhInstance =3D (EFI_FW_VOL_INSTANCE *) + ( + (UINTN)((UINT8 *)FwhInstance) + + FwhInstance->VolumeHeader.HeaderLength + + (sizeof (EFI_FW_VOL_INSTANCE) - sizeof (EFI_FIRMWARE_VO= LUME_HEADER)) + ); + Index++; + } + + EfiConvertPointer (0x0, (VOID **)&mFvbModuleGlobal); + QemuFlashConvertPointers (); +} + + +VOID +InstallVirtualAddressChangeHandler ( + VOID + ) +{ + EFI_STATUS Status; + EFI_EVENT VirtualAddressChangeEvent; + + Status =3D gBS->CreateEventEx ( + EVT_NOTIFY_SIGNAL, + TPL_NOTIFY, + FvbVirtualAddressChangeEvent, + NULL, + &gEfiEventVirtualAddressChangeGuid, + &VirtualAddressChangeEvent + ); + ASSERT_EFI_ERROR (Status); +} diff --git a/Platform/Loongson/LoongArchQemuPkg/Drivers/QemuFlashFvbService= sRuntimeDxe/QemuFlash.c b/Platform/Loongson/LoongArchQemuPkg/Drivers/QemuFl= ashFvbServicesRuntimeDxe/QemuFlash.c new file mode 100644 index 0000000000..a85d736060 --- /dev/null +++ b/Platform/Loongson/LoongArchQemuPkg/Drivers/QemuFlashFvbServicesRuntim= eDxe/QemuFlash.c @@ -0,0 +1,251 @@ +/** @file + LoongArch support for QEMU system firmware flash device + + Copyright (c) 2021 Loongson Technology Corporation Limited. All rights r= eserved.
+ + SPDX-License-Identifier: BSD-2-Clause-Patent + +**/ + +#include +#include +#include + +#include "QemuFlash.h" + +#define WRITE_BYTE_CMD 0x10 +#define BLOCK_ERASE_CMD 0x20 +#define CLEAR_STATUS_CMD 0x50 +#define READ_STATUS_CMD 0x70 +#define READ_DEVID_CMD 0x90 +#define BLOCK_ERASE_CONFIRM_CMD 0xd0 +#define READ_ARRAY_CMD 0xff + +#define CLEARED_ARRAY_STATUS 0x00 + +UINT8 *mFlashBase; + +STATIC UINTN mFdBlockSize =3D 0; +STATIC UINTN mFdBlockCount =3D 0; + +STATIC +volatile UINT8 * +QemuFlashPtr ( + IN EFI_LBA Lba, + IN UINTN Offset + ) +{ + return mFlashBase + ((UINTN)Lba * mFdBlockSize) + Offset; +} + + +/** + Determines if the QEMU flash memory device is present. + + @retval FALSE The QEMU flash device is not present. + @retval TRUE The QEMU flash device is present. + +**/ +STATIC +BOOLEAN +QemuFlashDetected ( + VOID + ) +{ + BOOLEAN FlashDetected; + volatile UINT8 *Ptr; + + UINTN Offset; + UINT8 OriginalUint8; + UINT8 ProbeUint8; + + FlashDetected =3D FALSE; + Ptr =3D QemuFlashPtr (0, 0); + + for (Offset =3D 0; Offset < mFdBlockSize; Offset++) { + Ptr =3D QemuFlashPtr (0, Offset); + ProbeUint8 =3D *Ptr; + if ((ProbeUint8 !=3D CLEAR_STATUS_CMD) && + (ProbeUint8 !=3D READ_STATUS_CMD) && + (ProbeUint8 !=3D CLEARED_ARRAY_STATUS)) + { + break; + } + } + + if (Offset >=3D mFdBlockSize) { + DEBUG ((DEBUG_INFO, "QEMU Flash: Failed to find probe location\n")); + return FALSE; + } + + DEBUG ((DEBUG_INFO, "QEMU Flash: Attempting flash detection at %p\n", Pt= r)); + + OriginalUint8 =3D *Ptr; + *Ptr =3D CLEAR_STATUS_CMD; + ProbeUint8 =3D *Ptr; + if ((OriginalUint8 !=3D CLEAR_STATUS_CMD) && + (ProbeUint8 =3D=3D CLEAR_STATUS_CMD)) + { + DEBUG ((DEBUG_INFO, "QemuFlashDetected =3D> FD behaves as RAM\n")); + *Ptr =3D OriginalUint8; + } else { + *Ptr =3D READ_STATUS_CMD; + ProbeUint8 =3D *Ptr; + if (ProbeUint8 =3D=3D OriginalUint8) { + DEBUG ((DEBUG_INFO, "QemuFlashDetected =3D> FD behaves as ROM\n")); + } else if (ProbeUint8 =3D=3D READ_STATUS_CMD) { + DEBUG ((DEBUG_INFO, "QemuFlashDetected =3D> FD behaves as RAM\n")); + *Ptr =3D OriginalUint8; + } else if (ProbeUint8 =3D=3D CLEARED_ARRAY_STATUS) { + DEBUG ((DEBUG_INFO, "QemuFlashDetected =3D> FD behaves as FLASH\n")); + FlashDetected =3D TRUE; + *Ptr =3D READ_ARRAY_CMD; + } + } + + DEBUG (( + DEBUG_INFO, + "QemuFlashDetected =3D> %a\n", + FlashDetected ? "Yes" : "No" + )); + return FlashDetected; +} + + +/** + Read from QEMU Flash + + @param[in] Lba The starting logical block index to read from. + @param[in] Offset Offset into the block at which to begin reading. + @param[in] NumBytes On input, indicates the requested read size. On + output, indicates the actual number of bytes read + @param[in] Buffer Pointer to the buffer to read into. + +**/ +EFI_STATUS +QemuFlashRead ( + IN EFI_LBA Lba, + IN UINTN Offset, + IN UINTN *NumBytes, + IN UINT8 *Buffer + ) +{ + UINT8 *Ptr; + + // + // Only write to the first 64k. We don't bother saving the FTW Spare + // block into the flash memory. + // + if (Lba >=3D mFdBlockCount) { + return EFI_INVALID_PARAMETER; + } + + // + // Get flash address + // + Ptr =3D (UINT8 *)QemuFlashPtr (Lba, Offset); + + CopyMem (Buffer, Ptr, *NumBytes); + + return EFI_SUCCESS; +} + + +/** + Write to QEMU Flash + + @param[in] Lba The starting logical block index to write to. + @param[in] Offset Offset into the block at which to begin writing. + @param[in] NumBytes On input, indicates the requested write size. On + output, indicates the actual number of bytes written + @param[in] Buffer Pointer to the data to write. + +**/ +EFI_STATUS +QemuFlashWrite ( + IN EFI_LBA Lba, + IN UINTN Offset, + IN UINTN *NumBytes, + IN UINT8 *Buffer + ) +{ + volatile UINT8 *Ptr; + UINTN Loop; + + // + // Only write to the first 64k. We don't bother saving the FTW Spare + // block into the flash memory. + // + if (Lba >=3D mFdBlockCount) { + return EFI_INVALID_PARAMETER; + } + + // + // Program flash + // + Ptr =3D QemuFlashPtr (Lba, Offset); + for (Loop =3D 0; Loop < *NumBytes; Loop++) { + *Ptr =3D WRITE_BYTE_CMD; + *Ptr =3D Buffer[Loop]; + Ptr++; + } + + // + // Restore flash to read mode + // + if (*NumBytes > 0) { + *(Ptr - 1) =3D READ_ARRAY_CMD; + } + + return EFI_SUCCESS; +} + + +/** + Erase a QEMU Flash block + + @param Lba The logical block index to erase. + +**/ +EFI_STATUS +QemuFlashEraseBlock ( + IN EFI_LBA Lba + ) +{ + volatile UINT8 *Ptr; + + if (Lba >=3D mFdBlockCount) { + return EFI_INVALID_PARAMETER; + } + + Ptr =3D QemuFlashPtr (Lba, 0); + *Ptr =3D BLOCK_ERASE_CMD; + *Ptr =3D BLOCK_ERASE_CONFIRM_CMD; + return EFI_SUCCESS; +} + + +/** + Initializes QEMU flash memory support + + @retval EFI_WRITE_PROTECTED The QEMU flash device is not present. + @retval EFI_SUCCESS The QEMU flash device is supported. + +**/ +EFI_STATUS +QemuFlashInitialize ( + VOID + ) +{ + mFlashBase =3D (UINT8 *)(UINTN)PcdGet64 (PcdOvmfFlashNvStorageVariable= Base); + mFdBlockSize =3D PcdGet32 (PcdFlashBlockSize); + ASSERT(PcdGet32 (PcdAllVarSize) % mFdBlockSize =3D=3D 0); + mFdBlockCount =3D PcdGet32 (PcdAllVarSize) / mFdBlockSize; + + if (!QemuFlashDetected ()) { + return EFI_WRITE_PROTECTED; + } + + return EFI_SUCCESS; +} + diff --git a/Platform/Loongson/LoongArchQemuPkg/Drivers/QemuFlashFvbService= sRuntimeDxe/QemuFlash.h b/Platform/Loongson/LoongArchQemuPkg/Drivers/QemuFl= ashFvbServicesRuntimeDxe/QemuFlash.h new file mode 100644 index 0000000000..27caabc5f0 --- /dev/null +++ b/Platform/Loongson/LoongArchQemuPkg/Drivers/QemuFlashFvbServicesRuntim= eDxe/QemuFlash.h @@ -0,0 +1,86 @@ +/** @file + LoongArch support for QEMU system firmware flash device + + Copyright (c) 2021 Loongson Technology Corporation Limited. All rights r= eserved.
+ + SPDX-License-Identifier: BSD-2-Clause-Patent + +**/ + +#ifndef __QEMU_FLASH_H__ +#define __QEMU_FLASH_H__ + +#include + +extern UINT8 *mFlashBase; + +/** + Read from QEMU Flash + + @param[in] Lba The starting logical block index to read from. + @param[in] Offset Offset into the block at which to begin reading. + @param[in] NumBytes On input, indicates the requested read size. On + output, indicates the actual number of bytes read + @param[in] Buffer Pointer to the buffer to read into. + +**/ +EFI_STATUS +QemuFlashRead ( + IN EFI_LBA Lba, + IN UINTN Offset, + IN UINTN *NumBytes, + IN UINT8 *Buffer + ); + + +/** + Write to QEMU Flash + + @param[in] Lba The starting logical block index to write to. + @param[in] Offset Offset into the block at which to begin writing. + @param[in] NumBytes On input, indicates the requested write size. On + output, indicates the actual number of bytes written + @param[in] Buffer Pointer to the data to write. + +**/ +EFI_STATUS +QemuFlashWrite ( + IN EFI_LBA Lba, + IN UINTN Offset, + IN UINTN *NumBytes, + IN UINT8 *Buffer + ); + + +/** + Erase a QEMU Flash block + + @param Lba The logical block index to erase. + +**/ +EFI_STATUS +QemuFlashEraseBlock ( + IN EFI_LBA Lba + ); + + +/** + Initializes QEMU flash memory support + + @retval EFI_WRITE_PROTECTED The QEMU flash device is not present. + @retval EFI_SUCCESS The QEMU flash device is supported. + +**/ +EFI_STATUS +QemuFlashInitialize ( + VOID + ); + + +VOID +QemuFlashConvertPointers ( + VOID + ); + +#endif + diff --git a/Platform/Loongson/LoongArchQemuPkg/Drivers/QemuFlashFvbService= sRuntimeDxe/QemuFlashDxe.c b/Platform/Loongson/LoongArchQemuPkg/Drivers/Qem= uFlashFvbServicesRuntimeDxe/QemuFlashDxe.c new file mode 100644 index 0000000000..b63314aac2 --- /dev/null +++ b/Platform/Loongson/LoongArchQemuPkg/Drivers/QemuFlashFvbServicesRuntim= eDxe/QemuFlashDxe.c @@ -0,0 +1,21 @@ +/** @file + LoongArch support for QEMU system firmware flash device: functions speci= fic to the + runtime DXE driver build. + + Copyright (c) 2021 Loongson Technology Corporation Limited. All rights r= eserved.
+ + SPDX-License-Identifier: BSD-2-Clause-Patent + +**/ + +#include + +#include "QemuFlash.h" + +VOID +QemuFlashConvertPointers ( + VOID + ) +{ + EfiConvertPointer (0x0, (VOID **)&mFlashBase); +} diff --git a/Platform/Loongson/LoongArchQemuPkg/Loongson.dsc b/Platform/Loo= ngson/LoongArchQemuPkg/Loongson.dsc index 578b80b7b0..ed06558f18 100644 --- a/Platform/Loongson/LoongArchQemuPkg/Loongson.dsc +++ b/Platform/Loongson/LoongArchQemuPkg/Loongson.dsc @@ -171,10 +171,10 @@ VirtioLib | OvmfPkg/Library/VirtioLib/VirtioLib.i= nf FrameBufferBltLib | MdeModulePkg/Library/FrameBufferBltLi= b/FrameBufferBltLib.inf QemuFwCfgLib | OvmfPkg/Library/QemuFwCfgLib/QemuFwCf= gLibMmio.inf - DebugLib | MdePkg/Library/BaseDebugLibSerialPort= /BaseDebugLibSerialPort.inf - PeiServicesLib | MdePkg/Library/PeiServicesLib/PeiServ= icesLib.inf + VariableFlashInfoLib | MdeModulePkg/Library/BaseVariableFlas= hInfoLib/BaseVariableFlashInfoLib.inf + [LibraryClasses.common.SEC] ReportStatusCodeLib | MdeModulePkg/Library/PeiReportStatusC= odeLib/PeiReportStatusCodeLib.inf HobLib | MdePkg/Library/PeiHobLib/PeiHobLib.inf --=20 2.31.1 -=3D-=3D-=3D-=3D-=3D-=3D-=3D-=3D-=3D-=3D-=3D- Groups.io Links: You receive all messages sent to this group. View/Reply Online (#93896): https://edk2.groups.io/g/devel/message/93896 Mute This Topic: https://groups.io/mt/93715815/1787277 Group Owner: devel+owner@edk2.groups.io Unsubscribe: https://edk2.groups.io/g/devel/unsub [importer@patchew.org] -=3D-=3D-=3D-=3D-=3D-=3D-=3D-=3D-=3D-=3D-=3D-