OvmfPkg: Add QemuFlashFvbServicesRuntimeDxe driver

If QEMU flash is detected, this module will install
FirmwareVolumeBlock support for the QEMU flash device.

It will also set PCDs with the results that:
1. OvmfPkg/EmuVariableFvbRuntimeDxe will be disabled
2. MdeModulePkg variable services will read/write flash directly

Contributed-under: TianoCore Contribution Agreement 1.0
Signed-off-by: Jordan Justen <jordan.l.justen@intel.com>
Acked-by: Laszlo Ersek <lersek@redhat.com>

git-svn-id: https://svn.code.sf.net/p/edk2/code/trunk/edk2@14839 6f19259b-4bc3-4df7-8a09-765794883524

6 files changed, 1984 insertions, 0 deletions

diff --git a/OvmfPkg/QemuFlashFvbServicesRuntimeDxe/FvbInfo.c b/OvmfPkg/QemuFlashFvbServicesRuntimeDxe/FvbInfo.c
new file mode 100644
index 0000000000..72845f9555
--- /dev/null
+++ b/OvmfPkg/QemuFlashFvbServicesRuntimeDxe/FvbInfo.c
@@ -0,0 +1,137 @@
+/**@file

+

+Copyright (c) 2006, Intel Corporation. All rights reserved.<BR>

+This program and the accompanying materials                          

+are licensed and made available under the terms and conditions of the BSD License         

+which accompanies this distribution.  The full text of the license may be found at        

+http://opensource.org/licenses/bsd-license.php                                            

+                                                                                          

+THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     

+WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             

+

+Module Name:

+

+  FvbInfo.c

+

+Abstract:

+

+  Defines data structure that is the volume header found.These data is intent

+  to decouple FVB driver with FV header.

+

+**/

+

+//

+// 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 <Guid/SystemNvDataGuid.h>

+#include <Protocol/FirmwareVolumeBlock.h>

+#include <Protocol/DevicePath.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>

+

+typedef struct {

+  UINT64                      FvLength;

+  EFI_FIRMWARE_VOLUME_HEADER  FvbInfo;

+  //

+  // EFI_FV_BLOCK_MAP_ENTRY    ExtraBlockMap[n];//n=0

+  //

+  EFI_FV_BLOCK_MAP_ENTRY      End[1];

+} EFI_FVB_MEDIA_INFO;

+

+EFI_FVB_MEDIA_INFO  mPlatformFvbMediaInfo[] = {

+  //

+  // Systen NvStorage FVB

+  //

+  {

+    FixedPcdGet32 (PcdFlashNvStorageVariableSize) +

+    FixedPcdGet32 (PcdFlashNvStorageFtwWorkingSize) +

+    FixedPcdGet32 (PcdFlashNvStorageFtwSpareSize) +

+    FixedPcdGet32 (PcdOvmfFlashNvStorageEventLogSize),

+    {

+      {

+        0,

+      },  // ZeroVector[16]

+      EFI_SYSTEM_NV_DATA_FV_GUID,

+      FixedPcdGet32 (PcdFlashNvStorageVariableSize) +

+      FixedPcdGet32 (PcdFlashNvStorageFtwWorkingSize) +

+      FixedPcdGet32 (PcdFlashNvStorageFtwSpareSize) +

+      FixedPcdGet32 (PcdOvmfFlashNvStorageEventLogSize),

+      EFI_FVH_SIGNATURE,

+      EFI_FVB2_MEMORY_MAPPED |  

+        EFI_FVB2_READ_ENABLED_CAP |

+        EFI_FVB2_READ_STATUS |

+        EFI_FVB2_WRITE_ENABLED_CAP |

+        EFI_FVB2_WRITE_STATUS |

+        EFI_FVB2_ERASE_POLARITY |

+        EFI_FVB2_ALIGNMENT_16,

+      sizeof (EFI_FIRMWARE_VOLUME_HEADER) + sizeof (EFI_FV_BLOCK_MAP_ENTRY),

+      0,  // CheckSum

+      0,  // ExtHeaderOffset

+      {

+        0,

+      },  // Reserved[1]

+      2,  // Revision

+      {

+       (FixedPcdGet32 (PcdFlashNvStorageVariableSize) +

+        FixedPcdGet32 (PcdFlashNvStorageFtwWorkingSize) +

+        FixedPcdGet32 (PcdFlashNvStorageFtwSpareSize) +

+        FixedPcdGet32 (PcdOvmfFlashNvStorageEventLogSize)) / FixedPcdGet32 (PcdOvmfFirmwareBlockSize),

+        FixedPcdGet32 (PcdOvmfFirmwareBlockSize),

+      }

+    },

+    {

+      0,

+      0

+    }

+  }

+};

+

+EFI_STATUS

+GetFvbInfo (

+  IN  UINT64                        FvLength,

+  OUT EFI_FIRMWARE_VOLUME_HEADER    **FvbInfo

+  )

+{

+  STATIC BOOLEAN Checksummed = FALSE;

+  UINTN Index;

+

+  if (!Checksummed) {

+    for (Index = 0; Index < sizeof (mPlatformFvbMediaInfo) / sizeof (EFI_FVB_MEDIA_INFO); Index += 1) {

+      UINT16 Checksum;

+      mPlatformFvbMediaInfo[Index].FvbInfo.Checksum = 0;

+      Checksum = CalculateCheckSum16 (

+                   (UINT16*) &mPlatformFvbMediaInfo[Index].FvbInfo,

+                   mPlatformFvbMediaInfo[Index].FvbInfo.HeaderLength

+                   );

+      mPlatformFvbMediaInfo[Index].FvbInfo.Checksum = Checksum;

+    }

+    Checksummed = TRUE;

+  }

+

+  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;

+}

diff --git a/OvmfPkg/QemuFlashFvbServicesRuntimeDxe/FvbServicesRuntimeDxe.inf b/OvmfPkg/QemuFlashFvbServicesRuntimeDxe/FvbServicesRuntimeDxe.inf
new file mode 100644
index 0000000000..81981f5941
--- /dev/null
+++ b/OvmfPkg/QemuFlashFvbServicesRuntimeDxe/FvbServicesRuntimeDxe.inf
@@ -0,0 +1,83 @@
+## @file

+# Component description file for QEMU Flash Fimware Volume Block DXE driver module.

+#

+# This DXE runtime driver implements and produces the Fimware Volue Block Protocol

+# for a QEMU flash device.

+#

+# Copyright (c) 2006 - 2013, Intel Corporation. All rights reserved.<BR>

+#

+#  This program and the accompanying materials

+#  are licensed and made available under the terms and conditions of the BSD License

+#  which accompanies this distribution. The full text of the license may be found at

+#  http://opensource.org/licenses/bsd-license.php

+#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+#

+##

+

+[Defines]

+  INF_VERSION                    = 0x00010005

+  BASE_NAME                      = FvbServicesRuntimeDxe

+  FILE_GUID                      = 733cbac2-b23f-4b92-bc8e-fb01ce5907b7

+  MODULE_TYPE                    = DXE_RUNTIME_DRIVER

+  VERSION_STRING                 = 1.0

+  ENTRY_POINT                    = FvbInitialize

+

+#

+# The following information is for reference only and not required by the build tools.

+#

+#  VALID_ARCHITECTURES           = IA32

+#

+

+[Sources]

+  FvbInfo.c

+  FwBlockService.c

+  QemuFlash.c

+

+[Packages]

+  MdePkg/MdePkg.dec

+  MdeModulePkg/MdeModulePkg.dec

+  OvmfPkg/OvmfPkg.dec

+

+[LibraryClasses]

+  UefiBootServicesTableLib

+  MemoryAllocationLib

+  BaseMemoryLib

+  HobLib

+  DebugLib

+  UefiRuntimeLib

+  DxeServicesTableLib

+  BaseLib

+  UefiDriverEntryPoint

+  UefiLib

+  PcdLib

+

+[Guids]

+  gEfiEventVirtualAddressChangeGuid             # ALWAYS_CONSUMED  Create Event: EVENT_GROUP_GUID

+

+[Protocols]

+  gEfiFirmwareVolumeBlockProtocolGuid           # PROTOCOL SOMETIMES_PRODUCED

+  gEfiDevicePathProtocolGuid                    # PROTOCOL SOMETIMES_PRODUCED

+

+[FixedPcd]

+  gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageVariableSize

+  gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageFtwWorkingSize

+  gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageFtwSpareSize

+  gUefiOvmfPkgTokenSpaceGuid.PcdOvmfFlashNvStorageVariableBase

