add ia32 and x64 direcotry for EdkFvbServiceLib
authorvanjeff <vanjeff@6f19259b-4bc3-4df7-8a09-765794883524>
Thu, 28 Jun 2007 11:55:39 +0000 (11:55 +0000)
committervanjeff <vanjeff@6f19259b-4bc3-4df7-8a09-765794883524>
Thu, 28 Jun 2007 11:55:39 +0000 (11:55 +0000)
updated module VariableRuntimeDxe

git-svn-id: https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2@2844 6f19259b-4bc3-4df7-8a09-765794883524

MdeModulePkg/Library/EdkFvbServiceLib/Ia32/Fvb.c [new file with mode: 0644]
MdeModulePkg/Library/EdkFvbServiceLib/X64/Fvb.c [new file with mode: 0644]
MdeModulePkg/MdeModulePkg.dsc
MdeModulePkg/Universal/VariableRuntimeDxe/Variable.c
MdeModulePkg/Universal/VariableRuntimeDxe/reclaim.c

diff --git a/MdeModulePkg/Library/EdkFvbServiceLib/Ia32/Fvb.c b/MdeModulePkg/Library/EdkFvbServiceLib/Ia32/Fvb.c
new file mode 100644 (file)
index 0000000..3ec0d6f
--- /dev/null
@@ -0,0 +1,610 @@
+/**@file\r
+\r
+  Firmware Volume Block Protocol Runtime Abstraction\r
+\r
+  mFvbEntry is an array of Handle Fvb pairs. The Fvb Lib Instance matches the\r
+  index in the mFvbEntry array. This should be the same sequence as the FVB's\r
+  were described in the HOB. We have to remember the handle so we can tell if\r
+  the protocol has been reinstalled and it needs updateing.\r
+\r
+  If you are using any of these lib functions.you must first call FvbInitialize ().\r
+\r
+Copyright (c) 2006, Intel Corporation\r
+All rights reserved. This program and the accompanying materials\r
+are licensed and made available under the terms and conditions of the BSD License\r
+which accompanies this distribution.  The full text of the license may be found at\r
+http://opensource.org/licenses/bsd-license.php\r
+\r
+THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
+WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
+\r
+**/\r
+\r
+\r
+#include "Fvb.h"\r
+\r
+//\r
+// Event for Exit Boot Services Callback\r
+//\r
+STATIC EFI_EVENT mExitBootServicesEvent = NULL;\r
+\r
+//\r
+// Lib will ASSERT if more FVB devices than this are added to the system.\r
+//\r
+STATIC FVB_ENTRY          *mFvbEntry;\r
+STATIC EFI_EVENT          mFvbRegistration;\r
+STATIC BOOLEAN            mEfiFvbInitialized        = FALSE;\r
+STATIC UINTN              mFvbCount;\r
+\r
+/**\r
+  Check whether an address is runtime memory or not.\r
+\r
+  @param    Address   The Address being checked.\r
+\r
+  @retval   TRUE      The address is runtime memory.\r
+  @retval   FALSE     The address is not runtime memory.\r
+**/\r
+BOOLEAN\r
+IsRuntimeMemory (\r
+  IN VOID   *Address\r
+  )\r
+{\r
+  EFI_STATUS                           Status;\r
+  UINT8                                TmpMemoryMap[1];\r
+  UINTN                                MapKey;\r
+  UINTN                                DescriptorSize;\r
+  UINT32                               DescriptorVersion;\r
+  UINTN                                MemoryMapSize;\r
+  EFI_MEMORY_DESCRIPTOR                *MemoryMap;\r
+  EFI_MEMORY_DESCRIPTOR                *MemoryMapPtr;\r
+  BOOLEAN                              IsRuntime;\r
+  UINTN                                Index;\r
+\r
+  IsRuntime = FALSE;\r
+\r
+  //\r
+  // Get System MemoryMapSize\r
+  //\r
+  MemoryMapSize = 1;\r
+  Status = gBS->GetMemoryMap (\r
+                  &MemoryMapSize,\r
+                  (EFI_MEMORY_DESCRIPTOR *)TmpMemoryMap,\r
+                  &MapKey,\r
+                  &DescriptorSize,\r
+                  &DescriptorVersion\r
+                  );\r
+  ASSERT (Status == EFI_BUFFER_TOO_SMALL);\r
+  //\r
+  // Enlarge space here, because we will allocate pool now.\r
+  //\r
+  MemoryMapSize += EFI_PAGE_SIZE;\r
+  Status = gBS->AllocatePool (\r
+                  EfiBootServicesData,\r
+                  MemoryMapSize,\r
+                  (VOID**)&MemoryMap\r
+                  );\r
+  ASSERT_EFI_ERROR (Status);\r
+\r
+  //\r
+  // Get System MemoryMap\r
+  //\r
+  Status = gBS->GetMemoryMap (\r
+                  &MemoryMapSize,\r
+                  MemoryMap,\r
+                  &MapKey,\r
+                  &DescriptorSize,\r
+                  &DescriptorVersion\r
+                  );\r
+  ASSERT_EFI_ERROR (Status);\r
+\r
+  MemoryMapPtr = MemoryMap;\r
+  //\r
+  // Search the request Address\r
+  //\r
+  for (Index = 0; Index < (MemoryMapSize / DescriptorSize); Index++) {\r
+    if (((EFI_PHYSICAL_ADDRESS)(UINTN)Address >= MemoryMap->PhysicalStart) &&\r
+        ((EFI_PHYSICAL_ADDRESS)(UINTN)Address < MemoryMap->PhysicalStart\r
+                                              + LShiftU64 (MemoryMap->NumberOfPages, EFI_PAGE_SHIFT))) {\r
+      //\r
+      // Found it\r
+      //\r
+      if (MemoryMap->Attribute & EFI_MEMORY_RUNTIME) {\r
+        IsRuntime = TRUE;\r
+      }\r
+      break;\r
+    }\r
+    //\r
+    // Get next item\r
+    //\r
+    MemoryMap = (EFI_MEMORY_DESCRIPTOR *)((UINTN)MemoryMap + DescriptorSize);\r
+  }\r
+\r
+  //\r
+  // Done\r
+  //\r
+  gBS->FreePool (MemoryMapPtr);\r
+\r
+  return IsRuntime;\r
+}\r
+\r
+/**\r
+  Update mFvbEntry. Add new entry, or update existing entry if Fvb protocol is\r
+  reinstalled.\r
+\r
+  @param Event      The Event that is being processed\r
+  @param Context    Event Context\r
+\r
+**/\r
+STATIC\r
+VOID\r
+EFIAPI\r
+FvbNotificationEvent (\r
+  IN  EFI_EVENT       Event,\r
+  IN  VOID            *Context\r
+  )\r
+{\r
+  EFI_STATUS  Status;\r
+  UINTN       BufferSize;\r
+  EFI_HANDLE  Handle;\r
+  UINTN       Index;\r
+  UINTN       UpdateIndex;\r
+\r
+  while (TRUE) {\r
+    BufferSize = sizeof (Handle);\r
+    Status = gBS->LocateHandle (\r
+                    ByRegisterNotify,\r
+                    &gEfiFirmwareVolumeBlockProtocolGuid,\r
+                    mFvbRegistration,\r
+                    &BufferSize,\r
+                    &Handle\r
+                    );\r
+    if (EFI_ERROR (Status)) {\r
+      //\r
+      // Exit Path of While Loop....\r
+      //\r
+      break;\r
+    }\r
+\r
+    UpdateIndex = MAX_FVB_COUNT;\r
+    for (Index = 0; Index < mFvbCount; Index++) {\r
+      if (mFvbEntry[Index].Handle == Handle) {\r
+        //\r
+        //  If the handle is already in the table just update the protocol\r
+        //\r
+        UpdateIndex = Index;\r
+        break;\r
+      }\r
+    }\r
+\r
+    if (UpdateIndex == MAX_FVB_COUNT) {\r
+      //\r
+      // Use the next free slot for a new entry\r
+      //\r
+      UpdateIndex                   = mFvbCount++;\r
+      //\r
+      // Check the UpdateIndex whether exceed the maximum value.\r
+      //\r
+      ASSERT (UpdateIndex < MAX_FVB_COUNT);\r
+      mFvbEntry[UpdateIndex].Handle = Handle;\r
+    }\r
+    //\r
+    // The array does not have enough entries\r
+    //\r
+    ASSERT (UpdateIndex < MAX_FVB_COUNT);\r
+\r
+    //\r
+    //  Get the interface pointer and if it's ours, skip it\r
+    //\r
+    Status = gBS->HandleProtocol (\r
+                    Handle,\r
+                    &gEfiFirmwareVolumeBlockProtocolGuid,\r
+                    (VOID **) &mFvbEntry[UpdateIndex].Fvb\r
+                    );\r
+    ASSERT_EFI_ERROR (Status);\r
+\r
+    Status = gBS->HandleProtocol (\r
+                    Handle,\r
+                    &gEfiFvbExtensionProtocolGuid,\r
+                    (VOID **) &mFvbEntry[UpdateIndex].FvbExtension\r
+                    );\r
+    if (Status != EFI_SUCCESS) {\r
+      mFvbEntry[UpdateIndex].FvbExtension = NULL;\r
+    }\r
+\r
+    //\r
+    // Check the FVB can be accessed in RUNTIME, The FVBs in FVB handle list comes\r
+    // from two way:\r
+    // 1) Dxe Core. (FVB information is transferred from FV HOB).\r
+    // 2) FVB driver.\r
+    // The FVB produced Dxe core is used for discoverying DXE driver and dispatch. These\r
+    // FVBs can only be accessed in boot time.\r
+    // FVB driver will discovery all FV in FLASH and these FVBs can be accessed in runtime.\r
+    // The FVB itself produced by FVB driver is allocated in runtime memory. So we can\r
+    // determine the what FVB can be accessed in RUNTIME by judging whether FVB itself is allocated\r
+    // in RUNTIME memory.\r
+    //\r
+    mFvbEntry[UpdateIndex].IsRuntimeAccess = IsRuntimeMemory (mFvbEntry[UpdateIndex].Fvb);\r
+  }\r
+}\r
+\r
+/**\r
+  Convert all pointers in mFvbEntry after ExitBootServices.\r
+\r
+  @param Event      The Event that is being processed\r
+  @param Context    Event Context\r
+\r
+**/\r
+VOID\r
+EFIAPI\r
+FvbVirtualAddressChangeNotifyEvent (\r
+  IN EFI_EVENT        Event,\r
+  IN VOID             *Context\r
+  )\r
+{\r
+  UINTN Index;\r
+  if (mFvbEntry != NULL) {\r
+    for (Index = 0; Index < MAX_FVB_COUNT; Index++) {\r
+      if (!mFvbEntry[Index].IsRuntimeAccess) {\r
+        continue;\r
+      }\r
+\r
+      if (NULL != mFvbEntry[Index].Fvb) {\r
+        EfiConvertPointer (0x0, (VOID **) &mFvbEntry[Index].Fvb->GetBlockSize);\r
+        EfiConvertPointer (0x0, (VOID **) &mFvbEntry[Index].Fvb->GetPhysicalAddress);\r
+        EfiConvertPointer (0x0, (VOID **) &mFvbEntry[Index].Fvb->GetAttributes);\r
+        EfiConvertPointer (0x0, (VOID **) &mFvbEntry[Index].Fvb->SetAttributes);\r
+        EfiConvertPointer (0x0, (VOID **) &mFvbEntry[Index].Fvb->Read);\r
+        EfiConvertPointer (0x0, (VOID **) &mFvbEntry[Index].Fvb->Write);\r
+        EfiConvertPointer (0x0, (VOID **) &mFvbEntry[Index].Fvb->EraseBlocks);\r
+        EfiConvertPointer (0x0, (VOID **) &mFvbEntry[Index].Fvb);\r
+      }\r
+\r
+      if (NULL != mFvbEntry[Index].FvbExtension) {\r
+        EfiConvertPointer (0x0, (VOID **) &mFvbEntry[Index].FvbExtension->EraseFvbCustomBlock);\r
+        EfiConvertPointer (0x0, (VOID **) &mFvbEntry[Index].FvbExtension);\r
+      }\r
+    }\r
+\r
+    EfiConvertPointer (0x0, (VOID **) &mFvbEntry);\r
+  }\r
+}\r
+\r
+/**\r
+  Library constructor function entry.\r
+\r
+  @param ImageHandle    The handle of image who call this libary.\r
+  @param SystemTable    The point of System Table.\r
+\r
+  @retval EFI_SUCESS    Sucess construct this library.\r
+  @retval Others        Fail to contruct this libary.\r
+**/\r
+EFI_STATUS\r
+EFIAPI\r
+FvbLibInitialize (\r
+  IN EFI_HANDLE         ImageHandle,\r
+  IN EFI_SYSTEM_TABLE   *SystemTable\r
+  )\r
+{\r
+  UINTN Status;\r
+  mFvbCount = 0;\r
+\r
+  Status = gBS->AllocatePool (\r
+                  EfiRuntimeServicesData,\r
+                  (UINTN) sizeof (FVB_ENTRY) * MAX_FVB_COUNT,\r
+                  (VOID *) &mFvbEntry\r
+                  );\r
+\r
+  if (EFI_ERROR (Status)) {\r
+    return Status;\r
+  }\r
+\r
+  ZeroMem (mFvbEntry, sizeof (FVB_ENTRY) * MAX_FVB_COUNT);\r
+\r
+  EfiCreateProtocolNotifyEvent (\r
+    &gEfiFirmwareVolumeBlockProtocolGuid,\r
+    TPL_CALLBACK,\r
+    FvbNotificationEvent,\r
+    NULL,\r
+    &mFvbRegistration\r
+    );\r
+\r
+  //\r
+  // Register SetVirtualAddressMap () notify function\r
+  //\r
+  Status = gBS->CreateEvent (\r
+                  EVT_SIGNAL_EXIT_BOOT_SERVICES,\r
+                  TPL_NOTIFY,\r
+                  FvbVirtualAddressChangeNotifyEvent,\r
+                  NULL,\r
+                  &mExitBootServicesEvent\r
+                  );\r
+  ASSERT_EFI_ERROR (Status);\r
+\r
+  mEfiFvbInitialized = TRUE;\r
+\r
+  return EFI_SUCCESS;\r
+}\r
+\r
+//\r
+// =============================================================================\r
+// The following functions wrap Fvb protocol in the Runtime Lib functions.\r
+// The Instance translates into Fvb instance. The Fvb order defined by HOBs and\r
+// thus the sequence of FVB protocol addition define Instance.\r
+//\r
+// EfiFvbInitialize () must be called before any of the following functions\r
+// must be called.\r
+// =============================================================================\r
+//\r
+\r
+/**\r
+  Reads specified number of bytes into a buffer from the specified block\r
+\r
+  @param Instance     The FV instance to be read from.\r
+  @param Lba          The logical block address to be read from\r
+  @param Offset       Offset into the block at which to begin reading\r
+  @param NumBytes     Pointer that on input contains the total size of\r
+                      the buffer. On output, it contains the total number\r
+                      of bytes read\r
+  @param Buffer       Pointer to a caller allocated buffer that will be\r
+                      used to hold the data read\r
+\r
+  @retval EFI_INVALID_PARAMETER  Invalid parameter\r
+  @retval EFI_SUCESS             Sucess to Read block\r
+  @retval Others                 Fail to read block\r
+**/\r
+EFI_STATUS\r
+EfiFvbReadBlock (\r
+  IN UINTN                                        Instance,\r
+  IN EFI_LBA                                      Lba,\r
+  IN UINTN                                        Offset,\r
+  IN OUT UINTN                                    *NumBytes,\r
+  IN UINT8                                        *Buffer\r
+  )\r
+{\r
+  if (Instance >= mFvbCount) {\r
+    return EFI_INVALID_PARAMETER;\r
+  }\r
+\r
+  if (EfiAtRuntime() && !mFvbEntry[Instance].IsRuntimeAccess) {\r
+    return EFI_INVALID_PARAMETER;\r
+  }\r
+\r
+  return mFvbEntry[Instance].Fvb->Read (mFvbEntry[Instance].Fvb, Lba, Offset, NumBytes, Buffer);\r
+}\r
+\r
+/**\r
+   Writes specified number of bytes from the input buffer to the block\r
+\r
+  @param Instance         The FV instance to be written to\r
+  @param Lba              The starting logical block index to write to\r
+  @param Offset           Offset into the block at which to begin writing\r
+  @param NumBytes         Pointer that on input contains the total size of\r
+                          the buffer. On output, it contains the total number\r
+                          of bytes actually written\r
+  @param Buffer           Pointer to a caller allocated buffer that contains\r
+                          the source for the write\r
+\r
+  @retval EFI_INVALID_PARAMETER  Invalid parameter\r
+  @retval EFI_SUCESS             Sucess to write block\r
+  @retval Others                 Fail to write block\r
+**/\r
+EFI_STATUS\r
+EfiFvbWriteBlock (\r
+  IN UINTN                                        Instance,\r
+  IN EFI_LBA                                      Lba,\r
+  IN UINTN                                        Offset,\r
+  IN OUT UINTN                                    *NumBytes,\r
+  IN UINT8                                        *Buffer\r
+  )\r
+{\r
+  if (Instance >= mFvbCount) {\r
+    return EFI_INVALID_PARAMETER;\r
+  }\r
+\r
+  if (EfiAtRuntime() && !mFvbEntry[Instance].IsRuntimeAccess) {\r
+    return EFI_INVALID_PARAMETER;\r
+  }\r
+\r
+  return mFvbEntry[Instance].Fvb->Write (mFvbEntry[Instance].Fvb, Lba, Offset, NumBytes, Buffer);\r
+}\r
+\r
+/**\r
+   Erases and initializes a firmware volume block\r
+\r
+   @param Instance      The FV instance to be erased\r
+   @param Lba           The logical block index to be erased\r
+\r
+   @retval EFI_INVALID_PARAMETER  Invalid parameter\r
+   @retval EFI_SUCESS             Sucess to erase block\r
+   @retval Others                 Fail to erase block\r
+**/\r
+EFI_STATUS\r
+EfiFvbEraseBlock (\r
+  IN UINTN                                Instance,\r
+  IN EFI_LBA                              Lba\r
+  )\r
+{\r
+  if (Instance >= mFvbCount) {\r
+    return EFI_INVALID_PARAMETER;\r
+  }\r
+\r
+  if (EfiAtRuntime() && !mFvbEntry[Instance].IsRuntimeAccess) {\r
+    return EFI_INVALID_PARAMETER;\r
+  }\r
+\r
+  return mFvbEntry[Instance].Fvb->EraseBlocks (mFvbEntry[Instance].Fvb, Lba, -1);\r
+}\r
+\r
+/**\r
+  Retrieves attributes, insures positive polarity of attribute bits, returns\r
+  resulting attributes in output parameter\r
+\r
+  @param Instance       The FV instance whose attributes is going to be returned\r
+  @param Attributes     Output buffer which contains attributes\r
+\r
+  @retval EFI_INVALID_PARAMETER  Invalid parameter\r
+  @retval EFI_SUCESS             Sucess to get Fv attribute\r
+  @retval Others                 Fail to get Fv attribute\r
+**/\r
+EFI_STATUS\r
+EfiFvbGetVolumeAttributes (\r
+  IN UINTN                                Instance,\r
+  OUT EFI_FVB_ATTRIBUTES                  *Attributes\r
+  )\r
+{\r
+  if (Instance >= mFvbCount) {\r
+    return EFI_INVALID_PARAMETER;\r
+  }\r
+\r
+  if (EfiAtRuntime() && !mFvbEntry[Instance].IsRuntimeAccess) {\r
+    return EFI_INVALID_PARAMETER;\r
+  }\r
+\r
+  return mFvbEntry[Instance].Fvb->GetAttributes (mFvbEntry[Instance].Fvb, Attributes);\r
+}\r
+\r
+/**\r
+   Modifies the current settings of the firmware volume according to the\r
+   input parameter, and returns the new setting of the volume\r
+\r
+   @param Instance        The FV instance whose attributes is going to be\r
+                          modified\r
+   @param Attributes      On input, it is a pointer to EFI_FVB_ATTRIBUTES\r
+                          containing the desired firmware volume settings.\r
+                          On successful return, it contains the new settings\r
+                          of the firmware volume\r
+\r
+  @retval EFI_INVALID_PARAMETER  Invalid parameter\r
+  @retval EFI_SUCESS             Sucess to set Fv attribute\r
+  @retval Others                 Fail to set Fv attribute\r
+**/\r
+EFI_STATUS\r
+EfiFvbSetVolumeAttributes (\r
+  IN UINTN                                Instance,\r
+  IN EFI_FVB_ATTRIBUTES                   Attributes\r
+  )\r
+{\r
+  if (Instance >= mFvbCount) {\r
+    return EFI_INVALID_PARAMETER;\r
+  }\r
+\r
+  if (EfiAtRuntime() && !mFvbEntry[Instance].IsRuntimeAccess) {\r
+    return EFI_INVALID_PARAMETER;\r
+  }\r
+\r
+  return mFvbEntry[Instance].Fvb->SetAttributes (mFvbEntry[Instance].Fvb, &Attributes);\r
+}\r
+\r
+/**\r
+   Retrieves the physical address of a memory mapped FV\r
+\r
+   @param Instance      The FV instance whose base address is going to be\r
+                        returned\r
+   @param BaseAddress   Pointer to a caller allocated EFI_PHYSICAL_ADDRESS\r
+                        that on successful return, contains the base address\r
+                        of the firmware volume.\r
+\r
+  @retval EFI_INVALID_PARAMETER  Invalid parameter\r
+  @retval EFI_SUCESS             Sucess to get physical address\r
+  @retval Others                 Fail to get physical address\r
+**/\r
+EFI_STATUS\r
+EfiFvbGetPhysicalAddress (\r
+  IN UINTN                                Instance,\r
+  OUT EFI_PHYSICAL_ADDRESS                *BaseAddress\r
+  )\r
+{\r
+  if (Instance >= mFvbCount) {\r
+    return EFI_INVALID_PARAMETER;\r
+  }\r
+\r
+  if (EfiAtRuntime() && !mFvbEntry[Instance].IsRuntimeAccess) {\r
+    return EFI_INVALID_PARAMETER;\r
+  }\r
+\r
+  return mFvbEntry[Instance].Fvb->GetPhysicalAddress (mFvbEntry[Instance].Fvb, BaseAddress);\r
+}\r
+\r
+/**\r
+   Retrieve the size of a logical block\r
+\r
+   @param Instance            The FV instance whose block size is going to be\r
+                              returned\r
+   @param Lba                 Indicates which block to return the size for.\r
+   @param BlockSize           A pointer to a caller allocated UINTN in which\r
+                              the size of the block is returned\r
+   @param NumOfBlocks         a pointer to a caller allocated UINTN in which the\r
+                              number of consecutive blocks starting with Lba is\r
+                              returned. All blocks in this range have a size of\r
+                              BlockSize\r
+\r
+  @retval EFI_INVALID_PARAMETER  Invalid parameter\r
+  @retval EFI_SUCESS             Sucess to get block size\r
+  @retval Others                 Fail to get block size\r
+**/\r
+EFI_STATUS\r
+EfiFvbGetBlockSize (\r
+  IN UINTN                                        Instance,\r
+  IN EFI_LBA                                      Lba,\r
+  OUT UINTN                                       *BlockSize,\r
+  OUT UINTN                                       *NumOfBlocks\r
+  )\r
+{\r
+  if (Instance >= mFvbCount) {\r
+    return EFI_INVALID_PARAMETER;\r
+  }\r
+\r
+  if (EfiAtRuntime() && !mFvbEntry[Instance].IsRuntimeAccess) {\r
+    return EFI_INVALID_PARAMETER;\r
+  }\r
+\r
+  return mFvbEntry[Instance].Fvb->GetBlockSize (mFvbEntry[Instance].Fvb, Lba, BlockSize, NumOfBlocks);\r
+}\r
+\r
+/**\r
+   Erases and initializes a specified range of a firmware volume\r
+\r
+   @param Instance          The FV instance to be erased\r
+   @param StartLba          The starting logical block index to be erased\r
+   @param OffsetStartLba    Offset into the starting block at which to\r
+                            begin erasing\r
+   @param LastLba           The last logical block index to be erased\r
+   @param OffsetLastLba     Offset into the last block at which to end erasing\r
+\r
+  @retval EFI_INVALID_PARAMETER  Invalid parameter\r
+  @retval EFI_SUCESS             Sucess to erase custom block range\r
+  @retval Others                 Fail to erase custom block range\r
+**/\r
+EFI_STATUS\r
+EfiFvbEraseCustomBlockRange (\r
+  IN UINTN                                Instance,\r
+  IN EFI_LBA                              StartLba,\r
+  IN UINTN                                OffsetStartLba,\r
+  IN EFI_LBA                              LastLba,\r
+  IN UINTN                                OffsetLastLba\r
+  )\r
+{\r
+  if (Instance >= mFvbCount) {\r
+    return EFI_INVALID_PARAMETER;\r
+  }\r
+\r
+  if (EfiAtRuntime() && !mFvbEntry[Instance].IsRuntimeAccess) {\r
+    return EFI_INVALID_PARAMETER;\r
+  }\r
+\r
+  if (!(mFvbEntry[Instance].FvbExtension)) {\r
+    return EFI_UNSUPPORTED;\r
+  }\r
+\r
+  if (!(mFvbEntry[Instance].FvbExtension->EraseFvbCustomBlock)) {\r
+    return EFI_UNSUPPORTED;\r
+  }\r
+\r
+  return mFvbEntry[Instance].FvbExtension->EraseFvbCustomBlock (\r
+                                            mFvbEntry[Instance].FvbExtension,\r
+                                            StartLba,\r
+                                            OffsetStartLba,\r
+                                            LastLba,\r
+                                            OffsetLastLba\r
+                                            );\r
+}\r
diff --git a/MdeModulePkg/Library/EdkFvbServiceLib/X64/Fvb.c b/MdeModulePkg/Library/EdkFvbServiceLib/X64/Fvb.c
new file mode 100644 (file)
index 0000000..4ffc15c
--- /dev/null
@@ -0,0 +1,614 @@
+/**@file\r
+\r
+  Firmware Volume Block Protocol Runtime Abstraction\r
+\r
+  mFvbEntry is an array of Handle Fvb pairs. The Fvb Lib Instance matches the\r
+  index in the mFvbEntry array. This should be the same sequence as the FVB's\r
+  were described in the HOB. We have to remember the handle so we can tell if\r
+  the protocol has been reinstalled and it needs updateing.\r
+\r
+  If you are using any of these lib functions.you must first call FvbInitialize ().\r
+\r
+Copyright (c) 2006, Intel Corporation\r
+All rights reserved. This program and the accompanying materials\r
+are licensed and made available under the terms and conditions of the BSD License\r
+which accompanies this distribution.  The full text of the license may be found at\r
+http://opensource.org/licenses/bsd-license.php\r
+\r
+THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
+WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
+\r
+**/\r
+\r
+//\r
+// Include common header file for this module.\r
+//\r
+#include "CommonHeader.h"\r
+\r
+#include "Fvb.h"\r
+\r
+//\r
+// Event for Exit Boot Services Callback\r
+//\r
+STATIC EFI_EVENT mExitBootServicesEvent = NULL;\r
+\r
+//\r
+// Lib will ASSERT if more FVB devices than this are added to the system.\r
+//\r
+STATIC FVB_ENTRY          *mFvbEntry;\r
+STATIC EFI_EVENT          mFvbRegistration;\r
+STATIC BOOLEAN            mEfiFvbInitialized        = FALSE;\r
+STATIC UINTN              mFvbCount;\r
+\r
+/**\r
+  Check whether an address is runtime memory or not.\r
+\r
+  @param    Address   The Address being checked.\r
+\r
+  @retval   TRUE      The address is runtime memory.\r
+  @retval   FALSE     The address is not runtime memory.\r
+**/\r
+BOOLEAN\r
+IsRuntimeMemory (\r
+  IN VOID   *Address\r
+  )\r
+{\r
+  EFI_STATUS                           Status;\r
+  UINT8                                TmpMemoryMap[1];\r
+  UINTN                                MapKey;\r
+  UINTN                                DescriptorSize;\r
+  UINT32                               DescriptorVersion;\r
+  UINTN                                MemoryMapSize;\r
+  EFI_MEMORY_DESCRIPTOR                *MemoryMap;\r
+  EFI_MEMORY_DESCRIPTOR                *MemoryMapPtr;\r
+  BOOLEAN                              IsRuntime;\r
+  UINTN                                Index;\r
+\r
+  IsRuntime = FALSE;\r
+\r
+  //\r
+  // Get System MemoryMapSize\r
+  //\r
+  MemoryMapSize = 1;\r
+  Status = gBS->GetMemoryMap (\r
+                  &MemoryMapSize,\r
+                  (EFI_MEMORY_DESCRIPTOR *)TmpMemoryMap,\r
+                  &MapKey,\r
+                  &DescriptorSize,\r
+                  &DescriptorVersion\r
+                  );\r
+  ASSERT (Status == EFI_BUFFER_TOO_SMALL);\r
+  //\r
+  // Enlarge space here, because we will allocate pool now.\r
+  //\r
+  MemoryMapSize += EFI_PAGE_SIZE;\r
+  Status = gBS->AllocatePool (\r
+                  EfiBootServicesData,\r
+                  MemoryMapSize,\r
+                  (VOID**)&MemoryMap\r
+                  );\r
+  ASSERT_EFI_ERROR (Status);\r
+\r
+  //\r
+  // Get System MemoryMap\r
+  //\r
+  Status = gBS->GetMemoryMap (\r
+                  &MemoryMapSize,\r
+                  MemoryMap,\r
+                  &MapKey,\r
+                  &DescriptorSize,\r
+                  &DescriptorVersion\r
+                  );\r
+  ASSERT_EFI_ERROR (Status);\r
+\r
+  MemoryMapPtr = MemoryMap;\r
+  //\r
+  // Search the request Address\r
+  //\r
+  for (Index = 0; Index < (MemoryMapSize / DescriptorSize); Index++) {\r
+    if (((EFI_PHYSICAL_ADDRESS)(UINTN)Address >= MemoryMap->PhysicalStart) &&\r
+        ((EFI_PHYSICAL_ADDRESS)(UINTN)Address < MemoryMap->PhysicalStart\r
+                                              + LShiftU64 (MemoryMap->NumberOfPages, EFI_PAGE_SHIFT))) {\r
+      //\r
+      // Found it\r
+      //\r
+      if (MemoryMap->Attribute & EFI_MEMORY_RUNTIME) {\r
+        IsRuntime = TRUE;\r
+      }\r
+      break;\r
+    }\r
+    //\r
+    // Get next item\r
+    //\r
+    MemoryMap = (EFI_MEMORY_DESCRIPTOR *)((UINTN)MemoryMap + DescriptorSize);\r
+  }\r
+\r
+  //\r
+  // Done\r
+  //\r
+  gBS->FreePool (MemoryMapPtr);\r
+\r
+  return IsRuntime;\r
+}\r
+\r
+/**\r
+  Update mFvbEntry. Add new entry, or update existing entry if Fvb protocol is\r
+  reinstalled.\r
+\r
+  @param Event      The Event that is being processed\r
+  @param Context    Event Context\r
+\r
+**/\r
+STATIC\r
+VOID\r
+EFIAPI\r
+FvbNotificationEvent (\r
+  IN  EFI_EVENT       Event,\r
+  IN  VOID            *Context\r
+  )\r
+{\r
+  EFI_STATUS  Status;\r
+  UINTN       BufferSize;\r
+  EFI_HANDLE  Handle;\r
+  UINTN       Index;\r
+  UINTN       UpdateIndex;\r
+\r
+  while (TRUE) {\r
+    BufferSize = sizeof (Handle);\r
+    Status = gBS->LocateHandle (\r
+                    ByRegisterNotify,\r
+                    &gEfiFirmwareVolumeBlockProtocolGuid,\r
+                    mFvbRegistration,\r
+                    &BufferSize,\r
+                    &Handle\r
+                    );\r
+    if (EFI_ERROR (Status)) {\r
+      //\r
+      // Exit Path of While Loop....\r
+      //\r
+      break;\r
+    }\r
+\r
+    UpdateIndex = MAX_FVB_COUNT;\r
+    for (Index = 0; Index < mFvbCount; Index++) {\r
+      if (mFvbEntry[Index].Handle == Handle) {\r
+        //\r
+        //  If the handle is already in the table just update the protocol\r
+        //\r
+        UpdateIndex = Index;\r
+        break;\r
+      }\r
+    }\r
+\r
+    if (UpdateIndex == MAX_FVB_COUNT) {\r
+      //\r
+      // Use the next free slot for a new entry\r
+      //\r
+      UpdateIndex                   = mFvbCount++;\r
+      //\r
+      // Check the UpdateIndex whether exceed the maximum value.\r
+      //\r
+      ASSERT (UpdateIndex < MAX_FVB_COUNT);\r
+      mFvbEntry[UpdateIndex].Handle = Handle;\r
+    }\r
+    //\r
+    // The array does not have enough entries\r
+    //\r
+    ASSERT (UpdateIndex < MAX_FVB_COUNT);\r
+\r
+    //\r
+    //  Get the interface pointer and if it's ours, skip it\r
+    //\r
+    Status = gBS->HandleProtocol (\r
+                    Handle,\r
+                    &gEfiFirmwareVolumeBlockProtocolGuid,\r
+                    (VOID **) &mFvbEntry[UpdateIndex].Fvb\r
+                    );\r
+    ASSERT_EFI_ERROR (Status);\r
+\r
+    Status = gBS->HandleProtocol (\r
+                    Handle,\r
+                    &gEfiFvbExtensionProtocolGuid,\r
+                    (VOID **) &mFvbEntry[UpdateIndex].FvbExtension\r
+                    );\r
+    if (Status != EFI_SUCCESS) {\r
+      mFvbEntry[UpdateIndex].FvbExtension = NULL;\r
+    }\r
+\r
+    //\r
+    // Check the FVB can be accessed in RUNTIME, The FVBs in FVB handle list comes\r
+    // from two way:\r
+    // 1) Dxe Core. (FVB information is transferred from FV HOB).\r
+    // 2) FVB driver.\r
+    // The FVB produced Dxe core is used for discoverying DXE driver and dispatch. These\r
+    // FVBs can only be accessed in boot time.\r
+    // FVB driver will discovery all FV in FLASH and these FVBs can be accessed in runtime.\r
+    // The FVB itself produced by FVB driver is allocated in runtime memory. So we can\r
+    // determine the what FVB can be accessed in RUNTIME by judging whether FVB itself is allocated\r
+    // in RUNTIME memory.\r
+    //\r
+    mFvbEntry[UpdateIndex].IsRuntimeAccess = IsRuntimeMemory (mFvbEntry[UpdateIndex].Fvb);\r
+  }\r
+}\r
+\r
+/**\r
+  Convert all pointers in mFvbEntry after ExitBootServices.\r
+\r
+  @param Event      The Event that is being processed\r
+  @param Context    Event Context\r
+\r
+**/\r
+VOID\r
+EFIAPI\r
+FvbVirtualAddressChangeNotifyEvent (\r
+  IN EFI_EVENT        Event,\r
+  IN VOID             *Context\r
+  )\r
+{\r
+  UINTN Index;\r
+  if (mFvbEntry != NULL) {\r
+    for (Index = 0; Index < MAX_FVB_COUNT; Index++) {\r
+      if (!mFvbEntry[Index].IsRuntimeAccess) {\r
+        continue;\r
+      }\r
+\r
+      if (NULL != mFvbEntry[Index].Fvb) {\r
+        EfiConvertPointer (0x0, (VOID **) &mFvbEntry[Index].Fvb->GetBlockSize);\r
+        EfiConvertPointer (0x0, (VOID **) &mFvbEntry[Index].Fvb->GetPhysicalAddress);\r
+        EfiConvertPointer (0x0, (VOID **) &mFvbEntry[Index].Fvb->GetVolumeAttributes);\r
+        EfiConvertPointer (0x0, (VOID **) &mFvbEntry[Index].Fvb->SetVolumeAttributes);\r
+        EfiConvertPointer (0x0, (VOID **) &mFvbEntry[Index].Fvb->Read);\r
+        EfiConvertPointer (0x0, (VOID **) &mFvbEntry[Index].Fvb->Write);\r
+        EfiConvertPointer (0x0, (VOID **) &mFvbEntry[Index].Fvb->EraseBlocks);\r
+        EfiConvertPointer (0x0, (VOID **) &mFvbEntry[Index].Fvb);\r
+      }\r
+\r
+      if (NULL != mFvbEntry[Index].FvbExtension) {\r
+        EfiConvertPointer (0x0, (VOID **) &mFvbEntry[Index].FvbExtension->EraseFvbCustomBlock);\r
+        EfiConvertPointer (0x0, (VOID **) &mFvbEntry[Index].FvbExtension);\r
+      }\r
+    }\r
+\r
+    EfiConvertPointer (0x0, (VOID **) &mFvbEntry);\r
+  }\r
+}\r
+\r
+/**\r
+  Library constructor function entry.\r
+\r
+  @param ImageHandle    The handle of image who call this libary.\r
+  @param SystemTable    The point of System Table.\r
+\r
+  @retval EFI_SUCESS    Sucess construct this library.\r
+  @retval Others        Fail to contruct this libary.\r
+**/\r
+EFI_STATUS\r
+EFIAPI\r
+FvbLibInitialize (\r
+  IN EFI_HANDLE         ImageHandle,\r
+  IN EFI_SYSTEM_TABLE   *SystemTable\r
+  )\r
+{\r
+  UINTN Status;\r
+  mFvbCount = 0;\r
+\r
+  Status = gBS->AllocatePool (\r
+                  EfiRuntimeServicesData,\r
+                  (UINTN) sizeof (FVB_ENTRY) * MAX_FVB_COUNT,\r
+                  (VOID *) &mFvbEntry\r
+                  );\r
+\r
+  if (EFI_ERROR (Status)) {\r
+    return Status;\r
+  }\r
+\r
+  ZeroMem (mFvbEntry, sizeof (FVB_ENTRY) * MAX_FVB_COUNT);\r
+\r
+  EfiCreateProtocolNotifyEvent (\r
+    &gEfiFirmwareVolumeBlockProtocolGuid,\r
+    TPL_CALLBACK,\r
+    FvbNotificationEvent,\r
+    NULL,\r
+    &mFvbRegistration\r
+    );\r
+\r
+  //\r
+  // Register SetVirtualAddressMap () notify function\r
+  //\r
+  Status = gBS->CreateEvent (\r
+                  EVT_SIGNAL_EXIT_BOOT_SERVICES,\r
+                  TPL_NOTIFY,\r
+                  FvbVirtualAddressChangeNotifyEvent,\r
+                  NULL,\r
+                  &mExitBootServicesEvent\r
+                  );\r
+  ASSERT_EFI_ERROR (Status);\r
+\r
+  mEfiFvbInitialized = TRUE;\r
+\r
+  return EFI_SUCCESS;\r
+}\r
+\r
+//\r
+// =============================================================================\r
+// The following functions wrap Fvb protocol in the Runtime Lib functions.\r
+// The Instance translates into Fvb instance. The Fvb order defined by HOBs and\r
+// thus the sequence of FVB protocol addition define Instance.\r
+//\r
+// EfiFvbInitialize () must be called before any of the following functions\r
+// must be called.\r
+// =============================================================================\r
+//\r
+\r
+/**\r
+  Reads specified number of bytes into a buffer from the specified block\r
+\r
+  @param Instance     The FV instance to be read from.\r
+  @param Lba          The logical block address to be read from\r
+  @param Offset       Offset into the block at which to begin reading\r
+  @param NumBytes     Pointer that on input contains the total size of\r
+                      the buffer. On output, it contains the total number\r
+                      of bytes read\r
+  @param Buffer       Pointer to a caller allocated buffer that will be\r
+                      used to hold the data read\r
+\r
+  @retval EFI_INVALID_PARAMETER  Invalid parameter\r
+  @retval EFI_SUCESS             Sucess to Read block\r
+  @retval Others                 Fail to read block\r
+**/\r
+EFI_STATUS\r
+EfiFvbReadBlock (\r
+  IN UINTN                                        Instance,\r
+  IN EFI_LBA                                      Lba,\r
+  IN UINTN                                        Offset,\r
+  IN OUT UINTN                                    *NumBytes,\r
+  IN UINT8                                        *Buffer\r
+  )\r
+{\r
+  if (Instance >= mFvbCount) {\r
+    return EFI_INVALID_PARAMETER;\r
+  }\r
+\r
+  if (EfiAtRuntime() && !mFvbEntry[Instance].IsRuntimeAccess) {\r
+    return EFI_INVALID_PARAMETER;\r
+  }\r
+\r
+  return mFvbEntry[Instance].Fvb->Read (mFvbEntry[Instance].Fvb, Lba, Offset, NumBytes, Buffer);\r
+}\r
+\r
+/**\r
+   Writes specified number of bytes from the input buffer to the block\r
+\r
+  @param Instance         The FV instance to be written to\r
+  @param Lba              The starting logical block index to write to\r
+  @param Offset           Offset into the block at which to begin writing\r
+  @param NumBytes         Pointer that on input contains the total size of\r
+                          the buffer. On output, it contains the total number\r
+                          of bytes actually written\r
+  @param Buffer           Pointer to a caller allocated buffer that contains\r
+                          the source for the write\r
+\r
+  @retval EFI_INVALID_PARAMETER  Invalid parameter\r
+  @retval EFI_SUCESS             Sucess to write block\r
+  @retval Others                 Fail to write block\r
+**/\r
+EFI_STATUS\r
+EfiFvbWriteBlock (\r
+  IN UINTN                                        Instance,\r
+  IN EFI_LBA                                      Lba,\r
+  IN UINTN                                        Offset,\r
+  IN OUT UINTN                                    *NumBytes,\r
+  IN UINT8                                        *Buffer\r
+  )\r
+{\r
+  if (Instance >= mFvbCount) {\r
+    return EFI_INVALID_PARAMETER;\r
+  }\r
+\r
+  if (EfiAtRuntime() && !mFvbEntry[Instance].IsRuntimeAccess) {\r
+    return EFI_INVALID_PARAMETER;\r
+  }\r
+\r
+  return mFvbEntry[Instance].Fvb->Write (mFvbEntry[Instance].Fvb, Lba, Offset, NumBytes, Buffer);\r
+}\r
+\r
+/**\r
+   Erases and initializes a firmware volume block\r
+\r
+   @param Instance      The FV instance to be erased\r
+   @param Lba           The logical block index to be erased\r
+\r
+   @retval EFI_INVALID_PARAMETER  Invalid parameter\r
+   @retval EFI_SUCESS             Sucess to erase block\r
+   @retval Others                 Fail to erase block\r
+**/\r
+EFI_STATUS\r
+EfiFvbEraseBlock (\r
+  IN UINTN                                Instance,\r
+  IN EFI_LBA                              Lba\r
+  )\r
+{\r
+  if (Instance >= mFvbCount) {\r
+    return EFI_INVALID_PARAMETER;\r
+  }\r
+\r
+  if (EfiAtRuntime() && !mFvbEntry[Instance].IsRuntimeAccess) {\r
+    return EFI_INVALID_PARAMETER;\r
+  }\r
+\r
+  return mFvbEntry[Instance].Fvb->EraseBlocks (mFvbEntry[Instance].Fvb, Lba, -1);\r
+}\r
+\r
+/**\r
+  Retrieves attributes, insures positive polarity of attribute bits, returns\r
+  resulting attributes in output parameter\r
+\r
+  @param Instance       The FV instance whose attributes is going to be returned\r
+  @param Attributes     Output buffer which contains attributes\r
+\r
+  @retval EFI_INVALID_PARAMETER  Invalid parameter\r
+  @retval EFI_SUCESS             Sucess to get Fv attribute\r
+  @retval Others                 Fail to get Fv attribute\r
+**/\r
+EFI_STATUS\r
+EfiFvbGetVolumeAttributes (\r
+  IN UINTN                                Instance,\r
+  OUT EFI_FVB_ATTRIBUTES                  *Attributes\r
+  )\r
+{\r
+  if (Instance >= mFvbCount) {\r
+    return EFI_INVALID_PARAMETER;\r
+  }\r
+\r
+  if (EfiAtRuntime() && !mFvbEntry[Instance].IsRuntimeAccess) {\r
+    return EFI_INVALID_PARAMETER;\r
+  }\r
+\r
+  return mFvbEntry[Instance].Fvb->GetVolumeAttributes (mFvbEntry[Instance].Fvb, Attributes);\r
+}\r
+\r
+/**\r
+   Modifies the current settings of the firmware volume according to the\r
+   input parameter, and returns the new setting of the volume\r
+\r
+   @param Instance        The FV instance whose attributes is going to be\r
+                          modified\r
+   @param Attributes      On input, it is a pointer to EFI_FVB_ATTRIBUTES\r
+                          containing the desired firmware volume settings.\r
+                          On successful return, it contains the new settings\r
+                          of the firmware volume\r
+\r
+  @retval EFI_INVALID_PARAMETER  Invalid parameter\r
+  @retval EFI_SUCESS             Sucess to set Fv attribute\r
+  @retval Others                 Fail to set Fv attribute\r
+**/\r
+EFI_STATUS\r
+EfiFvbSetVolumeAttributes (\r
+  IN UINTN                                Instance,\r
+  IN EFI_FVB_ATTRIBUTES                   Attributes\r
+  )\r
+{\r
+  if (Instance >= mFvbCount) {\r
+    return EFI_INVALID_PARAMETER;\r
+  }\r
+\r
+  if (EfiAtRuntime() && !mFvbEntry[Instance].IsRuntimeAccess) {\r
+    return EFI_INVALID_PARAMETER;\r
+  }\r
+\r
+  return mFvbEntry[Instance].Fvb->SetVolumeAttributes (mFvbEntry[Instance].Fvb, &Attributes);\r
+}\r
+\r
+/**\r
+   Retrieves the physical address of a memory mapped FV\r
+\r
+   @param Instance      The FV instance whose base address is going to be\r
+                        returned\r
+   @param BaseAddress   Pointer to a caller allocated EFI_PHYSICAL_ADDRESS\r
+                        that on successful return, contains the base address\r
+                        of the firmware volume.\r
+\r
+  @retval EFI_INVALID_PARAMETER  Invalid parameter\r
+  @retval EFI_SUCESS             Sucess to get physical address\r
+  @retval Others                 Fail to get physical address\r
+**/\r
+EFI_STATUS\r
+EfiFvbGetPhysicalAddress (\r
+  IN UINTN                                Instance,\r
+  OUT EFI_PHYSICAL_ADDRESS                *BaseAddress\r
+  )\r
+{\r
+  if (Instance >= mFvbCount) {\r
+    return EFI_INVALID_PARAMETER;\r
+  }\r
+\r
+  if (EfiAtRuntime() && !mFvbEntry[Instance].IsRuntimeAccess) {\r
+    return EFI_INVALID_PARAMETER;\r
+  }\r
+\r
+  return mFvbEntry[Instance].Fvb->GetPhysicalAddress (mFvbEntry[Instance].Fvb, BaseAddress);\r
+}\r
+\r
+/**\r
+   Retrieve the size of a logical block\r
+\r
+   @param Instance            The FV instance whose block size is going to be\r
+                              returned\r
+   @param Lba                 Indicates which block to return the size for.\r
+   @param BlockSize           A pointer to a caller allocated UINTN in which\r
+                              the size of the block is returned\r
+   @param NumOfBlocks         a pointer to a caller allocated UINTN in which the\r
+                              number of consecutive blocks starting with Lba is\r
+                              returned. All blocks in this range have a size of\r
+                              BlockSize\r
+\r
+  @retval EFI_INVALID_PARAMETER  Invalid parameter\r
+  @retval EFI_SUCESS             Sucess to get block size\r
+  @retval Others                 Fail to get block size\r
+**/\r
+EFI_STATUS\r
+EfiFvbGetBlockSize (\r
+  IN UINTN                                        Instance,\r
+  IN EFI_LBA                                      Lba,\r
+  OUT UINTN                                       *BlockSize,\r
+  OUT UINTN                                       *NumOfBlocks\r
+  )\r
+{\r
+  if (Instance >= mFvbCount) {\r
+    return EFI_INVALID_PARAMETER;\r
+  }\r
+\r
+  if (EfiAtRuntime() && !mFvbEntry[Instance].IsRuntimeAccess) {\r
+    return EFI_INVALID_PARAMETER;\r
+  }\r
+\r
+  return mFvbEntry[Instance].Fvb->GetBlockSize (mFvbEntry[Instance].Fvb, Lba, BlockSize, NumOfBlocks);\r
+}\r
+\r
+/**\r
+   Erases and initializes a specified range of a firmware volume\r
+\r
+   @param Instance          The FV instance to be erased\r
+   @param StartLba          The starting logical block index to be erased\r
+   @param OffsetStartLba    Offset into the starting block at which to\r
+                            begin erasing\r
+   @param LastLba           The last logical block index to be erased\r
+   @param OffsetLastLba     Offset into the last block at which to end erasing\r
+\r
+  @retval EFI_INVALID_PARAMETER  Invalid parameter\r
+  @retval EFI_SUCESS             Sucess to erase custom block range\r
+  @retval Others                 Fail to erase custom block range\r
+**/\r
+EFI_STATUS\r
+EfiFvbEraseCustomBlockRange (\r
+  IN UINTN                                Instance,\r
+  IN EFI_LBA                              StartLba,\r
+  IN UINTN                                OffsetStartLba,\r
+  IN EFI_LBA                              LastLba,\r
+  IN UINTN                                OffsetLastLba\r
+  )\r
+{\r
+  if (Instance >= mFvbCount) {\r
+    return EFI_INVALID_PARAMETER;\r
+  }\r
+\r
+  if (EfiAtRuntime() && !mFvbEntry[Instance].IsRuntimeAccess) {\r
+    return EFI_INVALID_PARAMETER;\r
+  }\r
+\r
+  if (!(mFvbEntry[Instance].FvbExtension)) {\r
+    return EFI_UNSUPPORTED;\r
+  }\r
+\r
+  if (!(mFvbEntry[Instance].FvbExtension->EraseFvbCustomBlock)) {\r
+    return EFI_UNSUPPORTED;\r
+  }\r
+\r
+  return mFvbEntry[Instance].FvbExtension->EraseFvbCustomBlock (\r
+                                            mFvbEntry[Instance].FvbExtension,\r
+                                            StartLba,\r
+                                            OffsetStartLba,\r
+                                            LastLba,\r
+                                            OffsetLastLba\r
+                                            );\r
+}\r
index cb5410b..f63aaaa 100644 (file)
   ${WORKSPACE}/MdeModulePkg/Universal/GenericMemoryTest/Dxe/NullMemoryTest.inf\r
   ${WORKSPACE}/MdeModulePkg/Universal/FirmwareVolume/FaultTolerantWriteLite/Dxe/FtwLite.inf\r
   #${WORKSPACE}/MdeModulePkg/Universal/FirmwareVolume/GuidedSectionExtraction/Crc32SectionExtract/Dxe/Crc32SectionExtract.inf\r
