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

Add missing module for duet package.

Browse Source 
git-svn-id: https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2@5088 6f19259b-4bc3-4df7-8a09-765794883524
This commit is contained in:
klu2
2008-04-18 03:09:54 +00:00
parent 25ab7ab110
commit 9071550e86
29 changed files with 7005 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

26
DuetPkg/FvbRuntimeService/DUETFwh.dxs Normal file
View File

@@ -0,0 +1,26 @@
#/*++
#
# Copyright (c) 2007, Intel Corporation
# All rights reserved. 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:
#
# Nt32Fwh.inf
#
# Abstract:
#
# Component description file for Nt32 Module
#
#--*/
#include "EfiDepex.h"
DEPENDENCY_START
TRUE
DEPENDENCY_END

62
DuetPkg/FvbRuntimeService/DUETFwh.inf Normal file
View File

@@ -0,0 +1,62 @@
#/*++
#
# Copyright (c) 2007, Intel Corporation
# All rights reserved. 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:
#
# DUETFwh.inf
#
# Abstract:
#
# Component description file for DUET Module
#
#--*/
[Defines]
INF_VERSION = 0x00010005
BASE_NAME = DuetFwh
FILE_GUID = BDFE5FAA-2A35-44bb-B17A-8084D4E2B9E9
MODULE_TYPE = DXE_RUNTIME_DRIVER
VERSION_STRING = 1.0
EDK_RELEASE_VERSION = 0x00020000
EFI_SPECIFICATION_VERSION = 0x00020000
ENTRY_POINT = FvbInitialize
[Packages]
MdePkg/MdePkg.dec
MdeModulePkg/MdeModulePkg.dec
DuetPkg/DuetPkg.dec
#TianoModulePkg/TianoModulePkg.dec
[Sources.common]
FwBlockService.c
FwBlockService.h
FvbInfo.c
FileIo.c
FileIo.h
[LibraryClasses]
DevicePathLib
UefiLib
UefiDriverEntryPoint
UefiRuntimeLib
HobLib
[Guids]
gEfiFlashMapHobGuid
gEfiHobListGuid
gEfiAlternateFvBlockGuid
[Protocols]
gEfiFvbExtensionProtocolGuid
gEfiSimpleFileSystemProtocolGuid
gEfiFirmwareVolumeBlockProtocolGuid
gEfiBlockIoProtocolGuid

1822
DuetPkg/FvbRuntimeService/FWBlockService.c Normal file
View File

File diff suppressed because it is too large Load Diff

210
DuetPkg/FvbRuntimeService/FileIo.c Normal file
View File