+  gUefiOvmfPkgTokenSpaceGuid.PcdOvmfFlashNvStorageFtwWorkingBase

+  gUefiOvmfPkgTokenSpaceGuid.PcdOvmfFlashNvStorageFtwSpareBase

+  gUefiOvmfPkgTokenSpaceGuid.PcdOvmfFlashNvStorageEventLogSize

+  gUefiOvmfPkgTokenSpaceGuid.PcdOvmfFdBaseAddress

+  gUefiOvmfPkgTokenSpaceGuid.PcdOvmfFirmwareFdSize

+  gUefiOvmfPkgTokenSpaceGuid.PcdOvmfFirmwareBlockSize

+

+[Pcd]

+  gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageFtwWorkingBase

+  gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageFtwSpareBase

+  gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageVariableBase

+  gUefiOvmfPkgTokenSpaceGuid.PcdOvmfFlashNvStorageEventLogBase

+  gEfiMdeModulePkgTokenSpaceGuid.PcdFlashNvStorageVariableBase64

+

+

+[Depex]

+  TRUE

diff --git a/OvmfPkg/QemuFlashFvbServicesRuntimeDxe/FwBlockService.c b/OvmfPkg/QemuFlashFvbServicesRuntimeDxe/FwBlockService.c
new file mode 100644
index 0000000000..2ae6678751
--- /dev/null
+++ b/OvmfPkg/QemuFlashFvbServicesRuntimeDxe/FwBlockService.c
@@ -0,0 +1,1226 @@
+/**@file

+

+Copyright (c) 2006 - 2013, Intel Corporation. All rights reserved.<BR>

+This program and the accompanying materials

+are licensed and made available under the terms and conditions of the BSD License

+which accompanies this distribution.  The full text of the license may be found at

+http://opensource.org/licenses/bsd-license.php

+

+THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+Module Name:

+

+  FWBlockService.c

+

+Abstract:

+

+Revision History

+

+**/

+

+//

+// 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 <Protocol/FirmwareVolumeBlock.h>

+#include <Protocol/DevicePath.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/BaseMemoryLib.h>

+#include <Library/MemoryAllocationLib.h>

+#include <Library/UefiBootServicesTableLib.h>

+#include <Library/DevicePathLib.h>

+

+#include "FwBlockService.h"

+#include "QemuFlash.h"

+

+#define EFI_FVB2_STATUS (EFI_FVB2_READ_STATUS | EFI_FVB2_WRITE_STATUS | EFI_FVB2_LOCK_STATUS)

+

+ESAL_FWB_GLOBAL         *mFvbModuleGlobal;

+

+FV_MEMMAP_DEVICE_PATH mFvMemmapDevicePathTemplate = {

+  {

+    {

+      HARDWARE_DEVICE_PATH,

+      HW_MEMMAP_DP,

+      {

+        (UINT8)(sizeof (MEMMAP_DEVICE_PATH)),

+        (UINT8)(sizeof (MEMMAP_DEVICE_PATH) >> 8)

+      }

+    },

+    EfiMemoryMappedIO,

+    (EFI_PHYSICAL_ADDRESS) 0,

+    (EFI_PHYSICAL_ADDRESS) 0,

+  },

+  {

+    END_DEVICE_PATH_TYPE,

+    END_ENTIRE_DEVICE_PATH_SUBTYPE,

+    {

+      END_DEVICE_PATH_LENGTH,

+      0

+    }

+  }

+};

+

+FV_PIWG_DEVICE_PATH mFvPIWGDevicePathTemplate = {

+  {

+    {

+      MEDIA_DEVICE_PATH,

+      MEDIA_PIWG_FW_VOL_DP,

+      {

+        (UINT8)(sizeof (MEDIA_FW_VOL_DEVICE_PATH)),

+        (UINT8)(sizeof (MEDIA_FW_VOL_DEVICE_PATH) >> 8)

+      }

+    },

+    { 0 }

+  },

+  {

+    END_DEVICE_PATH_TYPE,

+    END_ENTIRE_DEVICE_PATH_SUBTYPE,

+    {

+      END_DEVICE_PATH_LENGTH,

+      0

+    }

+  }

+};

+

+EFI_FW_VOL_BLOCK_DEVICE mFvbDeviceTemplate = {

+  FVB_DEVICE_SIGNATURE,

+  NULL,

+  0,

+  {

+    FvbProtocolGetAttributes,

+    FvbProtocolSetAttributes,

+    FvbProtocolGetPhysicalAddress,

+    FvbProtocolGetBlockSize,

+    FvbProtocolRead,

+    FvbProtocolWrite,

+    FvbProtocolEraseBlocks,

+    NULL

+  }

+};

+

+

+

+VOID

+EFIAPI

+FvbVirtualddressChangeEvent (

+  IN EFI_EVENT        Event,

+  IN VOID             *Context

+  )

+/*++

+

+Routine Description:

+

+  Fixup internal data so that EFI and SAL can be call in virtual mode.

+  Call the passed in Child Notify event and convert the mFvbModuleGlobal

+  date items to there virtual address.

+

+  mFvbModuleGlobal->FvInstance[FVB_PHYSICAL]  - Physical copy of instance data

+  mFvbModuleGlobal->FvInstance[FVB_VIRTUAL]   - Virtual pointer to common

+                                                instance data.

+

+Arguments:

+

+  (Standard EFI notify event - EFI_EVENT_NOTIFY)

+

+Returns:

+

+  None

+

+--*/

+{

+  EFI_FW_VOL_INSTANCE *FwhInstance;

+  UINTN               Index;

+

+  EfiConvertPointer (0x0, (VOID **) &mFvbModuleGlobal->FvInstance[FVB_VIRTUAL]);

+

+  //

+  // Convert the base address of all the instances

+  //

+  Index       = 0;

+  FwhInstance = mFvbModuleGlobal->FvInstance[FVB_PHYSICAL];

+  while (Index < mFvbModuleGlobal->NumFv) {

+    EfiConvertPointer (0x0, (VOID **) &FwhInstance->FvBase[FVB_VIRTUAL]);

+    FwhInstance = (EFI_FW_VOL_INSTANCE *)

+      (

+        (UINTN) ((UINT8 *) FwhInstance) + FwhInstance->VolumeHeader.HeaderLength +

+          (sizeof (EFI_FW_VOL_INSTANCE) - sizeof (EFI_FIRMWARE_VOLUME_HEADER))

+      );

+    Index++;

+  }

+

+  EfiConvertPointer (0x0, (VOID **) &mFvbModuleGlobal->FvbScratchSpace[FVB_VIRTUAL]);

+  EfiConvertPointer (0x0, (VOID **) &mFvbModuleGlobal);

+  QemuFlashConvertPointers ();

+}

+

+EFI_STATUS

+GetFvbInstance (

+  IN  UINTN                               Instance,

+  IN  ESAL_FWB_GLOBAL                     *Global,

+  OUT EFI_FW_VOL_INSTANCE                 **FwhInstance,

+  IN BOOLEAN                              Virtual

+  )

+/*++

+

+Routine Description:

+  Retrieves the physical address of a memory mapped FV

+

+Arguments:

+  Instance              - The FV instance whose base address is going to be

+                          returned

+  Global                - Pointer to ESAL_FWB_GLOBAL that contains all

+                          instance data

+  FwhInstance           - The EFI_FW_VOL_INSTANCE fimrware instance structure

+  Virtual               - Whether CPU is in virtual or physical mode

+

+Returns:

+  EFI_SUCCESS           - Successfully returns

+  EFI_INVALID_PARAMETER - Instance not found

+

+--*/

+{

+  EFI_FW_VOL_INSTANCE *FwhRecord;

+

+  if (Instance >= Global->NumFv) {

+    return EFI_INVALID_PARAMETER;

+  }

+  //

+  // Find the right instance of the FVB private data

+  //

+  FwhRecord = Global->FvInstance[Virtual];

+  while (Instance > 0) {

+    FwhRecord = (EFI_FW_VOL_INSTANCE *)

+      (

+        (UINTN) ((UINT8 *) FwhRecord) + FwhRecord->VolumeHeader.HeaderLength +

+          (sizeof (EFI_FW_VOL_INSTANCE) - sizeof (EFI_FIRMWARE_VOLUME_HEADER))

+      );

+    Instance--;

+  }

+

+  *FwhInstance = FwhRecord;

+

+  return EFI_SUCCESS;

+}

+

+EFI_STATUS

