dasharo/edk2-platforms
0
0
Fork 0
mirror of https://github.com/Dasharo/edk2-platforms.git synced 2026-03-06 14:51:43 -08:00
Code Issues Packages Projects Releases Wiki Activity
Files
master
edk2-platforms/Platform/RaspberryPi/Drivers/VarBlockServiceDxe/VarBlockService.c
Pete Batard 03f36b8fcf Platforms/RPi3: Restructure platform in preparation for Pi 4 
In preparation for adding Raspberry Pi 4 support, the Pi 3 platform
is restructured by factorizing all the drivers and libraries that are
going to be commonly used by the two platforms.

Because much of the Pi 4 SoC is an extension of the Pi 3 one this
means that almost everything, except the ACPI tables, is moved up
into a new common RaspberryPi/ subdirectory that will serve both
platforms. The .dec is also moved to this directory, under a new
RaspberryPi.dec name, and existing references to it are updated.

This commit requires the edk2-non-osi in use to contain commit 243e55f622ea
in order to build.

Signed-off-by: Pete Batard <pete@akeo.ie>
Reviewed-by: Philippe Mathieu-Daude <philmd@redhat.com>
Reviewed-by: Leif Lindholm <leif.lindholm@linaro.org>
2019-10-21 15:32:32 +01:00

966 lines
25 KiB
C
Raw Permalink Blame History