@@ -0,0 +1,210 @@
/**@file
Copyright (c) 2007, Intel Corporation
All rights reserved. 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:
FileIo.c
Abstract:
File operation for Firmware volume block driver
**/
#include "FileIo.h"
//
// Variable storage hot plug is supported but there are still some restrictions:
// After plugging the storage back,
// 1. Still use memory as NV if newly plugged storage is not same as the original one
// 2. Still use memory as NV if there are some update operation during storage is unplugged.
//
EFI_STATUS
FileWrite (
IN EFI_FILE *File,
IN UINTN Offset,
IN UINTN Buffer,
IN UINTN Size
)
{
EFI_STATUS Status;
Status = File->SetPosition (File, Offset);
ASSERT_EFI_ERROR (Status);
if (!EFI_ERROR (Status)) {
Status = File->Write (File, &Size, (VOID *) Buffer);
ASSERT_EFI_ERROR (Status);
}
return Status;
}
EFI_STATUS
CheckStore (
IN EFI_HANDLE SimpleFileSystemHandle,
IN UINT32 VolumeId,
OUT EFI_DEVICE_PATH_PROTOCOL **Device
)
{
#define BLOCK_SIZE 0x200
#define FAT16_VOLUME_ID_OFFSET 39
#define FAT32_VOLUME_ID_OFFSET 67
EFI_STATUS Status;
EFI_BLOCK_IO_PROTOCOL *BlkIo;
UINT8 BootSector[BLOCK_SIZE];
*Device = NULL;
Status = gBS->HandleProtocol (
SimpleFileSystemHandle,
&gEfiBlockIoProtocolGuid, // BlockIo should be supported if it supports SimpleFileSystem
(VOID*)&BlkIo
);
if (EFI_ERROR (Status)) {
goto ErrHandle;
}
if (!BlkIo->Media->MediaPresent) {
DEBUG ((EFI_D_ERROR, "FwhMappedFile: Media not present!\n"));
Status = EFI_NO_MEDIA;
goto ErrHandle;
}
if (BlkIo->Media->ReadOnly) {
DEBUG ((EFI_D_ERROR, "FwhMappedFile: Media is read-only!\n"));
Status = EFI_ACCESS_DENIED;
goto ErrHandle;
}
Status = BlkIo->ReadBlocks(
BlkIo,
BlkIo->Media->MediaId,
0,
BLOCK_SIZE,
BootSector
);
ASSERT_EFI_ERROR (Status);
if ((*(UINT32 *) &BootSector[FAT16_VOLUME_ID_OFFSET] != VolumeId) &&
(*(UINT32 *) &BootSector[FAT32_VOLUME_ID_OFFSET] != VolumeId)
) {
Status = EFI_NOT_FOUND;
goto ErrHandle;
}
*Device = DuplicateDevicePath (DevicePathFromHandle (SimpleFileSystemHandle));
ASSERT (*Device != NULL);
ErrHandle:
return Status;
}
EFI_STATUS
CheckStoreExists (
IN EFI_DEVICE_PATH_PROTOCOL *Device
)
{
EFI_HANDLE Handle;
EFI_SIMPLE_FILE_SYSTEM_PROTOCOL *Volume;
EFI_STATUS Status;
Status = gBS->LocateDevicePath (
&gEfiSimpleFileSystemProtocolGuid,
&Device,
&Handle
);
if (EFI_ERROR (Status)) {
return Status;
}
Status = gBS->HandleProtocol (
Handle,
&gEfiSimpleFileSystemProtocolGuid,
&Volume
);
if (EFI_ERROR (Status)) {
return Status;
}
return EFI_SUCCESS;
}
VOID
FileClose (
IN EFI_FILE *File
)
{
File->Flush (File);
File->Close (File);
}
EFI_STATUS
FileOpen (
IN EFI_DEVICE_PATH_PROTOCOL *Device,
IN CHAR16 *MappedFile,
OUT EFI_FILE **File,
IN UINT64 OpenMode
)
{
EFI_HANDLE Handle;
EFI_FILE_HANDLE Root;
EFI_SIMPLE_FILE_SYSTEM_PROTOCOL *Volume;
EFI_STATUS Status;
*File = NULL;
Status = gBS->LocateDevicePath (
&gEfiSimpleFileSystemProtocolGuid,
&Device,
&Handle
);
if (EFI_ERROR (Status)) {
return Status;
}
Status = gBS->HandleProtocol (
Handle,
&gEfiSimpleFileSystemProtocolGuid,
&Volume
);
ASSERT_EFI_ERROR (Status);
if (EFI_ERROR (Status)) {
return Status;
}
//
// Open the root directory of the volume
//
Root = NULL;
Status = Volume->OpenVolume (
Volume,
&Root
);
ASSERT_EFI_ERROR (Status);
ASSERT (Root != NULL);
//
// Open file
//
Status = Root->Open (
Root,
File,
MappedFile,
OpenMode,
0
);
if (EFI_ERROR (Status)) {
*File = NULL;
}
//
// Close the Root directory
//
Root->Close (Root);
return Status;
}

58
DuetPkg/FvbRuntimeService/FileIo.h Normal file
View File