+FvbGetPhysicalAddress (

+  IN UINTN                                Instance,

+  OUT EFI_PHYSICAL_ADDRESS                *Address,

+  IN ESAL_FWB_GLOBAL                      *Global,

+  IN BOOLEAN                              Virtual

+  )

+/*++

+

+Routine Description:

+  Retrieves the physical address of a memory mapped FV

+

+Arguments:

+  Instance              - The FV instance whose base address is going to be

+                          returned

+  Address               - Pointer to a caller allocated EFI_PHYSICAL_ADDRESS

+                          that on successful return, contains the base address

+                          of the firmware volume.

+  Global                - Pointer to ESAL_FWB_GLOBAL that contains all

+                          instance data

+  Virtual               - Whether CPU is in virtual or physical mode

+

+Returns:

+  EFI_SUCCESS           - Successfully returns

+  EFI_INVALID_PARAMETER - Instance not found

+

+--*/

+{

+  EFI_FW_VOL_INSTANCE *FwhInstance;

+  EFI_STATUS          Status;

+

+  //

+  // Find the right instance of the FVB private data

+  //

+  Status = GetFvbInstance (Instance, Global, &FwhInstance, Virtual);

+  ASSERT_EFI_ERROR (Status);

+  *Address = FwhInstance->FvBase[Virtual];

+

+  return EFI_SUCCESS;

+}

+

+EFI_STATUS

+FvbGetVolumeAttributes (

+  IN UINTN                                Instance,

+  OUT EFI_FVB_ATTRIBUTES_2                *Attributes,

+  IN ESAL_FWB_GLOBAL                      *Global,

+  IN BOOLEAN                              Virtual

+  )

+/*++

+

+Routine Description:

+  Retrieves attributes, insures positive polarity of attribute bits, returns

+  resulting attributes in output parameter

+

+Arguments:

+  Instance              - The FV instance whose attributes is going to be

+                          returned

+  Attributes            - Output buffer which contains attributes

+  Global                - Pointer to ESAL_FWB_GLOBAL that contains all

+                          instance data

+  Virtual               - Whether CPU is in virtual or physical mode

+

+Returns:

+  EFI_SUCCESS           - Successfully returns

+  EFI_INVALID_PARAMETER - Instance not found

+

+--*/

+{

+  EFI_FW_VOL_INSTANCE *FwhInstance;

+  EFI_STATUS          Status;

+

+  //

+  // Find the right instance of the FVB private data

+  //

+  Status = GetFvbInstance (Instance, Global, &FwhInstance, Virtual);

+  ASSERT_EFI_ERROR (Status);

+  *Attributes = FwhInstance->VolumeHeader.Attributes;

+

+  return EFI_SUCCESS;

+}

+

+EFI_STATUS

+FvbGetLbaAddress (

+  IN  UINTN                               Instance,

+  IN  EFI_LBA                             Lba,

+  OUT UINTN                               *LbaAddress,

+  OUT UINTN                               *LbaLength,

+  OUT UINTN                               *NumOfBlocks,

+  IN  ESAL_FWB_GLOBAL                     *Global,

+  IN  BOOLEAN                             Virtual

+  )

+/*++

+

+Routine Description:

+  Retrieves the starting address of an LBA in an FV

+

+Arguments:

+  Instance              - The FV instance which the Lba belongs to

+  Lba                   - The logical block address

+  LbaAddress            - On output, contains the physical starting address

+                          of the Lba

+  LbaLength             - On output, contains the length of the block

+  NumOfBlocks           - A pointer to a caller allocated UINTN in which the

+                          number of consecutive blocks starting with Lba is

+                          returned. All blocks in this range have a size of

+                          BlockSize

+  Global                - Pointer to ESAL_FWB_GLOBAL that contains all

+                          instance data

+  Virtual               - Whether CPU is in virtual or physical mode

+

+Returns:

+  EFI_SUCCESS           - Successfully returns

+  EFI_INVALID_PARAMETER - Instance not found

+

+--*/

+{

+  UINT32                  NumBlocks;

+  UINT32                  BlockLength;

+  UINTN                   Offset;

+  EFI_LBA                 StartLba;

+  EFI_LBA                 NextLba;

+  EFI_FW_VOL_INSTANCE     *FwhInstance;

+  EFI_FV_BLOCK_MAP_ENTRY  *BlockMap;

+  EFI_STATUS              Status;

+

+  //

+  // Find the right instance of the FVB private data

+  //

+  Status = GetFvbInstance (Instance, Global, &FwhInstance, Virtual);

+  ASSERT_EFI_ERROR (Status);

+

+  StartLba  = 0;

+  Offset    = 0;

+  BlockMap  = &(FwhInstance->VolumeHeader.BlockMap[0]);

+

+  //

+  // Parse the blockmap of the FV to find which map entry the Lba belongs to

+  //

+  while (TRUE) {

+    NumBlocks   = BlockMap->NumBlocks;

+    BlockLength = BlockMap->Length;

+

+    if (NumBlocks == 0 || BlockLength == 0) {

+      return EFI_INVALID_PARAMETER;

+    }

+

+    NextLba = StartLba + NumBlocks;

+

+    //

+    // The map entry found

+    //

+    if (Lba >= StartLba && Lba < NextLba) {

+      Offset = Offset + (UINTN) MultU64x32 ((Lba - StartLba), BlockLength);

+      if (LbaAddress != NULL) {

+        *LbaAddress = FwhInstance->FvBase[Virtual] + Offset;

+      }

+

+      if (LbaLength != NULL) {

+        *LbaLength = BlockLength;

+      }

+

+      if (NumOfBlocks != NULL) {

+        *NumOfBlocks = (UINTN) (NextLba - Lba);

+      }

+

+      return EFI_SUCCESS;

+    }

+

+    StartLba  = NextLba;

+    Offset    = Offset + NumBlocks * BlockLength;

+    BlockMap++;

+  }

+}

+

+EFI_STATUS

+FvbSetVolumeAttributes (

+  IN UINTN                                  Instance,

+  IN OUT EFI_FVB_ATTRIBUTES_2               *Attributes,

+  IN ESAL_FWB_GLOBAL                        *Global,

+  IN BOOLEAN                                Virtual

+  )

+/*++

+

+Routine Description:

+  Modifies the current settings of the firmware volume according to the

+  input parameter, and returns the new setting of the volume

+

+Arguments:

+  Instance              - The FV instance whose attributes is going to be

+                          modified

+  Attributes            - On input, it is a pointer to EFI_FVB_ATTRIBUTES_2

+                          containing the desired firmware volume settings.

+                          On successful return, it contains the new settings

+                          of the firmware volume

+  Global                - Pointer to ESAL_FWB_GLOBAL that contains all

+                          instance data

+  Virtual               - Whether CPU is in virtual or physical mode

+

+Returns:

+  EFI_SUCCESS           - Successfully returns

+  EFI_ACCESS_DENIED     - The volume setting is locked and cannot be modified

+  EFI_INVALID_PARAMETER - Instance not found, or The attributes requested are

+                          in conflict with the capabilities as declared in the

+                          firmware volume header

+

+--*/

