Remove core packages since we can get them from edk2 repository

Contributed-under: TianoCore Contribution Agreement 1.0

Signed-off-by: Guo Mang <mang.guo@intel.com>

6 files changed, 0 insertions, 1992 deletions

diff --git a/OvmfPkg/QemuFlashFvbServicesRuntimeDxe/FvbInfo.c b/OvmfPkg/QemuFlashFvbServicesRuntimeDxe/FvbInfo.c
deleted file mode 100644
index 62f9158773..0000000000
--- a/OvmfPkg/QemuFlashFvbServicesRuntimeDxe/FvbInfo.c
+++ /dev/null
@@ -1,141 +0,0 @@
-/**@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),

-        }

-      } // BlockMap[1]

-    },

-    {

-      {

-        0,

-        0

-      }

-    }  // End[1]

-  }

-};

-

-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
deleted file mode 100644
index e3e7176a41..0000000000
--- a/OvmfPkg/QemuFlashFvbServicesRuntimeDxe/FvbServicesRuntimeDxe.inf
+++ /dev/null
@@ -1,84 +0,0 @@
-## @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

-  gUefiOvmfPkgTokenSpaceGuid.PcdOvmfFlashVariablesEnable

-

-

-[Depex]

-  TRUE

diff --git a/OvmfPkg/QemuFlashFvbServicesRuntimeDxe/FwBlockService.c b/OvmfPkg/QemuFlashFvbServicesRuntimeDxe/FwBlockService.c
deleted file mode 100644
index 9160bb885b..0000000000
--- a/OvmfPkg/QemuFlashFvbServicesRuntimeDxe/FwBlockService.c
+++ /dev/null
@@ -1,1229 +0,0 @@
-/**@file

-

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

-This program and the accompanying materials

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

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

-

-  *FwhInstance = NULL;

-  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 =

-      (UINT16) (((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,

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

-                  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 (Offset / BlockSize);

-      ASSERT_EFI_ERROR (Status);

-    }

-

-    //

-    // Write good FV header

-    //

-    WriteLength = GoodFwVolHeader->HeaderLength;

-    Status = QemuFlashWrite (

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

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

-

-  PcdSetBool (PcdOvmfFlashVariablesEnable, TRUE);

-  return EFI_SUCCESS;

-}

diff --git a/OvmfPkg/QemuFlashFvbServicesRuntimeDxe/FwBlockService.h b/OvmfPkg/QemuFlashFvbServicesRuntimeDxe/FwBlockService.h
deleted file mode 100644
index 06a092d900..0000000000
--- a/OvmfPkg/QemuFlashFvbServicesRuntimeDxe/FwBlockService.h
+++ /dev/null
@@ -1,184 +0,0 @@
-/**@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
deleted file mode 100644
index a96e0e5275..0000000000
--- a/OvmfPkg/QemuFlashFvbServicesRuntimeDxe/QemuFlash.c
+++ /dev/null
@@ -1,265 +0,0 @@
-/** @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 + ((UINTN)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 - 1) = 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
deleted file mode 100644
index f77e880783..0000000000
--- a/OvmfPkg/QemuFlashFvbServicesRuntimeDxe/QemuFlash.h
+++ /dev/null
@@ -1,89 +0,0 @@
-/** @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

-