@@ -0,0 +1,58 @@
/**@file
Copyright (c) 2007, Intel Corporation
All rights reserved. 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:
FileIo.h
Abstract:
File operation for Firmware volume block driver
**/
#ifndef _FW_BLOCK_SERVICE_FILE_IO_H
#define _FW_BLOCK_SERVICE_FILE_IO_H
#include "FwBlockService.h"
EFI_STATUS
FileWrite (
IN EFI_FILE *File,
IN UINTN Offset,
IN UINTN Buffer,
IN UINTN Size
);
EFI_STATUS
CheckStore (
IN EFI_HANDLE SimpleFileSystemHandle,
IN UINT32 VolumeId,
OUT EFI_DEVICE_PATH_PROTOCOL **Device
);
EFI_STATUS
CheckStoreExists (
IN EFI_DEVICE_PATH_PROTOCOL *Device
);
EFI_STATUS
FileOpen (
IN EFI_DEVICE_PATH_PROTOCOL *Device,
IN CHAR16 *MappedFile,
OUT EFI_FILE **File,
IN UINT64 OpenMode
);
VOID
FileClose (
IN EFI_FILE *File
);
#endif // _FW_BLOCK_SERVICE_FILE_IO_H

121
DuetPkg/FvbRuntimeService/FvbInfo.c Normal file
View File

@@ -0,0 +1,121 @@
/**@file
Copyright (c) 2007, Intel Corporation
All rights reserved. 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:
FvbInfo.c
Abstract:
Defines data structure that is the volume header found.These data is intent
to decouple FVB driver with FV header.
**/
#include "FileIo.h"
#include "FlashLayout.h"
typedef struct {
UINT64 FvLength;
EFI_FIRMWARE_VOLUME_HEADER FvbInfo;
EFI_FV_BLOCK_MAP_ENTRY End;
} EFI_FVB_MEDIA_INFO;
#define FVB_MEDIA_BLOCK_SIZE FIRMWARE_BLOCK_SIZE
#define RECOVERY_BOIS_BLOCK_NUM FIRMWARE_BLOCK_NUMBER
#define SYSTEM_NV_BLOCK_NUM 2
EFI_FVB_MEDIA_INFO mPlatformFvbMediaInfo[] = {
//
// Systen NvStorage FVB
//
{
NV_STORAGE_FVB_SIZE,
{
{
0,
}, // ZeroVector[16]
EFI_SYSTEM_NV_DATA_FV_GUID,
NV_STORAGE_FVB_SIZE,
EFI_FVH_SIGNATURE,
EFI_FVB2_READ_ENABLED_CAP |
EFI_FVB2_READ_STATUS |
EFI_FVB2_WRITE_ENABLED_CAP |
EFI_FVB2_WRITE_STATUS |
EFI_FVB2_ERASE_POLARITY,
sizeof (EFI_FIRMWARE_VOLUME_HEADER) + sizeof (EFI_FV_BLOCK_MAP_ENTRY),
0, // CheckSum
0, // ExtHeaderOffset
{
0,
}, // Reserved[1]
1, // Revision
{
NV_STORAGE_FVB_BLOCK_NUM,
FV_BLOCK_SIZE,
}
},
{
0,
0
}
},
//
// System FTW FVB
//
{
NV_FTW_FVB_SIZE,
{
{
0,
}, // ZeroVector[16]
EFI_SYSTEM_NV_DATA_FV_GUID,
NV_FTW_FVB_SIZE,
EFI_FVH_SIGNATURE,
EFI_FVB2_READ_ENABLED_CAP |
EFI_FVB2_READ_STATUS |
EFI_FVB2_WRITE_ENABLED_CAP |
EFI_FVB2_WRITE_STATUS |
EFI_FVB2_ERASE_POLARITY,
sizeof (EFI_FIRMWARE_VOLUME_HEADER) + sizeof (EFI_FV_BLOCK_MAP_ENTRY),
0, // CheckSum
0, // ExtHeaderOffset
{
0,
}, // Reserved[1]
1, // Revision
{
NV_FTW_FVB_BLOCK_NUM,
FV_BLOCK_SIZE,
}
},
{
0,
0
}
}
};
EFI_STATUS
GetFvbInfo (
IN UINT64 FvLength,
OUT EFI_FIRMWARE_VOLUME_HEADER **FvbInfo
)
{
UINTN Index;
for (Index = 0; Index < sizeof (mPlatformFvbMediaInfo) / sizeof (EFI_FVB_MEDIA_INFO); Index += 1) {
if (mPlatformFvbMediaInfo[Index].FvLength == FvLength) {
*FvbInfo = &mPlatformFvbMediaInfo[Index].FvbInfo;
return EFI_SUCCESS;
}
}
return EFI_NOT_FOUND;
}