+{

+  EFI_FW_VOL_INSTANCE   *FwhInstance;

+  EFI_FVB_ATTRIBUTES_2  OldAttributes;

+  EFI_FVB_ATTRIBUTES_2  *AttribPtr;

+  UINT32                Capabilities;

+  UINT32                OldStatus;

+  UINT32                NewStatus;

+  EFI_STATUS            Status;

+  EFI_FVB_ATTRIBUTES_2  UnchangedAttributes;

+

+  //

+  // Find the right instance of the FVB private data

+  //

+  Status = GetFvbInstance (Instance, Global, &FwhInstance, Virtual);

+  ASSERT_EFI_ERROR (Status);

+

+  AttribPtr     = (EFI_FVB_ATTRIBUTES_2 *) &(FwhInstance->VolumeHeader.Attributes);

+  OldAttributes = *AttribPtr;

+  Capabilities  = OldAttributes & (EFI_FVB2_READ_DISABLED_CAP | \

+                                   EFI_FVB2_READ_ENABLED_CAP | \

+                                   EFI_FVB2_WRITE_DISABLED_CAP | \

+                                   EFI_FVB2_WRITE_ENABLED_CAP | \

+                                   EFI_FVB2_LOCK_CAP \

+                                   );

+  OldStatus     = OldAttributes & EFI_FVB2_STATUS;

+  NewStatus     = *Attributes & EFI_FVB2_STATUS;

+

+  UnchangedAttributes = EFI_FVB2_READ_DISABLED_CAP  | \

+                        EFI_FVB2_READ_ENABLED_CAP   | \

+                        EFI_FVB2_WRITE_DISABLED_CAP | \

+                        EFI_FVB2_WRITE_ENABLED_CAP  | \

+                        EFI_FVB2_LOCK_CAP           | \

+                        EFI_FVB2_STICKY_WRITE       | \

+                        EFI_FVB2_MEMORY_MAPPED      | \

+                        EFI_FVB2_ERASE_POLARITY     | \

+                        EFI_FVB2_READ_LOCK_CAP      | \

+                        EFI_FVB2_WRITE_LOCK_CAP     | \

+                        EFI_FVB2_ALIGNMENT;

+

+  //

+  // Some attributes of FV is read only can *not* be set

+  //

+  if ((OldAttributes & UnchangedAttributes) ^ (*Attributes & UnchangedAttributes)) {

+    return EFI_INVALID_PARAMETER;

+  }

+  //

+  // If firmware volume is locked, no status bit can be updated

+  //

+  if (OldAttributes & EFI_FVB2_LOCK_STATUS) {

+    if (OldStatus ^ NewStatus) {

+      return EFI_ACCESS_DENIED;

+    }

+  }

+  //

+  // Test read disable

+  //

+  if ((Capabilities & EFI_FVB2_READ_DISABLED_CAP) == 0) {

+    if ((NewStatus & EFI_FVB2_READ_STATUS) == 0) {

+      return EFI_INVALID_PARAMETER;

+    }

+  }

+  //

+  // Test read enable

+  //

+  if ((Capabilities & EFI_FVB2_READ_ENABLED_CAP) == 0) {

+    if (NewStatus & EFI_FVB2_READ_STATUS) {

+      return EFI_INVALID_PARAMETER;

+    }

+  }

+  //

+  // Test write disable

+  //

+  if ((Capabilities & EFI_FVB2_WRITE_DISABLED_CAP) == 0) {

+    if ((NewStatus & EFI_FVB2_WRITE_STATUS) == 0) {

+      return EFI_INVALID_PARAMETER;

+    }

+  }

+  //

+  // Test write enable

+  //

+  if ((Capabilities & EFI_FVB2_WRITE_ENABLED_CAP) == 0) {

+    if (NewStatus & EFI_FVB2_WRITE_STATUS) {

+      return EFI_INVALID_PARAMETER;

+    }

+  }

+  //

+  // Test lock

+  //

+  if ((Capabilities & EFI_FVB2_LOCK_CAP) == 0) {

+    if (NewStatus & EFI_FVB2_LOCK_STATUS) {

+      return EFI_INVALID_PARAMETER;

+    }

+  }

+

+  *AttribPtr  = (*AttribPtr) & (0xFFFFFFFF & (~EFI_FVB2_STATUS));

+  *AttribPtr  = (*AttribPtr) | NewStatus;

+  *Attributes = *AttribPtr;

+

+  return EFI_SUCCESS;

+}

+

+//

+// FVB protocol APIs

+//

+EFI_STATUS

+EFIAPI

+FvbProtocolGetPhysicalAddress (

+  IN CONST EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL           *This,

+  OUT EFI_PHYSICAL_ADDRESS                        *Address

+  )

+/*++

+

+Routine Description:

+

+  Retrieves the physical address of the device.

+

+Arguments:

+

+  This                  - Calling context

+  Address               - Output buffer containing the address.

+

+Returns:

+

+Returns:

+  EFI_SUCCESS           - Successfully returns

+

+--*/

+{

+  EFI_FW_VOL_BLOCK_DEVICE *FvbDevice;

+

+  FvbDevice = FVB_DEVICE_FROM_THIS (This);

+

+  return FvbGetPhysicalAddress (FvbDevice->Instance, Address, mFvbModuleGlobal, EfiGoneVirtual ());

+}

+

+EFI_STATUS

+EFIAPI

+FvbProtocolGetBlockSize (

+  IN CONST EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL           *This,

+  IN CONST EFI_LBA                                     Lba,

+  OUT UINTN                                       *BlockSize,

+  OUT UINTN                                       *NumOfBlocks

+  )

+/*++

+

+Routine Description:

+  Retrieve the size of a logical block

+

+Arguments:

+  This                  - Calling context

+  Lba                   - Indicates which block to return the size for.

+  BlockSize             - A pointer to a caller allocated UINTN in which

+                          the size of the block is returned

+  NumOfBlocks           - a pointer to a caller allocated UINTN in which the

+                          number of consecutive blocks starting with Lba is

+                          returned. All blocks in this range have a size of

+                          BlockSize

+

+Returns:

+  EFI_SUCCESS           - The firmware volume was read successfully and

+                          contents are in Buffer

+

+--*/

+{

+  EFI_FW_VOL_BLOCK_DEVICE *FvbDevice;

+

+  FvbDevice = FVB_DEVICE_FROM_THIS (This);

+

+  return FvbGetLbaAddress (

+          FvbDevice->Instance,

+          Lba,

+          NULL,

+          BlockSize,

+          NumOfBlocks,

+          mFvbModuleGlobal,

+          EfiGoneVirtual ()

+          );

+}

+

+EFI_STATUS

+EFIAPI

+FvbProtocolGetAttributes (

+  IN CONST EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL           *This,

+  OUT EFI_FVB_ATTRIBUTES_2                              *Attributes

+  )

+/*++

+

+Routine Description:

+    Retrieves Volume attributes.  No polarity translations are done.

+

+Arguments:

+    This                - Calling context

+    Attributes          - output buffer which contains attributes

+

+Returns:

+  EFI_SUCCESS           - Successfully returns

+

+--*/

+{

+  EFI_FW_VOL_BLOCK_DEVICE *FvbDevice;

+

+  FvbDevice = FVB_DEVICE_FROM_THIS (This);

+

+  return FvbGetVolumeAttributes (FvbDevice->Instance, Attributes, mFvbModuleGlobal, EfiGoneVirtual ());

+}

+

+EFI_STATUS

+EFIAPI

+FvbProtocolSetAttributes (

+  IN CONST EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL           *This,

+  IN OUT EFI_FVB_ATTRIBUTES_2                           *Attributes

+  )

+/*++

+

+Routine Description:

+  Sets Volume attributes. No polarity translations are done.

+

+Arguments:

+  This                  - Calling context

+  Attributes            - output buffer which contains attributes

+

+Returns:

+  EFI_SUCCESS           - Successfully returns

+

+--*/

+{

+  EFI_FW_VOL_BLOCK_DEVICE *FvbDevice;

+

+  FvbDevice = FVB_DEVICE_FROM_THIS (This);

+

+  return FvbSetVolumeAttributes (FvbDevice->Instance, Attributes, mFvbModuleGlobal, EfiGoneVirtual ());

+}

+

+EFI_STATUS

+EFIAPI

+FvbProtocolEraseBlocks (

+  IN CONST EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL    *This,

+  ...

+  )

+/*++

+

+Routine Description:

+

+  The EraseBlock() function erases one or more blocks as denoted by the

+  variable argument list. The entire parameter list of blocks must be verified

+  prior to erasing any blocks.  If a block is requested that does not exist

+  within the associated firmware volume (it has a larger index than the last

+  block of the firmware volume), the EraseBlock() function must return

+  EFI_INVALID_PARAMETER without modifying the contents of the firmware volume.

+

+Arguments:

+  This                  - Calling context

+  ...                   - Starting LBA followed by Number of Lba to erase.

+                          a -1 to terminate the list.

+

+Returns:

+  EFI_SUCCESS           - The erase request was successfully completed

+  EFI_ACCESS_DENIED     - The firmware volume is in the WriteDisabled state

+  EFI_DEVICE_ERROR      - The block device is not functioning correctly and

+                          could not be written. Firmware device may have been

+                          partially erased

+

+--*/

