init. 1AQQW051HEADmaster

2 files changed, 955 insertions, 0 deletions

diff --git a/EDK/Foundation/Core/Dxe/FwVolBlock/FwVolBlock.c b/EDK/Foundation/Core/Dxe/FwVolBlock/FwVolBlock.c
new file mode 100644
index 0000000..ebe3964
--- /dev/null
+++ b/EDK/Foundation/Core/Dxe/FwVolBlock/FwVolBlock.c
@@ -0,0 +1,621 @@
+/*++
+
+Copyright (c) 2004 - 2005, 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:
+
+  FwVolBlock.c
+
+Abstract:
+
+  Firmware Volume Block protocol..  Consumes FV hobs and creates
+  appropriate block protocols.
+
+  Also consumes NT_NON_MM_FV envinronment variable and produces appropriate
+  block protocols fro them also... (this is TBD)
+
+--*/
+
+#include "Tiano.h"
+#include "FwVolBlock.h"
+
+
+EFI_FW_VOL_BLOCK_DEVICE  mFwVolBlock = {
+  FVB_DEVICE_SIGNATURE,
+  NULL,
+  {
+    {
+      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      
+    },
+  },
+  {
+    FwVolBlockGetAttributes,
+    (EFI_FVB_SET_ATTRIBUTES)FwVolBlockSetAttributes,
+    FwVolBlockGetPhysicalAddress,
+    FwVolBlockGetBlockSize,
+    FwVolBlockReadBlock,
+    (EFI_FVB_WRITE)FwVolBlockWriteBlock,
+    (EFI_FVB_ERASE_BLOCKS)FwVolBlockEraseBlock,
+    NULL      
+  },
+  0,
+  NULL,
+  0,
+  0
+};
+
+
+
+
+EFI_STATUS
+EFIAPI
+FwVolBlockGetAttributes (
+  IN EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL   *This,
+  OUT EFI_FVB_ATTRIBUTES                          *Attributes
+  )
+/*++
+
+Routine Description:
+    Retrieves Volume attributes.  No polarity translations are done.
+
+Arguments:
+    This - Calling context
+    Attributes - output buffer which contains attributes
+
+Returns:
+    EFI_SUCCESS - The firmware volume attributes were returned.
+
+--*/
+{
+  EFI_FW_VOL_BLOCK_DEVICE               *FvbDevice;
+  
+  FvbDevice = FVB_DEVICE_FROM_THIS (This);
+
+  //
+  // Since we are read only, it's safe to get attributes data from our in-memory copy.
+  //
+  *Attributes = FvbDevice->FvbAttributes;
+
+  return EFI_SUCCESS;
+}
+
+
+EFI_STATUS
+EFIAPI
+FwVolBlockSetAttributes (
+  IN EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL   *This,
+  IN EFI_FVB_ATTRIBUTES                   *Attributes
+  )
+/*++
+
+Routine Description:
+  Modifies the current settings of the firmware volume according to the input parameter.
+
+Arguments:
+  This - Calling context
+  Attributes - input buffer which contains attributes
+
+Returns:
+  EFI_SUCCESS -  The firmware volume attributes were returned.
+  EFI_INVALID_PARAMETER  -  The attributes requested are in conflict with the capabilities as
+                             declared in the firmware volume header.
+  EFI_UNSUPPORTED        -  Not supported.
+--*/
+{
+  return EFI_UNSUPPORTED;
+}
+
+
+EFI_STATUS
+EFIAPI
+FwVolBlockEraseBlock (
+  IN 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. The firmware device may have been partially erased.
+  EFI_INVALID_PARAMETER  -  One or more of the LBAs listed in the variable argument list do
+  EFI_UNSUPPORTED        -  Not supported.
+    
+--*/
+{
+  return EFI_UNSUPPORTED;
+}
+
+
+EFI_STATUS
+EFIAPI
+FwVolBlockReadBlock (
+  IN     EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL     *This,
+  IN     EFI_LBA                                Lba,
+  IN     UINTN                                  Offset,
+  IN OUT UINTN                                  *NumBytes,
+  IN     UINT8                                  *Buffer
+  )
+/*++
+
+Routine Description:
+  Read the specified number of bytes from the block to the input buffer.
+
+Arguments:
+  This          -  Indicates the calling context.
+  Lba           -  The starting logical block index to read.
+  Offset        -  Offset into the block at which to begin reading.
+  NumBytes      -  Pointer to a UINT32. At entry, *NumBytes contains the
+                   total size of the buffer. At exit, *NumBytes contains the
+                   total number of bytes actually read.
+  Buffer        -  Pinter to a caller-allocated buffer that contains the destine
+                   for the read.    
+
+Returns:      
+  EFI_SUCCESS  -  The firmware volume was read successfully.
+  EFI_BAD_BUFFER_SIZE -  The read was attempted across an LBA boundary.
+  EFI_ACCESS_DENIED  -  Access denied.
+  EFI_DEVICE_ERROR   -  The block device is malfunctioning and could not be read.
+--*/
+{
+  EFI_FW_VOL_BLOCK_DEVICE               *FvbDevice;
+  EFI_FIRMWARE_VOLUME_HEADER            *FwVolHeader;
+  UINT8                                 *LbaOffset;
+  UINTN                                 LbaStart;
+  UINTN                                 NumOfBytesRead;
+  UINTN                                 LbaIndex;
+  
+  FvbDevice = FVB_DEVICE_FROM_THIS (This);
+
+  //
+  // Check if This FW can be read
+  //
+  if ((FvbDevice->FvbAttributes & EFI_FVB_READ_STATUS) == 0) {
+    return EFI_ACCESS_DENIED;
+  }
+  
+  LbaIndex = (UINTN)Lba;
+  if (LbaIndex >= FvbDevice->NumBlocks) {
+    //
+    // Invalid Lba, read nothing.
+    //
+    *NumBytes = 0;
+    return EFI_BAD_BUFFER_SIZE;
+  }
+  
+  if (Offset > FvbDevice->LbaCache[LbaIndex].Length) {
+    //
+    // all exceed boundry, read nothing.
+    //
+    *NumBytes = 0;
+    return EFI_BAD_BUFFER_SIZE;
+  }
+  
+  NumOfBytesRead = *NumBytes;
+  if (Offset + NumOfBytesRead > FvbDevice->LbaCache[LbaIndex].Length) {
+    //
+    // partial exceed boundry, read data from current postion to end.
+    //
+    NumOfBytesRead = FvbDevice->LbaCache[LbaIndex].Length - Offset;
+  }
+  
+  LbaStart = FvbDevice->LbaCache[LbaIndex].Base;
+  FwVolHeader = (EFI_FIRMWARE_VOLUME_HEADER *)((UINTN)FvbDevice->BaseAddress);
+  LbaOffset = (UINT8 *)FwVolHeader + LbaStart + Offset;
+
+  //
+  // Perform read operation
+  //
+  EfiCommonLibCopyMem (Buffer, LbaOffset, NumOfBytesRead);
+  
+  if (NumOfBytesRead == *NumBytes) {
+    return EFI_SUCCESS;
+  }
+    
+  *NumBytes = NumOfBytesRead;
+  return EFI_BAD_BUFFER_SIZE;
+}
+  
+
+EFI_STATUS
+EFIAPI
+FwVolBlockWriteBlock (
+  IN     EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL   *This,
+  IN     EFI_LBA                              Lba,
+  IN     UINTN                                Offset,
+  IN OUT UINTN                                *NumBytes,
+  IN     UINT8                                *Buffer
+  )
+/*++
+
+Routine Description:
+  Writes the specified number of bytes from the input buffer to the block.
+
+Arguments:
+  This          -  Indicates the calling context.
+  Lba           -  The starting logical block index to write to.
+  Offset        -  Offset into the block at which to begin writing.
+  NumBytes      -  Pointer to a UINT32. At entry, *NumBytes contains the
+                   total size of the buffer. At exit, *NumBytes contains the
+                   total number of bytes actually written.
+  Buffer        -  Pinter to a caller-allocated buffer that contains the source
+                   for the write.    
+
+Returns:     
+  EFI_SUCCESS  -  The firmware volume was written successfully.
+  EFI_BAD_BUFFER_SIZE -  The write was attempted across an 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 malfunctioning and could not be written.
+  EFI_UNSUPPORTED    -  Not supported.
+--*/
+{
+  return EFI_UNSUPPORTED;
+}
+ 
+
+EFI_STATUS
+EFIAPI
+FwVolBlockGetPhysicalAddress (
+  IN EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL  *This,
+  OUT EFI_PHYSICAL_ADDRESS                        *Address
+  )
+/*++
+
+Routine Description:
+  Get Fvb's base address.
+
+Arguments:
+  This          -  Indicates the calling context.
+  Address       -  Fvb device base address.
+
+Returns:     
+  EFI_SUCCESS  -  Successfully got Fvb's base address.
+  EFI_UNSUPPORTED -  Not supported.
+--*/
+{
+  EFI_FW_VOL_BLOCK_DEVICE               *FvbDevice;
+  
+  FvbDevice = FVB_DEVICE_FROM_THIS (This);
+  
+  if (FvbDevice->FvbAttributes & EFI_FVB_MEMORY_MAPPED) {
+    *Address = FvbDevice->BaseAddress;
+    return EFI_SUCCESS;
+  }
+  
+  return EFI_UNSUPPORTED;
+}
+
+
+EFI_STATUS
+EFIAPI
+FwVolBlockGetBlockSize (
+  IN EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL   *This,
+  IN EFI_LBA                              Lba,
+  OUT UINTN                               *BlockSize,
+  OUT UINTN                               *NumberOfBlocks
+  )
+/*++
+
+Routine Description:
+  Retrieves the size in bytes of a specific block within a firmware volume.
+
+Arguments:
+  This            -  Indicates the calling context.
+  Lba             -  Indicates the block for which to return the size.
+  BlockSize       -  Pointer to a caller-allocated UINTN in which the size of the
+                     block is returned.
+  NumberOfBlocks  -  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 base address is returned.
+  EFI_INVALID_PARAMETER  -  The requested LBA is out of range.
+--*/
+{
+  UINTN                                 TotalBlocks;
+  EFI_FW_VOL_BLOCK_DEVICE               *FvbDevice;
+  EFI_FV_BLOCK_MAP_ENTRY                *PtrBlockMapEntry;
+  EFI_FIRMWARE_VOLUME_HEADER            *FwVolHeader;
+  
+  FvbDevice = FVB_DEVICE_FROM_THIS (This);
+  
+  //
+  // Do parameter checking
+  //
+  if (Lba >= FvbDevice->NumBlocks) {
+    return EFI_INVALID_PARAMETER;
+  }
+  
+  FwVolHeader = (EFI_FIRMWARE_VOLUME_HEADER *)((UINTN)FvbDevice->BaseAddress);
+  
+  PtrBlockMapEntry = FwVolHeader->FvBlockMap;
+  
+  //
+  // Search the block map for the given block
+  //
+  TotalBlocks = 0;
+  while ((PtrBlockMapEntry->NumBlocks != 0) || (PtrBlockMapEntry->BlockLength !=0 )) {
+    TotalBlocks += PtrBlockMapEntry->NumBlocks;
+    if (Lba < TotalBlocks) {
+      //
+      // We find the range
+      //
+      break;
+    }
+    
+    PtrBlockMapEntry++;
+  }
+  
+  *BlockSize = PtrBlockMapEntry->BlockLength;
+  *NumberOfBlocks = TotalBlocks - (UINTN)Lba;
+  
+  return EFI_SUCCESS;
+}
+
+
+EFI_STATUS
+ProduceFVBProtocolOnBuffer (
+  IN EFI_PHYSICAL_ADDRESS   BaseAddress,
+  IN UINT64                 Length,
+  IN EFI_HANDLE             ParentHandle,
+  OUT EFI_HANDLE            *FvProtocol  OPTIONAL
+  )
+/*++
+
+Routine Description:
+    This routine produces a firmware volume block protocol on a given
+    buffer. 
+
+Arguments:
+    BaseAddress     - base address of the firmware volume image
+    Length          - length of the firmware volume image
+    ParentHandle    - handle of parent firmware volume, if this
+                      image came from an FV image file in another
+                      firmware volume (ala capsules)
+    FvProtocol      - Firmware volume block protocol produced.
+    
+Returns:
+    EFI_VOLUME_CORRUPTED    - Volume corrupted.
+    EFI_OUT_OF_RESOURCES    - No enough buffer to be allocated.
+    EFI_SUCCESS             - Successfully produced a FVB protocol on given buffer.
+                     
+--*/
+{
+  EFI_STATUS                    Status;
+  EFI_FW_VOL_BLOCK_DEVICE       *FvbDev;
+  EFI_FIRMWARE_VOLUME_HEADER    *FwVolHeader;
+  UINTN                         BlockIndex;
+  UINTN                         BlockIndex2;
+  UINTN                         LinearOffset;
+  EFI_FV_BLOCK_MAP_ENTRY        *PtrBlockMapEntry;
+
+  FwVolHeader = (EFI_FIRMWARE_VOLUME_HEADER *)(UINTN)BaseAddress;
+  //
+  // Validate FV Header, if not as expected, return
+  //
+  if (FwVolHeader->Signature != EFI_FVH_SIGNATURE) {
+    return EFI_VOLUME_CORRUPTED;
+  }
+  //
+  // Allocate EFI_FW_VOL_BLOCK_DEVICE 
+  //
+  FvbDev = CoreAllocateCopyPool (sizeof (EFI_FW_VOL_BLOCK_DEVICE), &mFwVolBlock);
+  if (FvbDev == NULL) {
+    return EFI_OUT_OF_RESOURCES;
+  }
+
+  FvbDev->BaseAddress   = BaseAddress;
+  FvbDev->FvbAttributes = FwVolHeader->Attributes;
+  FvbDev->FwVolBlockInstance.ParentHandle = ParentHandle;
+
+  //
+  // Init the block caching fields of the device
+  // First, count the number of blocks
+  //
+  FvbDev->NumBlocks = 0;
+  for (PtrBlockMapEntry = FwVolHeader->FvBlockMap;
+        PtrBlockMapEntry->NumBlocks != 0;
+        PtrBlockMapEntry++) {
+    FvbDev->NumBlocks += PtrBlockMapEntry->NumBlocks;
+  }
+  //
+  // Second, allocate the cache
+  //
+  FvbDev->LbaCache = CoreAllocateBootServicesPool (FvbDev->NumBlocks * sizeof (LBA_CACHE));
+  if (FvbDev->LbaCache == NULL) {
+    CoreFreePool (FvbDev);
+    return EFI_OUT_OF_RESOURCES;
+  }
+  //
+  // Last, fill in the cache with the linear address of the blocks
+  //
+  BlockIndex = 0;
+  LinearOffset = 0;
+  for (PtrBlockMapEntry = FwVolHeader->FvBlockMap;
+        PtrBlockMapEntry->NumBlocks != 0; PtrBlockMapEntry++) {
+    for (BlockIndex2 = 0; BlockIndex2 < PtrBlockMapEntry->NumBlocks; BlockIndex2++) {
+      FvbDev->LbaCache[BlockIndex].Base = LinearOffset;
+      FvbDev->LbaCache[BlockIndex].Length = PtrBlockMapEntry->BlockLength;
+      LinearOffset += PtrBlockMapEntry->BlockLength;
+      BlockIndex++;
+    }
+  }
+
+  //
+  // Set up the devicepath
+  //
+  FvbDev->DevicePath.MemMapDevPath.StartingAddress = BaseAddress;
+  FvbDev->DevicePath.MemMapDevPath.EndingAddress = BaseAddress + FwVolHeader->FvLength - 1;
+
+  //
+  //
+  // Attach FvVolBlock Protocol to new handle
+  //
+  Status = CoreInstallMultipleProtocolInterfaces (
+            &FvbDev->Handle,
+            &gEfiFirmwareVolumeBlockProtocolGuid,     &FvbDev->FwVolBlockInstance,
+            &gEfiDevicePathProtocolGuid,              &FvbDev->DevicePath,
+            &gEfiFirmwareVolumeDispatchProtocolGuid,  NULL,
+            NULL
+            );
+
+  //
+  // If they want the handle back, set it.
+  //
+  if (FvProtocol != NULL) {
+    *FvProtocol = FvbDev->Handle;
+  }
+
+  return Status;
+}
+
+
+EFI_STATUS
+EFIAPI
+FwVolBlockDriverInit (
+  IN EFI_HANDLE                 ImageHandle,
+  IN EFI_SYSTEM_TABLE           *SystemTable
+  )
+/*++
+
+Routine Description:
+    This routine is the driver initialization entry point.  It initializes the
+    libraries, consumes FV hobs and NT_NON_MM_FV environment variable and
+    produces instances of FW_VOL_BLOCK_PROTOCOL as appropriate.
+Arguments:
+    ImageHandle   - The image handle.
+    SystemTable   - The system table.
+Returns:
+    EFI_SUCCESS   - Successfully initialized firmware volume block driver.
+--*/
+{
+  EFI_STATUS                    Status;
+  VOID                          *HobList;
+  EFI_PHYSICAL_ADDRESS          BaseAddress;
+  UINT64                        Length;
+  EFI_STATUS                    HobStatus;
+
+  //
+  // First walk hobs and create appropriate FVs.
+  //
+  Status = CoreGetConfigTable (&gEfiHobListGuid, &HobList);
+  //
+  // Core Needs Firmware Volumes to function
+  //
+  ASSERT_EFI_ERROR (Status);
+
+  BaseAddress = 0;
+  Length      = 0;
+  HobStatus = GetNextFirmwareVolumeHob (
+                  &HobList,
+                  &BaseAddress,
+                  &Length
+                  );
+  while (!EFI_ERROR (HobStatus)) {
+    //
+    // Produce an FVB protocol for it
+    //
+    ProduceFVBProtocolOnBuffer (BaseAddress, Length, NULL, NULL);
+    HobStatus = GetNextFirmwareVolumeHob (
+                  &HobList,
+                  &BaseAddress,
+                  &Length
+                  );
+  }
+  
+  return EFI_SUCCESS;
+}
+
+
+EFI_STATUS
+CoreProcessFirmwareVolume (
+  IN VOID                             *FvHeader,
+  IN UINTN                            Size, 
+  OUT EFI_HANDLE                      *FVProtocolHandle
+  )
+/*++
+
+Routine Description:
+    This DXE service routine is used to process a firmware volume. In
+    particular, it can be called by BDS to process a single firmware
+    volume found in a capsule. 
+
+Arguments:
+    FvHeader              - pointer to a firmware volume header
+    Size                  - the size of the buffer pointed to by FvHeader
+    FVProtocolHandle      - the handle on which a firmware volume protocol
+                            was produced for the firmware volume passed in.
+
+Returns:
+    EFI_OUT_OF_RESOURCES  - if an FVB could not be produced due to lack of 
+                            system resources
+    EFI_VOLUME_CORRUPTED  - if the volume was corrupted
+    EFI_SUCCESS           - a firmware volume protocol was produced for the
+                            firmware volume
+
+--*/
+{
+  VOID        *Ptr;
+  EFI_STATUS  Status;
+
+  *FVProtocolHandle = NULL;
+  Status = ProduceFVBProtocolOnBuffer ( 
+            (EFI_PHYSICAL_ADDRESS) (UINTN) FvHeader, 
+            (UINT64)Size, 
+            NULL, 
+            FVProtocolHandle
+            );
+  //
+  // Since in our implementation we use register-protocol-notify to put a
+  // FV protocol on the FVB protocol handle, we can't directly verify that
+  // the FV protocol was produced. Therefore here we will check the handle
+  // and make sure an FV protocol is on it. This indicates that all went 
+  // well. Otherwise we have to assume that the volume was corrupted 
+  // somehow.
+  //
+  if (!EFI_ERROR(Status)) {
+    Ptr = NULL;
+    Status = CoreHandleProtocol (*FVProtocolHandle, &gEfiFirmwareVolumeProtocolGuid, &Ptr);
+    if (EFI_ERROR(Status) || (Ptr == NULL)) {
+      return EFI_VOLUME_CORRUPTED;
+    }
+    return EFI_SUCCESS;
+  }
+  return Status;
+}
+
+
diff --git a/EDK/Foundation/Core/Dxe/FwVolBlock/FwVolBlock.h b/EDK/Foundation/Core/Dxe/FwVolBlock/FwVolBlock.h
new file mode 100644
index 0000000..cbf9ffc
--- /dev/null
+++ b/EDK/Foundation/Core/Dxe/FwVolBlock/FwVolBlock.h
@@ -0,0 +1,334 @@
+/*++
+
+Copyright (c) 2004 - 2005, 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:
+
+  FwVolBlock.h
+
+Abstract:
+
+  Firmware Volume Block protocol..  Consumes FV hobs and creates
+  appropriate block protocols.
+
+  Also consumes NT_NON_MM_FV envinronment variable and produces appropriate
+  block protocols fro them also... (this is TBD)
+
+--*/
+
+#ifndef _FWVOL_BLOCK_H_
+#define _FWVOL_BLOCK_H_
+
+#include EFI_PROTOCOL_DEFINITION (FirmwareVolumeBlock)
+#include EFI_PROTOCOL_DEFINITION (DevicePath)
+#include "Peihob.h"
+#include "EfiHobLib.h"
+#include "DxeCore.h"
+
+#include EFI_GUID_DEFINITION (Hob)
+
+
+
+#define FVB_DEVICE_SIGNATURE       EFI_SIGNATURE_32('_','F','V','B')
+
+typedef struct {
+  UINTN                       Base;
+  UINTN                       Length;
+} LBA_CACHE;
+
+typedef struct {
+  MEMMAP_DEVICE_PATH          MemMapDevPath;
+  EFI_DEVICE_PATH_PROTOCOL    EndDevPath;
+} FV_DEVICE_PATH;
+
+
+typedef struct {
+  UINTN                                 Signature;
+  EFI_HANDLE                            Handle;
+  FV_DEVICE_PATH                        DevicePath;
+  EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL    FwVolBlockInstance;
+  UINTN                                 NumBlocks;
+  LBA_CACHE                             *LbaCache;
+  UINT32                                FvbAttributes;
+  EFI_PHYSICAL_ADDRESS                  BaseAddress;
+} EFI_FW_VOL_BLOCK_DEVICE;
+
+#define FVB_DEVICE_FROM_THIS(a) \
+  CR(a, EFI_FW_VOL_BLOCK_DEVICE, FwVolBlockInstance, FVB_DEVICE_SIGNATURE)
+
+
+
+EFI_STATUS
+EFIAPI
+FwVolBlockDriverInit (
+  IN EFI_HANDLE               ImageHandle,
+  IN EFI_SYSTEM_TABLE         *SystemTable
+  )
+/*++
+
+Routine Description:
+    This routine is the driver initialization entry point.  It initializes the
+    libraries, consumes FV hobs and NT_NON_MM_FV environment variable and
+    produces instances of FW_VOL_BLOCK_PROTOCOL as appropriate.
+Arguments:
+    ImageHandle   - The image handle.
+    SystemTable   - The system table.
+Returns:
+    EFI_SUCCESS   - Successfully initialized firmware volume block driver.
+--*/
+;
+
+
+EFI_STATUS
+EFIAPI
+FwVolBlockGetAttributes (
+  IN EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL   *This,
+  OUT EFI_FVB_ATTRIBUTES                          *Attributes
+  )
+/*++
+
+Routine Description:
+    Retrieves Volume attributes.  No polarity translations are done.
+
+Arguments:
+    This - Calling context
+    Attributes - output buffer which contains attributes
+
+Returns:
+    EFI_SUCCESS - The firmware volume attributes were returned.
+
+--*/
+;
+
+
+EFI_STATUS
+EFIAPI
+FwVolBlockSetAttributes (
+  IN EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL   *This,
+  OUT EFI_FVB_ATTRIBUTES                          *Attributes
+  )
+/*++
+
+Routine Description:
+  Modifies the current settings of the firmware volume according to the input parameter.
+
+Arguments:
+  This - Calling context
+  Attributes - input buffer which contains attributes
+
+Returns:
+  EFI_SUCCESS -  The firmware volume attributes were returned.
+  EFI_INVALID_PARAMETER  -  The attributes requested are in conflict with the capabilities as
+                             declared in the firmware volume header.
+  EFI_UNSUPPORTED        -  Not supported.
+--*/
+;
+
+
+EFI_STATUS
+EFIAPI
+FwVolBlockEraseBlock (
+  IN 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. The firmware device may have been partially erased.
+  EFI_INVALID_PARAMETER  -  One or more of the LBAs listed in the variable argument list do
+  EFI_UNSUPPORTED        -  Not supported.
+    
+--*/
+;
+
+
+EFI_STATUS
+EFIAPI
+FwVolBlockReadBlock (
+  IN EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL   *This,
+  IN EFI_LBA                                      Lba,
+  IN UINTN                                        Offset,
+  IN OUT UINTN                                    *NumBytes,
+  IN UINT8                                        *Buffer
+  )
+/*++
+
+Routine Description:
+  Read the specified number of bytes from the block to the input buffer.
+
+Arguments:
+  This          -  Indicates the calling context.
+  Lba           -  The starting logical block index to read.
+  Offset        -  Offset into the block at which to begin reading.
+  NumBytes      -  Pointer to a UINT32. At entry, *NumBytes contains the
+                   total size of the buffer. At exit, *NumBytes contains the
+                   total number of bytes actually read.
+  Buffer        -  Pinter to a caller-allocated buffer that contains the destine
+                   for the read.    
+
+Returns:      
+  EFI_SUCCESS  -  The firmware volume was read successfully.
+  EFI_BAD_BUFFER_SIZE -  The read was attempted across an LBA boundary.
+  EFI_ACCESS_DENIED  -  Access denied.
+  EFI_DEVICE_ERROR   -  The block device is malfunctioning and could not be read.
+--*/
+;
+
+  
+EFI_STATUS
+EFIAPI
+FwVolBlockWriteBlock (
+  IN EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL    *This,
+  IN EFI_LBA                              Lba,
+  IN UINTN                                Offset,
+  IN OUT UINTN                            *NumBytes,
+  IN UINT8                                *Buffer
+  )
+/*++
+
+Routine Description:
+  Writes the specified number of bytes from the input buffer to the block.
+
+Arguments:
+  This          -  Indicates the calling context.
+  Lba           -  The starting logical block index to write to.
+  Offset        -  Offset into the block at which to begin writing.
+  NumBytes      -  Pointer to a UINT32. At entry, *NumBytes contains the
+                   total size of the buffer. At exit, *NumBytes contains the
+                   total number of bytes actually written.
+  Buffer        -  Pinter to a caller-allocated buffer that contains the source
+                   for the write.    
+
+Returns:     
+  EFI_SUCCESS  -  The firmware volume was written successfully.
+  EFI_BAD_BUFFER_SIZE -  The write was attempted across an 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 malfunctioning and could not be written.
+  EFI_UNSUPPORTED    -  Not supported.
+--*/
+;
+
+    
+EFI_STATUS
+EFIAPI
+FwVolBlockGetPhysicalAddress (
+  IN EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL  *This,
+  OUT EFI_PHYSICAL_ADDRESS                        *Address
+  )
+/*++
+
+Routine Description:
+  Get Fvb's base address.
+
+Arguments:
+  This          -  Indicates the calling context.
+  Address       -  Fvb device base address.
+
+Returns:     
+  EFI_SUCCESS  -  Successfully got Fvb's base address.
+  EFI_UNSUPPORTED -  Not supported.
+--*/
+;
+
+
+EFI_STATUS
+EFIAPI
+FwVolBlockGetBlockSize (
+  IN EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL   *This,
+  IN EFI_LBA                             Lba,
+  OUT UINTN                              *BlockSize,
+  OUT UINTN                              *NumberOfBlocks
+  )
+/*++
+
+Routine Description:
+  Retrieves the size in bytes of a specific block within a firmware volume.
+
+Arguments:
+  This            -  Indicates the calling context.
+  Lba             -  Indicates the block for which to return the size.
+  BlockSize       -  Pointer to a caller-allocated UINTN in which the size of the
+                     block is returned.
+  NumberOfBlocks  -  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 base address is returned.
+  EFI_INVALID_PARAMETER  -  The requested LBA is out of range.
+--*/
+;
+
+EFI_STATUS
+FwVolBlockDriverInit (
+  IN EFI_HANDLE               ImageHandle,
+  IN EFI_SYSTEM_TABLE         *SystemTable
+  )
+/*++
+
+Routine Description:
+    This routine is the driver initialization entry point.  It initializes the
+    libraries, consumes FV hobs and NT_NON_MM_FV environment variable and
+    produces instances of FW_VOL_BLOCK_PROTOCOL as appropriate.
+Arguments:
+    ImageHandle   - The image handle.
+    SystemTable   - The system table.
+Returns:
+    Status code
+
+--*/
+;
+
+EFI_STATUS
+ProduceFVBProtocolOnBuffer (
+  IN EFI_PHYSICAL_ADDRESS   BaseAddress,
+  IN UINT64                 Length,
+  IN EFI_HANDLE             ParentHandle,
+  OUT EFI_HANDLE            *FvProtocolHandle  OPTIONAL
+  )
+/*++
+
+Routine Description:
+    This routine produces a firmware volume block protocol on a given
+    buffer. 
+
+Arguments:
+    BaseAddress     - base address of the firmware volume image
+    Length          - length of the firmware volume image
+    ParentHandle    - handle of parent firmware volume, if this
+                      image came from an FV image file in another
+                      firmware volume (ala capsules)
+    FvProtocolHandle  - Firmware volume block protocol produced.
+    
+Returns:
+    EFI_VOLUME_CORRUPTED    - Volume corrupted.
+    EFI_OUT_OF_RESOURCES    - No enough buffer to be allocated.
+    EFI_SUCCESS             - Successfully produced a FVB protocol on given buffer.
+                     
+--*/
+;
+
+#endif