-  ${WORKSPACE}/MdeModulePkg/Universal/Variable/RuntimeDxe/Variable.inf\r
+  ${WORKSPACE}/MdeModulePkg/Universal/VariableRuntimeDxe/Variable.inf\r
   ${WORKSPACE}/MdeModulePkg/Bus/Pci/AtapiPassThru/Dxe/AtapiPassThru.inf\r
   ${WORKSPACE}/MdeModulePkg/Universal/WatchDogTimerDxe/WatchDogTimer.inf\r
-  ${WORKSPACE}/MdeModulePkg/Universal/VariablePei/Variable.inf\r
+#  ${WORKSPACE}/MdeModulePkg/Universal/VariablePei/Variable.inf\r
index f6aa468..4322961 100644 (file)
@@ -134,15 +134,15 @@ Returns:
   UINTN                       BlockIndex2;\r
   UINTN                       LinearOffset;\r
   UINTN                       CurrWriteSize;\r
-  UINTN                                 CurrWritePtr;\r
-  UINT8                                 *CurrBuffer;\r
-  EFI_LBA                               LbaNumber;\r
-  UINTN                                 Size;\r
-  FRAMEWORK_EFI_FIRMWARE_VOLUME_HEADER  *FwVolHeader;\r
-  VARIABLE_STORE_HEADER                 *VolatileBase;\r
-  EFI_PHYSICAL_ADDRESS                  FvVolHdr;\r
-  EFI_PHYSICAL_ADDRESS                  DataPtr;\r
-  EFI_STATUS                            Status;\r
+  UINTN                       CurrWritePtr;\r
+  UINT8                       *CurrBuffer;\r
+  EFI_LBA                     LbaNumber;\r
+  UINTN                       Size;\r
+  EFI_FIRMWARE_VOLUME_HEADER  *FwVolHeader;\r
+  VARIABLE_STORE_HEADER       *VolatileBase;\r
+  EFI_PHYSICAL_ADDRESS        FvVolHdr;\r
+  EFI_PHYSICAL_ADDRESS        DataPtr;\r
+  EFI_STATUS                  Status;\r
 \r
   FwVolHeader = NULL;\r
   DataPtr     = DataPtrIndex;\r