+{

+  EFI_FW_VOL_BLOCK_DEVICE *FvbDevice;

+  EFI_FW_VOL_INSTANCE     *FwhInstance;

+  UINTN                   NumOfBlocks;

+  VA_LIST                 args;

+  EFI_LBA                 StartingLba;

+  UINTN                   NumOfLba;

+  EFI_STATUS              Status;

+

+  FvbDevice = FVB_DEVICE_FROM_THIS (This);

+

+  Status    = GetFvbInstance (FvbDevice->Instance, mFvbModuleGlobal, &FwhInstance, EfiGoneVirtual ());

+  ASSERT_EFI_ERROR (Status);

+

+  NumOfBlocks = FwhInstance->NumOfBlocks;

+

+  VA_START (args, This);

+

+  do {

+    StartingLba = VA_ARG (args, EFI_LBA);

+    if (StartingLba == EFI_LBA_LIST_TERMINATOR) {

+      break;

+    }

+

+    NumOfLba = VA_ARG (args, UINT32);

+

+    //

+    // Check input parameters

+    //

+    if ((NumOfLba == 0) || ((StartingLba + NumOfLba) > NumOfBlocks)) {

+      VA_END (args);

+      return EFI_INVALID_PARAMETER;

+    }

+  } while (1);

+

+  VA_END (args);

+

+  VA_START (args, This);

+  do {

+    StartingLba = VA_ARG (args, EFI_LBA);

+    if (StartingLba == EFI_LBA_LIST_TERMINATOR) {

+      break;

+    }

+

+    NumOfLba = VA_ARG (args, UINT32);

+

+    while (NumOfLba > 0) {

+      Status = QemuFlashEraseBlock (StartingLba);

+      if (EFI_ERROR (Status)) {

+        VA_END (args);

+        return Status;

+      }

+

+      StartingLba++;

+      NumOfLba--;

+    }

+

+  } while (1);

+

+  VA_END (args);

+

+  return EFI_SUCCESS;

+}

+

+EFI_STATUS

+EFIAPI

+FvbProtocolWrite (

+  IN CONST EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL           *This,

+  IN       EFI_LBA                                      Lba,

+  IN       UINTN                                        Offset,

+  IN OUT   UINTN                                    *NumBytes,

+  IN       UINT8                                        *Buffer

+  )

+/*++

+

+Routine Description:

+

+  Writes data beginning at Lba:Offset from FV. The write terminates either

+  when *NumBytes of data have been written, or when a block boundary is

+  reached.  *NumBytes is updated to reflect the actual number of bytes

+  written. The write opertion does not include erase. This routine will

+  attempt to write only the specified bytes. If the writes do not stick,

+  it will return an error.

+

+Arguments:

+  This                  - Calling context

+  Lba                   - Block in which to begin write

+  Offset                - Offset in the block at which to begin write

+  NumBytes              - On input, indicates the requested write size. On

+                          output, indicates the actual number of bytes written

+  Buffer                - Buffer containing source data for the write.

+

+Returns:

+  EFI_SUCCESS           - The firmware volume was written successfully

+  EFI_BAD_BUFFER_SIZE   - Write attempted across a LBA boundary. On output,

+                          NumBytes contains the total number of bytes

+                          actually written

+  EFI_ACCESS_DENIED     - The firmware volume is in the WriteDisabled state

+  EFI_DEVICE_ERROR      - The block device is not functioning correctly and

+                          could not be written

+  EFI_INVALID_PARAMETER - NumBytes or Buffer are NULL

+

+--*/

+{

+  return QemuFlashWrite ((EFI_LBA)Lba, (UINTN)Offset, NumBytes, (UINT8 *)Buffer);

+}

+

+EFI_STATUS

+EFIAPI

+FvbProtocolRead (

+  IN CONST EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL           *This,

+  IN CONST EFI_LBA                                      Lba,

+  IN CONST UINTN                                        Offset,

+  IN OUT UINTN                                    *NumBytes,

+  IN UINT8                                        *Buffer

+  )

+/*++

+

+Routine Description:

+

+  Reads data beginning at Lba:Offset from FV. The Read terminates either

+  when *NumBytes of data have been read, or when a block boundary is

+  reached.  *NumBytes is updated to reflect the actual number of bytes

+  written. The write opertion does not include erase. This routine will

+  attempt to write only the specified bytes. If the writes do not stick,

+  it will return an error.

+

+Arguments:

+  This                  - Calling context

+  Lba                   - Block in which to begin Read

+  Offset                - Offset in the block at which to begin Read

+  NumBytes              - On input, indicates the requested write size. On

+                          output, indicates the actual number of bytes Read

+  Buffer                - Buffer containing source data for the Read.

+

+Returns:

+  EFI_SUCCESS           - The firmware volume was read successfully and

+                          contents are in Buffer

+  EFI_BAD_BUFFER_SIZE   - Read attempted across a LBA boundary. On output,

+                          NumBytes contains the total number of bytes returned

+                          in Buffer

+  EFI_ACCESS_DENIED     - The firmware volume is in the ReadDisabled state

+  EFI_DEVICE_ERROR      - The block device is not functioning correctly and

+                          could not be read

+  EFI_INVALID_PARAMETER - NumBytes or Buffer are NULL

+

+--*/

+{

+  return QemuFlashRead ((EFI_LBA)Lba, (UINTN)Offset, NumBytes, (UINT8 *)Buffer);

+}

+

+EFI_STATUS

+ValidateFvHeader (

+  EFI_FIRMWARE_VOLUME_HEADER            *FwVolHeader

+  )

+/*++

+

+Routine Description:

+  Check the integrity of firmware volume header

+

+Arguments:

+  FwVolHeader           - A pointer to a firmware volume header

+

+Returns:

+  EFI_SUCCESS           - The firmware volume is consistent

+  EFI_NOT_FOUND         - The firmware volume has corrupted. So it is not an FV

+

+--*/

+{

+  UINT16 Checksum;

+

+  //

+  // Verify the header revision, header signature, length

+  // Length of FvBlock cannot be 2**64-1

+  // HeaderLength cannot be an odd number

+  //

+  if ((FwVolHeader->Revision != EFI_FVH_REVISION) ||

+      (FwVolHeader->Signature != EFI_FVH_SIGNATURE) ||

+      (FwVolHeader->FvLength == ((UINTN) -1)) ||

+      ((FwVolHeader->HeaderLength & 0x01) != 0)

+      ) {

+    return EFI_NOT_FOUND;

+  }

+  

+  //

+  // Verify the header checksum

+  //

+

+  Checksum = CalculateSum16 ((UINT16 *) FwVolHeader, FwVolHeader->HeaderLength);

+  if (Checksum != 0) {

+    UINT16 Expected;

+

+    Expected = ((UINTN) FwVolHeader->Checksum + 0x10000 - Checksum) & 0xffff;

+

+    DEBUG ((EFI_D_INFO, "FV@%p Checksum is 0x%x, expected 0x%x\n",

+            FwVolHeader, FwVolHeader->Checksum, Expected));

+    return EFI_NOT_FOUND;

+  }

+

+  return EFI_SUCCESS;

+}

+

+STATIC

+EFI_STATUS

+MarkMemoryRangeForRuntimeAccess (

+  EFI_PHYSICAL_ADDRESS                BaseAddress,

+  UINT64                              Length

+  )

+{

+  EFI_STATUS                          Status;

+

+  //

+  // Mark flash region as runtime memory

+  //

+  Status = gDS->RemoveMemorySpace (

+                  BaseAddress,

+                  Length

+                  );

+

+  Status = gDS->AddMemorySpace (

+                  EfiGcdMemoryTypeSystemMemory,

+                  BaseAddress,

+                  Length,

+                  EFI_MEMORY_UC | EFI_MEMORY_RUNTIME

+                  );

+  ASSERT_EFI_ERROR (Status);

+

+  Status = gBS->AllocatePages (

+                  AllocateAddress,

+                  EfiRuntimeServicesData,

+                  (UINTN) EFI_SIZE_TO_PAGES (Length),

+                  &BaseAddress

+                  );

+  ASSERT_EFI_ERROR (Status);

+

+  return Status;

+}

+

+STATIC

+EFI_STATUS

+InitializeVariableFvHeader (

+  VOID

+  )

