|
@@ -0,0 +1,1088 @@
|
|
|
+/** @file
|
|
|
+Firmware Volume Block Driver to provide FVB service.
|
|
|
+
|
|
|
+ Copyright (c) 2014 - 2021, Intel Corporation. All rights reserved.<BR>
|
|
|
+ SPDX-License-Identifier: BSD-2-Clause-Patent
|
|
|
+
|
|
|
+**/
|
|
|
+
|
|
|
+#include "FvbService.h"
|
|
|
+
|
|
|
+//
|
|
|
+// Global variable for this FVB driver which contains
|
|
|
+// the private data of all firmware volume block instances
|
|
|
+//
|
|
|
+FWB_GLOBAL mFvbModuleGlobal;
|
|
|
+
|
|
|
+FV_MEMMAP_DEVICE_PATH mFvMemmapDevicePathTemplate = {
|
|
|
+ {
|
|
|
+ {
|
|
|
+ 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 = {
|
|
|
+ {
|
|
|
+ {
|
|
|
+ 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 = {
|
|
|
+ FVB_DEVICE_SIGNATURE,
|
|
|
+ NULL,
|
|
|
+ 0, // Instance
|
|
|
+ {
|
|
|
+ FvbProtocolGetAttributes,
|
|
|
+ FvbProtocolSetAttributes,
|
|
|
+ FvbProtocolGetPhysicalAddress,
|
|
|
+ FvbProtocolGetBlockSize,
|
|
|
+ FvbProtocolRead,
|
|
|
+ FvbProtocolWrite,
|
|
|
+ FvbProtocolEraseBlocks,
|
|
|
+ NULL
|
|
|
+ } // FwVolBlockInstance
|
|
|
+};
|
|
|
+
|
|
|
+
|
|
|
+/**
|
|
|
+ Get the pointer to EFI_FW_VOL_INSTANCE from the buffer pointed
|
|
|
+ by mFvbModuleGlobal.FvInstance based on a index.
|
|
|
+ Each EFI_FW_VOL_INSTANCE is with variable length as
|
|
|
+ we have a block map at the end of the EFI_FIRMWARE_VOLUME_HEADER.
|
|
|
+
|
|
|
+ @param[in] Instance The index of the EFI_FW_VOL_INSTANCE.
|
|
|
+
|
|
|
+ @return A pointer to EFI_FW_VOL_INSTANCE.
|
|
|
+
|
|
|
+**/
|
|
|
+EFI_FW_VOL_INSTANCE *
|
|
|
+GetFvbInstance (
|
|
|
+ IN UINTN Instance
|
|
|
+ )
|
|
|
+{
|
|
|
+ EFI_FW_VOL_INSTANCE *FwhRecord;
|
|
|
+
|
|
|
+ if ( Instance >= mFvbModuleGlobal.NumFv ) {
|
|
|
+ ASSERT_EFI_ERROR (EFI_INVALID_PARAMETER);
|
|
|
+ return NULL;
|
|
|
+ }
|
|
|
+
|
|
|
+ //
|
|
|
+ // Find the right instance of the FVB private data
|
|
|
+ //
|
|
|
+ FwhRecord = mFvbModuleGlobal.FvInstance;
|
|
|
+ while ( Instance > 0 ) {
|
|
|
+ FwhRecord = (EFI_FW_VOL_INSTANCE *) ((UINTN)((UINT8 *)FwhRecord) +
|
|
|
+ FwhRecord->VolumeHeader.HeaderLength +
|
|
|
+ (sizeof (EFI_FW_VOL_INSTANCE) - sizeof (EFI_FIRMWARE_VOLUME_HEADER)));
|
|
|
+ Instance--;
|
|
|
+ }
|
|
|
+
|
|
|
+ return FwhRecord;
|
|
|
+
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+/**
|
|
|
+ Get the EFI_FVB_ATTRIBUTES_2 of a FV.
|
|
|
+
|
|
|
+ @param[in] Instance The index of the EFI_FW_VOL_INSTANCE.
|
|
|
+
|
|
|
+ @retval EFI_FVB_ATTRIBUTES_2 of the FV identified by Instance.
|
|
|
+
|
|
|
+**/
|
|
|
+STATIC
|
|
|
+EFI_FVB_ATTRIBUTES_2
|
|
|
+FvbGetVolumeAttributes (
|
|
|
+ IN UINTN Instance
|
|
|
+ )
|
|
|
+{
|
|
|
+ EFI_FW_VOL_INSTANCE * FwInstance;
|
|
|
+ FwInstance = GetFvbInstance(Instance);
|
|
|
+ ASSERT (FwInstance != NULL);
|
|
|
+
|
|
|
+ if (FwInstance == NULL) {
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+
|
|
|
+ return FwInstance->VolumeHeader.Attributes;
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+/**
|
|
|
+ Retrieves the starting address of an LBA in an FV. It also
|
|
|
+ return a few other attribut of the FV.
|
|
|
+
|
|
|
+ @param[in] Instance The index of the EFI_FW_VOL_INSTANCE.
|
|
|
+ @param[in] Lba The logical block address
|
|
|
+ @param[out] LbaAddress On output, contains the physical starting address
|
|
|
+ of the Lba
|
|
|
+ @param[out] LbaLength On output, contains the length of the block
|
|
|
+ @param[out] 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
|
|
|
+
|
|
|
+ @retval EFI_SUCCESS Successfully returns
|
|
|
+ @retval EFI_INVALID_PARAMETER Instance not found
|
|
|
+
|
|
|
+**/
|
|
|
+STATIC
|
|
|
+EFI_STATUS
|
|
|
+FvbGetLbaAddress (
|
|
|
+ IN UINTN Instance,
|
|
|
+ IN EFI_LBA Lba,
|
|
|
+ OUT UINTN *LbaAddress,
|
|
|
+ OUT UINTN *LbaLength,
|
|
|
+ OUT UINTN *NumOfBlocks
|
|
|
+ )
|
|
|
+{
|
|
|
+ UINT32 NumBlocks;
|
|
|
+ UINT32 BlockLength;
|
|
|
+ UINTN Offset;
|
|
|
+ EFI_LBA StartLba;
|
|
|
+ EFI_LBA NextLba;
|
|
|
+ EFI_FW_VOL_INSTANCE *FwhInstance;
|
|
|
+ EFI_FV_BLOCK_MAP_ENTRY *BlockMap;
|
|
|
+
|
|
|
+ //
|
|
|
+ // Find the right instance of the FVB private data
|
|
|
+ //
|
|
|
+ FwhInstance = GetFvbInstance (Instance);
|
|
|
+ if (FwhInstance == NULL) {
|
|
|
+ return EFI_INVALID_PARAMETER;
|
|
|
+ }
|
|
|
+
|
|
|
+ StartLba = 0;
|
|
|
+ Offset = 0;
|
|
|
+ BlockMap = &FwhInstance->VolumeHeader.BlockMap[0];
|
|
|
+ ASSERT (BlockMap != NULL);
|
|
|
+
|
|
|
+ //
|
|
|
+ // Parse the blockmap of the FV to find which map entry the Lba belongs to
|
|
|
+ //
|
|
|
+ while (TRUE) {
|
|
|
+ if ( BlockMap != NULL) {
|
|
|
+ NumBlocks = BlockMap->NumBlocks;
|
|
|
+ BlockLength = BlockMap->Length;
|
|
|
+ }
|
|
|
+
|
|
|
+ if ( NumBlocks == 0 || BlockLength == 0) {
|
|
|
+ return EFI_INVALID_PARAMETER;
|
|
|
+ }
|
|
|
+
|
|
|
+ NextLba = StartLba + NumBlocks;
|
|
|
+
|
|
|
+ //
|
|
|
+ // The map entry found
|
|
|
+ //
|
|
|
+ if (Lba >= StartLba && Lba < NextLba) {
|
|
|
+ Offset = Offset + (UINTN)MultU64x32((Lba - StartLba), BlockLength);
|
|
|
+ if (LbaAddress != NULL) {
|
|
|
+ *LbaAddress = FwhInstance->FvBase + Offset;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (LbaLength != NULL) {
|
|
|
+ *LbaLength = BlockLength;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (NumOfBlocks != NULL) {
|
|
|
+ *NumOfBlocks = (UINTN)(NextLba - Lba);
|
|
|
+ }
|
|
|
+ return EFI_SUCCESS;
|
|
|
+ }
|
|
|
+
|
|
|
+ StartLba = NextLba;
|
|
|
+ Offset = Offset + NumBlocks * BlockLength;
|
|
|
+ BlockMap++;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+/**
|
|
|
+ Reads specified number of bytes into a buffer from the specified block
|
|
|
+
|
|
|
+ @param[in] Instance The FV instance to be read from
|
|
|
+ @param[in] Lba The logical block address to be read from
|
|
|
+ @param[in] BlockOffset Offset into the block at which to begin reading
|
|
|
+ @param[in, out] NumBytes Pointer that on input contains the total size of
|
|
|
+ the buffer. On output, it contains the total number
|
|
|
+ of bytes read
|
|
|
+ @param[in] Buffer Pointer to a caller allocated buffer that will be
|
|
|
+ used to hold the data read
|
|
|
+
|
|
|
+
|
|
|
+ @retval EFI_SUCCESS The firmware volume was read successfully and
|
|
|
+ contents are in Buffer
|
|
|
+ @retval EFI_BAD_BUFFER_SIZE Read attempted across a LBA boundary. On output,
|
|
|
+ NumBytes contains the total number of bytes returned
|
|
|
+ in Buffer
|
|
|
+ @retval EFI_ACCESS_DENIED The firmware volume is in the ReadDisabled state
|
|
|
+ @retval EFI_DEVICE_ERROR The block device is not functioning correctly and
|
|
|
+ could not be read
|
|
|
+ @retval EFI_INVALID_PARAMETER Instance not found, or NumBytes, Buffer are NULL
|
|
|
+
|
|
|
+**/
|
|
|
+STATIC
|
|
|
+EFI_STATUS
|
|
|
+FvbReadBlock (
|
|
|
+ IN UINTN Instance,
|
|
|
+ IN EFI_LBA Lba,
|
|
|
+ IN UINTN BlockOffset,
|
|
|
+ IN OUT UINTN *NumBytes,
|
|
|
+ IN UINT8 *Buffer
|
|
|
+ )
|
|
|
+{
|
|
|
+ EFI_FVB_ATTRIBUTES_2 Attributes;
|
|
|
+ UINTN LbaAddress;
|
|
|
+ UINTN LbaLength;
|
|
|
+ EFI_STATUS Status;
|
|
|
+ EFI_STATUS ReadStatus;
|
|
|
+
|
|
|
+ if ( (NumBytes == NULL) || (Buffer == NULL)) {
|
|
|
+ return (EFI_INVALID_PARAMETER);
|
|
|
+ }
|
|
|
+ if (*NumBytes == 0) {
|
|
|
+ return (EFI_INVALID_PARAMETER);
|
|
|
+ }
|
|
|
+
|
|
|
+ Status = FvbGetLbaAddress (Instance, Lba, &LbaAddress, &LbaLength, NULL);
|
|
|
+ if (EFI_ERROR(Status)) {
|
|
|
+ return Status;
|
|
|
+ }
|
|
|
+
|
|
|
+ Attributes = FvbGetVolumeAttributes (Instance);
|
|
|
+
|
|
|
+ if ( (Attributes & EFI_FVB2_READ_STATUS) == 0) {
|
|
|
+ return (EFI_ACCESS_DENIED);
|
|
|
+ }
|
|
|
+
|
|
|
+ if (BlockOffset > LbaLength) {
|
|
|
+ return (EFI_INVALID_PARAMETER);
|
|
|
+ }
|
|
|
+
|
|
|
+ if (LbaLength < ( *NumBytes + BlockOffset ) ) {
|
|
|
+ *NumBytes = (UINT32) (LbaLength - BlockOffset);
|
|
|
+ Status = EFI_BAD_BUFFER_SIZE;
|
|
|
+ }
|
|
|
+
|
|
|
+ ReadStatus = LibFvbFlashDeviceRead (LbaAddress + BlockOffset, NumBytes, Buffer);
|
|
|
+ if (EFI_ERROR(ReadStatus)) {
|
|
|
+ return ReadStatus;
|
|
|
+ }
|
|
|
+
|
|
|
+ return Status;
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+/**
|
|
|
+ Writes specified number of bytes from the input buffer to the block
|
|
|
+
|
|
|
+ @param[in] Instance The FV instance to be written to
|
|
|
+ @param[in] Lba The starting logical block index to write to
|
|
|
+ @param[in] BlockOffset Offset into the block at which to begin writing
|
|
|
+ @param[in, out] NumBytes Pointer that on input contains the total size of
|
|
|
+ the buffer. On output, it contains the total number
|
|
|
+ of bytes actually written
|
|
|
+ @param[in] Buffer Pointer to a caller allocated buffer that contains
|
|
|
+ the source for the write
|
|
|
+ @retval EFI_SUCCESS The firmware volume was written successfully
|
|
|
+ @retval EFI_BAD_BUFFER_SIZE Write attempted across a LBA boundary. On output,
|
|
|
+ NumBytes contains the total number of bytes
|
|
|
+ actually written
|
|
|
+ @retval EFI_ACCESS_DENIED The firmware volume is in the WriteDisabled state
|
|
|
+ @retval EFI_DEVICE_ERROR The block device is not functioning correctly and
|
|
|
+ could not be written
|
|
|
+ @retval EFI_INVALID_PARAMETER Instance not found, or NumBytes, Buffer are NULL
|
|
|
+
|
|
|
+**/
|
|
|
+EFI_STATUS
|
|
|
+FvbWriteBlock (
|
|
|
+ IN UINTN Instance,
|
|
|
+ IN EFI_LBA Lba,
|
|
|
+ IN UINTN BlockOffset,
|
|
|
+ IN OUT UINTN *NumBytes,
|
|
|
+ IN UINT8 *Buffer
|
|
|
+ )
|
|
|
+{
|
|
|
+ EFI_FVB_ATTRIBUTES_2 Attributes;
|
|
|
+ UINTN LbaAddress;
|
|
|
+ UINTN LbaLength;
|
|
|
+ EFI_STATUS Status;
|
|
|
+
|
|
|
+ if ( (NumBytes == NULL) || (Buffer == NULL)) {
|
|
|
+ return (EFI_INVALID_PARAMETER);
|
|
|
+ }
|
|
|
+ if (*NumBytes == 0) {
|
|
|
+ return (EFI_INVALID_PARAMETER);
|
|
|
+ }
|
|
|
+
|
|
|
+ Status = FvbGetLbaAddress (Instance, Lba, &LbaAddress, &LbaLength, NULL);
|
|
|
+ if (EFI_ERROR(Status)) {
|
|
|
+ return Status;
|
|
|
+ }
|
|
|
+
|
|
|
+ //
|
|
|
+ // Check if the FV is write enabled
|
|
|
+ //
|
|
|
+ Attributes = FvbGetVolumeAttributes (Instance);
|
|
|
+ if ( (Attributes & EFI_FVB2_WRITE_STATUS) == 0) {
|
|
|
+ return EFI_ACCESS_DENIED;
|
|
|
+ }
|
|
|
+
|
|
|
+ //
|
|
|
+ // Perform boundary checks and adjust NumBytes
|
|
|
+ //
|
|
|
+ if (BlockOffset > LbaLength) {
|
|
|
+ return EFI_INVALID_PARAMETER;
|
|
|
+ }
|
|
|
+
|
|
|
+ if ( LbaLength < ( *NumBytes + BlockOffset ) ) {
|
|
|
+ DEBUG ((DEBUG_ERROR,
|
|
|
+ "FvWriteBlock: Reducing Numbytes from 0x%x to 0x%x\n",
|
|
|
+ *NumBytes, (UINT32)(LbaLength - BlockOffset)));
|
|
|
+ *NumBytes = (UINT32) (LbaLength - BlockOffset);
|
|
|
+ return EFI_BAD_BUFFER_SIZE;
|
|
|
+ }
|
|
|
+
|
|
|
+ LibFvbFlashDeviceBlockLock (LbaAddress, LbaLength, FALSE);
|
|
|
+ Status = LibFvbFlashDeviceWrite (LbaAddress + BlockOffset, NumBytes, Buffer);
|
|
|
+
|
|
|
+ LibFvbFlashDeviceBlockLock (LbaAddress, LbaLength, TRUE);
|
|
|
+ WriteBackInvalidateDataCacheRange ((VOID *) (LbaAddress + BlockOffset), *NumBytes);
|
|
|
+ return Status;
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+/**
|
|
|
+ Erases and initializes a firmware volume block
|
|
|
+
|
|
|
+ @param[in] Instance The FV instance to be erased
|
|
|
+ @param[in] Lba The logical block index to be erased
|
|
|
+
|
|
|
+ @retval EFI_SUCCESS The erase request was successfully completed
|
|
|
+ @retval EFI_ACCESS_DENIED The firmware volume is in the WriteDisabled state
|
|
|
+ @retval EFI_DEVICE_ERROR The block device is not functioning correctly and
|
|
|
+ could not be written. Firmware device may have been
|
|
|
+ partially erased
|
|
|
+ @retval EFI_INVALID_PARAMETER Instance not found
|
|
|
+
|
|
|
+**/
|
|
|
+EFI_STATUS
|
|
|
+FvbEraseBlock (
|
|
|
+ IN UINTN Instance,
|
|
|
+ IN EFI_LBA Lba
|
|
|
+ )
|
|
|
+{
|
|
|
+
|
|
|
+ EFI_FVB_ATTRIBUTES_2 Attributes;
|
|
|
+ UINTN LbaAddress;
|
|
|
+ UINTN LbaLength;
|
|
|
+ EFI_STATUS Status;
|
|
|
+
|
|
|
+ //
|
|
|
+ // Check if the FV is write enabled
|
|
|
+ //
|
|
|
+ Attributes = FvbGetVolumeAttributes (Instance);
|
|
|
+
|
|
|
+ if( (Attributes & EFI_FVB2_WRITE_STATUS) == 0) {
|
|
|
+ return (EFI_ACCESS_DENIED);
|
|
|
+ }
|
|
|
+
|
|
|
+ //
|
|
|
+ // Get the starting address of the block for erase.
|
|
|
+ //
|
|
|
+ Status = FvbGetLbaAddress (Instance, Lba, &LbaAddress, &LbaLength, NULL);
|
|
|
+ if (EFI_ERROR(Status)) {
|
|
|
+ return Status;
|
|
|
+ }
|
|
|
+
|
|
|
+ LibFvbFlashDeviceBlockLock (LbaAddress, LbaLength, FALSE);
|
|
|
+
|
|
|
+ Status = LibFvbFlashDeviceBlockErase (LbaAddress, LbaLength);
|
|
|
+
|
|
|
+ LibFvbFlashDeviceBlockLock (LbaAddress, LbaLength, TRUE);
|
|
|
+
|
|
|
+ WriteBackInvalidateDataCacheRange ((VOID *) LbaAddress, LbaLength);
|
|
|
+
|
|
|
+ return Status;
|
|
|
+}
|
|
|
+
|
|
|
+/**
|
|
|
+ Modifies the current settings of the firmware volume according to the
|
|
|
+ input parameter, and returns the new setting of the volume
|
|
|
+
|
|
|
+ @param[in] Instance The FV instance whose attributes is going to be
|
|
|
+ modified
|
|
|
+ @param[in, out] Attributes On input, it is a pointer to EFI_FVB_ATTRIBUTES_2
|
|
|
+ containing the desired firmware volume settings.
|
|
|
+ On successful return, it contains the new settings
|
|
|
+ of the firmware volume
|
|
|
+
|
|
|
+ @retval EFI_SUCCESS Successfully returns
|
|
|
+ @retval EFI_ACCESS_DENIED The volume setting is locked and cannot be modified
|
|
|
+ @retval EFI_INVALID_PARAMETER Instance not found, or The attributes requested are
|
|
|
+ in conflict with the capabilities as declared in the
|
|
|
+ firmware volume header
|
|
|
+
|
|
|
+**/
|
|
|
+STATIC
|
|
|
+EFI_STATUS
|
|
|
+FvbSetVolumeAttributes (
|
|
|
+ IN UINTN Instance,
|
|
|
+ IN OUT EFI_FVB_ATTRIBUTES_2 *Attributes
|
|
|
+ )
|
|
|
+{
|
|
|
+ EFI_FW_VOL_INSTANCE *FwhInstance;
|
|
|
+ EFI_FVB_ATTRIBUTES_2 OldAttributes;
|
|
|
+ EFI_FVB_ATTRIBUTES_2 *AttribPtr;
|
|
|
+ EFI_FVB_ATTRIBUTES_2 UnchangedAttributes;
|
|
|
+ UINT32 Capabilities;
|
|
|
+ UINT32 OldStatus;
|
|
|
+ UINT32 NewStatus;
|
|
|
+
|
|
|
+ //
|
|
|
+ // Find the right instance of the FVB private data
|
|
|
+ //
|
|
|
+ FwhInstance = GetFvbInstance (Instance);
|
|
|
+ if (FwhInstance == NULL) {
|
|
|
+ return EFI_INVALID_PARAMETER;
|
|
|
+ }
|
|
|
+
|
|
|
+ AttribPtr = (EFI_FVB_ATTRIBUTES_2 *) &(FwhInstance->VolumeHeader.Attributes);
|
|
|
+ ASSERT (AttribPtr != NULL);
|
|
|
+ if ( AttribPtr == NULL) {
|
|
|
+ return EFI_INVALID_PARAMETER;
|
|
|
+ }
|
|
|
+
|
|
|
+ OldAttributes = *AttribPtr;
|
|
|
+ Capabilities = OldAttributes & EFI_FVB2_CAPABILITIES;
|
|
|
+ OldStatus = OldAttributes & EFI_FVB2_STATUS;
|
|
|
+ NewStatus = *Attributes & EFI_FVB2_STATUS;
|
|
|
+
|
|
|
+ UnchangedAttributes = 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) != 0) {
|
|
|
+ if ((OldStatus ^ NewStatus) != 0) {
|
|
|
+ return EFI_ACCESS_DENIED;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ //
|
|
|
+ // Test read disable
|
|
|
+ //
|
|
|
+ if ((Capabilities & EFI_FVB2_READ_DISABLED_CAP) == 0) {
|
|
|
+ if ((NewStatus & EFI_FVB2_READ_STATUS) == 0) {
|
|
|
+ return EFI_INVALID_PARAMETER;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ //
|
|
|
+ // Test read enable
|
|
|
+ //
|
|
|
+ if ((Capabilities & EFI_FVB2_READ_ENABLED_CAP) == 0) {
|
|
|
+ if ((NewStatus & EFI_FVB2_READ_STATUS) != 0) {
|
|
|
+ return EFI_INVALID_PARAMETER;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ //
|
|
|
+ // Test write disable
|
|
|
+ //
|
|
|
+ if ((Capabilities & EFI_FVB2_WRITE_DISABLED_CAP) == 0) {
|
|
|
+ if ((NewStatus & EFI_FVB2_WRITE_STATUS) == 0) {
|
|
|
+ return EFI_INVALID_PARAMETER;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ //
|
|
|
+ // Test write enable
|
|
|
+ //
|
|
|
+ if ((Capabilities & EFI_FVB2_WRITE_ENABLED_CAP) == 0) {
|
|
|
+ if ((NewStatus & EFI_FVB2_WRITE_STATUS) != 0) {
|
|
|
+ return EFI_INVALID_PARAMETER;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ //
|
|
|
+ // Test lock
|
|
|
+ //
|
|
|
+ if ((Capabilities & EFI_FVB2_LOCK_CAP) == 0) {
|
|
|
+ if ((NewStatus & EFI_FVB2_LOCK_STATUS) != 0) {
|
|
|
+ return EFI_INVALID_PARAMETER;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ *AttribPtr = (*AttribPtr) & (0xFFFFFFFF & (~EFI_FVB2_STATUS));
|
|
|
+ *AttribPtr = (*AttribPtr) | NewStatus;
|
|
|
+ *Attributes = *AttribPtr;
|
|
|
+
|
|
|
+ return EFI_SUCCESS;
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+/**
|
|
|
+ Retrieves the physical address of the device.
|
|
|
+
|
|
|
+ @param[in] This A pointer to EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL.
|
|
|
+ @param[out] Address Output buffer containing the address.
|
|
|
+
|
|
|
+ @retval EFI_SUCCESS The function always return successfully.
|
|
|
+ @retval EFI_INVALID_PARAMETER Instance not found.
|
|
|
+
|
|
|
+**/
|
|
|
+EFI_STATUS
|
|
|
+EFIAPI
|
|
|
+FvbProtocolGetPhysicalAddress (
|
|
|
+ IN CONST EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *This,
|
|
|
+ OUT EFI_PHYSICAL_ADDRESS *Address
|
|
|
+ )
|
|
|
+{
|
|
|
+ EFI_FW_VOL_BLOCK_DEVICE *FvbDevice;
|
|
|
+ EFI_FW_VOL_INSTANCE *FwhInstance;
|
|
|
+
|
|
|
+ FvbDevice = FVB_DEVICE_FROM_THIS (This);
|
|
|
+ FwhInstance = GetFvbInstance(FvbDevice->Instance);
|
|
|
+ if (FwhInstance == NULL) {
|
|
|
+ return EFI_INVALID_PARAMETER;
|
|
|
+ }
|
|
|
+
|
|
|
+ *Address = FwhInstance->FvBase;
|
|
|
+ return EFI_SUCCESS;
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+/**
|
|
|
+ Retrieve the size of a logical block
|
|
|
+
|
|
|
+ @param[in] This Calling context
|
|
|
+ @param[in] Lba Indicates which block to return the size for.
|
|
|
+ @param[out] BlockSize A pointer to a caller allocated UINTN in which
|
|
|
+ the size of the block is returned
|
|
|
+ @param[out] 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
|
|
|
+
|
|
|
+ @retval EFI_SUCCESS The function always return successfully.
|
|
|
+
|
|
|
+**/
|
|
|
+EFI_STATUS
|
|
|
+EFIAPI
|
|
|
+FvbProtocolGetBlockSize (
|
|
|
+ IN CONST EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *This,
|
|
|
+ IN EFI_LBA Lba,
|
|
|
+ OUT UINTN *BlockSize,
|
|
|
+ OUT UINTN *NumOfBlocks
|
|
|
+ )
|
|
|
+{
|
|
|
+ EFI_FW_VOL_BLOCK_DEVICE *FvbDevice;
|
|
|
+
|
|
|
+ FvbDevice = FVB_DEVICE_FROM_THIS (This);
|
|
|
+ return FvbGetLbaAddress (FvbDevice->Instance, Lba, NULL, BlockSize, NumOfBlocks);
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+/**
|
|
|
+ Retrieves Volume attributes. No polarity translations are done.
|
|
|
+
|
|
|
+ @param[in] This Calling context
|
|
|
+ @param[out] Attributes Output buffer which contains attributes
|
|
|
+
|
|
|
+ @retval EFI_SUCCESS The function always return successfully.
|
|
|
+
|
|
|
+**/
|
|
|
+EFI_STATUS
|
|
|
+EFIAPI
|
|
|
+FvbProtocolGetAttributes (
|
|
|
+ IN CONST EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *This,
|
|
|
+ OUT EFI_FVB_ATTRIBUTES_2 *Attributes
|
|
|
+ )
|
|
|
+{
|
|
|
+ EFI_FW_VOL_BLOCK_DEVICE *FvbDevice;
|
|
|
+
|
|
|
+ FvbDevice = FVB_DEVICE_FROM_THIS (This);
|
|
|
+ *Attributes = FvbGetVolumeAttributes (FvbDevice->Instance);
|
|
|
+
|
|
|
+ return EFI_SUCCESS;
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+/**
|
|
|
+ Sets Volume attributes. No polarity translations are done.
|
|
|
+
|
|
|
+ @param[in] This Calling context
|
|
|
+ @param[in, out] Attributes Output buffer which contains attributes
|
|
|
+
|
|
|
+ @retval EFI_SUCCESS The function always return successfully.
|
|
|
+
|
|
|
+**/
|
|
|
+EFI_STATUS
|
|
|
+EFIAPI
|
|
|
+FvbProtocolSetAttributes (
|
|
|
+ IN CONST EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *This,
|
|
|
+ IN OUT EFI_FVB_ATTRIBUTES_2 *Attributes
|
|
|
+ )
|
|
|
+{
|
|
|
+ EFI_STATUS Status;
|
|
|
+ EFI_FW_VOL_BLOCK_DEVICE *FvbDevice;
|
|
|
+
|
|
|
+ FvbDevice = FVB_DEVICE_FROM_THIS (This);
|
|
|
+ Status = FvbSetVolumeAttributes (FvbDevice->Instance, Attributes);
|
|
|
+ return Status;
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+/**
|
|
|
+ This 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 does 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 firmware volume.
|
|
|
+
|
|
|
+ @param[in] This Calling context
|
|
|
+ @param[in] ... Starting LBA followed by Number of Lba to erase.
|
|
|
+ a -1 to terminate the list.
|
|
|
+
|
|
|
+ @retval EFI_SUCCESS The erase request was successfully completed
|
|
|
+ @retval EFI_ACCESS_DENIED The firmware volume is in the WriteDisabled state
|
|
|
+ @retval EFI_DEVICE_ERROR The block device is not functioning correctly and
|
|
|
+ could not be written. Firmware device may have been
|
|
|
+ partially erased
|
|
|
+
|
|
|
+**/
|
|
|
+EFI_STATUS
|
|
|
+EFIAPI
|
|
|
+FvbProtocolEraseBlocks (
|
|
|
+ IN CONST EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *This,
|
|
|
+ ...
|
|
|
+ )
|
|
|
+{
|
|
|
+ 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 = FVB_DEVICE_FROM_THIS (This);
|
|
|
+ FwhInstance = GetFvbInstance (FvbDevice->Instance);
|
|
|
+ if (FwhInstance == NULL) {
|
|
|
+ return EFI_OUT_OF_RESOURCES;
|
|
|
+ }
|
|
|
+
|
|
|
+ NumOfBlocks = FwhInstance->NumOfBlocks;
|
|
|
+ VA_START (args, This);
|
|
|
+
|
|
|
+ do {
|
|
|
+ StartingLba = VA_ARG (args, EFI_LBA);
|
|
|
+ if ( StartingLba == EFI_LBA_LIST_TERMINATOR ) {
|
|
|
+ break;
|
|
|
+ }
|
|
|
+
|
|
|
+ NumOfLba = VA_ARG (args, UINT32);
|
|
|
+
|
|
|
+ //
|
|
|
+ // Check input parameters
|
|
|
+ //
|
|
|
+ if (NumOfLba == 0) {
|
|
|
+ VA_END (args);
|
|
|
+ return EFI_INVALID_PARAMETER;
|
|
|
+ }
|
|
|
+
|
|
|
+ if ( ( StartingLba + NumOfLba ) > NumOfBlocks ) {
|
|
|
+ return EFI_INVALID_PARAMETER;
|
|
|
+ }
|
|
|
+ } while ( 1 );
|
|
|
+
|
|
|
+ VA_END (args);
|
|
|
+
|
|
|
+ VA_START (args, This);
|
|
|
+ do {
|
|
|
+ StartingLba = VA_ARG (args, EFI_LBA);
|
|
|
+ if (StartingLba == EFI_LBA_LIST_TERMINATOR) {
|
|
|
+ break;
|
|
|
+ }
|
|
|
+
|
|
|
+ NumOfLba = VA_ARG (args, UINT32);
|
|
|
+
|
|
|
+ while ( NumOfLba > 0 ) {
|
|
|
+ Status = FvbEraseBlock (FvbDevice->Instance, StartingLba);
|
|
|
+ if ( EFI_ERROR(Status)) {
|
|
|
+ VA_END (args);
|
|
|
+ return Status;
|
|
|
+ }
|
|
|
+ StartingLba++;
|
|
|
+ NumOfLba--;
|
|
|
+ }
|
|
|
+ } while ( 1 );
|
|
|
+
|
|
|
+ VA_END (args);
|
|
|
+
|
|
|
+ return EFI_SUCCESS;
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+/**
|
|
|
+ Writes data beginning at Lba:Offset from FV. The write terminates either
|
|
|
+ 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 opertion 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.
|
|
|
+
|
|
|
+ @param[in] This Calling context
|
|
|
+ @param[in] Lba Block in which to begin write
|
|
|
+ @param[in] Offset Offset in the block at which to begin write
|
|
|
+ @param[in,out] NumBytes On input, indicates the requested write size. On
|
|
|
+ output, indicates the actual number of bytes written
|
|
|
+ @param[in] Buffer Buffer containing source data for the write.
|
|
|
+
|
|
|
+ @retval EFI_SUCCESS The firmware volume was written successfully
|
|
|
+ @retval EFI_BAD_BUFFER_SIZE Write attempted across a LBA boundary. On output,
|
|
|
+ NumBytes contains the total number of bytes
|
|
|
+ actually written
|
|
|
+ @retval EFI_ACCESS_DENIED The firmware volume is in the WriteDisabled state
|
|
|
+ @retval EFI_DEVICE_ERROR The block device is not functioning correctly and
|
|
|
+ could not be written
|
|
|
+ @retval EFI_INVALID_PARAMETER NumBytes or Buffer are NULL
|
|
|
+
|
|
|
+**/
|
|
|
+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_FW_VOL_BLOCK_DEVICE *FvbDevice;
|
|
|
+ EFI_STATUS Status;
|
|
|
+
|
|
|
+ FvbDevice = FVB_DEVICE_FROM_THIS (This);
|
|
|
+ Status = FvbWriteBlock (FvbDevice->Instance, Lba, Offset, NumBytes, Buffer);
|
|
|
+ DEBUG((DEBUG_VERBOSE,
|
|
|
+ "FvbWrite: Lba: 0x%lx Offset: 0x%x NumBytes: 0x%x, Buffer: 0x%x Status:%r\n",
|
|
|
+ Lba, Offset, *NumBytes, Buffer, Status));
|
|
|
+
|
|
|
+ return Status;
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+/**
|
|
|
+ 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 opertion 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.
|
|
|
+
|
|
|
+ @param[in] This Calling context
|
|
|
+ @param[in] Lba Block in which to begin write
|
|
|
+ @param[in] Offset Offset in the block at which to begin write
|
|
|
+ @param[in,out] NumBytes On input, indicates the requested write size. On
|
|
|
+ output, indicates the actual number of bytes written
|
|
|
+ @param[out] Buffer Buffer containing source data for the write.
|
|
|
+
|
|
|
+
|
|
|
+Returns:
|
|
|
+ @retval EFI_SUCCESS The firmware volume was read successfully and
|
|
|
+ contents are in Buffer
|
|
|
+ @retval EFI_BAD_BUFFER_SIZE Read attempted across a LBA boundary. On output,
|
|
|
+ NumBytes contains the total number of bytes returned
|
|
|
+ in Buffer
|
|
|
+ @retval EFI_ACCESS_DENIED The firmware volume is in the ReadDisabled state
|
|
|
+ @retval EFI_DEVICE_ERROR The block device is not functioning correctly and
|
|
|
+ could not be read
|
|
|
+ @retval EFI_INVALID_PARAMETER NumBytes or Buffer are NULL
|
|
|
+
|
|
|
+**/
|
|
|
+EFI_STATUS
|
|
|
+EFIAPI
|
|
|
+FvbProtocolRead (
|
|
|
+ IN CONST EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *This,
|
|
|
+ IN EFI_LBA Lba,
|
|
|
+ IN UINTN Offset,
|
|
|
+ IN OUT UINTN *NumBytes,
|
|
|
+ OUT UINT8 *Buffer
|
|
|
+ )
|
|
|
+{
|
|
|
+
|
|
|
+ EFI_FW_VOL_BLOCK_DEVICE *FvbDevice;
|
|
|
+ EFI_STATUS Status;
|
|
|
+
|
|
|
+ FvbDevice = FVB_DEVICE_FROM_THIS (This);
|
|
|
+ Status = FvbReadBlock (FvbDevice->Instance, Lba, Offset, NumBytes, Buffer);
|
|
|
+ DEBUG((DEBUG_VERBOSE,
|
|
|
+ "FvbRead: Lba: 0x%lx Offset: 0x%x NumBytes: 0x%x, Buffer: 0x%x, Status:%r\n",
|
|
|
+ Lba, Offset, *NumBytes, Buffer, Status));
|
|
|
+
|
|
|
+ return Status;
|
|
|
+}
|
|
|
+
|
|
|
+/**
|
|
|
+ Check the integrity of firmware volume header in FvBase
|
|
|
+
|
|
|
+ @param[in] FvBase A pointer to firmware volume base address.
|
|
|
+
|
|
|
+ @retval TRUE The firmware volume is consistent
|
|
|
+ @retval FALSE The firmware volume has corrupted.
|
|
|
+
|
|
|
+**/
|
|
|
+BOOLEAN
|
|
|
+IsFvHeaderValid (
|
|
|
+ IN EFI_PHYSICAL_ADDRESS FvBase
|
|
|
+ )
|
|
|
+{
|
|
|
+ UINT16 Sum;
|
|
|
+ EFI_FIRMWARE_VOLUME_HEADER *FwVolHeader;
|
|
|
+
|
|
|
+ FwVolHeader = (EFI_FIRMWARE_VOLUME_HEADER *) (UINTN) FvBase;
|
|
|
+ if (FvBase == PcdGet32(PcdFlashNvStorageVariableBase)) {
|
|
|
+ if (CompareMem (&FwVolHeader->FileSystemGuid, &gEfiSystemNvDataFvGuid, sizeof(EFI_GUID)) != 0 ) {
|
|
|
+ DEBUG((DEBUG_INFO, " --FileSystemGuid not match: %g\n", &FwVolHeader->FileSystemGuid));
|
|
|
+ return FALSE;
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ if (CompareMem (&FwVolHeader->FileSystemGuid, &gEfiFirmwareFileSystem2Guid, sizeof(EFI_GUID)) != 0 ) {
|
|
|
+ DEBUG((DEBUG_INFO, " --not expected guid.\n"));
|
|
|
+ return FALSE;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if ( (FwVolHeader->Revision != EFI_FVH_REVISION) ||
|
|
|
+ (FwVolHeader->Signature != EFI_FVH_SIGNATURE) ||
|
|
|
+ (FwVolHeader->FvLength == ((UINTN) -1)) ||
|
|
|
+ ((FwVolHeader->HeaderLength & 0x01 ) !=0) ) {
|
|
|
+ DEBUG((DEBUG_INFO, " -- >Revision = 0x%x, Signature = 0x%x\n", FwVolHeader->Revision, FwVolHeader->Signature ));
|
|
|
+ DEBUG((DEBUG_INFO, " -- >FvLength = 0x%lx, HeaderLength = 0x%x\n", FwVolHeader->FvLength, FwVolHeader->HeaderLength ));
|
|
|
+ return FALSE;
|
|
|
+ }
|
|
|
+
|
|
|
+ Sum = CalculateSum16 ((UINT16 *) FwVolHeader, FwVolHeader->HeaderLength);
|
|
|
+ if (Sum != 0) {
|
|
|
+ DEBUG((DEBUG_INFO, "error: checksum: 0x%04X (expect 0x0)\n", Sum));
|
|
|
+ return FALSE;
|
|
|
+ }
|
|
|
+
|
|
|
+ return TRUE;
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+/**
|
|
|
+ Get intial variable data.
|
|
|
+
|
|
|
+ @param[out] VarData Valid variable data.
|
|
|
+ @param[out] VarSize Valid variable size.
|
|
|
+
|
|
|
+ @retval RETURN_SUCCESS Successfully found initial variable data.
|
|
|
+ @retval RETURN_NOT_FOUND Failed to find the variable data file from FV.
|
|
|
+ @retval EFI_INVALID_PARAMETER VarData or VarSize is null.
|
|
|
+
|
|
|
+**/
|
|
|
+EFI_STATUS
|
|
|
+GetInitialVariableData (
|
|
|
+ OUT VOID **VarData,
|
|
|
+ OUT UINTN *VarSize
|
|
|
+ )
|
|
|
+{
|
|
|
+ EFI_STATUS Status;
|
|
|
+ VOID *ImageData;
|
|
|
+ UINTN ImageSize;
|
|
|
+ EFI_FIRMWARE_VOLUME_HEADER *FvHeader;
|
|
|
+ VARIABLE_STORE_HEADER *VariableStore;
|
|
|
+ AUTHENTICATED_VARIABLE_HEADER *Variable;
|
|
|
+ UINTN VariableSize;
|
|
|
+ UINTN VarEndAddr;
|
|
|
+
|
|
|
+ if ((VarData == NULL) || (VarSize == NULL)) {
|
|
|
+ return EFI_INVALID_PARAMETER;
|
|
|
+ }
|
|
|
+
|
|
|
+ Status = GetSectionFromAnyFv (PcdGetPtr(PcdNvsDataFile), EFI_SECTION_RAW, 0, &ImageData, &ImageSize);
|
|
|
+ if (EFI_ERROR (Status)) {
|
|
|
+ return Status;
|
|
|
+ }
|
|
|
+
|
|
|
+ FvHeader = (EFI_FIRMWARE_VOLUME_HEADER *) ImageData;
|
|
|
+ VariableStore = (VARIABLE_STORE_HEADER *) ((UINT8 *)ImageData + FvHeader->HeaderLength);
|
|
|
+ VarEndAddr = (UINTN)VariableStore + VariableStore->Size;
|
|
|
+ Variable = (AUTHENTICATED_VARIABLE_HEADER *) HEADER_ALIGN (VariableStore + 1);
|
|
|
+ *VarData = (VOID *)Variable;
|
|
|
+ while (((UINTN)Variable < VarEndAddr)) {
|
|
|
+ if (Variable->StartId != VARIABLE_DATA) {
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ VariableSize = sizeof (AUTHENTICATED_VARIABLE_HEADER) + Variable->DataSize + Variable->NameSize;
|
|
|
+ Variable = (AUTHENTICATED_VARIABLE_HEADER *) HEADER_ALIGN ((UINTN) Variable + VariableSize);
|
|
|
+ }
|
|
|
+
|
|
|
+ *VarSize = (UINTN)Variable - HEADER_ALIGN (VariableStore + 1);
|
|
|
+
|
|
|
+ return EFI_SUCCESS;
|
|
|
+}
|
|
|
+
|
|
|
+/**
|
|
|
+ The function does the necessary initialization work for
|
|
|
+ Firmware Volume Block Driver.
|
|
|
+
|
|
|
+ @retval EFI_SUCCESS This funtion always return EFI_SUCCESS.
|
|
|
+ It will ASSERT on errors.
|
|
|
+
|
|
|
+**/
|
|
|
+EFI_STATUS
|
|
|
+FvbInitialize (
|
|
|
+ VOID
|
|
|
+ )
|
|
|
+{
|
|
|
+ EFI_FW_VOL_INSTANCE *FwVolInstance;
|
|
|
+ EFI_FIRMWARE_VOLUME_HEADER *FvHeader;
|
|
|
+ EFI_FV_BLOCK_MAP_ENTRY *BlockMap;
|
|
|
+ EFI_PHYSICAL_ADDRESS BaseAddress;
|
|
|
+ UINTN WriteAddr;
|
|
|
+ EFI_STATUS Status;
|
|
|
+ UINTN BufferSize;
|
|
|
+ UINTN Length;
|
|
|
+ VARIABLE_STORE_HEADER VariableStore;
|
|
|
+ VOID *VarData;
|
|
|
+
|
|
|
+ InitVariableStore ();
|
|
|
+ BaseAddress = PcdGet32(PcdFlashNvStorageVariableBase);
|
|
|
+ FvHeader = (EFI_FIRMWARE_VOLUME_HEADER *) (UINTN) BaseAddress;
|
|
|
+
|
|
|
+ //
|
|
|
+ // Check FV header and variable store header
|
|
|
+ //
|
|
|
+ if (!IsFvHeaderValid (BaseAddress)) {
|
|
|
+ //
|
|
|
+ // Write back a healthy FV header
|
|
|
+ //
|
|
|
+ DEBUG ((DEBUG_ERROR, "Fvb: Writing back a healthy FV header: 0x%lx\n", BaseAddress));
|
|
|
+ FvHeader = GetFvHeaderTemplate ();
|
|
|
+ LibFvbFlashDeviceBlockLock ((UINTN)BaseAddress, FvHeader->BlockMap->Length, FALSE);
|
|
|
+
|
|
|
+ Status = LibFvbFlashDeviceBlockErase ((UINTN)BaseAddress, FvHeader->BlockMap->Length);
|
|
|
+ ASSERT_EFI_ERROR(Status);
|
|
|
+
|
|
|
+ Length = FvHeader->HeaderLength;
|
|
|
+ WriteAddr = (UINTN)BaseAddress;
|
|
|
+ Status = LibFvbFlashDeviceWrite (WriteAddr, &Length, (UINT8 *) FvHeader);
|
|
|
+ WriteAddr += Length;
|
|
|
+ ASSERT_EFI_ERROR(Status);
|
|
|
+
|
|
|
+ //
|
|
|
+ // Write back variable store header
|
|
|
+ //
|
|
|
+ VariableStore.Size = PcdGet32(PcdFlashNvStorageVariableSize) - FvHeader->HeaderLength;
|
|
|
+ VariableStore.Format = VARIABLE_STORE_FORMATTED;
|
|
|
+ VariableStore.State = VARIABLE_STORE_HEALTHY;
|
|
|
+ CopyGuid (&VariableStore.Signature, &gEfiAuthenticatedVariableGuid);
|
|
|
+ BufferSize = sizeof (VARIABLE_STORE_HEADER);
|
|
|
+ Status = LibFvbFlashDeviceWrite (WriteAddr, &BufferSize, (UINT8 *) &VariableStore);
|
|
|
+ WriteAddr += BufferSize;
|
|
|
+ ASSERT_EFI_ERROR(Status);
|
|
|
+
|
|
|
+ //
|
|
|
+ // Write initial variable data if found
|
|
|
+ //
|
|
|
+ Status = GetInitialVariableData (&VarData, &Length);
|
|
|
+ if (!EFI_ERROR (Status)) {
|
|
|
+ Status = LibFvbFlashDeviceWrite (WriteAddr, &Length, (UINT8 *) VarData);
|
|
|
+ ASSERT_EFI_ERROR(Status);
|
|
|
+ }
|
|
|
+
|
|
|
+ LibFvbFlashDeviceBlockLock ((UINTN)BaseAddress, FvHeader->BlockMap->Length, TRUE);
|
|
|
+ WriteBackInvalidateDataCacheRange ((VOID *) (UINTN) BaseAddress, FvHeader->BlockMap->Length);
|
|
|
+ }
|
|
|
+
|
|
|
+ //
|
|
|
+ // Create a new FW volume instance for NVS variable
|
|
|
+ //
|
|
|
+ BufferSize = FvHeader->HeaderLength + sizeof (EFI_FW_VOL_INSTANCE) - sizeof (EFI_FIRMWARE_VOLUME_HEADER);
|
|
|
+ FwVolInstance = (EFI_FW_VOL_INSTANCE *) AllocateRuntimeZeroPool (BufferSize);
|
|
|
+ if (FwVolInstance == NULL) {
|
|
|
+ return EFI_OUT_OF_RESOURCES;
|
|
|
+ }
|
|
|
+ FwVolInstance->FvBase = (UINTN)BaseAddress;
|
|
|
+ CopyMem (&FwVolInstance->VolumeHeader, FvHeader, FvHeader->HeaderLength);
|
|
|
+
|
|
|
+ //
|
|
|
+ // Process the block map for each FV. Assume it has same block size.
|
|
|
+ //
|
|
|
+ FwVolInstance->NumOfBlocks = 0;
|
|
|
+ FvHeader = &FwVolInstance->VolumeHeader;
|
|
|
+ for (BlockMap = FvHeader->BlockMap; BlockMap->NumBlocks != 0; BlockMap++) {
|
|
|
+ FwVolInstance->NumOfBlocks += BlockMap->NumBlocks;
|
|
|
+ }
|
|
|
+
|
|
|
+ //
|
|
|
+ // Add a FVB Protocol Instance
|
|
|
+ //
|
|
|
+ Status = InstallFvbProtocol (FwVolInstance, mFvbModuleGlobal.NumFv);
|
|
|
+ mFvbModuleGlobal.NumFv++;
|
|
|
+ mFvbModuleGlobal.FvInstance = FwVolInstance;
|
|
|
+
|
|
|
+ return Status;
|
|
|
+}
|