@@ -152,7 +152,7 @@ Returns:
   //\r
   if (!Volatile) {\r
     EfiFvbGetPhysicalAddress (Instance, &FvVolHdr);\r
-    FwVolHeader = (FRAMEWORK_EFI_FIRMWARE_VOLUME_HEADER *) ((UINTN) FvVolHdr);\r
+    FwVolHeader = (EFI_FIRMWARE_VOLUME_HEADER *) ((UINTN) FvVolHdr);\r
     //\r
     // Data Pointer should point to the actual Address where data is to be\r
     // written\r
@@ -198,7 +198,7 @@ Returns:
     return EFI_INVALID_PARAMETER;\r
   }\r
 \r
-  for (PtrBlockMapEntry = FwVolHeader->FvBlockMap; PtrBlockMapEntry->NumBlocks != 0; PtrBlockMapEntry++) {\r
+  for (PtrBlockMapEntry = FwVolHeader->BlockMap; PtrBlockMapEntry->NumBlocks != 0; PtrBlockMapEntry++) {\r
     for (BlockIndex2 = 0; BlockIndex2 < PtrBlockMapEntry->NumBlocks; BlockIndex2++) {\r
       //\r
       // Check to see if the Variable Writes are spanning through multiple\r
index 309d285..3ee3736 100644 (file)
@@ -95,13 +95,13 @@ GetLbaAndOffsetByAddress (
   OUT UINTN                  *Offset\r
   )\r
 {\r
-  EFI_STATUS                            Status;\r
-  EFI_HANDLE                            FvbHandle;\r
-  EFI_PHYSICAL_ADDRESS                  FvbBaseAddress;\r
-  EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL    *Fvb;\r
-  FRAMEWORK_EFI_FIRMWARE_VOLUME_HEADER  *FwVolHeader;\r
-  EFI_FV_BLOCK_MAP_ENTRY                *FvbMapEntry;\r
-  UINT32                                LbaIndex;\r
+  EFI_STATUS                          Status;\r
+  EFI_HANDLE                          FvbHandle;\r
+  EFI_PHYSICAL_ADDRESS                FvbBaseAddress;\r
+  EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL  *Fvb;\r
+  EFI_FIRMWARE_VOLUME_HEADER          *FwVolHeader;\r
+  EFI_FV_BLOCK_MAP_ENTRY              *FvbMapEntry;\r
+  UINT32                              LbaIndex;\r
 \r
   *Lba    = (EFI_LBA) (-1);\r
   *Offset = 0;\r
@@ -130,7 +130,7 @@ GetLbaAndOffsetByAddress (
     return Status;\r
   }\r
 \r
-  FwVolHeader = (FRAMEWORK_EFI_FIRMWARE_VOLUME_HEADER *) ((UINTN) FvbBaseAddress);\r
+  FwVolHeader = (EFI_FIRMWARE_VOLUME_HEADER *) ((UINTN) FvbBaseAddress);\r
 \r
   //\r
   // Get the (LBA, Offset) of Address\r
@@ -140,7 +140,7 @@ GetLbaAndOffsetByAddress (
       //\r
       // BUGBUG: Assume one FV has one type of BlockLength\r
       //\r
-      FvbMapEntry = &FwVolHeader->FvBlockMap[0];\r
+      FvbMapEntry = &FwVolHeader->BlockMap[0];\r
       for (LbaIndex = 1; LbaIndex <= FvbMapEntry->NumBlocks; LbaIndex += 1) {\r
         if (Address < (FvbBaseAddress + FvbMapEntry->Length * LbaIndex)) {\r
           //\r
@@ -149,7 +149,7 @@ GetLbaAndOffsetByAddress (
           *Lba    = LbaIndex - 1;\r
           *Offset = (UINTN) (Address - (FvbBaseAddress + FvbMapEntry->Length * (LbaIndex - 1)));\r
           return EFI_SUCCESS;\r
-        }\r
+       }\r
       }\r
     }\r
   }\r