+{

+  EFI_STATUS                          Status;

+  EFI_FIRMWARE_VOLUME_HEADER          *GoodFwVolHeader;

+  EFI_FIRMWARE_VOLUME_HEADER          *FwVolHeader;

+  UINTN                               Length;

+  UINTN                               WriteLength;

+  UINTN                               BlockSize;

+

+  FwVolHeader =

+    (EFI_FIRMWARE_VOLUME_HEADER *) (UINTN)

+      PcdGet32 (PcdOvmfFlashNvStorageVariableBase);

+

+  Length = 

+    (FixedPcdGet32 (PcdFlashNvStorageVariableSize) +

+     FixedPcdGet32 (PcdFlashNvStorageFtwWorkingSize) +

+     FixedPcdGet32 (PcdFlashNvStorageFtwSpareSize) +

+     FixedPcdGet32 (PcdOvmfFlashNvStorageEventLogSize));

+

+  BlockSize = PcdGet32 (PcdOvmfFirmwareBlockSize);

+

+  Status      = ValidateFvHeader (FwVolHeader);

+  if (!EFI_ERROR (Status)) {

+    if (FwVolHeader->FvLength != Length ||

+        FwVolHeader->BlockMap[0].Length != BlockSize) {

+      Status = EFI_VOLUME_CORRUPTED;

+    }

+  }

+  if (EFI_ERROR (Status)) {

+    UINTN   Offset;

+    UINTN   Start;

+

+    DEBUG ((EFI_D_INFO, "Variable FV header is not valid. It will be reinitialized.\n"));

+

+    //

+    // Get FvbInfo to provide in FwhInstance.

+    //

+    Status = GetFvbInfo (Length, &GoodFwVolHeader);

+    ASSERT (!EFI_ERROR (Status));

+

+    Start = (UINTN)(UINT8*) FwVolHeader - PcdGet32 (PcdOvmfFdBaseAddress);

+    ASSERT (Start % BlockSize == 0 && Length % BlockSize == 0);

+    ASSERT (GoodFwVolHeader->HeaderLength <= BlockSize);

+

+    //

+    // Erase all the blocks

+    //

+    for (Offset = Start; Offset < Start + Length; Offset += BlockSize) {

+      Status = QemuFlashEraseBlock ((EFI_LBA) Offset / BlockSize);

+      ASSERT_EFI_ERROR (Status);

+    }

+

+    //

+    // Write good FV header

+    //

+    WriteLength = GoodFwVolHeader->HeaderLength;

+    Status = QemuFlashWrite (

+               (EFI_LBA) Start / BlockSize,

+               0,

+               &WriteLength,

+               (UINT8 *) GoodFwVolHeader);

+    ASSERT_EFI_ERROR (Status);

+    ASSERT (WriteLength == GoodFwVolHeader->HeaderLength);

+  }

+

+  return Status;

+}

+

+EFI_STATUS

+EFIAPI

+FvbInitialize (

+  IN EFI_HANDLE         ImageHandle,

+  IN EFI_SYSTEM_TABLE   *SystemTable

+  )

+/*++

+

+Routine Description:

+  This function does common initialization for FVB services

+

+Arguments:

+

+Returns:

+

+--*/

+{

+  EFI_STATUS                          Status;

+  EFI_FW_VOL_INSTANCE                 *FwhInstance;

+  EFI_FIRMWARE_VOLUME_HEADER          *FwVolHeader;

+  UINT32                              BufferSize;

+  EFI_FV_BLOCK_MAP_ENTRY              *PtrBlockMapEntry;

+  EFI_HANDLE                          FwbHandle;

+  EFI_FW_VOL_BLOCK_DEVICE             *FvbDevice;

+  EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL  *OldFwbInterface;

+  UINT32                              MaxLbaSize;

+  EFI_PHYSICAL_ADDRESS                BaseAddress;

+  UINT64                              Length;

+  UINTN                               NumOfBlocks;

+  EFI_EVENT                           VirtualAddressChangeEvent;

+

+  if (EFI_ERROR (QemuFlashInitialize ())) {

+    //

+    // Return an error so image will be unloaded

+    //

+    DEBUG ((EFI_D_INFO, "QEMU flash was not detected. Writable FVB is not being installed.\n"));

+    return EFI_WRITE_PROTECTED;

+  }

+

+  //

+  // Allocate runtime services data for global variable, which contains

+  // the private data of all firmware volume block instances

+  //

+  mFvbModuleGlobal = AllocateRuntimePool (sizeof (ESAL_FWB_GLOBAL));

+  ASSERT (mFvbModuleGlobal != NULL);

+

+  BaseAddress = (UINTN) PcdGet32 (PcdOvmfFdBaseAddress);

+  Length = PcdGet32 (PcdOvmfFirmwareFdSize);

+

+  Status = InitializeVariableFvHeader ();

+  if (EFI_ERROR (Status)) {

+    DEBUG ((EFI_D_INFO, "QEMU Flash: Unable to initialize variable FV header\n"));

+    return EFI_WRITE_PROTECTED;

+  }

+

+  FwVolHeader = (EFI_FIRMWARE_VOLUME_HEADER *) (UINTN) BaseAddress;

+  Status      = ValidateFvHeader (FwVolHeader);

+  if (EFI_ERROR (Status)) {

+    //

+    // Get FvbInfo

+    //

+    Status = GetFvbInfo (Length, &FwVolHeader);

+    if (EFI_ERROR (Status)) {

+      DEBUG ((EFI_D_INFO, "EFI_ERROR (GetFvbInfo (Length, &FwVolHeader))\n"));

+      return EFI_WRITE_PROTECTED;

+    }

+  }

+

+  BufferSize = (sizeof (EFI_FW_VOL_INSTANCE) + FwVolHeader->HeaderLength - sizeof (EFI_FIRMWARE_VOLUME_HEADER));

+

+  //

+  // Only need to allocate once. There is only one copy of physical memory for

+  // the private data of each FV instance. But in virtual mode or in physical

+  // mode, the address of the the physical memory may be different.

+  //

+  mFvbModuleGlobal->FvInstance[FVB_PHYSICAL] = AllocateRuntimePool (BufferSize);

+  ASSERT (mFvbModuleGlobal->FvInstance[FVB_PHYSICAL] != NULL);

+

+  //

+  // Make a virtual copy of the FvInstance pointer.

+  //

+  FwhInstance = mFvbModuleGlobal->FvInstance[FVB_PHYSICAL];

+  mFvbModuleGlobal->FvInstance[FVB_VIRTUAL] = FwhInstance;

+

+  mFvbModuleGlobal->NumFv                   = 0;

+  MaxLbaSize = 0;

+

+  FwVolHeader =

+    (EFI_FIRMWARE_VOLUME_HEADER *) (UINTN)

+      PcdGet32 (PcdOvmfFlashNvStorageVariableBase);

+

+  FwhInstance->FvBase[FVB_PHYSICAL] = (UINTN) BaseAddress;

+  FwhInstance->FvBase[FVB_VIRTUAL]  = (UINTN) BaseAddress;

+

+  CopyMem ((UINTN *) &(FwhInstance->VolumeHeader), (UINTN *) FwVolHeader, FwVolHeader->HeaderLength);

+  FwVolHeader = &(FwhInstance->VolumeHeader);

+  EfiInitializeLock (&(FwhInstance->FvbDevLock), TPL_HIGH_LEVEL);

+

+  NumOfBlocks = 0;

+

+  for (PtrBlockMapEntry = FwVolHeader->BlockMap; PtrBlockMapEntry->NumBlocks != 0; PtrBlockMapEntry++) {

+    //

+    // Get the maximum size of a block.

+    //

+    if (MaxLbaSize < PtrBlockMapEntry->Length) {

+      MaxLbaSize = PtrBlockMapEntry->Length;

+    }

+

+    NumOfBlocks = NumOfBlocks + PtrBlockMapEntry->NumBlocks;

+  }

+

+  //

+  // The total number of blocks in the FV.

+  //

+  FwhInstance->NumOfBlocks = NumOfBlocks;

+

+  //

+  // Add a FVB Protocol Instance

+  //

+  FvbDevice = AllocateRuntimePool (sizeof (EFI_FW_VOL_BLOCK_DEVICE));

+  ASSERT (FvbDevice != NULL);

+

+  CopyMem (FvbDevice, &mFvbDeviceTemplate, sizeof (EFI_FW_VOL_BLOCK_DEVICE));

+

+  FvbDevice->Instance = mFvbModuleGlobal->NumFv;

+  mFvbModuleGlobal->NumFv++;

+

+  //

+  // 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 *) AllocateCopyPool (sizeof (FV_MEMMAP_DEVICE_PATH), &mFvMemmapDevicePathTemplate);

+    ((FV_MEMMAP_DEVICE_PATH *) FvbDevice->DevicePath)->MemMapDevPath.StartingAddress = BaseAddress;

+    ((FV_MEMMAP_DEVICE_PATH *) FvbDevice->DevicePath)->MemMapDevPath.EndingAddress   = BaseAddress + FwVolHeader->FvLength - 1;

+  } else {

+    FvbDevice->DevicePath = (EFI_DEVICE_PATH_PROTOCOL *) AllocateCopyPool (sizeof (FV_PIWG_DEVICE_PATH), &mFvPIWGDevicePathTemplate);

+    CopyGuid (

+      &((FV_PIWG_DEVICE_PATH *)FvbDevice->DevicePath)->FvDevPath.FvName, 

+      (GUID *)(UINTN)(BaseAddress + 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

+    //

+    FwbHandle = NULL;

+    DEBUG ((EFI_D_INFO, "Installing QEMU flash FVB\n"));

+    Status = gBS->InstallMultipleProtocolInterfaces (

+                    &FwbHandle,

+                    &gEfiFirmwareVolumeBlockProtocolGuid,

+                    &FvbDevice->FwVolBlockInstance,

+                    &gEfiDevicePathProtocolGuid,

+                    FvbDevice->DevicePath,

+                    NULL

+                    );

+    ASSERT_EFI_ERROR (Status);

+  } else if (IsDevicePathEnd (FvbDevice->DevicePath)) {

+    //

+    // Device already exists, so reinstall the FVB protocol

+    //

+    Status = gBS->HandleProtocol (

+                    FwbHandle,

+                    &gEfiFirmwareVolumeBlockProtocolGuid,

+                    (VOID**)&OldFwbInterface

+                    );

+    ASSERT_EFI_ERROR (Status);

+

+    DEBUG ((EFI_D_INFO, "Reinstalling FVB for QEMU flash region\n"));

+    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);

+  }

+

+  MarkMemoryRangeForRuntimeAccess (BaseAddress, Length);

+

+  //

+  // Set several PCD values to point to flash

+  //

+  PcdSet64 (

+    PcdFlashNvStorageVariableBase64,

+    (UINTN) PcdGet32 (PcdOvmfFlashNvStorageVariableBase)

+    );

+  PcdSet32 (

+    PcdFlashNvStorageFtwWorkingBase,

+    PcdGet32 (PcdOvmfFlashNvStorageFtwWorkingBase)

+    );

+  PcdSet32 (

+    PcdFlashNvStorageFtwSpareBase,

+    PcdGet32 (PcdOvmfFlashNvStorageFtwSpareBase)

+    );

+

+  FwhInstance = (EFI_FW_VOL_INSTANCE *)

+    (

+      (UINTN) ((UINT8 *) FwhInstance) + FwVolHeader->HeaderLength +

+      (sizeof (EFI_FW_VOL_INSTANCE) - sizeof (EFI_FIRMWARE_VOLUME_HEADER))

+    );

+

+  VirtualAddressChangeEvent = NULL;

+  Status = gBS->CreateEventEx (

+                  EVT_NOTIFY_SIGNAL,

+                  TPL_NOTIFY,

+                  FvbVirtualddressChangeEvent,

+                  NULL,

+                  &gEfiEventVirtualAddressChangeGuid,

+                  &VirtualAddressChangeEvent

+                  );

+  ASSERT_EFI_ERROR (Status);

+

+  return EFI_SUCCESS;

+}