/** @file
*
* Copyright (c) 2018, Andrei Warkentin <andrey.warkentin@gmail.com>
* Copyright (c) 2006-2014, Intel Corporation. All rights reserved.
*
* SPDX-License-Identifier: BSD-2-Clause-Patent
*
**/
#include <Protocol/DevicePath.h>
#include <Protocol/FirmwareVolumeBlock.h>
#include <Library/BaseLib.h>
#include <Library/BaseMemoryLib.h>
#include <Library/DebugLib.h>
#include <Library/DevicePathLib.h>
#include <Library/DxeServicesTableLib.h>
#include <Library/MemoryAllocationLib.h>
#include <Library/UefiBootServicesTableLib.h>
#include "VarBlockService.h"
#define EFI_FVB2_STATUS \
(EFI_FVB2_READ_STATUS | EFI_FVB2_WRITE_STATUS | EFI_FVB2_LOCK_STATUS)
EFI_FW_VOL_INSTANCE *mFvInstance;
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 = {
NULL,
{
FvbProtocolGetAttributes,
FvbProtocolSetAttributes,
FvbProtocolGetPhysicalAddress,
FvbProtocolGetBlockSize,
FvbProtocolRead,
FvbProtocolWrite,
FvbProtocolEraseBlocks,
NULL
}
};
EFI_STATUS
VarStoreWrite (
IN UINTN Address,
IN OUT UINTN *NumBytes,
IN UINT8 *Buffer
)
{
CopyMem ((VOID*)Address, Buffer, *NumBytes);
mFvInstance->Dirty = TRUE;
return EFI_SUCCESS;
}
EFI_STATUS
VarStoreErase (
IN UINTN Address,
IN UINTN LbaLength
)
{
SetMem ((VOID*)Address, LbaLength, 0xff);
mFvInstance->Dirty = TRUE;
return EFI_SUCCESS;
}
EFI_STATUS
FvbGetVolumeAttributes (
OUT EFI_FVB_ATTRIBUTES_2 *Attributes
)
{
*Attributes = mFvInstance->VolumeHeader->Attributes;
return EFI_SUCCESS;
}
EFI_STATUS
FvbGetLbaAddress (
IN EFI_LBA Lba,
OUT UINTN *LbaAddress,
OUT UINTN *LbaLength,
OUT UINTN *NumOfBlocks
)
/*++
Routine Description:
Retrieves the starting address of an LBA in an FV
Arguments:
Lba - The logical block address
LbaAddress - On output, contains the physical starting address
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
Returns:
EFI_SUCCESS
EFI_INVALID_PARAMETER
--*/
{
UINT32 NumBlocks;
UINT32 BlockLength;
UINTN Offset;
EFI_LBA StartLba;
EFI_LBA NextLba;
EFI_FV_BLOCK_MAP_ENTRY *BlockMap;
StartLba = 0;
Offset = 0;
BlockMap = &(mFvInstance->VolumeHeader->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 != NULL) {
*LbaAddress = mFvInstance->FvBase + Offset;
}
if (LbaLength != NULL) {
*LbaLength = BlockLength;
}
if (NumOfBlocks != NULL) {
*NumOfBlocks = (UINTN)(NextLba - Lba);
}
return EFI_SUCCESS;
}
StartLba = NextLba;
Offset = Offset + NumBlocks * BlockLength;
BlockMap++;
}
}
EFI_STATUS
FvbEraseBlock (
IN EFI_LBA Lba
)
/*++
Routine Description:
Erases and initializes a firmware volume block
Arguments:
Lba - The logical block index to be erased
Returns:
EFI_SUCCESS - The erase request was successfully completed
EFI_ACCESS_DENIED - The firmware volume is in the WriteDisabled state
EFI_DEVICE_ERROR - The block device is not functioning correctly and
could not be written. Firmware device may have been
partially erased
EFI_INVALID_PARAMETER
--*/
{
EFI_FVB_ATTRIBUTES_2 Attributes;
UINTN LbaAddress;
UINTN LbaLength;
EFI_STATUS Status;
//
// Check if the FV is write enabled
//
FvbGetVolumeAttributes (&Attributes);
if ((Attributes & EFI_FVB2_WRITE_STATUS) == 0) {
return EFI_ACCESS_DENIED;
}
//
// Get the starting address of the block for erase. For debug reasons,
// LbaWriteAddress may not be the same as LbaAddress.
//
Status = FvbGetLbaAddress (Lba, &LbaAddress, &LbaLength, NULL);
if (EFI_ERROR (Status)) {
return Status;
}
return VarStoreErase (
LbaAddress,
LbaLength
);
}
EFI_STATUS
FvbSetVolumeAttributes (
IN OUT EFI_FVB_ATTRIBUTES_2 *Attributes
)
/*++
Routine Description:
Modifies the current settings of the firmware volume according to the
input parameter, and returns the new setting of the volume
Arguments:
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 setting.
Returns:
EFI_SUCCESS - Successfully returns
EFI_ACCESS_DENIED - The volume setting is locked and cannot be modified
EFI_INVALID_PARAMETER
--*/
{
EFI_FVB_ATTRIBUTES_2 OldAttributes;
EFI_FVB_ATTRIBUTES_2 *AttribPtr;
UINT32 Capabilities;
UINT32 OldStatus;
UINT32 NewStatus;
EFI_FVB_ATTRIBUTES_2 UnchangedAttributes;
AttribPtr =
(EFI_FVB_ATTRIBUTES_2*) &(mFvInstance->VolumeHeader->Attributes);
OldAttributes = *AttribPtr;
Capabilities = 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 = 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;
}
EFI_STATUS
EFIAPI
FvbProtocolGetPhysicalAddress (
IN CONST EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *This,
OUT EFI_PHYSICAL_ADDRESS *Address
)
{
*Address = mFvInstance->FvBase;
return EFI_SUCCESS;
}
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
--*/
{
return FvbGetLbaAddress (
Lba,
NULL,
BlockSize,
NumOfBlocks
);
}
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
--*/
{
return FvbGetVolumeAttributes (Attributes);
}
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
--*/
{
return FvbSetVolumeAttributes (Attributes);
}
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 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.
Arguments:
This - Calling context
... - Starting LBA followed by Number of Lba to erase.
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 state
EFI_DEVICE_ERROR - The block device is not functioning correctly and
could not be written. Firmware device may have been
partially erased
--*/
{
UINTN NumOfBlocks;
VA_LIST args;
EFI_LBA StartingLba;
UINTN NumOfLba;
EFI_STATUS Status;
NumOfBlocks = mFvInstance->NumOfBlocks;
VA_START (args, This);
do {
StartingLba = VA_ARG (args, EFI_LBA);
if (StartingLba == EFI_LBA_LIST_TERMINATOR) {
break;
}
NumOfLba = VA_ARG (args, UINTN);
if ((NumOfLba == 0) || ((StartingLba + NumOfLba) > NumOfBlocks)) {
VA_END (args);
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, UINTN);
while (NumOfLba > 0) {
Status = FvbEraseBlock (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 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.
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 output,
NumBytes contains the total number of bytes
actually written
EFI_ACCESS_DENIED - The firmware volume is in the WriteDisabled state
EFI_DEVICE_ERROR - The block device is not functioning correctly and
could not be written
EFI_INVALID_PARAMETER - NumBytes or Buffer are NULL
--*/
{
EFI_FVB_ATTRIBUTES_2 Attributes;
UINTN LbaAddress;
UINTN LbaLength;
EFI_STATUS Status;
EFI_STATUS ReturnStatus;
//
// Check for invalid conditions.
//
if ((NumBytes == NULL) || (Buffer == NULL)) {
return EFI_INVALID_PARAMETER;
}
if (*NumBytes == 0) {
return EFI_INVALID_PARAMETER;
}
Status = FvbGetLbaAddress (Lba, &LbaAddress, &LbaLength, NULL);
if (EFI_ERROR (Status)) {
return Status;
}
//
// Check if the FV is write enabled.
//
FvbGetVolumeAttributes (&Attributes);
if ((Attributes & EFI_FVB2_WRITE_STATUS) == 0) {
return EFI_ACCESS_DENIED;
}
//
// Perform boundary checks and adjust NumBytes.
//
if (Offset > LbaLength) {
return EFI_INVALID_PARAMETER;
}
if (LbaLength < (*NumBytes + Offset)) {
*NumBytes = (UINT32)(LbaLength - Offset);
Status = EFI_BAD_BUFFER_SIZE;
}
ReturnStatus = VarStoreWrite (
LbaAddress + Offset,
NumBytes,
Buffer
);
if (EFI_ERROR (ReturnStatus)) {
return ReturnStatus;
}
return Status;
}
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 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.
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 Read
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 output,
NumBytes contains the total number of bytes
returned in Buffer
EFI_ACCESS_DENIED - The firmware volume is in the ReadDisabled state
EFI_DEVICE_ERROR - The block device is not functioning correctly and
could not be read
EFI_INVALID_PARAMETER - NumBytes or Buffer are NULL
--*/
{
EFI_FVB_ATTRIBUTES_2 Attributes;
UINTN LbaAddress;
UINTN LbaLength;
EFI_STATUS Status;
//
// Check for invalid conditions.
//
if ((NumBytes == NULL) || (Buffer == NULL)) {
return EFI_INVALID_PARAMETER;
}
if (*NumBytes == 0) {
return EFI_INVALID_PARAMETER;
}
Status = FvbGetLbaAddress (Lba, &LbaAddress, &LbaLength, NULL);
if (EFI_ERROR (Status)) {
return Status;
}
//
// Check if the FV is read enabled.
//
FvbGetVolumeAttributes (&Attributes);
if ((Attributes & EFI_FVB2_READ_STATUS) == 0) {
return EFI_ACCESS_DENIED;
}
//
// Perform boundary checks and adjust NumBytes.
//
if (Offset > LbaLength) {
return EFI_INVALID_PARAMETER;
}
if (LbaLength < (*NumBytes + Offset)) {
*NumBytes = (UINT32)(LbaLength - Offset);
Status = EFI_BAD_BUFFER_SIZE;
}
CopyMem (Buffer, (VOID*)(LbaAddress + Offset), (UINTN)*NumBytes);
return Status;
}
EFI_STATUS
ValidateFvHeader (
IN 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 not 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 != EFI_FVH_REVISION) ||
(FwVolHeader->Signature != EFI_FVH_SIGNATURE) ||
(FwVolHeader->FvLength == ((UINTN)-1)) ||
((FwVolHeader->HeaderLength & 0x01) != 0)
) {
return EFI_NOT_FOUND;
}
//
// Verify the header checksum.
//
Checksum = CalculateSum16 ((UINT16*)FwVolHeader, FwVolHeader->HeaderLength);
if (Checksum != 0) {
UINT16 Expected;
Expected =
(UINT16)(((UINTN)FwVolHeader->Checksum + 0x10000 - Checksum) & 0xffff);
DEBUG ((DEBUG_INFO, "FV@%p Checksum is 0x%x, expected 0x%x\n",
FwVolHeader, FwVolHeader->Checksum, Expected));
return EFI_NOT_FOUND;
}
return EFI_SUCCESS;
}
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;
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;
UINTN StartOffset;
BaseAddress = PcdGet32 (PcdNvStorageVariableBase);
Length = (FixedPcdGet32 (PcdFlashNvStorageVariableSize) +
FixedPcdGet32 (PcdFlashNvStorageFtwWorkingSize) +
FixedPcdGet32 (PcdFlashNvStorageFtwSpareSize) +
FixedPcdGet32 (PcdNvStorageEventLogSize));
StartOffset = BaseAddress - FixedPcdGet64 (PcdFdBaseAddress);
BufferSize = sizeof (EFI_FW_VOL_INSTANCE);
mFvInstance = AllocateRuntimeZeroPool (BufferSize);
if (mFvInstance == NULL) {
return EFI_OUT_OF_RESOURCES;
}
mFvInstance->FvBase = (UINTN)BaseAddress;
mFvInstance->FvLength = (UINTN)Length;
mFvInstance->Offset = StartOffset;
/*
* Should I parse config.txt instead and find the real name?
*/
mFvInstance->MappedFile = L"RPI_EFI.FD";
Status = ValidateFvHeader (mFvInstance->VolumeHeader);
if (!EFI_ERROR (Status)) {
if (mFvInstance->VolumeHeader->FvLength != Length ||
mFvInstance->VolumeHeader->BlockMap[0].Length !=
PcdGet32 (PcdFirmwareBlockSize)) {
Status = EFI_VOLUME_CORRUPTED;
}
}
if (EFI_ERROR (Status)) {
EFI_FIRMWARE_VOLUME_HEADER *GoodFwVolHeader;
UINTN WriteLength;
DEBUG ((DEBUG_INFO,
"Variable FV header is not valid. It will be reinitialized.\n"));
//
// Get FvbInfo
//
Status = GetFvbInfo (Length, &GoodFwVolHeader);
ASSERT_EFI_ERROR (Status);
//
// Erase all the blocks
//
Status = VarStoreErase ((UINTN)mFvInstance->FvBase, mFvInstance->FvLength);
ASSERT_EFI_ERROR (Status);
//
// Write good FV header
//
WriteLength = GoodFwVolHeader->HeaderLength;
Status = VarStoreWrite ((UINTN)mFvInstance->FvBase, &WriteLength,
(UINT8*)GoodFwVolHeader);
ASSERT_EFI_ERROR (Status);
ASSERT (WriteLength == GoodFwVolHeader->HeaderLength);
Status = ValidateFvHeader (mFvInstance->VolumeHeader);
ASSERT_EFI_ERROR (Status);
}
MaxLbaSize = 0;
NumOfBlocks = 0;
for (PtrBlockMapEntry = mFvInstance->VolumeHeader->BlockMap;
PtrBlockMapEntry->NumBlocks != 0;
PtrBlockMapEntry++) {
//
// Get the maximum size of a block.
//
if (MaxLbaSize < PtrBlockMapEntry->Length) {
MaxLbaSize = PtrBlockMapEntry->Length;
}
NumOfBlocks = NumOfBlocks + PtrBlockMapEntry->NumBlocks;
}
//
// The total number of blocks in the FV.
//
mFvInstance->NumOfBlocks = NumOfBlocks;
//
// Add a FVB Protocol Instance
//
FvbDevice = AllocateRuntimePool (sizeof (EFI_FW_VOL_BLOCK_DEVICE));
ASSERT (FvbDevice != NULL);
CopyMem (FvbDevice, &mFvbDeviceTemplate, sizeof (EFI_FW_VOL_BLOCK_DEVICE));
//
// Set up the devicepath
//
if (mFvInstance->VolumeHeader->ExtHeaderOffset == 0) {
FV_MEMMAP_DEVICE_PATH *FvMemmapDevicePath;
//
// FV does not contains extension header, then produce MEMMAP_DEVICE_PATH
//
FvMemmapDevicePath = AllocateCopyPool (sizeof (FV_MEMMAP_DEVICE_PATH),
&mFvMemmapDevicePathTemplate);
FvMemmapDevicePath->MemMapDevPath.StartingAddress = mFvInstance->FvBase;
FvMemmapDevicePath->MemMapDevPath.EndingAddress = mFvInstance->FvBase +
mFvInstance->FvLength - 1;
FvbDevice->DevicePath = (EFI_DEVICE_PATH_PROTOCOL*)FvMemmapDevicePath;
} else {
FV_PIWG_DEVICE_PATH *FvPiwgDevicePath;
FvPiwgDevicePath = AllocateCopyPool (sizeof (FV_PIWG_DEVICE_PATH),
&mFvPIWGDevicePathTemplate);
CopyGuid (&FvPiwgDevicePath->FvDevPath.FvName,
(GUID*)(UINTN)(mFvInstance->FvBase + mFvInstance->VolumeHeader->ExtHeaderOffset));
FvbDevice->DevicePath = (EFI_DEVICE_PATH_PROTOCOL*)FvPiwgDevicePath;
}
//
// Module type specific hook.
//
InstallProtocolInterfaces (FvbDevice);
//
// Set several PCD values to point to flash.
//
PcdStatus = PcdSet64S (PcdFlashNvStorageVariableBase64,
(UINTN)PcdGet32 (PcdNvStorageVariableBase));
ASSERT_RETURN_ERROR (PcdStatus);
PcdStatus = PcdSet32S (PcdFlashNvStorageFtwWorkingBase,
PcdGet32 (PcdNvStorageFtwWorkingBase));
ASSERT_RETURN_ERROR (PcdStatus);
PcdStatus = PcdSet32S (PcdFlashNvStorageFtwSpareBase,
PcdGet32 (PcdNvStorageFtwSpareBase));
ASSERT_RETURN_ERROR (PcdStatus);
InstallFSNotifyHandler ();
InstallDumpVarEventHandlers ();
InstallVirtualAddressChangeHandler ();
return EFI_SUCCESS;
}
Reference in New Issue View Git Blame Copy Permalink