/**@file
Copyright (c) 2007 - 2009, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
Module Name:
FWBlockService.c
Abstract:
Revision History
**/
#include "FWBlockService.h"
#include "EfiFlashMap.h"
#include "FileIo.h"
#include "FlashLayout.h"
ESAL_FWB_GLOBAL *mFvbModuleGlobal;
VOID *mSFSRegistration;
#define TRY_ASSIGN(var, value) if(var != NULL) {*var = value;}
EFI_FW_VOL_BLOCK_DEVICE mFvbDeviceTemplate = {
FVB_DEVICE_SIGNATURE,
{
{
{
HARDWARE_DEVICE_PATH,
HW_MEMMAP_DP,
{
sizeof (MEMMAP_DEVICE_PATH),
0
}
},
EfiMemoryMappedIO,
0,
0,
},
{
END_DEVICE_PATH_TYPE,
END_ENTIRE_DEVICE_PATH_SUBTYPE,
{
sizeof (EFI_DEVICE_PATH_PROTOCOL),
0
}
}
},
0,
{
FvbProtocolGetAttributes,
FvbProtocolSetAttributes,
FvbProtocolGetPhysicalAddress,
FvbProtocolGetBlockSize,
FvbProtocolRead,
FvbProtocolWrite,
FvbProtocolEraseBlocks,
NULL
}
};
EFI_STATUS
FlashFdWrite (
IN UINTN Address,
IN EFI_FW_VOL_INSTANCE *FwhInstance,
IN OUT UINTN *NumBytes,
IN UINT8 *Buffer
)
/*++
Routine Description:
Writes specified number of bytes from the input buffer to the address
Arguments:
Returns:
--*/
{
EFI_STATUS Status;
EFI_FILE_PROTOCOL *File;
UINTN FileOffset;
UINTN BufferForFile;
UINTN Length;
Status = EFI_SUCCESS;
CopyMem ((VOID *) Address, Buffer, *NumBytes);
if (!EfiAtRuntime () && (FwhInstance->Device != NULL)) {
Status = FileOpen (FwhInstance->Device, FwhInstance->MappedFile, &File, EFI_FILE_MODE_READ | EFI_FILE_MODE_WRITE);
ASSERT_EFI_ERROR (Status);
if (!EFI_ERROR (Status)) {
if (Address - FwhInstance->FvBase[FVB_PHYSICAL] < FwhInstance->Offset) {
FileOffset = 0;
BufferForFile = FwhInstance->FvBase[FVB_PHYSICAL] + FwhInstance->Offset;
Length = *NumBytes - (FwhInstance->Offset - (Address - FwhInstance->FvBase[FVB_PHYSICAL]));
} else {
FileOffset = Address - FwhInstance->FvBase[FVB_PHYSICAL] - FwhInstance->Offset;
BufferForFile = Address;
Length = *NumBytes;
}
Status = FileWrite (File, FileOffset, BufferForFile, Length);
ASSERT_EFI_ERROR (Status);
FileClose (File);
}
}
return Status;
}
EFI_STATUS
FlashFdErase (
IN UINTN Address,
IN EFI_FW_VOL_INSTANCE *FwhInstance,
IN UINTN LbaLength
)
/*++
Routine Description:
Erase a certain block from address LbaWriteAddress
Arguments:
Returns:
--*/
{
EFI_STATUS Status;
EFI_FILE_PROTOCOL *File;
UINTN FileOffset;
UINTN BufferForFile;
UINTN Length;
Status = EFI_SUCCESS;
SetMem ((VOID *)Address, LbaLength, 0xff);
if (!EfiAtRuntime () && (FwhInstance->Device != NULL)) {
Status = FileOpen (FwhInstance->Device, FwhInstance->MappedFile, &File, EFI_FILE_MODE_READ | EFI_FILE_MODE_WRITE);
ASSERT_EFI_ERROR (Status);
if (!EFI_ERROR (Status)) {
if (Address - FwhInstance->FvBase[FVB_PHYSICAL] < FwhInstance->Offset) {
FileOffset = 0;
BufferForFile = FwhInstance->FvBase[FVB_PHYSICAL] + FwhInstance->Offset;
Length = LbaLength - (FwhInstance->Offset - (Address - FwhInstance->FvBase[FVB_PHYSICAL]));
} else {
FileOffset = Address - FwhInstance->FvBase[FVB_PHYSICAL] - FwhInstance->Offset;
BufferForFile = Address;
Length = LbaLength;
}
Status = FileWrite (File, FileOffset, BufferForFile, Length);
ASSERT_EFI_ERROR (Status);
FileClose (File);
}
}
return Status;
}
VOID
EFIAPI
FvbVirtualddressChangeEvent (
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.
mFvbModuleGlobal->FvInstance[FVB_PHYSICAL] - Physical copy of instance data
mFvbModuleGlobal->FvInstance[FVB_VIRTUAL] - Virtual pointer to common
instance data.
Arguments:
(Standard EFI notify event - EFI_EVENT_NOTIFY)
Returns:
None
--*/
{
EFI_FW_VOL_INSTANCE *FwhInstance;
UINTN Index;
EfiConvertPointer (0, (VOID **) &mFvbModuleGlobal->FvInstance[FVB_VIRTUAL]);
//
// Convert the base address of all the instances
//
Index = 0;
FwhInstance = mFvbModuleGlobal->FvInstance[FVB_PHYSICAL];
while (Index < mFvbModuleGlobal->NumFv) {
EfiConvertPointer (0, (VOID **) &FwhInstance->FvBase[FVB_VIRTUAL]);
FwhInstance = (EFI_FW_VOL_INSTANCE *) ((UINTN)((UINT8 *)FwhInstance) + FwhInstance->VolumeHeader.HeaderLength
+ (sizeof (EFI_FW_VOL_INSTANCE) - sizeof (EFI_FIRMWARE_VOLUME_HEADER)));
Index++;
}
EfiConvertPointer (0, (VOID **) &mFvbModuleGlobal->FvbScratchSpace[FVB_VIRTUAL]);
EfiConvertPointer (0, (VOID **) &mFvbModuleGlobal);
}
EFI_STATUS
GetFvbInstance (
IN UINTN Instance,
IN ESAL_FWB_GLOBAL *Global,
OUT EFI_FW_VOL_INSTANCE **FwhInstance,
IN BOOLEAN Virtual
)
/*++
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 fimrware instance structure
Virtual - Whether CPU is in virtual or physical mode
Returns:
EFI_SUCCESS - Successfully returns
EFI_INVALID_PARAMETER - Instance not found
--*/
{
EFI_FW_VOL_INSTANCE *FwhRecord;
if (Instance >= Global->NumFv) {
return EFI_INVALID_PARAMETER;
}
//
// Find the right instance of the FVB private data
//
FwhRecord = Global->FvInstance[Virtual];
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--;
}
*FwhInstance = FwhRecord;
return EFI_SUCCESS;
}
EFI_STATUS
FvbGetPhysicalAddress (
IN UINTN Instance,
OUT EFI_PHYSICAL_ADDRESS *Address,
IN ESAL_FWB_GLOBAL *Global,
IN BOOLEAN Virtual
)
/*++
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_ADDRESS
that on successful return, contains the base address
of the firmware volume.
Global - Pointer to ESAL_FWB_GLOBAL that contains all
instance data
Virtual - Whether CPU is in virtual or physical mode
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 = GetFvbInstance (Instance, Global, &FwhInstance, Virtual);
ASSERT_EFI_ERROR (Status);
*Address = FwhInstance->FvBase[Virtual];
return EFI_SUCCESS;
}
EFI_STATUS
FvbGetVolumeAttributes (
IN UINTN Instance,
OUT EFI_FVB_ATTRIBUTES_2 *Attributes,
IN ESAL_FWB_GLOBAL *Global,
IN BOOLEAN Virtual
)
/*++
Routine Description:
Retrieves attributes, insures positive polarity of attribute bits, returns
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
Virtual - Whether CPU is in virtual or physical mode
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 = GetFvbInstance (Instance, Global, &FwhInstance, Virtual);
ASSERT_EFI_ERROR (Status);
*Attributes = FwhInstance->VolumeHeader.Attributes;
return EFI_SUCCESS;
}
EFI_STATUS
FvbGetLbaAddress (
IN UINTN Instance,
IN EFI_LBA Lba,
OUT UINTN *LbaAddress OPTIONAL,
OUT UINTN *LbaLength OPTIONAL,
OUT UINTN *NumOfBlocks OPTIONAL,
IN ESAL_FWB_GLOBAL *Global,
IN BOOLEAN Virtual
)
/*++
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 address
of the Lba for writing
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
Virtual - Whether CPU is in virtual or physical mode
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 = GetFvbInstance (Instance, Global, &FwhInstance, Virtual);
ASSERT_EFI_ERROR (Status);
StartLba = 0;
Offset = 0;
BlockMap = &(FwhInstance->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) {
*LbaAddress = FwhInstance->FvBase[Virtual] + Offset;
}
if (LbaLength) {
*LbaLength = BlockLength;
}
if (NumOfBlocks) {
*NumOfBlocks = (UINTN) (NextLba - Lba);
}
return EFI_SUCCESS;
}
StartLba = NextLba;
Offset = Offset + NumBlocks * BlockLength;
BlockMap++;
}
}
EFI_STATUS
FvbReadBlock (
IN UINTN Instance,
IN EFI_LBA Lba,
IN UINTN BlockOffset,
IN OUT UINTN *NumBytes,
IN UINT8 *Buffer,
IN ESAL_FWB_GLOBAL *Global,
IN BOOLEAN Virtual
)
/*++
Routine Description:
Reads specified number of bytes into a buffer from the specified block
Arguments:
Instance - The FV instance to be read from
Lba - The logical block address to be read from
BlockOffset - Offset into the block at which to begin reading
NumBytes - Pointer that on input contains the total size of
the buffer. On output, it contains the total number
of bytes read
Buffer - Pointer to a caller allocated buffer that will be
used to hold the data read
Global - Pointer to ESAL_FWB_GLOBAL that contains all
instance data
Virtual - Whether CPU is in virtual or physical mode
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 - Instance not found, or NumBytes, 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 (Instance, Lba, &LbaAddress, &LbaLength, NULL, Global, Virtual);
if (EFI_ERROR (Status)) {
return Status;
}
//
// Check if the FV is read enabled
//
FvbGetVolumeAttributes (Instance, &Attributes, Global, Virtual);
if ((Attributes & EFI_FVB2_READ_STATUS) == 0) {
return EFI_ACCESS_DENIED;
}
//
// Perform boundary checks and adjust NumBytes
//
if (BlockOffset > LbaLength) {
return EFI_INVALID_PARAMETER;
}
if (LbaLength < (*NumBytes + BlockOffset)) {
*NumBytes = (UINT32) (LbaLength - BlockOffset);
Status = EFI_BAD_BUFFER_SIZE;
}
CopyMem (Buffer, (VOID *) (LbaAddress + BlockOffset), (UINTN) *NumBytes);
return Status;
}
EFI_STATUS
FvbWriteBlock (
IN UINTN Instance,
IN EFI_LBA Lba,
IN UINTN BlockOffset,
IN OUT UINTN *NumBytes,
IN UINT8 *Buffer,
IN ESAL_FWB_GLOBAL *Global,
IN BOOLEAN Virtual
)
/*++
Routine Description:
Writes specified number of bytes from the input buffer to the block
Arguments:
Instance - The FV instance to be written to
Lba - The starting logical block index to write to
BlockOffset - Offset into the block at which to begin writing
NumBytes - Pointer that on input contains the total size of
the buffer. On output, it contains the total number
of bytes actually written
Buffer - Pointer to a caller allocated buffer that contains
the source for the write
Global - Pointer to ESAL_FWB_GLOBAL that contains all
instance data
Virtual - Whether CPU is in virtual or physical mode
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 - Instance not found, or NumBytes, Buffer are NULL
--*/
{
EFI_FVB_ATTRIBUTES_2 Attributes;
UINTN LbaAddress;
UINTN LbaLength;
EFI_FW_VOL_INSTANCE *FwhInstance;
EFI_STATUS Status;
EFI_STATUS ReturnStatus;
//
// Find the right instance of the FVB private data
//
Status = GetFvbInstance (Instance, Global, &FwhInstance, Virtual);
ASSERT_EFI_ERROR (Status);
//
// Writes are enabled in the init routine itself
//
if (!FwhInstance->WriteEnabled) {
return EFI_ACCESS_DENIED;
}
//
// Check for invalid conditions
//
if ((NumBytes == NULL) || (Buffer == NULL)) {
return EFI_INVALID_PARAMETER;
}
if (*NumBytes == 0) {
return EFI_INVALID_PARAMETER;
}
Status = FvbGetLbaAddress (Instance, Lba, &LbaAddress, &LbaLength, NULL, Global, Virtual);
if (EFI_ERROR (Status)) {
return Status;
}
//
// Check if the FV is write enabled
//
FvbGetVolumeAttributes (Instance, &Attributes, Global, Virtual);
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)) {
*NumBytes = (UINT32) (LbaLength - BlockOffset);
Status = EFI_BAD_BUFFER_SIZE;
}
ReturnStatus = FlashFdWrite (
LbaAddress + BlockOffset,
FwhInstance,
NumBytes,
Buffer
);
if (EFI_ERROR (ReturnStatus)) {
return ReturnStatus;
}
return Status;
}
EFI_STATUS
FvbEraseBlock (
IN UINTN Instance,
IN EFI_LBA Lba,
IN ESAL_FWB_GLOBAL *Global,
IN BOOLEAN Virtual
)
/*++
Routine Description:
Erases and initializes a firmware volume block
Arguments:
Instance - The FV instance to be erased
Lba - The logical block index to be erased
Global - Pointer to ESAL_FWB_GLOBAL that contains all
instance data
Virtual - Whether CPU is in virtual or physical mode
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 - Instance not found
--*/
{
EFI_FVB_ATTRIBUTES_2 Attributes;
UINTN LbaAddress;
EFI_FW_VOL_INSTANCE *FwhInstance;
UINTN LbaLength;
EFI_STATUS Status;
//
// Find the right instance of the FVB private data
//
Status = GetFvbInstance (Instance, Global, &FwhInstance, Virtual);
ASSERT_EFI_ERROR (Status);
//
// Writes are enabled in the init routine itself
//
if (!FwhInstance->WriteEnabled) {
return EFI_ACCESS_DENIED;
}
//
// Check if the FV is write enabled
//
FvbGetVolumeAttributes (Instance, &Attributes, Global, Virtual);
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 (Instance, Lba, &LbaAddress, &LbaLength, NULL, Global, Virtual);
if (EFI_ERROR (Status)) {
return Status;
}
return FlashFdErase (
LbaAddress,
FwhInstance,
LbaLength
);
}
EFI_STATUS
FvbSetVolumeAttributes (
IN UINTN Instance,
IN OUT EFI_FVB_ATTRIBUTES_2 *Attributes,
IN ESAL_FWB_GLOBAL *Global,
IN BOOLEAN Virtual
)
/*++
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_ATTRIBUTES_2
containing the desired firmware volume settings.
On successful return, it contains the new settings
of the firmware volume
Global - Pointer to ESAL_FWB_GLOBAL that contains all
instance data
Virtual - Whether CPU is in virtual or physical mode
Returns:
EFI_SUCCESS - Successfully returns
EFI_ACCESS_DENIED - The volume setting is locked and cannot be modified
EFI_INVALID_PARAMETER - Instance not found, or The attributes requested 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;
//
// Find the right instance of the FVB private data
//
Status = GetFvbInstance (Instance, Global, &FwhInstance, Virtual);
ASSERT_EFI_ERROR (Status);
AttribPtr = (EFI_FVB_ATTRIBUTES_2 *) &(FwhInstance->VolumeHeader.Attributes);
OldAttributes = *AttribPtr;
Capabilities = OldAttributes & EFI_FVB2_CAPABILITIES;
OldStatus = OldAttributes & EFI_FVB2_STATUS;
NewStatus = *Attributes & EFI_FVB2_STATUS;
//
// 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;
}
//
// 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:
Returns:
EFI_SUCCESS - Successfully returns
--*/
{
EFI_FW_VOL_BLOCK_DEVICE *FvbDevice;
FvbDevice = FVB_DEVICE_FROM_THIS (This);
return FvbGetPhysicalAddress (FvbDevice->Instance, Address, mFvbModuleGlobal, EfiGoneVirtual ());
}
EFI_STATUS
EFIAPI
FvbProtocolGetBlockSize (
IN CONST EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *This,
IN 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 = FVB_DEVICE_FROM_THIS (This);
return FvbGetLbaAddress (
FvbDevice->Instance,
Lba,
NULL,
BlockSize,
NumOfBlocks,
mFvbModuleGlobal,
EfiGoneVirtual ()
);
}
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 = FVB_DEVICE_FROM_THIS (This);
return FvbGetVolumeAttributes (FvbDevice->Instance, Attributes, mFvbModuleGlobal, EfiGoneVirtual ());
}
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 = FVB_DEVICE_FROM_THIS (This);
return FvbSetVolumeAttributes (FvbDevice->Instance, Attributes, mFvbModuleGlobal, EfiGoneVirtual ());
}
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
--*/
{
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);
Status = GetFvbInstance (FvbDevice->Instance, mFvbModuleGlobal, &FwhInstance, EfiGoneVirtual ());
ASSERT_EFI_ERROR (Status);
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) || ((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, UINT32);
while (NumOfLba > 0) {
Status = FvbEraseBlock (FvbDevice->Instance, StartingLba, mFvbModuleGlobal, EfiGoneVirtual ());
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_FW_VOL_BLOCK_DEVICE *FvbDevice;
FvbDevice = FVB_DEVICE_FROM_THIS (This);
return FvbWriteBlock (FvbDevice->Instance, Lba, Offset, NumBytes, Buffer, mFvbModuleGlobal, EfiGoneVirtual ());
}
EFI_STATUS
EFIAPI
FvbProtocolRead (
IN CONST EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *This,
IN EFI_LBA Lba,
IN 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_FW_VOL_BLOCK_DEVICE *FvbDevice;
FvbDevice = FVB_DEVICE_FROM_THIS (This);
return FvbReadBlock (FvbDevice->Instance, Lba, Offset, NumBytes, Buffer, mFvbModuleGlobal, EfiGoneVirtual ());
}
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 not an FV
--*/
{
UINT16 *Ptr;
UINT16 HeaderLength;
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
//
HeaderLength = (UINT16) (FwVolHeader->HeaderLength / 2);
Ptr = (UINT16 *) FwVolHeader;
Checksum = 0;
while (HeaderLength > 0) {
Checksum = Checksum + (*Ptr);
HeaderLength--;
Ptr++;
}
if (Checksum != 0) {
return EFI_NOT_FOUND;
}
return EFI_SUCCESS;
}
EFI_STATUS
GetFvbHeader (
IN OUT EFI_PEI_HOB_POINTERS *HobList,
OUT EFI_FIRMWARE_VOLUME_HEADER **FwVolHeader,
OUT EFI_PHYSICAL_ADDRESS *BaseAddress OPTIONAL,
OUT UINT32 *VolumeId OPTIONAL,
OUT CHAR16 **MappedFile OPTIONAL,
OUT UINT32 *ActuralSize OPTIONAL,
OUT UINT32 *Offset OPTIONAL,
OUT BOOLEAN *WriteBack OPTIONAL
)
{
EFI_STATUS Status;
EFI_FLASH_MAP_FS_ENTRY_DATA *FlashMapEntry;
EFI_FLASH_SUBAREA_ENTRY *FlashMapSubEntry;
Status = EFI_SUCCESS;
*FwVolHeader = NULL;
TRY_ASSIGN (WriteBack, FALSE);
DEBUG ((EFI_D_INFO, "Hob start is 0x%x\n", (UINTN)(*HobList).Raw));
(*HobList).Raw = GetNextGuidHob (&gEfiFlashMapHobGuid, (*HobList).Raw);
if ((*HobList).Raw == NULL) {
return EFI_NOT_FOUND;
}
FlashMapEntry = (EFI_FLASH_MAP_FS_ENTRY_DATA *) GET_GUID_HOB_DATA ((*HobList).Guid);
FlashMapSubEntry = &FlashMapEntry->Entries[0];
//
// Check if it is a "FVB" area
//
if (!CompareGuid (&FlashMapSubEntry->FileSystem, &gEfiFirmwareVolumeBlockProtocolGuid)) {
return Status;
}
//
// Check if it is a "real" flash
//
if (FlashMapSubEntry->Attributes != (EFI_FLASH_AREA_FV | EFI_FLASH_AREA_MEMMAPPED_FV)) {
return Status;
}
TRY_ASSIGN (BaseAddress, FlashMapSubEntry->Base);
//
// Cast buffer to FLASH_AREA_INFO to get extra information related to the special FVB driver
//
TRY_ASSIGN (VolumeId, FlashMapEntry->VolumeId);
TRY_ASSIGN (ActuralSize, FlashMapEntry->ActuralSize);
TRY_ASSIGN (MappedFile, ((CHAR16 *) FlashMapEntry->FilePath));
TRY_ASSIGN (Offset, FlashMapEntry->Offset);
DEBUG ((
EFI_D_INFO,
"FlashMap HOB: BaseAddress = 0x%x, Length = 0x%x, ActuralLength = 0x%x, Offset = 0x%x\n",
(UINTN) FlashMapSubEntry->Base, (UINTN) FlashMapSubEntry->Length,
(UINTN) FlashMapEntry->ActuralSize, (UINTN) FlashMapEntry->Offset
));
DEBUG ((
EFI_D_INFO,
"FlashMap HOB: VolumeId = 0x%lx, MappedFile = %s\n",
(UINTN) FlashMapEntry->VolumeId, (UINTN) FlashMapEntry->FilePath
));
*FwVolHeader = (EFI_FIRMWARE_VOLUME_HEADER *) (UINTN) (FlashMapSubEntry->Base);
Status = ValidateFvHeader (*FwVolHeader);
if (EFI_ERROR (Status)) {
//
// Get FvbInfo
//
TRY_ASSIGN (WriteBack, TRUE);
Status = GetFvbInfo (FlashMapSubEntry->Length, FwVolHeader);
DEBUG ((EFI_D_ERROR, "Fvb: FV header invalid, GetFvbInfo - %r\n", Status));
ASSERT_EFI_ERROR (Status);
}
return EFI_SUCCESS;
}
VOID
EFIAPI
OnSimpleFileSystemInstall (
IN EFI_EVENT Event,
IN VOID *Context
)
{
EFI_STATUS Status;
UINTN HandleSize;
EFI_HANDLE Handle;
UINTN Instance;
EFI_DEVICE_PATH_PROTOCOL *Device;
EFI_FILE_PROTOCOL *File;
EFI_FW_VOL_INSTANCE *FwhInstance;
while (TRUE) {
HandleSize = sizeof (EFI_HANDLE);
Status = gBS->LocateHandle (
ByRegisterNotify,
NULL,
mSFSRegistration,
&HandleSize,
&Handle
);
if (Status == EFI_NOT_FOUND) {
break;
}
DEBUG ((EFI_D_ERROR, "Fwh: New FileSystem Installed!\n"));
ASSERT_EFI_ERROR (Status);
//
// Check if this is the storage we care about, and store it in FwhInstance
//
for (Instance = 0; Instance < mFvbModuleGlobal->NumFv; ++Instance) {
Status = GetFvbInstance (Instance, mFvbModuleGlobal, &FwhInstance, FALSE);
ASSERT_EFI_ERROR (Status);
if (FwhInstance->MappedFile[0] == L'\0') {
//
// The instance of FVB isn't mapped to file.
//
continue;
}
if ((FwhInstance->Device != NULL) &&
!EFI_ERROR (CheckStoreExists (FwhInstance->Device))
) {
//
// The instance of FVB has already associated to a device
// and the device is not removed from system.
//
DEBUG ((
EFI_D_ERROR, "Fwh: MappedFile FVB (0x%x:0x%x) - Already mapped, Skip!\n",
(UINTN) FwhInstance->FvBase[FVB_PHYSICAL],
(UINTN) FwhInstance->Offset
));
continue;
}
Status = CheckStore (Handle, FwhInstance->VolumeId, &Device);
if (!EFI_ERROR (Status)) {
//
// Write back memory content to file
//
Status = FileOpen (Device, FwhInstance->MappedFile, &File, EFI_FILE_MODE_WRITE | EFI_FILE_MODE_READ | EFI_FILE_MODE_CREATE);
ASSERT_EFI_ERROR (Status);
if (!EFI_ERROR (Status)) {
DEBUG ((
EFI_D_ERROR, "Fwh: MappedFile FVB (0x%x:0x%x) - Write back to mapped file!\n",
(UINTN) FwhInstance->FvBase[FVB_PHYSICAL],
(UINTN) FwhInstance->Offset
));
Status = FileWrite (
File,
0,
FwhInstance->FvBase[FVB_PHYSICAL] + FwhInstance->Offset,
FwhInstance->ActuralSize - FwhInstance->Offset
);
ASSERT_EFI_ERROR (Status);
if (!EFI_ERROR (Status)) {
if (FwhInstance->Device != NULL) {
gBS->FreePool (FwhInstance->Device);
}
FwhInstance->Device = Device;
DEBUG ((
EFI_D_ERROR, "Fwh: MappedFile FVB (0x%x:0x%x) - Mapped!\n",
(UINTN) FwhInstance->FvBase[FVB_PHYSICAL],
(UINTN) FwhInstance->Offset
));
}
FileClose (File);
}
}
}
}
}
VOID
FvbInstallSfsNotify (
VOID
)
{
EFI_STATUS Status;
EFI_EVENT Event;
Status = gBS->CreateEvent (
EVT_NOTIFY_SIGNAL,
TPL_CALLBACK,
OnSimpleFileSystemInstall,
NULL,
&Event
);
ASSERT_EFI_ERROR (Status);
Status = gBS->RegisterProtocolNotify (
&gEfiSimpleFileSystemProtocolGuid,
Event,
&mSFSRegistration
);
ASSERT_EFI_ERROR (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;
EFI_PEI_HOB_POINTERS FirmwareVolumeHobList;
UINT32 BufferSize;
EFI_FV_BLOCK_MAP_ENTRY *PtrBlockMapEntry;
UINTN LbaAddress;
EFI_HANDLE FwbHandle;
EFI_FW_VOL_BLOCK_DEVICE *FvbDevice;
EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *OldFwbInterface;
EFI_DEVICE_PATH_PROTOCOL *TempFwbDevicePath;
FV_DEVICE_PATH TempFvbDevicePathData;
UINT32 MaxLbaSize;
EFI_PHYSICAL_ADDRESS BaseAddress;
UINT32 VolumeId;
CHAR16 *MappedFile;
UINT32 ActuralSize;
UINT32 Offset;
BOOLEAN WriteBack;
UINTN NumOfBlocks;
UINTN HeaderLength;
BOOLEAN InstallSfsNotify;
HeaderLength = 0;
InstallSfsNotify = FALSE;
//
// Allocate runtime services data for global variable, which contains
// the private data of all firmware volume block instances
//
Status = gBS->AllocatePool (
EfiRuntimeServicesData,
sizeof (ESAL_FWB_GLOBAL),
&mFvbModuleGlobal
);
ASSERT_EFI_ERROR (Status);
//
// Calculate the total size for all firmware volume block instances
//
BufferSize = 0;
FirmwareVolumeHobList.Raw = GetHobList();
do {
Status = GetFvbHeader (&FirmwareVolumeHobList, &FwVolHeader, NULL, NULL, NULL, NULL, NULL, NULL);
if (EFI_ERROR (Status)) {
break;
}
FirmwareVolumeHobList.Raw = GET_NEXT_HOB (FirmwareVolumeHobList);
if (FwVolHeader) {
BufferSize += (FwVolHeader->HeaderLength + sizeof (EFI_FW_VOL_INSTANCE) - sizeof (EFI_FIRMWARE_VOLUME_HEADER));
}
} while (TRUE);
//
// Only need to allocate once. There is only one copy of physical memory for
// the private data of each FV instance. But in virtual mode or in physical
// mode, the address of the the physical memory may be different.
//
Status = gBS->AllocatePool (
EfiRuntimeServicesData,
BufferSize,
&mFvbModuleGlobal->FvInstance[FVB_PHYSICAL]
);
ASSERT_EFI_ERROR (Status);
//
// Make a virtual copy of the FvInstance pointer.
//
FwhInstance = mFvbModuleGlobal->FvInstance[FVB_PHYSICAL];
mFvbModuleGlobal->FvInstance[FVB_VIRTUAL] = FwhInstance;
mFvbModuleGlobal->NumFv = 0;
FirmwareVolumeHobList.Raw = GetHobList();
MaxLbaSize = 0;
//
// Fill in the private data of each firmware volume block instance
//
do {
Status = GetFvbHeader (
&FirmwareVolumeHobList, &FwVolHeader,
&BaseAddress, &VolumeId, &MappedFile, &ActuralSize, &Offset,
&WriteBack
);
if (EFI_ERROR (Status)) {
break;
}
FirmwareVolumeHobList.Raw = GET_NEXT_HOB (FirmwareVolumeHobList);
if (!FwVolHeader) {
continue;
}
CopyMem ((UINTN *) &(FwhInstance->VolumeHeader), (UINTN *) FwVolHeader, FwVolHeader->HeaderLength);
FwVolHeader = &(FwhInstance->VolumeHeader);
FwhInstance->FvBase[FVB_PHYSICAL] = (UINTN) BaseAddress;
FwhInstance->FvBase[FVB_VIRTUAL] = (UINTN) BaseAddress;
FwhInstance->Device = NULL;
FwhInstance->Offset = Offset;
if (*MappedFile != '\0') {
FwhInstance->VolumeId = VolumeId;
FwhInstance->ActuralSize = ActuralSize;
StrCpy (FwhInstance->MappedFile, MappedFile);
InstallSfsNotify = TRUE;
} else {
FwhInstance->VolumeId = (UINT32) -1;
FwhInstance->ActuralSize = (UINT32) -1;
FwhInstance->MappedFile[0] = L'\0';
}
DEBUG ((EFI_D_INFO, "FirmVolume Found! BaseAddress=0x%lx, VolumeId=0x%x, MappedFile=%s, Size=0x%x\n",
(UINTN) BaseAddress, VolumeId, MappedFile, ActuralSize));
//
// We may expose readonly FVB in future.
//
FwhInstance->WriteEnabled = TRUE; // Ken: Why enable write?
EfiInitializeLock (&(FwhInstance->FvbDevLock), TPL_HIGH_LEVEL);
LbaAddress = (UINTN) FwhInstance->FvBase[0];
NumOfBlocks = 0;
if (FwhInstance->WriteEnabled) {
for (PtrBlockMapEntry = FwVolHeader->BlockMap; PtrBlockMapEntry->NumBlocks != 0; PtrBlockMapEntry++) {
LbaAddress += PtrBlockMapEntry->NumBlocks * PtrBlockMapEntry->Length;
//
// Get the maximum size of a block. The size will be used to allocate
// buffer for Scratch space, the intermediate buffer for FVB extension
// protocol
//
if (MaxLbaSize < PtrBlockMapEntry->Length) {
MaxLbaSize = PtrBlockMapEntry->Length;
}
NumOfBlocks += PtrBlockMapEntry->NumBlocks;
}
//
// Write back a healthy FV header
//
if (WriteBack) {
Status = FlashFdErase (
(UINTN) FwhInstance->FvBase[0],
FwhInstance,
FwVolHeader->BlockMap->Length
);
HeaderLength = (UINTN) FwVolHeader->HeaderLength;
Status = FlashFdWrite (
(UINTN) FwhInstance->FvBase[0],
FwhInstance,
(UINTN *) &HeaderLength,
(UINT8 *) FwVolHeader
);
FwVolHeader->HeaderLength = (UINT16) HeaderLength;
DEBUG ((EFI_D_ERROR, "Fvb (0x%x): FV header invalid, write back - %r\n", (UINTN) FwhInstance->FvBase[0], Status));
}
}
//
// The total number of blocks in the FV.
//
FwhInstance->NumOfBlocks = NumOfBlocks;
//
// Add a FVB Protocol Instance
//
Status = gBS->AllocatePool (
EfiRuntimeServicesData,
sizeof (EFI_FW_VOL_BLOCK_DEVICE),
&FvbDevice
);
ASSERT_EFI_ERROR (Status);
CopyMem (FvbDevice, &mFvbDeviceTemplate, sizeof (EFI_FW_VOL_BLOCK_DEVICE));
FvbDevice->Instance = mFvbModuleGlobal->NumFv;
mFvbModuleGlobal->NumFv++;
//
// Set up the devicepath
//
FvbDevice->DevicePath.MemMapDevPath.StartingAddress = BaseAddress;
FvbDevice->DevicePath.MemMapDevPath.EndingAddress = BaseAddress + (FwVolHeader->FvLength - 1);
//
// Find a handle with a matching device path that has supports FW Block protocol
//
TempFwbDevicePath = (EFI_DEVICE_PATH_PROTOCOL *) &TempFvbDevicePathData;
CopyMem (TempFwbDevicePath, &FvbDevice->DevicePath, sizeof (FV_DEVICE_PATH));
Status = gBS->LocateDevicePath (&gEfiFirmwareVolumeBlockProtocolGuid, &TempFwbDevicePath, &FwbHandle);
if (EFI_ERROR (Status)) {
//
// LocateDevicePath fails so install a new interface and device path
//
FwbHandle = NULL;
Status = gBS->InstallMultipleProtocolInterfaces (
&FwbHandle,
&gEfiFirmwareVolumeBlockProtocolGuid,
&FvbDevice->FwVolBlockInstance,
&gEfiDevicePathProtocolGuid,
&FvbDevice->DevicePath,
NULL
);
ASSERT_EFI_ERROR (Status);
} else if (IsDevicePathEnd (TempFwbDevicePath)) {
//
// Device allready exists, so reinstall the FVB protocol
//
Status = gBS->HandleProtocol (
FwbHandle,
&gEfiFirmwareVolumeBlockProtocolGuid,
&OldFwbInterface
);
ASSERT_EFI_ERROR (Status);
Status = 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);
}
FwhInstance = (EFI_FW_VOL_INSTANCE *)
(
(UINTN) ((UINT8 *) FwhInstance) + FwVolHeader->HeaderLength +
(sizeof (EFI_FW_VOL_INSTANCE) - sizeof (EFI_FIRMWARE_VOLUME_HEADER))
);
} while (TRUE);
//
// Allocate for scratch space, an intermediate buffer for FVB extention
//
Status = gBS->AllocatePool (
EfiRuntimeServicesData,
MaxLbaSize,
&mFvbModuleGlobal->FvbScratchSpace[FVB_PHYSICAL]
);
ASSERT_EFI_ERROR (Status);
mFvbModuleGlobal->FvbScratchSpace[FVB_VIRTUAL] = mFvbModuleGlobal->FvbScratchSpace[FVB_PHYSICAL];
if (InstallSfsNotify) {
FvbInstallSfsNotify ();
}
return EFI_SUCCESS;
}