diff --git a/OvmfPkg/QemuFlashFvbServicesRuntimeDxe/FwBlockService.h b/OvmfPkg/QemuFlashFvbServicesRuntimeDxe/FwBlockService.h
new file mode 100644
index 0000000000..06a092d900
--- /dev/null
+++ b/OvmfPkg/QemuFlashFvbServicesRuntimeDxe/FwBlockService.h
@@ -0,0 +1,184 @@
+/**@file

+

+Copyright (c) 2006, Intel Corporation. All rights reserved.<BR>

+This program and the accompanying materials                          

+are licensed and made available under the terms and conditions of the BSD License         

+which accompanies this distribution.  The full text of the license may be found at        

+http://opensource.org/licenses/bsd-license.php                                            

+                                                                                          

+THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     

+WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             

+

+Module Name:

+

+  FwBlockService.h

+  

+Abstract:

+

+  Firmware volume block driver for Intel Firmware Hub (FWH) device

+

+**/

+

+#ifndef _FW_BLOCK_SERVICE_H

+#define _FW_BLOCK_SERVICE_H

+

+//

+// BugBug: Add documentation here for data structure!!!!

+//

+#define FVB_PHYSICAL  0

+#define FVB_VIRTUAL   1

+

+typedef struct {

+  EFI_LOCK                    FvbDevLock;

+  UINTN                       FvBase[2];

+  UINTN                       NumOfBlocks;

+  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            SIGNATURE_32 ('F', 'V', 'B', 'N')

+

+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;

+  UINTN                               Instance;

+  EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL  FwVolBlockInstance;

+} EFI_FW_VOL_BLOCK_DEVICE;

+

+EFI_STATUS

+GetFvbInfo (

+  IN  UINT64                            FvLength,

+  OUT EFI_FIRMWARE_VOLUME_HEADER        **FvbInfo

+  );

+

+EFI_STATUS

+FvbSetVolumeAttributes (

+  IN UINTN                                Instance,

+  IN OUT EFI_FVB_ATTRIBUTES_2             *Attributes,

+  IN ESAL_FWB_GLOBAL                      *Global,

+  IN BOOLEAN                              Virtual

+  );

+

+EFI_STATUS

+FvbGetVolumeAttributes (

+  IN UINTN                                Instance,

+  OUT EFI_FVB_ATTRIBUTES_2                *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

+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

+  );

+

+//

+// 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 CONST EFI_LBA                                     Lba,

+  OUT UINTN                                       *BlockSize,

+  OUT UINTN                                       *NumOfBlocks

+  );

+

+EFI_STATUS

+EFIAPI

+FvbProtocolRead (

+  IN CONST EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL           *This,

+  IN CONST EFI_LBA                                      Lba,

+  IN CONST UINTN                                        Offset,

+  IN OUT UINTN                                    *NumBytes,

+  IN UINT8                                        *Buffer

+  );

+

+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,

+  ...

+  );

+

+#endif

diff --git a/OvmfPkg/QemuFlashFvbServicesRuntimeDxe/QemuFlash.c b/OvmfPkg/QemuFlashFvbServicesRuntimeDxe/QemuFlash.c
new file mode 100644
index 0000000000..a3fe7d8741
--- /dev/null
+++ b/OvmfPkg/QemuFlashFvbServicesRuntimeDxe/QemuFlash.c
@@ -0,0 +1,265 @@
+/** @file

+  OVMF support for QEMU system firmware flash device

+

+  Copyright (c) 2009 - 2013, Intel Corporation. All rights reserved.<BR>

+  This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+**/

+

+#include "PiDxe.h"

+#include <Library/DebugLib.h>

+#include <Library/BaseMemoryLib.h>

+#include <Library/PcdLib.h>

+#include <Library/UefiBootServicesTableLib.h>

+#include <Library/UefiRuntimeLib.h>

+#include <Guid/EventGroup.h>

+

+#include "QemuFlash.h"

+

+#define WRITE_BYTE_CMD           0x10

+#define BLOCK_ERASE_CMD          0x20

+#define CLEAR_STATUS_CMD         0x50

+#define READ_STATUS_CMD          0x70

+#define READ_DEVID_CMD           0x90

+#define BLOCK_ERASE_CONFIRM_CMD  0xd0

+#define READ_ARRAY_CMD           0xff

+

+#define CLEARED_ARRAY_STATUS  0x00

+

+

+STATIC UINT8       *mFlashBase = NULL;

+STATIC UINTN       mFdBlockSize = 0;

+STATIC UINTN       mFdBlockCount = 0;

+

+

+VOID

+QemuFlashConvertPointers (

+  VOID

+  )

+{

+  EfiConvertPointer (0x0, (VOID **) &mFlashBase);

+}

+

+

+STATIC

+volatile UINT8*

+QemuFlashPtr (

+  IN        EFI_LBA                             Lba,

+  IN        UINTN                               Offset

+  )

+{

+  return mFlashBase + (Lba * mFdBlockSize) + Offset;

+}

+

+

+/**

+  Determines if the QEMU flash memory device is present.

+

+  @retval FALSE   The QEMU flash device is not present.

+  @retval TRUE    The QEMU flash device is present.

+

+**/

+STATIC

+BOOLEAN

+QemuFlashDetected (

+  VOID

+  )

