sravan/system76-edk2
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Upload BSD-licensed Vlv2TbltDevicePkg and Vlv2DeviceRefCodePkg to

Browse Source 
https://svn.code.sf.net/p/edk2/code/trunk/edk2/, 

which are for MinnowBoard MAX open source project.


Contributed-under: TianoCore Contribution Agreement 1.0
Signed-off-by: David Wei <david.wei@intel.com>
Reviewed-by: Mike Wu <mike.wu@intel.com>
Reviewed-by: Hot Tian <hot.tian@intel.com>


git-svn-id: https://svn.code.sf.net/p/edk2/code/trunk/edk2@16599 6f19259b-4bc3-4df7-8a09-765794883524
This commit is contained in:
David Wei
2015-01-12 09:37:20 +00:00
committed by zwei4
parent 6f785cfcc3
commit 3cbfba02fe
518 changed files with 118538 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

175
Vlv2TbltDevicePkg/FvbRuntimeDxe/FvbInfo.c Normal file
View File

@@ -0,0 +1,175 @@
/**@file
Defines data structure that is the volume header found.
These data is intent to decouple FVB driver with FV header.
Copyright (c) 2006 - 2014, 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 that 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.
**/
#include <PiDxe.h>
#include <Protocol/FirmwareVolumeBlock.h>
#include <Library/PcdLib.h>
#include <Library/DebugLib.h>
#include <Library/BaseLib.h>
#include <Guid/FirmwareFileSystem2.h>
#include <Guid/SystemNvDataGuid.h>
#define FIRMWARE_BLOCK_SIZE 0x8000
#define FVB_MEDIA_BLOCK_SIZE (FIRMWARE_BLOCK_SIZE * 2)
#define FV_RECOVERY_BASE_ADDRESS FixedPcdGet32(PcdFlashFvRecoveryBase)
#define RECOVERY_BIOS_BLOCK_NUM (FixedPcdGet32(PcdFlashFvRecoverySize) / FVB_MEDIA_BLOCK_SIZE)
#define FV_MAIN_BASE_ADDRESS FixedPcdGet32(PcdFlashFvMainBase)
#define MAIN_BIOS_BLOCK_NUM (FixedPcdGet32(PcdFlashFvMainSize) / FVB_MEDIA_BLOCK_SIZE)
#define NV_STORAGE_BASE_ADDRESS FixedPcdGet32(PcdFlashNvStorageVariableBase)
#define SYSTEM_NV_BLOCK_NUM ((FixedPcdGet32(PcdFlashNvStorageVariableSize)+ FixedPcdGet32(PcdFlashNvStorageFtwWorkingSize) + FixedPcdGet32(PcdFlashNvStorageFtwSpareSize))/ FVB_MEDIA_BLOCK_SIZE)
typedef struct {
EFI_PHYSICAL_ADDRESS BaseAddress;
EFI_FIRMWARE_VOLUME_HEADER FvbInfo;
EFI_FV_BLOCK_MAP_ENTRY End[1];
} EFI_FVB2_MEDIA_INFO;
//
// This data structure contains a template of all correct FV headers, which is used to restore
// Fv header if it's corrupted.
//
EFI_FVB2_MEDIA_INFO mPlatformFvbMediaInfo[] = {
//
// Main BIOS FVB
//
{
FV_MAIN_BASE_ADDRESS,
{
{0,}, //ZeroVector[16]
EFI_FIRMWARE_FILE_SYSTEM2_GUID,
FVB_MEDIA_BLOCK_SIZE * MAIN_BIOS_BLOCK_NUM,
EFI_FVH_SIGNATURE,
0x0004feff, // check MdePkg/Include/Pi/PiFirmwareVolume.h for details on EFI_FVB_ATTRIBUTES_2
sizeof (EFI_FIRMWARE_VOLUME_HEADER) + sizeof (EFI_FV_BLOCK_MAP_ENTRY),
0, //CheckSum which will be calucated dynamically.
0, //ExtHeaderOffset
{0,}, //Reserved[1]
2, //Revision
{
{
MAIN_BIOS_BLOCK_NUM,
FVB_MEDIA_BLOCK_SIZE,
}
}
},
{
{
0,
0
}
}
},
//
// Systen NvStorage FVB
//
{
NV_STORAGE_BASE_ADDRESS,
{
{0,}, //ZeroVector[16]
EFI_SYSTEM_NV_DATA_FV_GUID,
FVB_MEDIA_BLOCK_SIZE * SYSTEM_NV_BLOCK_NUM,
EFI_FVH_SIGNATURE,
0x0004feff, // check MdePkg/Include/Pi/PiFirmwareVolume.h for details on EFI_FVB_ATTRIBUTES_2
sizeof (EFI_FIRMWARE_VOLUME_HEADER) + sizeof (EFI_FV_BLOCK_MAP_ENTRY),
0, //CheckSum which will be calucated dynamically.
0, //ExtHeaderOffset
{0,}, //Reserved[1]
2, //Revision
{
{
SYSTEM_NV_BLOCK_NUM,
FVB_MEDIA_BLOCK_SIZE,
}
}
},
{
{
0,
0
}
}
},
//
// Recovery BIOS FVB
//
{
FV_RECOVERY_BASE_ADDRESS,
{
{0,}, //ZeroVector[16]
EFI_FIRMWARE_FILE_SYSTEM2_GUID,
FVB_MEDIA_BLOCK_SIZE * RECOVERY_BIOS_BLOCK_NUM,
EFI_FVH_SIGNATURE,
0x0004feff, // check MdePkg/Include/Pi/PiFirmwareVolume.h for details on EFI_FVB_ATTRIBUTES_2
sizeof (EFI_FIRMWARE_VOLUME_HEADER) + sizeof (EFI_FV_BLOCK_MAP_ENTRY),
0, //CheckSum which will be calucated dynamically.
0, //ExtHeaderOffset
{0,}, //Reserved[1]
2, //Revision
{
{
RECOVERY_BIOS_BLOCK_NUM,
FVB_MEDIA_BLOCK_SIZE,
}
}
},
{
{
0,
0
}
}
}
};
EFI_STATUS
GetFvbInfo (
IN EFI_PHYSICAL_ADDRESS FvBaseAddress,
OUT EFI_FIRMWARE_VOLUME_HEADER **FvbInfo
)
{
UINTN Index;
EFI_FIRMWARE_VOLUME_HEADER *FvHeader;
for (Index = 0; Index < sizeof (mPlatformFvbMediaInfo) / sizeof (EFI_FVB2_MEDIA_INFO); Index += 1) {
if (mPlatformFvbMediaInfo[Index].BaseAddress == FvBaseAddress) {
FvHeader = &mPlatformFvbMediaInfo[Index].FvbInfo;
//
// Update the checksum value of FV header.
//
FvHeader->Checksum = CalculateCheckSum16 ((UINT16 *) FvHeader, FvHeader->HeaderLength / sizeof (UINT16));
*FvbInfo = FvHeader;
DEBUG ((EFI_D_INFO, "\nBaseAddr: 0x%lx \n", FvBaseAddress));
DEBUG ((EFI_D_INFO, "FvLength: 0x%lx \n", (*FvbInfo)->FvLength));
DEBUG ((EFI_D_INFO, "HeaderLength: 0x%x \n", (*FvbInfo)->HeaderLength));
DEBUG ((EFI_D_INFO, "FvBlockMap[0].NumBlocks: 0x%x \n", (*FvbInfo)->BlockMap[0].NumBlocks));

85
Vlv2TbltDevicePkg/FvbRuntimeDxe/FvbRuntimeDxe.inf Normal file
View File

@@ -0,0 +1,85 @@
## @file
# This driver implement the EFI_FIRMWARE_VOLUMEN_PROTOCOL.
#
# Copyright (c) 2006 - 2014, 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 that 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.
#
#
#
#
##
[Defines]
INF_VERSION = 0x00010005
BASE_NAME = FvbRuntimeDxe
FILE_GUID = FD3B7E55-FA7B-4e07-AE1D-208B81FB0BAD
MODULE_TYPE = DXE_RUNTIME_DRIVER
VERSION_STRING = 1.0
ENTRY_POINT = DxeFvbInitialize
#
# The following information is for reference only and not required by the build tools.
#
# VALID_ARCHITECTURES = IA32 X64
#
# VIRTUAL_ADDRESS_MAP_CALLBACK = FvbVirtualddressChangeEvent
#
[Sources]
FvbInfo.c
FvbService.h
FvbService.c
FvbServiceDxe.c
[Packages]
MdePkg/MdePkg.dec
MdeModulePkg/MdeModulePkg.dec
Vlv2TbltDevicePkg/PlatformPkg.dec
Vlv2DeviceRefCodePkg/Vlv2DeviceRefCodePkg.dec
[LibraryClasses]
FlashDeviceLib
PcdLib
MemoryAllocationLib
CacheMaintenanceLib
IoLib
BaseMemoryLib
DebugLib
BaseLib
UefiLib
UefiRuntimeLib
UefiBootServicesTableLib
UefiDriverEntryPoint
[Guids]
gEfiFirmwareFileSystem2Guid # ALWAYS_CONSUMED
gEfiSystemNvDataFvGuid # ALWAYS_CONSUMED
gEfiEventVirtualAddressChangeGuid
[Protocols]
gEfiDevicePathProtocolGuid # PROTOCOL ALWAYS_PRODUCED
gEfiFirmwareVolumeBlockProtocolGuid # PROTOCOL ALWAYS_PRODUCED
[FixedPcd]
gPlatformModuleTokenSpaceGuid.PcdFlashFvMainBase
gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageVariableBase
gPlatformModuleTokenSpaceGuid.PcdFlashFvRecoveryBase
[Pcd]
gPlatformModuleTokenSpaceGuid.PcdFlashFvMainSize

1114
Vlv2TbltDevicePkg/FvbRuntimeDxe/FvbService.c Normal file
View File

File diff suppressed because it is too large Load Diff

187
Vlv2TbltDevicePkg/FvbRuntimeDxe/FvbService.h Normal file
View File

@@ -0,0 +1,187 @@
/** @file
The header file for Firmware volume block driver.
Copyright (c) 2006 - 2014, 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 that 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.
**/
#ifndef _FW_BLOCK_SERVICE_H
#define _FW_BLOCK_SERVICE_H
#include <Guid/EventGroup.h>
#include <Guid/FirmwareFileSystem2.h>
#include <Guid/SystemNvDataGuid.h>
#include <Protocol/DevicePath.h>
#include <Protocol/FirmwareVolumeBlock.h>
#include <Library/UefiDriverEntryPoint.h>
#include <Library/UefiBootServicesTableLib.h>
#include <Library/UefiLib.h>
#include <Library/BaseLib.h>
#include <Library/DebugLib.h>
#include <Library/BaseMemoryLib.h>
#include <Library/IoLib.h>
#include <Library/CacheMaintenanceLib.h>
#include <Library/MemoryAllocationLib.h>
#include <Library/PcdLib.h>
#include <Library/FlashDeviceLib.h>
#include <Library/DevicePathLib.h>
//
// Define two helper macro to extract the Capability field or Status field in FVB
// bit fields.
//
#define EFI_FVB2_CAPABILITIES (EFI_FVB2_READ_DISABLED_CAP | \
EFI_FVB2_READ_ENABLED_CAP | \
EFI_FVB2_WRITE_DISABLED_CAP | \
EFI_FVB2_WRITE_ENABLED_CAP | \
EFI_FVB2_LOCK_CAP \
)
#define EFI_FVB2_STATUS (EFI_FVB2_READ_STATUS | EFI_FVB2_WRITE_STATUS | EFI_FVB2_LOCK_STATUS)
typedef struct {
UINTN FvBase;
UINTN NumOfBlocks;
//
// Note!!!: VolumeHeader must be the last element
// of the structure.
//
EFI_FIRMWARE_VOLUME_HEADER VolumeHeader;
} EFI_FW_VOL_INSTANCE;
typedef struct {
EFI_FW_VOL_INSTANCE *FvInstance;
UINT32 NumFv;
} FWB_GLOBAL;
//
// Fvb Protocol instance data.
//
#define FVB_DEVICE_FROM_THIS(a) CR(a, EFI_FW_VOL_BLOCK_DEVICE, FwVolBlockInstance, FVB_DEVICE_SIGNATURE)
#define FVB_EXTEND_DEVICE_FROM_THIS(a) CR(a, EFI_FW_VOL_BLOCK_DEVICE, FvbExtension, FVB_DEVICE_SIGNATURE)
#define FVB_DEVICE_SIGNATURE SIGNATURE_32('F','V','B','C')
typedef struct {
MEDIA_FW_VOL_DEVICE_PATH FvDevPath;
EFI_DEVICE_PATH_PROTOCOL EndDevPath;
} FV_PIWG_DEVICE_PATH;
typedef struct {
MEMMAP_DEVICE_PATH MemMapDevPath;
EFI_DEVICE_PATH_PROTOCOL EndDevPath;
} FV_MEMMAP_DEVICE_PATH;
typedef struct {
UINT32 Signature;
EFI_DEVICE_PATH_PROTOCOL *DevicePath;
UINTN Instance;
EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL FwVolBlockInstance;
} EFI_FW_VOL_BLOCK_DEVICE;
EFI_STATUS
GetFvbInfo (
IN EFI_PHYSICAL_ADDRESS FvBaseAddress,
OUT EFI_FIRMWARE_VOLUME_HEADER **FvbInfo
);
//
// Protocol APIs
//
EFI_STATUS
EFIAPI
FvbProtocolGetAttributes (
IN CONST EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *This,
OUT EFI_FVB_ATTRIBUTES_2 *Attributes
);
EFI_STATUS
EFIAPI
FvbProtocolSetAttributes (
IN CONST EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *This,
IN OUT EFI_FVB_ATTRIBUTES_2 *Attributes
);
EFI_STATUS
EFIAPI
FvbProtocolGetPhysicalAddress (
IN CONST EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *This,
OUT EFI_PHYSICAL_ADDRESS *Address
);
EFI_STATUS
EFIAPI
FvbProtocolGetBlockSize (
IN CONST EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *This,
IN EFI_LBA Lba,
OUT UINTN *BlockSize,
OUT UINTN *NumOfBlocks
);
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_STATUS
EFIAPI
FvbProtocolWrite (
IN CONST EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *This,
IN EFI_LBA Lba,
IN UINTN Offset,
IN OUT UINTN *NumBytes,
IN UINT8 *Buffer
);
EFI_STATUS
EFIAPI
FvbProtocolEraseBlocks (
IN CONST EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *This,
...
);
EFI_FW_VOL_INSTANCE *
GetFvbInstance (
IN UINTN Instance
);
BOOLEAN
IsFvHeaderValid (
IN EFI_PHYSICAL_ADDRESS FvBase,
IN CONST EFI_FIRMWARE_VOLUME_HEADER *FwVolHeader
);
VOID
InstallFvbProtocol (
IN EFI_FW_VOL_INSTANCE *FwhInstance,
IN UINTN InstanceNum
);
EFI_STATUS
FvbInitialize (
VOID
);

204
Vlv2TbltDevicePkg/FvbRuntimeDxe/FvbServiceDxe.c Normal file
View File

@@ -0,0 +1,204 @@
/** @file
Firmware Volume Block Driver for Lakeport Platform.
Firmware volume block driver for FWH or SPI device.
It depends on which Flash Device Library to be linked with this driver.
Copyright (c) 2006 - 2014, 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 that 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.
**/
#include <PiDxe.h>
#include <Library/UefiRuntimeLib.h>
#include "FvbService.h"
extern FWB_GLOBAL mFvbModuleGlobal;
/**
Call back function on EVT_SIGNAL_VIRTUAL_ADDRESS_CHANGE event.
Fixup internal data so that the driver is callable in EFI runtime
in virtual mode. Convert the mFvbModuleGlobal date items to there
virtual address.
@param Event Event whose notification function is being invoked.
@param Context The context of the Notification context. Not used in
this call back function.
**/
VOID
EFIAPI
FvbVirtualddressChangeEvent (
IN EFI_EVENT Event,
IN VOID *Context
)
{
EFI_FW_VOL_INSTANCE *FwhInstance;
UINTN Index;
//
// Convert the base address of all the instances.
//
for (Index = 0; Index < mFvbModuleGlobal.NumFv; Index++) {
FwhInstance = GetFvbInstance (Index);
EfiConvertPointer (0, (VOID **) &FwhInstance->FvBase);
}
EfiConvertPointer (0, (VOID **) &mFvbModuleGlobal.FvInstance);
}
/**
The function installs EFI_FIRMWARE_VOLUME_BLOCK protocol
for each FV in the system.
@param[in] FwhInstance The pointer to a FW volume instance structure,
which contains the information about one FV.
@param[in] InstanceNum The instance number which can be used as a ID
to locate this FwhInstance in other functions.
@retval VOID
**/
VOID
InstallFvbProtocol (
IN EFI_FW_VOL_INSTANCE *FwhInstance,
IN UINTN InstanceNum
)
{
EFI_FW_VOL_BLOCK_DEVICE *FvbDevice;
EFI_FIRMWARE_VOLUME_HEADER *FwVolHeader;
EFI_STATUS Status;
EFI_HANDLE FwbHandle;
EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *OldFwbInterface;
FvbDevice = (EFI_FW_VOL_BLOCK_DEVICE *) AllocateRuntimeCopyPool (
sizeof (EFI_FW_VOL_BLOCK_DEVICE),
&mFvbDeviceTemplate
);
ASSERT (FvbDevice != NULL);
FvbDevice->Instance = InstanceNum;
FwVolHeader = &FwhInstance->VolumeHeader;
//
// Set up the devicepath.
//
DEBUG ((EFI_D_INFO, "FwBlockService.c: Setting up DevicePath for 0x%lx:\n", FwhInstance->FvBase));
if (FwVolHeader->ExtHeaderOffset == 0) {
//
// FV does not contains extension header, then produce MEMMAP_DEVICE_PATH.
//
FvbDevice->DevicePath = (EFI_DEVICE_PATH_PROTOCOL *) AllocateRuntimeCopyPool (sizeof (FV_MEMMAP_DEVICE_PATH), &mFvMemmapDevicePathTemplate);
((FV_MEMMAP_DEVICE_PATH *) FvbDevice->DevicePath)->MemMapDevPath.StartingAddress = FwhInstance->FvBase;
((FV_MEMMAP_DEVICE_PATH *) FvbDevice->DevicePath)->MemMapDevPath.EndingAddress = FwhInstance->FvBase + FwVolHeader->FvLength - 1;
} else {
FvbDevice->DevicePath = (EFI_DEVICE_PATH_PROTOCOL *) AllocateRuntimeCopyPool (sizeof (FV_PIWG_DEVICE_PATH), &mFvPIWGDevicePathTemplate);
CopyGuid (
&((FV_PIWG_DEVICE_PATH *)FvbDevice->DevicePath)->FvDevPath.FvName,
(GUID *)(UINTN)(FwhInstance->FvBase + FwVolHeader->ExtHeaderOffset)
);
}
//
// Find a handle with a matching device path that has supports FW Block protocol.
//
Status = gBS->LocateDevicePath (
&gEfiFirmwareVolumeBlockProtocolGuid,
&FvbDevice->DevicePath,
&FwbHandle
);
if (EFI_ERROR (Status) ) {
//
// LocateDevicePath fails so install a new interface and device path.
//
DEBUG ((EFI_D_INFO, "FwBlockService.c: LocateDevicePath failed, install new interface 0x%lx:\n", FwhInstance->FvBase));
FwbHandle = NULL;
Status = gBS->InstallMultipleProtocolInterfaces (
&FwbHandle,
&gEfiFirmwareVolumeBlockProtocolGuid,
&FvbDevice->FwVolBlockInstance,
&gEfiDevicePathProtocolGuid,
FvbDevice->DevicePath,
NULL
);
ASSERT_EFI_ERROR (Status);
DEBUG ((EFI_D_INFO, "FwBlockService.c: IMPI FirmwareVolBlockProt, DevPath 0x%lx: %r\n", FwhInstance->FvBase, Status));
} else if (IsDevicePathEnd (FvbDevice->DevicePath)) {
//
// Device allready exists, so reinstall the FVB protocol.
//
DEBUG ((EFI_D_ERROR, "FwBlockService.c: LocateDevicePath succeeded, reinstall interface 0x%lx:\n", FwhInstance->FvBase));
Status = gBS->HandleProtocol (
FwbHandle,
&gEfiFirmwareVolumeBlockProtocolGuid,
(VOID **) &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);
}
}
/**
The driver entry point for Firmware Volume Block Driver.
The function does the necessary initialization work for
Firmware Volume Block Driver.
@param[in] ImageHandle The firmware allocated handle for the UEFI image.
@param[in] SystemTable A pointer to the EFI system table.
@retval EFI_SUCCESS This funtion always return EFI_SUCCESS.
It will ASSERT on errors.
**/
EFI_STATUS
EFIAPI
DxeFvbInitialize (
IN EFI_HANDLE ImageHandle,
IN EFI_SYSTEM_TABLE *SystemTable
)
{
EFI_STATUS Status;
EFI_EVENT Event;
Status = gBS->CreateEventEx (
EVT_NOTIFY_SIGNAL,
TPL_NOTIFY,
FvbVirtualddressChangeEvent,
NULL,
&gEfiEventVirtualAddressChangeGuid,

132
Vlv2TbltDevicePkg/FvbRuntimeDxe/FvbServiceSmm.c Normal file
View File

@@ -0,0 +1,132 @@
/** @file
SMM Firmware Volume Block Driver for Lakeport Platform.
Firmware volume block driver for FWH or SPI device.
It depends on which Flash Device Library to be linked with this driver.
Copyright (c) 2010 - 2014, 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 that 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.
**/
#include <PiSmm.h>
#include <Library/SmmServicesTableLib.h>
#include "FvbSmmCommon.h"
#include "FvbService.h"
/**
The function installs EFI_SMM_FIRMWARE_VOLUME_BLOCK protocol
for each FV in the system.
@param[in] FwhInstance The pointer to a FW volume instance structure,
which contains the information about one FV.
@param[in] InstanceNum The instance number which can be used as a ID
to locate this FwhInstance in other functions.
@retval VOID
**/
VOID
InstallFvbProtocol (
IN EFI_FW_VOL_INSTANCE *FwhInstance,
IN UINTN InstanceNum
)
{
EFI_FW_VOL_BLOCK_DEVICE *FvbDevice;
EFI_FIRMWARE_VOLUME_HEADER *FwVolHeader;
EFI_STATUS Status;
EFI_HANDLE FvbHandle;
FvbDevice = (EFI_FW_VOL_BLOCK_DEVICE *) AllocateRuntimeCopyPool (
sizeof (EFI_FW_VOL_BLOCK_DEVICE),
&mFvbDeviceTemplate
);
ASSERT (FvbDevice != NULL);
FvbDevice->Instance = InstanceNum;
FwVolHeader = &FwhInstance->VolumeHeader;
//
// Set up the devicepath.
//
if (FwVolHeader->ExtHeaderOffset == 0) {
//
// FV does not contains extension header, then produce MEMMAP_DEVICE_PATH.
//
FvbDevice->DevicePath = (EFI_DEVICE_PATH_PROTOCOL *) AllocateRuntimeCopyPool (sizeof (FV_MEMMAP_DEVICE_PATH), &mFvMemmapDevicePathTemplate);
((FV_MEMMAP_DEVICE_PATH *) FvbDevice->DevicePath)->MemMapDevPath.StartingAddress = FwhInstance->FvBase;
((FV_MEMMAP_DEVICE_PATH *) FvbDevice->DevicePath)->MemMapDevPath.EndingAddress = FwhInstance->FvBase + FwVolHeader->FvLength - 1;
} else {
FvbDevice->DevicePath = (EFI_DEVICE_PATH_PROTOCOL *) AllocateRuntimeCopyPool (sizeof (FV_PIWG_DEVICE_PATH), &mFvPIWGDevicePathTemplate);
CopyGuid (
&((FV_PIWG_DEVICE_PATH *)FvbDevice->DevicePath)->FvDevPath.FvName,
(GUID *)(UINTN)(FwhInstance->FvBase + FwVolHeader->ExtHeaderOffset)
);
}
//
// Install the SMM Firmware Volume Block Protocol and Device Path Protocol.
//
FvbHandle = NULL;
Status = gSmst->SmmInstallProtocolInterface (
&FvbHandle,
&gEfiSmmFirmwareVolumeBlockProtocolGuid,
EFI_NATIVE_INTERFACE,
&FvbDevice->FwVolBlockInstance
);
ASSERT_EFI_ERROR (Status);
Status = gSmst->SmmInstallProtocolInterface (
&FvbHandle,
&gEfiDevicePathProtocolGuid,
EFI_NATIVE_INTERFACE,
FvbDevice->DevicePath
);
ASSERT_EFI_ERROR (Status);
//
// Notify the Fvb wrapper driver SMM fvb is ready.
//
FvbHandle = NULL;
Status = gBS->InstallProtocolInterface (
&FvbHandle,
&gEfiSmmFirmwareVolumeBlockProtocolGuid,
EFI_NATIVE_INTERFACE,
&FvbDevice->FwVolBlockInstance
);
}
/**
The driver entry point for SMM Firmware Volume Block Driver.
The function does the necessary initialization work
Firmware Volume Block Driver.
@param[in] ImageHandle The firmware allocated handle for the UEFI image.
@param[in] SystemTable A pointer to the EFI system table.
@retval EFI_SUCCESS This funtion always return EFI_SUCCESS.
It will ASSERT on errors.
**/
EFI_STATUS
EFIAPI
FvbSmmInitialize (

87
Vlv2TbltDevicePkg/FvbRuntimeDxe/FvbSmm.inf Normal file
View File

@@ -0,0 +1,87 @@
## @file
# This driver implement the EFI_SMM_FIRMWARE_VOLUMEN_PROTOCOL.
#
# Copyright (c) 2010 - 2014, 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 that 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.
#
#
#
#
##
[Defines]
INF_VERSION = 0x00010005
BASE_NAME = FvbSmm
FILE_GUID = A4EC8ADB-B7A8-47d1-8E52-EC820D0ACF6F
MODULE_TYPE = DXE_SMM_DRIVER
VERSION_STRING = 1.0
PI_SPECIFICATION_VERSION = 0x0001000A
ENTRY_POINT = FvbSmmInitialize
#
# The following information is for reference only and not required by the build tools.
#
# VALID_ARCHITECTURES = IA32 X64
#
# VIRTUAL_ADDRESS_MAP_CALLBACK = FvbVirtualddressChangeEvent
#
[Sources]
FvbInfo.c
FvbService.h
FvbService.c
FvbServiceSmm.c
FvbSmmCommon.h
[Packages]
MdePkg/MdePkg.dec
MdeModulePkg/MdeModulePkg.dec
Vlv2TbltDevicePkg/PlatformPkg.dec
Vlv2DeviceRefCodePkg/Vlv2DeviceRefCodePkg.dec
[LibraryClasses]
FlashDeviceLib
PcdLib
MemoryAllocationLib
CacheMaintenanceLib
IoLib
BaseMemoryLib
DebugLib
BaseLib
UefiLib
SmmLib
SmmServicesTableLib
UefiBootServicesTableLib
UefiDriverEntryPoint
[Guids]
gEfiFirmwareFileSystem2Guid # ALWAYS_CONSUMED
gEfiSystemNvDataFvGuid # ALWAYS_CONSUMED
gEfiEventVirtualAddressChangeGuid
[Protocols]
gEfiDevicePathProtocolGuid # PROTOCOL ALWAYS_PRODUCED
gEfiSmmFirmwareVolumeBlockProtocolGuid # PROTOCOL ALWAYS_PRODUCED
[FixedPcd]
gPlatformModuleTokenSpaceGuid.PcdFlashFvMainBase
gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageVariableBase
gPlatformModuleTokenSpaceGuid.PcdFlashFvRecoveryBase
[Pcd]

78
Vlv2TbltDevicePkg/FvbRuntimeDxe/FvbSmmCommon.h Normal file
View File

@@ -0,0 +1,78 @@
/** @file
The common header file for SMM FVB module and SMM FVB runtime Module.
Copyright (c) 2010 - 2014, 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 that 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.
**/
#ifndef _SMM_FVB_COMMON_H_
#define _SMM_FVB_COMMON_H_
#include <Protocol/SmmFirmwareVolumeBlock.h>
#define EFI_FUNCTION_GET_ATTRIBUTES 1
#define EFI_FUNCTION_SET_ATTRIBUTES 2
#define EFI_FUNCTION_GET_PHYSICAL_ADDRESS 3
#define EFI_FUNCTION_GET_BLOCK_SIZE 4
#define EFI_FUNCTION_READ 5
#define EFI_FUNCTION_WRITE 6
#define EFI_FUNCTION_ERASE_BLOCKS 7
typedef struct {
UINTN Function;
EFI_STATUS ReturnStatus;
UINT8 Data[1];
} SMM_FVB_COMMUNICATE_FUNCTION_HEADER;
///
/// Size of SMM communicate header, without including the payload.
///
#define SMM_COMMUNICATE_HEADER_SIZE (OFFSET_OF (EFI_SMM_COMMUNICATE_HEADER, Data))
///
/// Size of SMM FVB communicate function header, without including the payload.
///
#define SMM_FVB_COMMUNICATE_HEADER_SIZE (OFFSET_OF (SMM_FVB_COMMUNICATE_FUNCTION_HEADER, Data))
typedef struct {
EFI_SMM_FIRMWARE_VOLUME_BLOCK_PROTOCOL *SmmFvb;
EFI_FVB_ATTRIBUTES_2 Attributes;
} SMM_FVB_ATTRIBUTES_HEADER;
typedef struct {
EFI_SMM_FIRMWARE_VOLUME_BLOCK_PROTOCOL *SmmFvb;
EFI_PHYSICAL_ADDRESS Address;
} SMM_FVB_PHYSICAL_ADDRESS_HEADER;
typedef struct {
EFI_SMM_FIRMWARE_VOLUME_BLOCK_PROTOCOL *SmmFvb;
EFI_LBA Lba;
UINTN BlockSize;
UINTN NumOfBlocks;
} SMM_FVB_BLOCK_SIZE_HEADER;
typedef struct {
EFI_SMM_FIRMWARE_VOLUME_BLOCK_PROTOCOL *SmmFvb;
EFI_LBA Lba;
UINTN Offset;
UINTN NumBytes;

949
Vlv2TbltDevicePkg/FvbRuntimeDxe/FvbSmmDxe.c Normal file
View File

@@ -0,0 +1,949 @@
/** @file
Implement the Firmware Volume Block (FVB) services based on SMM FVB
module and install FVB protocol.
Copyright (c) 2010 - 2014, 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 that 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.
**/
#include "FvbSmmDxe.h"
EFI_HANDLE mHandle = NULL;
EFI_SMM_COMMUNICATION_PROTOCOL *mSmmCommunication = NULL;
//
// Template structure used when installing FVB protocol.
//
EFI_FVB_DEVICE mFvbDeviceTemplate = {
FVB_DEVICE_SIGNATURE,
NULL,
{
FvbGetAttributes,
FvbSetAttributes,
FvbGetPhysicalAddress,
FvbGetBlockSize,
FvbRead,
FvbWrite,
FvbEraseBlocks,
NULL
},
NULL
};
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
}
}
};
/**
Initialize the communicate buffer using DataSize and Function.
The communicate size is: SMM_COMMUNICATE_HEADER_SIZE + SMM_VARIABLE_COMMUNICATE_HEADER_SIZE +
DataSize.
@param[out] CommunicateBuffer The communicate buffer. Caller should free it after use.
@param[out] DataPtr Points to the data in the communicate buffer. Caller should not free it.
@param[in] DataSize The payload size.
@param[in] Function The function number used to initialize the communicate header.
@retval EFI_INVALID_PARAMETER The data size is too big.
@retval EFI_SUCCESS Find the specified variable.
**/
EFI_STATUS
InitCommunicateBuffer (
OUT VOID **CommunicateBuffer,
OUT VOID **DataPtr,
IN UINTN DataSize,
IN UINTN Function
)
{
EFI_SMM_COMMUNICATE_HEADER *SmmCommunicateHeader;
SMM_FVB_COMMUNICATE_FUNCTION_HEADER *SmmFvbFunctionHeader;
//
// The whole buffer size: SMM_COMMUNICATE_HEADER_SIZE + SMM_FVB_COMMUNICATE_HEADER_SIZE + DataSize.
//
SmmCommunicateHeader = AllocatePool (DataSize + SMM_COMMUNICATE_HEADER_SIZE + SMM_FVB_COMMUNICATE_HEADER_SIZE);
ASSERT (SmmCommunicateHeader != NULL);
//
// Prepare data buffer.
//
CopyGuid (&SmmCommunicateHeader->HeaderGuid, &gEfiSmmFirmwareVolumeBlockProtocolGuid);
SmmCommunicateHeader->MessageLength = DataSize + SMM_FVB_COMMUNICATE_HEADER_SIZE;
SmmFvbFunctionHeader = (SMM_FVB_COMMUNICATE_FUNCTION_HEADER *) SmmCommunicateHeader->Data;
SmmFvbFunctionHeader->Function = Function;
*CommunicateBuffer = SmmCommunicateHeader;
*DataPtr = SmmFvbFunctionHeader->Data;
return EFI_SUCCESS;
}
/**
Send the data in communicate buffer to SMM.
@param[out] SmmCommunicateHeader The communicate buffer.
@param[in] DataSize The payload size.
**/
EFI_STATUS
SendCommunicateBuffer (
IN EFI_SMM_COMMUNICATE_HEADER *SmmCommunicateHeader,
IN UINTN DataSize
)
{
EFI_STATUS Status;
UINTN CommSize;
SMM_FVB_COMMUNICATE_FUNCTION_HEADER *SmmFvbFunctionHeader;
CommSize = DataSize + SMM_COMMUNICATE_HEADER_SIZE + SMM_FVB_COMMUNICATE_HEADER_SIZE;
Status = mSmmCommunication->Communicate (
mSmmCommunication,
SmmCommunicateHeader,
&CommSize
);
ASSERT_EFI_ERROR (Status);
SmmFvbFunctionHeader = (SMM_FVB_COMMUNICATE_FUNCTION_HEADER *) SmmCommunicateHeader->Data;
return SmmFvbFunctionHeader->ReturnStatus;
}
/**
This function retrieves the attributes and current settings of the block.
@param[in] This Indicates the EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL instance.
@param[out] Attributes Pointer to EFI_FVB_ATTRIBUTES_2 in which the attributes
and current settings are returned. Type EFI_FVB_ATTRIBUTES_2
is defined in EFI_FIRMWARE_VOLUME_HEADER.
@retval EFI_SUCCESS The firmware volume attributes were returned.
@retval EFI_INVALID_PARAMETER Attributes is NULL.
**/
EFI_STATUS
EFIAPI
FvbGetAttributes (
IN CONST EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *This,
OUT EFI_FVB_ATTRIBUTES_2 *Attributes
)
{
EFI_STATUS Status;
UINTN PayloadSize;
EFI_SMM_COMMUNICATE_HEADER *SmmCommunicateHeader;
SMM_FVB_ATTRIBUTES_HEADER *SmmFvbAttributesHeader;
EFI_SMM_FIRMWARE_VOLUME_BLOCK_PROTOCOL *SmmFvb;
EFI_FVB_DEVICE *FvbDevice;
if (Attributes == NULL) {
return EFI_INVALID_PARAMETER;
}
FvbDevice = FVB_DEVICE_FROM_THIS (This);
SmmFvb = FvbDevice->SmmFvbInstance;
//
// Initialize the communicate buffer.
//
PayloadSize = sizeof (SMM_FVB_ATTRIBUTES_HEADER);
Status = InitCommunicateBuffer (
(VOID **)&SmmCommunicateHeader,
(VOID **)&SmmFvbAttributesHeader,
PayloadSize,
EFI_FUNCTION_GET_ATTRIBUTES
);
if (EFI_ERROR (Status)) {
return Status;
}
SmmFvbAttributesHeader->SmmFvb = SmmFvb;
SmmFvbAttributesHeader->Attributes = 0;
//
// Send data to SMM.
//
Status = SendCommunicateBuffer (SmmCommunicateHeader, PayloadSize);
//
// Get data from SMM.
//
*Attributes = SmmFvbAttributesHeader->Attributes;
FreePool (SmmCommunicateHeader);
return Status;
}
/**
Sets Volume attributes. No polarity translations are done.
@param[in] This Calling context.
@param[out] Attributes Output buffer which contains attributes.
@retval EFI_SUCCESS Set the Attributes successfully.
@retval EFI_INVALID_PARAMETER Attributes is NULL.
**/
EFI_STATUS
EFIAPI
FvbSetAttributes (
IN CONST EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *This,
IN OUT EFI_FVB_ATTRIBUTES_2 *Attributes
)
{
EFI_STATUS Status;
UINTN PayloadSize;
EFI_SMM_COMMUNICATE_HEADER *SmmCommunicateHeader;
SMM_FVB_ATTRIBUTES_HEADER *SmmFvbAttributesHeader;
EFI_SMM_FIRMWARE_VOLUME_BLOCK_PROTOCOL *SmmFvb;
EFI_FVB_DEVICE *FvbDevice;
if (Attributes == NULL) {
return EFI_INVALID_PARAMETER;
}
FvbDevice = FVB_DEVICE_FROM_THIS (This);
SmmFvb = FvbDevice->SmmFvbInstance;
//
// Initialize the communicate buffer.
//
PayloadSize = sizeof (SMM_FVB_ATTRIBUTES_HEADER);
Status = InitCommunicateBuffer (
(VOID **)&SmmCommunicateHeader,
(VOID **)&SmmFvbAttributesHeader,
PayloadSize,
EFI_FUNCTION_SET_ATTRIBUTES
);
if (EFI_ERROR (Status)) {
return Status;
}
SmmFvbAttributesHeader->SmmFvb = SmmFvb;
SmmFvbAttributesHeader->Attributes = *Attributes;
//
// Send data to SMM.
//
Status = SendCommunicateBuffer (SmmCommunicateHeader, PayloadSize);
//
// Get data from SMM.
//
*Attributes = SmmFvbAttributesHeader->Attributes;
FreePool (SmmCommunicateHeader);
return Status;
}
/**
Retrieves the physical address of the FVB instance.
@param[in] SmmFvb A pointer to EFI_SMM_FIRMWARE_VOLUME_BLOCK_PROTOCOL.
@param[out] Address Output buffer containing the address.
@retval EFI_SUCCESS Get the address successfully.
@retval Others Failed to get address.
**/
EFI_STATUS
GetPhysicalAddress (
IN EFI_SMM_FIRMWARE_VOLUME_BLOCK_PROTOCOL *SmmFvb,
OUT EFI_PHYSICAL_ADDRESS *Address
)
{
EFI_STATUS Status;
UINTN PayloadSize;
EFI_SMM_COMMUNICATE_HEADER *SmmCommunicateHeader;
SMM_FVB_PHYSICAL_ADDRESS_HEADER *SmmFvbPhysicalAddressHeader;
//
// Initialize the communicate buffer.
//
PayloadSize = sizeof (SMM_FVB_PHYSICAL_ADDRESS_HEADER);
Status = InitCommunicateBuffer (
(VOID **)&SmmCommunicateHeader,
(VOID **)&SmmFvbPhysicalAddressHeader,
PayloadSize,
EFI_FUNCTION_GET_PHYSICAL_ADDRESS
);
if (EFI_ERROR (Status)) {
return Status;
}
SmmFvbPhysicalAddressHeader->SmmFvb = SmmFvb;
SmmFvbPhysicalAddressHeader->Address = 0;
//
// Send data to SMM.
//
Status = SendCommunicateBuffer (SmmCommunicateHeader, PayloadSize);
//
// Get data from SMM.
//
*Address = SmmFvbPhysicalAddressHeader->Address;
FreePool (SmmCommunicateHeader);
return Status;
}
/**
Retrieves the physical address of the FVB instance.
@param[in] This A pointer to EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL.
@param[out] Address Output buffer containing the address.
@retval EFI_SUCCESS Get the address successfully.
@retval Others Failed to get the address.
**/
EFI_STATUS
EFIAPI
FvbGetPhysicalAddress (
IN CONST EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *This,
OUT EFI_PHYSICAL_ADDRESS *Address
)
{
EFI_STATUS Status;
EFI_SMM_FIRMWARE_VOLUME_BLOCK_PROTOCOL *SmmFvb;
EFI_FVB_DEVICE *FvbDevice;
if (Address == NULL) {
return EFI_INVALID_PARAMETER;
}
FvbDevice = FVB_DEVICE_FROM_THIS (This);
SmmFvb = FvbDevice->SmmFvbInstance;
Status = GetPhysicalAddress (SmmFvb, Address);
return Status;
}
/**
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 Get BlockSize and NumOfBlocks successfully.
@retval EFI_INVALID_PARAMETER BlockSize or NumOfBlocks are NULL.
**/
EFI_STATUS
EFIAPI
FvbGetBlockSize (
IN CONST EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *This,
IN EFI_LBA Lba,
OUT UINTN *BlockSize,
OUT UINTN *NumOfBlocks
)
{
EFI_STATUS Status;
UINTN PayloadSize;
EFI_SMM_COMMUNICATE_HEADER *SmmCommunicateHeader;
SMM_FVB_BLOCK_SIZE_HEADER *SmmFvbBlockSizeHeader;
EFI_SMM_FIRMWARE_VOLUME_BLOCK_PROTOCOL *SmmFvb;
EFI_FVB_DEVICE *FvbDevice;
if ((BlockSize == NULL) || (NumOfBlocks == NULL)) {
return EFI_INVALID_PARAMETER;
}
FvbDevice = FVB_DEVICE_FROM_THIS (This);
SmmFvb = FvbDevice->SmmFvbInstance;
//
// Initialize the communicate buffer.
//
PayloadSize = sizeof (SMM_FVB_BLOCK_SIZE_HEADER);
Status = InitCommunicateBuffer (
(VOID **)&SmmCommunicateHeader,
(VOID **)&SmmFvbBlockSizeHeader,
PayloadSize,
EFI_FUNCTION_GET_BLOCK_SIZE
);
if (EFI_ERROR (Status)) {
return Status;
}
SmmFvbBlockSizeHeader->SmmFvb = SmmFvb;
SmmFvbBlockSizeHeader->Lba = Lba;
//
// Send data to SMM.
//
Status = SendCommunicateBuffer (SmmCommunicateHeader, PayloadSize);
//
// Get data from SMM.
//
*BlockSize = SmmFvbBlockSizeHeader->BlockSize;
*NumOfBlocks = SmmFvbBlockSizeHeader->NumOfBlocks;
FreePool (SmmCommunicateHeader);
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[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
FvbRead (
IN CONST EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *This,
IN EFI_LBA Lba,
IN UINTN Offset,
IN OUT UINTN *NumBytes,
OUT UINT8 *Buffer
)
{
EFI_STATUS Status;
UINTN PayloadSize;
EFI_SMM_COMMUNICATE_HEADER *SmmCommunicateHeader;
SMM_FVB_READ_WRITE_HEADER *SmmFvbReadWriteHeader;
EFI_SMM_FIRMWARE_VOLUME_BLOCK_PROTOCOL *SmmFvb;
EFI_FVB_DEVICE *FvbDevice;
if ((NumBytes == NULL) || (Buffer == NULL)) {
return EFI_INVALID_PARAMETER;
}
FvbDevice = FVB_DEVICE_FROM_THIS (This);
SmmFvb = FvbDevice->SmmFvbInstance;
//
// Initialize the communicate buffer.
//
PayloadSize = sizeof (SMM_FVB_READ_WRITE_HEADER) + *NumBytes;
Status = InitCommunicateBuffer (
(VOID **)&SmmCommunicateHeader,
(VOID **)&SmmFvbReadWriteHeader,
PayloadSize, EFI_FUNCTION_READ
);
if (EFI_ERROR (Status)) {
return Status;
}
SmmFvbReadWriteHeader->SmmFvb = SmmFvb;
SmmFvbReadWriteHeader->Lba = Lba;
SmmFvbReadWriteHeader->Offset = Offset;
SmmFvbReadWriteHeader->NumBytes = *NumBytes;
//
// Send data to SMM.
//
Status = SendCommunicateBuffer (SmmCommunicateHeader, PayloadSize);
//
// Get data from SMM.
//
*NumBytes = SmmFvbReadWriteHeader->NumBytes;
if (!EFI_ERROR (Status)) {
CopyMem (Buffer, (UINT8 *)(SmmFvbReadWriteHeader + 1), *NumBytes);
}
FreePool (SmmCommunicateHeader);
return Status;
}
/**
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
FvbWrite (
IN CONST EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *This,
IN EFI_LBA Lba,
IN UINTN Offset,
IN OUT UINTN *NumBytes,
IN UINT8 *Buffer
)
{
EFI_STATUS Status;
UINTN PayloadSize;
EFI_SMM_COMMUNICATE_HEADER *SmmCommunicateHeader;
SMM_FVB_READ_WRITE_HEADER *SmmFvbReadWriteHeader;
EFI_SMM_FIRMWARE_VOLUME_BLOCK_PROTOCOL *SmmFvb;
EFI_FVB_DEVICE *FvbDevice;
if ((NumBytes == NULL) || (Buffer == NULL)) {
return EFI_INVALID_PARAMETER;
}
FvbDevice = FVB_DEVICE_FROM_THIS (This);
SmmFvb = FvbDevice->SmmFvbInstance;
//
// Initialize the communicate buffer.
//
PayloadSize = sizeof (SMM_FVB_READ_WRITE_HEADER) + *NumBytes;
Status = InitCommunicateBuffer (
(VOID **)&SmmCommunicateHeader,
(VOID **)&SmmFvbReadWriteHeader,
PayloadSize,
EFI_FUNCTION_WRITE
);
if (EFI_ERROR (Status)) {
return Status;
}
SmmFvbReadWriteHeader->SmmFvb = SmmFvb;
SmmFvbReadWriteHeader->Lba = Lba;
SmmFvbReadWriteHeader->Offset = Offset;
SmmFvbReadWriteHeader->NumBytes = *NumBytes;
CopyMem ((UINT8 *)(SmmFvbReadWriteHeader + 1), Buffer, *NumBytes);
//
// Send data to SMM.
//
Status = SendCommunicateBuffer (SmmCommunicateHeader, PayloadSize);
//
// Get data from SMM.
//
*NumBytes = SmmFvbReadWriteHeader->NumBytes;
FreePool (SmmCommunicateHeader);
return Status;
}
/**
The EraseBlock() function erases NumOfLba blocks started from StartingLba.
@param[in] This Calling context.
@param[in] StartingLba Starting LBA followed to erase.
@param[in] NumOfLba Number of block to erase.
@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
EraseBlock (
IN CONST EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *This,
IN EFI_LBA StartingLba,
IN UINTN NumOfLba
)
{
EFI_STATUS Status;
UINTN PayloadSize;
EFI_SMM_COMMUNICATE_HEADER *SmmCommunicateHeader;
SMM_FVB_BLOCKS_HEADER *SmmFvbBlocksHeader;
EFI_SMM_FIRMWARE_VOLUME_BLOCK_PROTOCOL *SmmFvb;
EFI_FVB_DEVICE *FvbDevice;
FvbDevice = FVB_DEVICE_FROM_THIS (This);
SmmFvb = FvbDevice->SmmFvbInstance;
//
// Initialize the communicate buffer.
//
PayloadSize = sizeof (SMM_FVB_BLOCKS_HEADER);
Status = InitCommunicateBuffer (
(VOID **)&SmmCommunicateHeader,
(VOID **)&SmmFvbBlocksHeader,
PayloadSize,
EFI_FUNCTION_ERASE_BLOCKS
);
if (EFI_ERROR (Status)) {
return Status;
}
SmmFvbBlocksHeader->SmmFvb = SmmFvb;
SmmFvbBlocksHeader->StartLba = StartingLba;
SmmFvbBlocksHeader->NumOfLba = NumOfLba;
//
// Send data to SMM.
//
Status = SendCommunicateBuffer (SmmCommunicateHeader, PayloadSize);
//
// Get data from SMM.
//
FreePool (SmmCommunicateHeader);
return Status;
}
/**
The EraseBlocks() 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
FvbEraseBlocks (
IN CONST EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *This,
...
)
{
EFI_STATUS Status;
VA_LIST Marker;
EFI_LBA StartingLba;
UINTN NumOfLba;
Status = EFI_SUCCESS;
//
// Check the parameter.
//
VA_START (Marker, This);
do {
StartingLba = VA_ARG (Marker, EFI_LBA);
if (StartingLba == EFI_LBA_LIST_TERMINATOR ) {
break;
}
NumOfLba = VA_ARG (Marker, UINT32);
if (NumOfLba == 0) {
return EFI_INVALID_PARAMETER;
}
} while ( 1 );
VA_END (Marker);
//
// Erase the blocks.
//
VA_START (Marker, This);
do {
StartingLba = VA_ARG (Marker, EFI_LBA);
if (StartingLba == EFI_LBA_LIST_TERMINATOR ) {
break;
}
NumOfLba = VA_ARG (Marker, UINT32);
Status = EraseBlock (This, StartingLba, NumOfLba);
if (EFI_ERROR (Status)) {
break;
}
} while ( 1 );
VA_END (Marker);
return Status;
}
/**
Install the FVB protocol which based on SMM FVB protocol.
@param[in] SmmFvb The SMM FVB protocol.
**/
VOID
InstallFvb (
IN EFI_SMM_FIRMWARE_VOLUME_BLOCK_PROTOCOL *SmmFvb
)
{
EFI_STATUS Status;
EFI_HANDLE FvbHandle;
EFI_FVB_DEVICE *FvbDevice;
EFI_FIRMWARE_VOLUME_HEADER *VolumeHeader;
EFI_PHYSICAL_ADDRESS Address;
EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *OldFvbInterface;
FvbDevice = AllocateRuntimeCopyPool (sizeof (EFI_FVB_DEVICE), &mFvbDeviceTemplate);
ASSERT (FvbDevice != NULL);
FvbDevice->SmmFvbInstance = SmmFvb;
Status = gBS->LocateProtocol (
&gEfiSmmCommunicationProtocolGuid,
NULL,
(VOID **) &mSmmCommunication
);
ASSERT_EFI_ERROR (Status);
Status = GetPhysicalAddress (SmmFvb, &Address);
ASSERT_EFI_ERROR (Status);
VolumeHeader = (EFI_FIRMWARE_VOLUME_HEADER *) (UINTN)Address;
//
// Set up the devicepath.
//
if (VolumeHeader->ExtHeaderOffset == 0) {
//
// FV does not contains extension header, then produce MEMMAP_DEVICE_PATH.
//
FvbDevice->DevicePath = (EFI_DEVICE_PATH_PROTOCOL *) AllocateRuntimeCopyPool (sizeof (FV_MEMMAP_DEVICE_PATH), &mFvMemmapDevicePathTemplate);
((FV_MEMMAP_DEVICE_PATH *) FvbDevice->DevicePath)->MemMapDevPath.StartingAddress = (UINTN)Address;
((FV_MEMMAP_DEVICE_PATH *) FvbDevice->DevicePath)->MemMapDevPath.EndingAddress = (UINTN)Address + VolumeHeader->FvLength - 1;
} else {
FvbDevice->DevicePath = (EFI_DEVICE_PATH_PROTOCOL *) AllocateRuntimeCopyPool (sizeof (FV_PIWG_DEVICE_PATH), &mFvPIWGDevicePathTemplate);
CopyGuid (
&((FV_PIWG_DEVICE_PATH *)FvbDevice->DevicePath)->FvDevPath.FvName,
(GUID *)(UINTN)((UINTN)Address + VolumeHeader->ExtHeaderOffset)
);
}
//
// Find a handle with a matching device path that has supports FW Block protocol.
//
Status = gBS->LocateDevicePath (
&gEfiFirmwareVolumeBlockProtocolGuid,
&FvbDevice->DevicePath,
&FvbHandle
);
if (EFI_ERROR (Status) ) {
//
// LocateDevicePath fails so install a new interface and device path.
//
FvbHandle = NULL;
Status = gBS->InstallMultipleProtocolInterfaces (
&FvbHandle,
&gEfiFirmwareVolumeBlockProtocolGuid,
&FvbDevice->FvbInstance,
&gEfiDevicePathProtocolGuid,
FvbDevice->DevicePath,
NULL
);
ASSERT_EFI_ERROR (Status);
} else if (IsDevicePathEnd (FvbDevice->DevicePath)) {
//
// Device allready exists, so reinstall the FVB protocol.
//
Status = gBS->HandleProtocol (
FvbHandle,
&gEfiFirmwareVolumeBlockProtocolGuid,
(VOID **) &OldFvbInterface
);
ASSERT_EFI_ERROR (Status);
Status = gBS->ReinstallProtocolInterface (
FvbHandle,
&gEfiFirmwareVolumeBlockProtocolGuid,
OldFvbInterface,
&FvbDevice->FvbInstance
);
ASSERT_EFI_ERROR (Status);
} else {
//
// There was a FVB protocol on an End Device Path node.
//
ASSERT (FALSE);
}
}
/**
SMM Firmware Volume Block Protocol notification event handler.
Discover NV Variable Store and install Variable Write Arch Protocol.
@param[in] Event Event whose notification function is being invoked.
@param[in] Context Pointer to the notification function's context.
**/
VOID
EFIAPI
SmmFvbReady (
IN EFI_EVENT Event,
IN VOID *Context
)
{
EFI_STATUS Status;
EFI_HANDLE *HandleBuffer;
UINTN HandleCount;
UINTN Index;
EFI_SMM_FIRMWARE_VOLUME_BLOCK_PROTOCOL *SmmFvb;
//
// Locate all handles of Smm Fvb protocol.
//
Status = gBS->LocateHandleBuffer (
ByProtocol,
&gEfiSmmFirmwareVolumeBlockProtocolGuid,
NULL,
&HandleCount,
&HandleBuffer
);
if (EFI_ERROR (Status)) {
return ;
}
//
// Install FVB protocol.
//
for (Index = 0; Index < HandleCount; Index++) {
SmmFvb = NULL;
Status = gBS->HandleProtocol (
HandleBuffer[Index],
&gEfiSmmFirmwareVolumeBlockProtocolGuid,
(VOID **) &SmmFvb
);
if (EFI_ERROR (Status)) {
break;
}
InstallFvb (SmmFvb);
}
FreePool (HandleBuffer);
}
/**
The driver entry point for Firmware Volume Block Driver.
The function does the necessary initialization work
Firmware Volume Block Driver.
@param[in] ImageHandle The firmware allocated handle for the UEFI image.
@param[in] SystemTable A pointer to the EFI system table.
@retval EFI_SUCCESS This funtion always return EFI_SUCCESS.
It will ASSERT on errors.
**/
EFI_STATUS
EFIAPI
FvbSmmDxeInitialize (
IN EFI_HANDLE ImageHandle,
IN EFI_SYSTEM_TABLE *SystemTable
)
{
VOID *SmmFvbRegistration;
//
// Smm FVB driver is ready.
//
EfiCreateProtocolNotifyEvent (
&gEfiSmmFirmwareVolumeBlockProtocolGuid,

237
Vlv2TbltDevicePkg/FvbRuntimeDxe/FvbSmmDxe.h Normal file
View File

@@ -0,0 +1,237 @@
/** @file
The internal header file includes the common header files, defines
internal structure and functions used by FVB module.
Copyright (c) 2010 - 2014, 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 that 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.
**/
#ifndef _SMM_FVB_DXE_H_
#define _SMM_FVB_DXE_H_
#include <PiDxe.h>
#include <Protocol/SmmFirmwareVolumeBlock.h>
#include <Protocol/SmmCommunication.h>
#include <Library/UefiBootServicesTableLib.h>
#include <Library/UefiDriverEntryPoint.h>
#include <Library/DebugLib.h>
#include <Library/BaseMemoryLib.h>
#include <Library/UefiLib.h>
#include <Library/BaseLib.h>
#include <Library/MemoryAllocationLib.h>
#include <Library/DevicePathLib.h>
#include <Guid/EventGroup.h>
#include "FvbSmmCommon.h"
#define FVB_DEVICE_SIGNATURE SIGNATURE_32 ('F', 'V', 'B', 'S')
#define FVB_DEVICE_FROM_THIS(a) CR (a, EFI_FVB_DEVICE, FvbInstance, FVB_DEVICE_SIGNATURE)
typedef struct {
MEDIA_FW_VOL_DEVICE_PATH FvDevPath;
EFI_DEVICE_PATH_PROTOCOL EndDevPath;
} FV_PIWG_DEVICE_PATH;
typedef struct {
MEMMAP_DEVICE_PATH MemMapDevPath;
EFI_DEVICE_PATH_PROTOCOL EndDevPath;
} FV_MEMMAP_DEVICE_PATH;
typedef struct {
UINTN Signature;
EFI_DEVICE_PATH_PROTOCOL *DevicePath;
EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL FvbInstance;
EFI_SMM_FIRMWARE_VOLUME_BLOCK_PROTOCOL *SmmFvbInstance;
} EFI_FVB_DEVICE;
/**
This function retrieves the attributes and current settings of the block.
@param[in] This Indicates the EFI_FIRMWARE_VOLUME_BLOCK2_PROTOCOL instance.
@param[out] Attributes Pointer to EFI_FVB_ATTRIBUTES_2 in which the attributes
and current settings are returned. Type EFI_FVB_ATTRIBUTES_2
is defined in EFI_FIRMWARE_VOLUME_HEADER.
@retval EFI_SUCCESS The firmware volume attributes were returned.
**/
EFI_STATUS
EFIAPI
FvbGetAttributes (
IN CONST EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *This,
OUT EFI_FVB_ATTRIBUTES_2 *Attributes
);
/**
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
FvbSetAttributes (
IN CONST EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *This,
IN OUT EFI_FVB_ATTRIBUTES_2 *Attributes
);
/**
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
FvbGetPhysicalAddress (
IN CONST EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *This,
OUT EFI_PHYSICAL_ADDRESS *Address
);
/**
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
FvbGetBlockSize (
IN CONST EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *This,
IN EFI_LBA Lba,
OUT UINTN *BlockSize,
OUT UINTN *NumOfBlocks
);
/**
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
FvbRead (
IN CONST EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *This,
IN EFI_LBA Lba,
IN UINTN Offset,
IN OUT UINTN *NumBytes,
OUT UINT8 *Buffer
);
/**
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
FvbWrite (
IN CONST EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *This,
IN EFI_LBA Lba,
IN UINTN Offset,
IN OUT UINTN *NumBytes,
IN UINT8 *Buffer
);
/**
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.

55
Vlv2TbltDevicePkg/FvbRuntimeDxe/FvbSmmDxe.inf Normal file
View File

@@ -0,0 +1,55 @@
## @file
# Component description file for Firmware Volume Block module.
#
# Copyright (c) 2010 - 2014, 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 that 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.
#
#
#
##
[Defines]
INF_VERSION = 0x00010005
BASE_NAME = FvbSmmDxe
FILE_GUID = 9E8AD3F4-383D-4ec3-816E-7A4749371290
MODULE_TYPE = DXE_DRIVER
VERSION_STRING = 1.0
ENTRY_POINT = FvbSmmDxeInitialize
#
# The following information is for reference only and not required by the build tools.
#
# VALID_ARCHITECTURES = IA32 X64
#
[Sources]
FvbSmmDxe.c
FvbSmmDxe.h
FvbSmmCommon.h
[Packages]
MdePkg/MdePkg.dec
MdeModulePkg/MdeModulePkg.dec
[LibraryClasses]
BaseLib
UefiBootServicesTableLib
DebugLib
DxeServicesTableLib
UefiDriverEntryPoint