348
DuetPkg/FvbRuntimeService/FwBlockService.h Normal file
View File

@@ -0,0 +1,348 @@
/**@file
Copyright (c) 2007, Intel Corporation
All rights reserved. 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.h
Abstract:
Firmware volume block driver for Intel Firmware Hub (FWH) device
**/
#ifndef _FW_BLOCK_SERVICE_H
#define _FW_BLOCK_SERVICE_H
//
// The package level header files this module uses
//
#include <PiDxe.h>
//
// The protocols, PPI and GUID defintions for this module
//
#include <Guid/EventGroup.h>
#include <Guid/FirmwareFileSystem2.h>
#include <Protocol/FvbExtension.h>
#include <Protocol/FirmwareVolumeBlock.h>
#include <Guid/AlternateFvBlock.h>
#include <Protocol/DevicePath.h>
#include <Protocol/SimpleFileSystem.h>
#include <Protocol/BlockIo.h>
#include <Library/DevicePathLib.h>
#include <Guid/SystemNvDataGuid.h>
#include <Guid/FlashMapHob.h>
#include <Guid/HobList.h>
#include <Guid/AlternateFvBlock.h>
#include <Protocol/FvbExtension.h>
//
// The Library classes this module consumes
//
#include <Library/UefiLib.h>
#include <Library/UefiDriverEntryPoint.h>
#include <Library/BaseLib.h>
#include <Library/DxeServicesTableLib.h>
#include <Library/UefiRuntimeLib.h>
#include <Library/DebugLib.h>
#include <Library/HobLib.h>
#include <Library/BaseMemoryLib.h>
#include <Library/MemoryAllocationLib.h>
#include <Library/UefiBootServicesTableLib.h>
#include <Library/PcdLib.h>
#define FWH_READ_LOCK (1 << 2)
#define FWH_LOCK_DOWN (1 << 1)
#define FWH_WRITE_LOCK 1
#define FWH_WRITE_STATE_STATUS (1 << 7)
#define FWH_ERASE_STATUS (1 << 5)
#define FWH_PROGRAM_STATUS (1 << 4)
#define FWH_VPP_STATUS (1 << 3)
#define STALL_TIME 5
#define FWH_ERASE_STATUS_BITS (FWH_ERASE_STATUS || FWH_VPP_STATUS)
#define FWH_WRITE_STATUS_BITS (FWH_WRITE_STATUS || FWH_VPP_STATUS)
//
// BugBug: Add documentation here for data structure!!!!
//
#define FVB_PHYSICAL 0
#define FVB_VIRTUAL 1
#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 {
EFI_LOCK FvbDevLock;
UINTN FvBase[2];
//
// We can treat VolumeSignature combined with MappedFile
// as a unique key to locate the mapped file.
#define MAX_PATH 256
UINT32 VolumeId;
CHAR16 MappedFile[MAX_PATH];
UINT32 ActuralSize;
UINT32 Offset;
EFI_DEVICE_PATH_PROTOCOL *Device; // only used in BS period, won't use after memory map changed
UINTN NumOfBlocks;
BOOLEAN WriteEnabled;
EFI_FIRMWARE_VOLUME_HEADER VolumeHeader;
} EFI_FW_VOL_INSTANCE;
typedef struct {
UINT32 NumFv;
EFI_FW_VOL_INSTANCE *FvInstance[2];
UINT8 *FvbScratchSpace[2];
} ESAL_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 EFI_SIGNATURE_32 ('F', 'V', 'B', 'C')
typedef struct {
MEMMAP_DEVICE_PATH MemMapDevPath;
EFI_DEVICE_PATH_PROTOCOL EndDevPath;
} FV_DEVICE_PATH;
typedef struct {
UINTN Signature;
FV_DEVICE_PATH DevicePath;
UINTN Instance;
EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL FwVolBlockInstance;
EFI_FVB_EXTENSION_PROTOCOL FvbExtension;
} EFI_FW_VOL_BLOCK_DEVICE;
EFI_STATUS
GetFvbInfo (
IN EFI_PHYSICAL_ADDRESS FvBaseAddress,
OUT EFI_FIRMWARE_VOLUME_HEADER **FvbInfo
)
;
EFI_STATUS
EnableFvbWrites (
IN BOOLEAN EnableWrites
)
;
EFI_STATUS
PlatformGetFvbWriteBase (
IN UINTN CurrentBaseAddress,
IN UINTN *NewBaseAddress,
IN BOOLEAN *WriteEnabled
)
;
EFI_STATUS
EnablePlatformFvb (
VOID
)
;
BOOLEAN
SetPlatformFvbLock (
IN UINTN LbaAddress
)
;
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
)
;
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
)
;
EFI_STATUS
FvbEraseBlock (
IN UINTN Instance,
IN EFI_LBA Lba,
IN ESAL_FWB_GLOBAL *Global,
IN BOOLEAN Virtual
)
;
EFI_STATUS
FvbSetVolumeAttributes (
IN UINTN Instance,
IN OUT EFI_FVB_ATTRIBUTES *Attributes,
IN ESAL_FWB_GLOBAL *Global,
IN BOOLEAN Virtual
)
;
EFI_STATUS
FvbGetVolumeAttributes (
IN UINTN Instance,
OUT EFI_FVB_ATTRIBUTES *Attributes,
IN ESAL_FWB_GLOBAL *Global,
IN BOOLEAN Virtual
)
;
EFI_STATUS
FvbGetPhysicalAddress (
IN UINTN Instance,
OUT EFI_PHYSICAL_ADDRESS *Address,
IN ESAL_FWB_GLOBAL *Global,
IN BOOLEAN Virtual
)
;
EFI_STATUS
EFIAPI
FvbInitialize (
IN EFI_HANDLE ImageHandle,
IN EFI_SYSTEM_TABLE *SystemTable
)
;
VOID
EFIAPI
FvbClassAddressChangeEvent (
IN EFI_EVENT Event,
IN VOID *Context
)
;
EFI_STATUS
FvbSpecificInitialize (
IN ESAL_FWB_GLOBAL *mFvbModuleGlobal
)
;
EFI_STATUS
FvbGetLbaAddress (
IN UINTN Instance,
IN EFI_LBA Lba,
OUT UINTN *LbaAddress,
OUT UINTN *LbaLength,
OUT UINTN *NumOfBlocks,
IN ESAL_FWB_GLOBAL *Global,
IN BOOLEAN Virtual
)
;
EFI_STATUS
FvbEraseCustomBlockRange (
IN UINTN Instance,
IN EFI_LBA StartLba,
IN UINTN OffsetStartLba,
IN EFI_LBA LastLba,
IN UINTN OffsetLastLba,
IN ESAL_FWB_GLOBAL *Global,
IN BOOLEAN Virtual
)
;
//
// Protocol APIs
//
EFI_STATUS
EFIAPI
FvbProtocolGetAttributes (
IN CONST EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *This,
OUT EFI_FVB_ATTRIBUTES *Attributes
)
;
EFI_STATUS
EFIAPI
FvbProtocolSetAttributes (
IN CONST EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL *This,
IN OUT EFI_FVB_ATTRIBUTES *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,
IN 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_STATUS
EFIAPI
FvbExtendProtocolEraseCustomBlockRange (
IN EFI_FVB_EXTENSION_PROTOCOL *This,
IN EFI_LBA StartLba,
IN UINTN OffsetStartLba,
IN EFI_LBA LastLba,
IN UINTN OffsetLastLba
)
;
#endif