|
@@ -0,0 +1,903 @@
|
|
|
+/** @file
|
|
|
+ Common driver source for several Serial Flash devices
|
|
|
+ which are compliant with the Intel(R) Serial Flash Interface Compatibility Specification.
|
|
|
+
|
|
|
+Copyright (c) 2017, Intel Corporation. All rights reserved.<BR>
|
|
|
+SPDX-License-Identifier: BSD-2-Clause-Patent
|
|
|
+
|
|
|
+**/
|
|
|
+
|
|
|
+#include "SpiFvbServiceCommon.h"
|
|
|
+
|
|
|
+//
|
|
|
+// Global variable for this FVB driver which contains
|
|
|
+// the private data of all firmware volume block instances
|
|
|
+//
|
|
|
+FVB_GLOBAL mFvbModuleGlobal;
|
|
|
+
|
|
|
+//
|
|
|
+// This platform driver knows there are multiple FVs on FD.
|
|
|
+// Now we only provide FVs on Variable region and MicorCode region for performance issue.
|
|
|
+//
|
|
|
+FV_INFO mPlatformFvBaseAddress[] = {
|
|
|
+ {0, 0}, // {FixedPcdGet32(PcdFlashNvStorageVariableBase), FixedPcdGet32(PcdFlashNvStorageVariableSize)},
|
|
|
+ {0, 0}, // {FixedPcdGet32(PcdFlashMicrocodeFvBase), FixedPcdGet32(PcdFlashMicrocodeFvSize)},
|
|
|
+ {0, 0}
|
|
|
+};
|
|
|
+
|
|
|
+FV_INFO mPlatformDefaultBaseAddress[] = {
|
|
|
+ {0, 0}, // {FixedPcdGet32(PcdFlashNvStorageVariableBase), FixedPcdGet32(PcdFlashNvStorageVariableSize)},
|
|
|
+ {0, 0}, // {FixedPcdGet32(PcdFlashMicrocodeFvBase), FixedPcdGet32(PcdFlashMicrocodeFvSize)},
|
|
|
+ {0, 0}
|
|
|
+};
|
|
|
+
|
|
|
+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
|
|
|
+ }
|
|
|
+ }
|
|
|
+};
|
|
|
+
|
|
|
+//
|
|
|
+// Template structure used when installing FVB protocol
|
|
|
+//
|
|
|
+EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL mFvbProtocolTemplate = {
|
|
|
+ FvbProtocolGetAttributes,
|
|
|
+ FvbProtocolSetAttributes,
|
|
|
+ FvbProtocolGetPhysicalAddress,
|
|
|
+ FvbProtocolGetBlockSize,
|
|
|
+ FvbProtocolRead,
|
|
|
+ FvbProtocolWrite,
|
|
|
+ FvbProtocolEraseBlocks,
|
|
|
+ NULL
|
|
|
+};
|
|
|
+
|
|
|
+/**
|
|
|
+ Get the EFI_FVB_ATTRIBUTES_2 of a FV.
|
|
|
+
|
|
|
+ @param[in] FvbInstance The pointer to the EFI_FVB_INSTANCE.
|
|
|
+
|
|
|
+ @return Attributes of the FV identified by FvbInstance.
|
|
|
+
|
|
|
+**/
|
|
|
+EFI_FVB_ATTRIBUTES_2
|
|
|
+FvbGetVolumeAttributes (
|
|
|
+ IN EFI_FVB_INSTANCE *FvbInstance
|
|
|
+ )
|
|
|
+{
|
|
|
+ return FvbInstance->FvHeader.Attributes;
|
|
|
+}
|
|
|
+
|
|
|
+/**
|
|
|
+ Retrieves the starting address of an LBA in an FV. It also
|
|
|
+ return a few other attribut of the FV.
|
|
|
+
|
|
|
+ @param[in] FvbInstance The pointer to the EFI_FVB_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
|
|
|
+
|
|
|
+**/
|
|
|
+EFI_STATUS
|
|
|
+FvbGetLbaAddress (
|
|
|
+ IN EFI_FVB_INSTANCE *FvbInstance,
|
|
|
+ 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_FV_BLOCK_MAP_ENTRY *BlockMap;
|
|
|
+
|
|
|
+ StartLba = 0;
|
|
|
+ Offset = 0;
|
|
|
+ BlockMap = &(FvbInstance->FvHeader.BlockMap[0]);
|
|
|
+
|
|
|
+ //
|
|
|
+ // Parse the blockmap of the FV to find which map entry the Lba belongs to
|
|
|
+ //
|
|
|
+ while (TRUE) {
|
|
|
+ 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 ) {
|
|
|
+ *LbaAddress = FvbInstance->FvBase + Offset;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (LbaLength ) {
|
|
|
+ *LbaLength = BlockLength;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (NumOfBlocks ) {
|
|
|
+ *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] FvbInstance The pointer to the EFI_FVB_INSTANCE
|
|
|
+ @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] 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
|
|
|
+
|
|
|
+**/
|
|
|
+EFI_STATUS
|
|
|
+FvbReadBlock (
|
|
|
+ IN EFI_FVB_INSTANCE *FvbInstance,
|
|
|
+ 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;
|
|
|
+ BOOLEAN BadBufferSize = FALSE;
|
|
|
+
|
|
|
+ if ((NumBytes == NULL) || (Buffer == NULL)) {
|
|
|
+ return EFI_INVALID_PARAMETER;
|
|
|
+ }
|
|
|
+ if (*NumBytes == 0) {
|
|
|
+ return EFI_INVALID_PARAMETER;
|
|
|
+ }
|
|
|
+
|
|
|
+ Status = FvbGetLbaAddress (FvbInstance, Lba, &LbaAddress, &LbaLength, NULL);
|
|
|
+ if (EFI_ERROR(Status)) {
|
|
|
+ return Status;
|
|
|
+ }
|
|
|
+
|
|
|
+ Attributes = FvbGetVolumeAttributes (FvbInstance);
|
|
|
+
|
|
|
+ if ((Attributes & EFI_FVB2_READ_STATUS) == 0) {
|
|
|
+ return EFI_ACCESS_DENIED;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (BlockOffset > LbaLength) {
|
|
|
+ return EFI_INVALID_PARAMETER;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (LbaLength < (*NumBytes + BlockOffset)) {
|
|
|
+ DEBUG ((DEBUG_INFO,
|
|
|
+ "FvReadBlock: Reducing Numbytes from 0x%x to 0x%x\n",
|
|
|
+ *NumBytes,
|
|
|
+ (UINT32)(LbaLength - BlockOffset))
|
|
|
+ );
|
|
|
+ *NumBytes = (UINT32) (LbaLength - BlockOffset);
|
|
|
+ BadBufferSize = TRUE;
|
|
|
+ }
|
|
|
+
|
|
|
+ Status = SpiFlashRead (LbaAddress + BlockOffset, (UINT32 *)NumBytes, Buffer);
|
|
|
+
|
|
|
+ if (!EFI_ERROR (Status) && BadBufferSize) {
|
|
|
+ return EFI_BAD_BUFFER_SIZE;
|
|
|
+ } else {
|
|
|
+ return Status;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/**
|
|
|
+ Writes specified number of bytes from the input buffer to the block.
|
|
|
+
|
|
|
+ @param[in] FvbInstance The pointer to the EFI_FVB_INSTANCE
|
|
|
+ @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] 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 EFI_FVB_INSTANCE *FvbInstance,
|
|
|
+ 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;
|
|
|
+ BOOLEAN BadBufferSize = FALSE;
|
|
|
+
|
|
|
+ if ((NumBytes == NULL) || (Buffer == NULL)) {
|
|
|
+ return EFI_INVALID_PARAMETER;
|
|
|
+ }
|
|
|
+ if (*NumBytes == 0) {
|
|
|
+ return EFI_INVALID_PARAMETER;
|
|
|
+ }
|
|
|
+
|
|
|
+ Status = FvbGetLbaAddress (FvbInstance, Lba, &LbaAddress, &LbaLength, NULL);
|
|
|
+ if (EFI_ERROR(Status)) {
|
|
|
+ return Status;
|
|
|
+ }
|
|
|
+
|
|
|
+ //
|
|
|
+ // Check if the FV is write enabled
|
|
|
+ //
|
|
|
+ Attributes = FvbGetVolumeAttributes (FvbInstance);
|
|
|
+ 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_INFO,
|
|
|
+ "FvWriteBlock: Reducing Numbytes from 0x%x to 0x%x\n",
|
|
|
+ *NumBytes,
|
|
|
+ (UINT32)(LbaLength - BlockOffset))
|
|
|
+ );
|
|
|
+ *NumBytes = (UINT32) (LbaLength - BlockOffset);
|
|
|
+ BadBufferSize = TRUE;
|
|
|
+ }
|
|
|
+
|
|
|
+ Status = SpiFlashWrite (LbaAddress + BlockOffset, (UINT32 *)NumBytes, Buffer);
|
|
|
+ if (EFI_ERROR (Status)) {
|
|
|
+ return Status;
|
|
|
+ }
|
|
|
+
|
|
|
+ Status = SpiFlashLock ();
|
|
|
+ if (EFI_ERROR (Status)) {
|
|
|
+ return Status;
|
|
|
+ }
|
|
|
+
|
|
|
+ WriteBackInvalidateDataCacheRange ((VOID *) (LbaAddress + BlockOffset), *NumBytes);
|
|
|
+
|
|
|
+ if (!EFI_ERROR (Status) && BadBufferSize) {
|
|
|
+ return EFI_BAD_BUFFER_SIZE;
|
|
|
+ } else {
|
|
|
+ return Status;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+/**
|
|
|
+ Erases and initializes a firmware volume block.
|
|
|
+
|
|
|
+ @param[in] FvbInstance The pointer to the EFI_FVB_INSTANCE
|
|
|
+ @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 EFI_FVB_INSTANCE *FvbInstance,
|
|
|
+ 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 (FvbInstance);
|
|
|
+
|
|
|
+ if( (Attributes & EFI_FVB2_WRITE_STATUS) == 0) {
|
|
|
+ return EFI_ACCESS_DENIED;
|
|
|
+ }
|
|
|
+
|
|
|
+ //
|
|
|
+ // Get the starting address of the block for erase.
|
|
|
+ //
|
|
|
+ Status = FvbGetLbaAddress (FvbInstance, Lba, &LbaAddress, &LbaLength, NULL);
|
|
|
+ if (EFI_ERROR(Status)) {
|
|
|
+ return Status;
|
|
|
+ }
|
|
|
+
|
|
|
+ Status = SpiFlashBlockErase (LbaAddress, &LbaLength);
|
|
|
+ if (EFI_ERROR (Status)) {
|
|
|
+ return Status;
|
|
|
+ }
|
|
|
+
|
|
|
+ Status = SpiFlashLock ();
|
|
|
+ if (EFI_ERROR (Status)) {
|
|
|
+ return Status;
|
|
|
+ }
|
|
|
+
|
|
|
+ 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] FvbInstance The pointer to the EFI_FVB_INSTANCE.
|
|
|
+ @param[in] 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
|
|
|
+
|
|
|
+**/
|
|
|
+EFI_STATUS
|
|
|
+FvbSetVolumeAttributes (
|
|
|
+ IN EFI_FVB_INSTANCE *FvbInstance,
|
|
|
+ IN OUT EFI_FVB_ATTRIBUTES_2 *Attributes
|
|
|
+ )
|
|
|
+{
|
|
|
+ EFI_FVB_ATTRIBUTES_2 OldAttributes;
|
|
|
+ EFI_FVB_ATTRIBUTES_2 *AttribPtr;
|
|
|
+ EFI_FVB_ATTRIBUTES_2 UnchangedAttributes;
|
|
|
+ UINT32 Capabilities;
|
|
|
+ UINT32 OldStatus, NewStatus;
|
|
|
+
|
|
|
+ AttribPtr = (EFI_FVB_ATTRIBUTES_2 *) &(FvbInstance->FvHeader.Attributes);
|
|
|
+ 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 ) {
|
|
|
+ if ( OldStatus ^ NewStatus ) {
|
|
|
+ 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) {
|
|
|
+ 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) {
|
|
|
+ return EFI_INVALID_PARAMETER;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ //
|
|
|
+ // Test lock
|
|
|
+ //
|
|
|
+ if ((Capabilities & EFI_FVB2_LOCK_CAP) == 0) {
|
|
|
+ if (NewStatus & EFI_FVB2_LOCK_STATUS) {
|
|
|
+ return EFI_INVALID_PARAMETER;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ *AttribPtr = (*AttribPtr) & (0xFFFFFFFF & (~EFI_FVB2_STATUS));
|
|
|
+ *AttribPtr = (*AttribPtr) | NewStatus;
|
|
|
+ *Attributes = *AttribPtr;
|
|
|
+
|
|
|
+ return EFI_SUCCESS;
|
|
|
+}
|
|
|
+
|
|
|
+/**
|
|
|
+ Check the integrity of firmware volume header
|
|
|
+
|
|
|
+ @param[in] FvHeader A pointer to a firmware volume header
|
|
|
+
|
|
|
+ @retval TRUE The firmware volume is consistent
|
|
|
+ @retval FALSE The firmware volume has corrupted.
|
|
|
+
|
|
|
+**/
|
|
|
+BOOLEAN
|
|
|
+IsFvHeaderValid (
|
|
|
+ IN EFI_PHYSICAL_ADDRESS FvBase,
|
|
|
+ IN CONST EFI_FIRMWARE_VOLUME_HEADER *FvHeader
|
|
|
+ )
|
|
|
+{
|
|
|
+ if (FvBase == PcdGet32(PcdFlashNvStorageVariableBase)) {
|
|
|
+ if (CompareMem (&FvHeader->FileSystemGuid, &gEfiSystemNvDataFvGuid, sizeof(EFI_GUID)) != 0 ) {
|
|
|
+ return FALSE;
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ if (CompareMem (&FvHeader->FileSystemGuid, &gEfiFirmwareFileSystem2Guid, sizeof(EFI_GUID)) != 0 ) {
|
|
|
+ return FALSE;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if ( (FvHeader->Revision != EFI_FVH_REVISION) ||
|
|
|
+ (FvHeader->Signature != EFI_FVH_SIGNATURE) ||
|
|
|
+ (FvHeader->FvLength == ((UINTN) -1)) ||
|
|
|
+ ((FvHeader->HeaderLength & 0x01 ) !=0) ) {
|
|
|
+ return FALSE;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (CalculateCheckSum16 ((UINT16 *) FvHeader, FvHeader->HeaderLength) != 0) {
|
|
|
+ return FALSE;
|
|
|
+ }
|
|
|
+
|
|
|
+ return TRUE;
|
|
|
+}
|
|
|
+
|
|
|
+//
|
|
|
+// FVB protocol APIs
|
|
|
+//
|
|
|
+
|
|
|
+/**
|
|
|
+ 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.
|
|
|
+
|
|
|
+**/
|
|
|
+EFI_STATUS
|
|
|
+EFIAPI
|
|
|
+FvbProtocolGetPhysicalAddress (
|
|
|
+ IN CONST EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *This,
|
|
|
+ OUT EFI_PHYSICAL_ADDRESS *Address
|
|
|
+ )
|
|
|
+{
|
|
|
+ EFI_FVB_INSTANCE *FvbInstance;
|
|
|
+
|
|
|
+ FvbInstance = FVB_INSTANCE_FROM_THIS (This);
|
|
|
+
|
|
|
+ *Address = FvbInstance->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_FVB_INSTANCE *FvbInstance;
|
|
|
+
|
|
|
+ FvbInstance = FVB_INSTANCE_FROM_THIS (This);
|
|
|
+
|
|
|
+ DEBUG((DEBUG_INFO,
|
|
|
+ "FvbProtocolGetBlockSize: Lba: 0x%lx BlockSize: 0x%x NumOfBlocks: 0x%x\n",
|
|
|
+ Lba,
|
|
|
+ BlockSize,
|
|
|
+ NumOfBlocks)
|
|
|
+ );
|
|
|
+
|
|
|
+ return FvbGetLbaAddress (
|
|
|
+ FvbInstance,
|
|
|
+ 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_FVB_INSTANCE *FvbInstance;
|
|
|
+
|
|
|
+ FvbInstance = FVB_INSTANCE_FROM_THIS (This);
|
|
|
+
|
|
|
+ *Attributes = FvbGetVolumeAttributes (FvbInstance);
|
|
|
+
|
|
|
+ DEBUG ((DEBUG_INFO,
|
|
|
+ "FvbProtocolGetAttributes: This: 0x%x Attributes: 0x%x\n",
|
|
|
+ This,
|
|
|
+ *Attributes)
|
|
|
+ );
|
|
|
+
|
|
|
+ return EFI_SUCCESS;
|
|
|
+}
|
|
|
+
|
|
|
+/**
|
|
|
+ Sets 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
|
|
|
+FvbProtocolSetAttributes (
|
|
|
+ IN CONST EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *This,
|
|
|
+ IN OUT EFI_FVB_ATTRIBUTES_2 *Attributes
|
|
|
+ )
|
|
|
+{
|
|
|
+ EFI_STATUS Status;
|
|
|
+ EFI_FVB_INSTANCE *FvbInstance;
|
|
|
+
|
|
|
+ DEBUG((DEBUG_INFO,
|
|
|
+ "FvbProtocolSetAttributes: Before SET - This: 0x%x Attributes: 0x%x\n",
|
|
|
+ This,
|
|
|
+ *Attributes)
|
|
|
+ );
|
|
|
+
|
|
|
+ FvbInstance = FVB_INSTANCE_FROM_THIS (This);
|
|
|
+
|
|
|
+ Status = FvbSetVolumeAttributes (FvbInstance, Attributes);
|
|
|
+
|
|
|
+ DEBUG((DEBUG_INFO,
|
|
|
+ "FvbProtocolSetAttributes: After SET - This: 0x%x Attributes: 0x%x\n",
|
|
|
+ This,
|
|
|
+ *Attributes)
|
|
|
+ );
|
|
|
+
|
|
|
+ return Status;
|
|
|
+}
|
|
|
+
|
|
|
+/**
|
|
|
+ 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 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_FVB_INSTANCE *FvbInstance;
|
|
|
+ UINTN NumOfBlocks;
|
|
|
+ VA_LIST Args;
|
|
|
+ EFI_LBA StartingLba;
|
|
|
+ UINTN NumOfLba;
|
|
|
+ EFI_STATUS Status;
|
|
|
+
|
|
|
+ DEBUG((DEBUG_INFO, "FvbProtocolEraseBlocks: \n"));
|
|
|
+
|
|
|
+ FvbInstance = FVB_INSTANCE_FROM_THIS (This);
|
|
|
+
|
|
|
+ NumOfBlocks = FvbInstance->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 (FvbInstance, 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_FVB_INSTANCE *FvbInstance;
|
|
|
+
|
|
|
+ FvbInstance = FVB_INSTANCE_FROM_THIS (This);
|
|
|
+
|
|
|
+ DEBUG((DEBUG_INFO,
|
|
|
+ "FvbProtocolWrite: Lba: 0x%lx Offset: 0x%x NumBytes: 0x%x, Buffer: 0x%x\n",
|
|
|
+ Lba,
|
|
|
+ Offset,
|
|
|
+ *NumBytes,
|
|
|
+ Buffer)
|
|
|
+ );
|
|
|
+
|
|
|
+ return FvbWriteBlock (FvbInstance, Lba, Offset, NumBytes, Buffer);
|
|
|
+}
|
|
|
+
|
|
|
+/**
|
|
|
+ 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[in] Buffer Buffer containing source data for the write.
|
|
|
+
|
|
|
+ @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_FVB_INSTANCE *FvbInstance;
|
|
|
+ EFI_STATUS Status;
|
|
|
+
|
|
|
+ FvbInstance = FVB_INSTANCE_FROM_THIS (This);
|
|
|
+ Status = FvbReadBlock (FvbInstance, Lba, Offset, NumBytes, Buffer);
|
|
|
+ DEBUG((DEBUG_INFO,
|
|
|
+ "FvbProtocolRead: Lba: 0x%lx Offset: 0x%x NumBytes: 0x%x, Buffer: 0x%x\n",
|
|
|
+ Lba,
|
|
|
+ Offset,
|
|
|
+ *NumBytes,
|
|
|
+ Buffer)
|
|
|
+ );
|
|
|
+
|
|
|
+ return Status;
|
|
|
+}
|