+{

+  BOOLEAN  FlashDetected;

+  volatile UINT8  *Ptr;

+

+  UINTN Offset;

+  UINT8 OriginalUint8;

+  UINT8 ProbeUint8;

+

+  FlashDetected = FALSE;

+  Ptr = QemuFlashPtr (0, 0);

+

+  for (Offset = 0; Offset < mFdBlockSize; Offset++) {

+    Ptr = QemuFlashPtr (0, Offset);

+    ProbeUint8 = *Ptr;

+    if (ProbeUint8 != CLEAR_STATUS_CMD &&

+        ProbeUint8 != READ_STATUS_CMD &&

+        ProbeUint8 != CLEARED_ARRAY_STATUS) {

+      break;

+    }

+  }

+

+  if (Offset >= mFdBlockSize) {

+    DEBUG ((EFI_D_INFO, "QEMU Flash: Failed to find probe location\n"));

+    return FALSE;

+  }

+

+  DEBUG ((EFI_D_INFO, "QEMU Flash: Attempting flash detection at %p\n", Ptr));

+

+  OriginalUint8 = *Ptr;

+  *Ptr = CLEAR_STATUS_CMD;

+  ProbeUint8 = *Ptr;

+  if (OriginalUint8 != CLEAR_STATUS_CMD &&

+      ProbeUint8 == CLEAR_STATUS_CMD) {

+    DEBUG ((EFI_D_INFO, "QemuFlashDetected => FD behaves as RAM\n"));

+    *Ptr = OriginalUint8;

+  } else {

+    *Ptr = READ_STATUS_CMD;

+    ProbeUint8 = *Ptr;

+    if (ProbeUint8 == OriginalUint8) {

+      DEBUG ((EFI_D_INFO, "QemuFlashDetected => FD behaves as ROM\n"));

+    } else if (ProbeUint8 == READ_STATUS_CMD) {

+      DEBUG ((EFI_D_INFO, "QemuFlashDetected => FD behaves as RAM\n"));

+      *Ptr = OriginalUint8;

+    } else if (ProbeUint8 == CLEARED_ARRAY_STATUS) {

+      DEBUG ((EFI_D_INFO, "QemuFlashDetected => FD behaves as FLASH\n"));

+      FlashDetected = TRUE;

+      *Ptr = READ_ARRAY_CMD;

+    }

+  }

+

+  DEBUG ((EFI_D_INFO, "QemuFlashDetected => %a\n",

+                      FlashDetected ? "Yes" : "No"));

+  return FlashDetected;

+}

+

+

+/**

+  Read from QEMU Flash

+

+  @param[in] Lba      The starting logical block index to read from.

+  @param[in] Offset   Offset into the block at which to begin reading.

+  @param[in] NumBytes On input, indicates the requested read size. On

+                      output, indicates the actual number of bytes read

+  @param[in] Buffer   Pointer to the buffer to read into.

+

+**/

+EFI_STATUS

+QemuFlashRead (

+  IN        EFI_LBA                              Lba,

+  IN        UINTN                                Offset,

+  IN        UINTN                                *NumBytes,

+  IN        UINT8                                *Buffer

+  )

+{

+  UINT8  *Ptr;

+

+  //

+  // Only write to the first 64k. We don't bother saving the FTW Spare

+  // block into the flash memory.

+  //

+  if (Lba >= mFdBlockCount) {

+    return EFI_INVALID_PARAMETER;

+  }

+

+  //

+  // Get flash address

+  //

+  Ptr = (UINT8*) QemuFlashPtr (Lba, Offset);

+

+  CopyMem (Buffer, Ptr, *NumBytes);

+

+  return EFI_SUCCESS;

+}

+

+

+/**

+  Write to QEMU Flash

+

+  @param[in] Lba      The starting logical block index to write to.

+  @param[in] Offset   Offset into the block at which to begin writing.

+  @param[in] NumBytes On input, indicates the requested write size. On

+                      output, indicates the actual number of bytes written

+  @param[in] Buffer   Pointer to the data to write.

+

+**/

+EFI_STATUS

+QemuFlashWrite (

+  IN        EFI_LBA                             Lba,

+  IN        UINTN                               Offset,

+  IN        UINTN                               *NumBytes,

+  IN        UINT8                               *Buffer

+  )

+{

+  volatile UINT8  *Ptr;

+  UINTN           Loop;

+

+  //

+  // Only write to the first 64k. We don't bother saving the FTW Spare

+  // block into the flash memory.

+  //

+  if (Lba >= mFdBlockCount) {

+    return EFI_INVALID_PARAMETER;

+  }

+

+  //

+  // Program flash

+  //

+  Ptr = QemuFlashPtr (Lba, Offset);

+  for (Loop = 0; Loop < *NumBytes; Loop++) {

+    *Ptr = WRITE_BYTE_CMD;

+    *Ptr = Buffer[Loop];

+    Ptr++;

+  }

+

+  //

+  // Restore flash to read mode

+  //

+  if (*NumBytes > 0) {

+    *Ptr = READ_ARRAY_CMD;

+  }

+

+  return EFI_SUCCESS;

+}

+

+

+/**

+  Erase a QEMU Flash block

+

+  @param Lba    The logical block index to erase.

+

+**/

+EFI_STATUS

+QemuFlashEraseBlock (

+  IN   EFI_LBA      Lba

+  )

+{

+  volatile UINT8  *Ptr;

+

+  if (Lba >= mFdBlockCount) {

+    return EFI_INVALID_PARAMETER;

+  }

+

+  Ptr = QemuFlashPtr (Lba, 0);

+  *Ptr = BLOCK_ERASE_CMD;

+  *Ptr = BLOCK_ERASE_CONFIRM_CMD;

+  return EFI_SUCCESS;

+}

+

+

+/**

+  Initializes QEMU flash memory support

+

+  @retval EFI_WRITE_PROTECTED   The QEMU flash device is not present.

+  @retval EFI_SUCCESS           The QEMU flash device is supported.

+

+**/

+EFI_STATUS

+QemuFlashInitialize (

+  VOID

+  )

+{

+  mFlashBase = (UINT8*)(UINTN) PcdGet32 (PcdOvmfFdBaseAddress);

+  mFdBlockSize = PcdGet32 (PcdOvmfFirmwareBlockSize);

+  ASSERT(PcdGet32 (PcdOvmfFirmwareFdSize) % mFdBlockSize == 0);

+  mFdBlockCount = PcdGet32 (PcdOvmfFirmwareFdSize) / mFdBlockSize;

+

+  if (!QemuFlashDetected ()) {

+    return EFI_WRITE_PROTECTED;

+  }

+

+  return EFI_SUCCESS;

+}

+

diff --git a/OvmfPkg/QemuFlashFvbServicesRuntimeDxe/QemuFlash.h b/OvmfPkg/QemuFlashFvbServicesRuntimeDxe/QemuFlash.h
new file mode 100644
index 0000000000..f77e880783
--- /dev/null
+++ b/OvmfPkg/QemuFlashFvbServicesRuntimeDxe/QemuFlash.h
@@ -0,0 +1,89 @@
+/** @file

+  OVMF support for QEMU system firmware flash device

+

+  Copyright (c) 2009 - 2013, Intel Corporation. All rights reserved.<BR>

+  This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+**/

+

+#ifndef __QEMU_FLASH_H__

+#define __QEMU_FLASH_H__

+

+#include <Protocol/FirmwareVolumeBlock.h>

+

+/**

+  Read from QEMU Flash

+

+  @param[in] Lba      The starting logical block index to read from.

+  @param[in] Offset   Offset into the block at which to begin reading.

+  @param[in] NumBytes On input, indicates the requested read size. On

+                      output, indicates the actual number of bytes read

+  @param[in] Buffer   Pointer to the buffer to read into.

+

+**/

+EFI_STATUS

+QemuFlashRead (

+  IN        EFI_LBA                              Lba,

+  IN        UINTN                                Offset,

+  IN        UINTN                                *NumBytes,

+  IN        UINT8                                *Buffer

+  );

+

+

+/**

+  Write to QEMU Flash

+

+  @param[in] Lba      The starting logical block index to write to.

+  @param[in] Offset   Offset into the block at which to begin writing.

+  @param[in] NumBytes On input, indicates the requested write size. On

+                      output, indicates the actual number of bytes written

+  @param[in] Buffer   Pointer to the data to write.

+

+**/

+EFI_STATUS

+QemuFlashWrite (

+  IN        EFI_LBA                              Lba,

+  IN        UINTN                                Offset,

+  IN        UINTN                                *NumBytes,

+  IN        UINT8                                *Buffer

+  );

+

+

+/**

+  Erase a QEMU Flash block

+

+  @param Lba    The logical block index to erase.

+

+**/

+EFI_STATUS

+QemuFlashEraseBlock (

+  IN   EFI_LBA      Lba

+  );

+

+

+/**

+  Initializes QEMU flash memory support

+

+  @retval EFI_WRITE_PROTECTED   The QEMU flash device is not present.

+  @retval EFI_SUCCESS           The QEMU flash device is supported.

+

+**/

+EFI_STATUS

+QemuFlashInitialize (

+  VOID

+  );

+

+

+VOID

+QemuFlashConvertPointers (

+  VOID

+  );

+

+#endif

+